sendnrw/windows_exporter
2
0
Fork 0
mirror of https://github.com/prometheus-community/windows_exporter.git synced 2026-10-17 10:09:05 +02:00
Code Issues Packages Projects Releases Wiki Activity

collector: publish base units and _total counter names (#2743)

Browse Source 
Signed-off-by: Jan-Otto Kröpke <mail@jkroepke.de>
This commit is contained in:
Jan-Otto Kröpke
2026-10-16 10:48:26 +02:00
committed by GitHub
parent dc8092f46d
commit 3fb18521f6
131 changed files with 1674 additions and 1459 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/collector.ad.md
+1 -1
View File
@@ -26,7 +26,7 @@ Name | Description | Type | Labels
`windows_ad_searches_total` | Total number of directory searches, by search scope (Base/Subtree/Onelevel searches) | counter | `scope`
`windows_ad_database_operations_total` | Total number of directory database operations, by operation (Database adds/deletes/modifys/recycles) | counter | `operation`
`windows_ad_binds_total` | Total number of binds, by bind method | counter | `bind_method`
`windows_ad_replication_highest_usn` | Highest update sequence number (USN) committed or issued by this domain controller (DRA Highest USN Committed/Issued) | counter | `state`
`windows_ad_replication_highest_usn_total` | Highest update sequence number (USN) committed or issued by this domain controller (DRA Highest USN Committed/Issued) | counter | `state`
`windows_ad_replication_data_intrasite_bytes_total` | Total number of uncompressed bytes replicated within the site, by direction (DRA Inbound/Outbound Bytes Not Compressed (Within Site)) | counter | `direction`
`windows_ad_replication_data_intersite_bytes_total` | Total number of compressed bytes, after compression, replicated between sites, by direction (DRA Inbound/Outbound Bytes Compressed (Between Sites, After Compression)) | counter | `direction`
`windows_ad_replication_inbound_sync_objects_remaining` | Number of objects remaining until a full synchronization completes (DRA Inbound Full Sync Objects Remaining) | gauge | None
docs/collector.cache.md
-3
View File
@@ -27,7 +27,6 @@ Name | Description | Type | Labels
`windows_cache_data_flushes_total` | Number of times the file system cache has flushed its contents to disk as the result of a request to flush or to satisfy a write-through file write request. | counter | None
`windows_cache_data_flush_pages_total` | Number of pages the file system cache has flushed to disk as a result of a request to flush or to satisfy a write-through file write request. | counter | None
`windows_cache_data_map_hits_total` | Number of data maps in the file system cache that could be resolved without having to retrieve a page from the disk, because the page was already in physical memory. | counter | None
`windows_cache_data_map_hits_percent` | Deprecated: raw data-map hit count, not a percentage. Use `windows_cache_data_map_hits_total`. | gauge | None
`windows_cache_data_map_pins_total` | Number of data maps in the file system cache that resulted in pinning a page in main memory, an action usually preparatory to writing to the file on disk. | counter | None
`windows_cache_data_maps_total` | Number of times that a file system such as NTFS, maps a page of a file into the file system cache to read the page. | counter | None
`windows_cache_dirty_pages` | Number of dirty pages on the system cache. | gauge | None
@@ -48,8 +47,6 @@ Name | Description | Type | Labels
`windows_cache_sync_mdl_reads_total` | Number of reads from the file system cache that use a Memory Descriptor List (MDL) to access the pages. If the accessed page(s) are not in main memory, the caller will wait for the pages to fault in from the disk. | counter | None
`windows_cache_sync_pin_reads_total` | Number of reads into the file system cache preparatory to writing the data back to disk. The file system will not regain control until the page is pinned in the file system cache, in particular if the disk must be accessed to retrieve the page. | counter | None
`windows_cache_data_map_hits_percent` is retained as a deprecated gauge exposing the same raw hit count as `windows_cache_data_map_hits_total`. It is not a percentage and can exceed 100. Use the hit-total counter for new queries.
### Example metric
Percentage of copy reads that hit the cache
```
docs/collector.container.md
+4 -4
View File
@@ -31,9 +31,9 @@ If the endpoint is not available, for example on hosts without Kubernetes, the H
| Name | Description | Type | Labels |
|------------------------------------------------------------|-----------------------------------------------------|---------|------------------------------------------------------------|
| `windows_container_available` | Available | gauge | `container_id`,`namespace`,`pod`,`container`,`hostprocess` |
| `windows_container_count` | Number of running HCS containers | gauge | None |
| `windows_container_cpu_usage_seconds_kernelmode` | Runtime in Kernel mode in Seconds | counter | `container_id`,`namespace`,`pod`,`container` |
| `windows_container_cpu_usage_seconds_usermode` | Runtime in User mode in Seconds | counter | `container_id`,`namespace`,`pod`,`container` |
| `windows_containers` | Number of running HCS containers | gauge | None |
| `windows_container_cpu_usage_kernelmode_seconds_total` | Runtime in Kernel mode in Seconds | counter | `container_id`,`namespace`,`pod`,`container` |
| `windows_container_cpu_usage_usermode_seconds_total` | Runtime in User mode in Seconds | counter | `container_id`,`namespace`,`pod`,`container` |
| `windows_container_cpu_usage_seconds_total` | Total Runtime in Seconds | counter | `container_id`,`namespace`,`pod`,`container` |
| `windows_container_memory_page_faults_total` | Total number of page faults (HostProcess only) | counter | `container_id`,`namespace`,`pod`,`container` |
| `windows_container_memory_usage_commit_bytes` | Memory Usage Commit Bytes | gauge | `container_id`,`namespace`,`pod`,`container` |
@@ -60,7 +60,7 @@ If the endpoint is not available, for example on hosts without Kubernetes, the H
`windows_container_storage_writable_layer_usage_bytes` is read from the CRI endpoint and only exported for Kubernetes containers.
containerd measures it periodically, so it may lag behind and is missing until the first measurement.
`windows_container_count` only counts HCS containers. HostProcess and Hyper-V isolated containers aren't counted.
`windows_containers` only counts HCS containers. HostProcess and Hyper-V isolated containers aren't counted.
### Hyper-V isolated containers
docs/collector.cpu.md
+9 -9
View File
@@ -20,29 +20,29 @@ These metrics are available on all versions of Windows:
|--------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-----------------|
| `windows_cpu_logical_processor` | Number of installed logical processors | gauge | None |
| `windows_cpu_cstate_seconds_total` | Time spent in low-power idle states | counter | `core`, `state` |
| `windows_cpu_time_total` | Time that processor spent in different modes (dpc, idle, interrupt, privileged, user) | counter | `core`, `mode` |
| `windows_cpu_time_seconds_total` | Time that processor spent in different modes (dpc, idle, interrupt, privileged, user) | counter | `core`, `mode` |
| `windows_cpu_interrupts_total` | Total number of received and serviced hardware interrupts | counter | `core` |
| `windows_cpu_dpcs_total` | Total number of received and serviced deferred procedure calls (DPCs) | counter | `core` |
| `windows_cpu_clock_interrupts_total` | Total number of received and serviced clock tick interrupts | counter | `core` |
| `windows_cpu_idle_break_events_total` | Total number of time processor was woken from idle | counter | `core` |
| `windows_cpu_parking_status` | Parking Status represents whether a processor is parked or not | gauge | `core` |
| `windows_cpu_core_frequency_mhz` | Core frequency in megahertz | gauge | `core` |
| `windows_cpu_core_frequency_hertz` | Core frequency in hertz | gauge | `core` |
| `windows_cpu_processor_performance_total` | Processor Performance is the number of CPU cycles executing instructions by each core; it is believed to be similar to the value that the APERF MSR would show, were it exposed | counter | `core` |
| `windows_cpu_processor_mperf_total` | Processor MPerf Total is proportioanl to the number of TSC ticks each core has accumulated while executing instructions. Due to the manner in which it is presented, it should be scaled by 1e2 to properly line up with Processor Performance Total. As above, it is believed to be closely related to the MPERF MSR. | counter | `core` |
| `windows_cpu_processor_rtc_total` | RTC total is assumed to represent the 64Hz tick rate in Windows. It is not by itself useful, but can be used with `windows_cpu_processor_utility_total` to more accurately measure CPU utilisation than with `windows_cpu_time_total` | counter | `core` |
| `windows_cpu_processor_rtc_total` | RTC total is assumed to represent the 64Hz tick rate in Windows. It is not by itself useful, but can be used with `windows_cpu_processor_utility_total` to more accurately measure CPU utilisation than with `windows_cpu_time_seconds_total` | counter | `core` |
| `windows_cpu_processor_utility_total` | Processor Utility Total is a newer, more accurate measure of CPU utilization, in particular handling modern CPUs with variant CPU frequencies. The rate of this counter divided by the rate of `windows_cpu_processor_rtc_total` should provide an accurate view of CPU utilisation on modern systems, as observed in Task Manager. | counter | `core` |
| `windows_cpu_processor_privileged_utility_total` | Processor Privileged Utility Total, when used in a similar fashion to `windows_cpu_processor_utility_total` will show the portion of CPU utilization which is happening in privileged mode. | counter | `core` |
### Example metric
Show frequency of host CPU cores
```
windows_cpu_core_frequency_mhz{instance="localhost"}
windows_cpu_core_frequency_hertz{instance="localhost"}
```
## Useful queries
Show CPU usage by mode.
```
sum by (mode) (irate(windows_cpu_time_total{instance="localhost"}[5m]))
sum by (mode) (irate(windows_cpu_time_seconds_total{instance="localhost"}[5m]))
```
Show per-cpu utilisation using the processor utility metrics
```
@@ -72,7 +72,7 @@ count by (instance) (
Show actual average CPU frequency in Hz
```
avg by(instance) (
1e4 * windows_cpu_core_frequency_mhz{}
1e-2 * windows_cpu_core_frequency_hertz{}
* rate(windows_cpu_processor_performance_total{}[5m])
/ rate(windows_cpu_processor_mperf_total{}[5m])
)
@@ -113,7 +113,7 @@ avg by(instance) (
```yaml
# Alert on hosts with more than 80% CPU usage over a 10 minute period
- alert: CpuUsage
expr: 100 - (avg by (instance) (irate(windows_cpu_time_total{mode="idle"}[2m])) * 100) > 80
expr: 100 - (avg by (instance) (irate(windows_cpu_time_seconds_total{mode="idle"}[2m])) * 100) > 80
for: 10m
labels:
severity: warning
@@ -128,12 +128,12 @@ avg by(instance) (
- alert: NoCpuTurbo
expr: |
avg by(instance) (
1e4 * windows_cpu_core_frequency_mhz{}
1e-2 * windows_cpu_core_frequency_hertz{}
* rate(windows_cpu_processor_performance_total{}[5m])
/ rate(windows_cpu_processor_mperf_total{}[5m])
)
/
(1e6 * avg by (instance) (windows_cpu_core_frequency_mhz))
avg by (instance) (windows_cpu_core_frequency_hertz)
< 1.1
for: 1h
annotations:
docs/collector.cpu_info.md
+8 -8
View File
@@ -20,8 +20,8 @@ None
| `windows_cpu_info` | Labelled CPU information | gauge | `architecture`, `device_id`, `description`, `family`, `name` |
| `windows_cpu_info_core` | Number of cores per CPU | gauge | `device_id` |
| `windows_cpu_info_enabled_core` | Number of enabled cores per CPU | gauge | `device_id` |
| `windows_cpu_info_l2_cache_size` | Size of L2 cache per CPU | gauge | `device_id` |
| `windows_cpu_info_l3_cache_size` | Size of L3 cache per CPU | gauge | `device_id` |
| `windows_cpu_info_l2_cache_size_bytes` | Size of L2 cache per CPU in bytes | gauge | `device_id` |
| `windows_cpu_info_l3_cache_size_bytes` | Size of L3 cache per CPU in bytes | gauge | `device_id` |
| `windows_cpu_info_logical_processor` | Number of logical processors per CPU | gauge | `device_id` |
| `windows_cpu_info_thread` | Number of threads per CPU | gauge | `device_id` |
@@ -36,12 +36,12 @@ windows_cpu_info_core{device_id="CPU0"} 12
# HELP windows_cpu_info_enabled_core Number of enabled cores per CPU
# TYPE windows_cpu_info_enabled_core gauge
windows_cpu_info_enabled_core{device_id="CPU0"} 12
# HELP windows_cpu_info_l2_cache_size Size of L2 cache per CPU
# TYPE windows_cpu_info_l2_cache_size gauge
windows_cpu_info_l2_cache_size{device_id="CPU0"} 6144
# HELP windows_cpu_info_l3_cache_size Size of L3 cache per CPU
# TYPE windows_cpu_info_l3_cache_size gauge
windows_cpu_info_l3_cache_size{device_id="CPU0"} 65536
# HELP windows_cpu_info_l2_cache_size_bytes Size of L2 cache per CPU in bytes
# TYPE windows_cpu_info_l2_cache_size_bytes gauge
windows_cpu_info_l2_cache_size_bytes{device_id="CPU0"} 6.291456e+06
# HELP windows_cpu_info_l3_cache_size_bytes Size of L3 cache per CPU in bytes
# TYPE windows_cpu_info_l3_cache_size_bytes gauge
windows_cpu_info_l3_cache_size_bytes{device_id="CPU0"} 6.7108864e+07
# HELP windows_cpu_info_logical_processor Number of logical processors per CPU
# TYPE windows_cpu_info_logical_processor gauge
windows_cpu_info_logical_processor{device_id="CPU0"} 24
docs/collector.diskdrive.md
+1 -1
View File
@@ -19,7 +19,7 @@ None
| `windows_diskdrive_info` | General identifiable information about the disk drive | gauge | device_id,model,caption,name |
| `windows_diskdrive_availability` | The disk drive's current availability | gauge | name,availability |
| `windows_diskdrive_partitions` | Number of partitions on the drive | gauge | name |
| `windows_diskdrive_size` | Size of the disk drive. It is calculated by multiplying the total number of cylinders, tracks in each cylinder, sectors in each track, and bytes in each sector. | gauge | name |
| `windows_diskdrive_size_bytes` | Size of the disk drive. It is calculated by multiplying the total number of cylinders, tracks in each cylinder, sectors in each track, and bytes in each sector. | gauge | name |
| `windows_diskdrive_status` | Operational status of the drive | gauge | name,status |
## Alerting examples
docs/collector.exchange.md
+17 -17
View File
@@ -20,20 +20,20 @@ Supported values are `ADAccessProcesses`, `TransportQueues`, `HttpProxy`, `Activ
## Metrics
| Name | Description | Type | Labels |
|-----------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|---------|--------|
| `windows_exchange_rpc_avg_latency_sec` | The latency (sec), averaged for the past 1024 packets | gauge | None |
| `windows_exchange_rpc_avg_latency_seconds` | The latency in seconds, averaged for the past 1024 packets | gauge | None |
| `windows_exchange_rpc_requests` | Number of client requests currently being processed by the RPC Client Access service | gauge | None |
| `windows_exchange_rpc_active_user_count` | Number of unique users that have shown some kind of activity in the last 2 minutes | gauge | None |
| `windows_exchange_rpc_connection_count` | Total number of client connections maintained | gauge | None |
| `windows_exchange_rpc_active_users` | Number of unique users that have shown some kind of activity in the last 2 minutes | gauge | None |
| `windows_exchange_rpc_connections` | Total number of client connections maintained | gauge | None |
| `windows_exchange_rpc_operations_total` | The rate at which RPC operations occur | counter | None |
| `windows_exchange_rpc_user_count` | Number of users | gauge | None |
| `windows_exchange_ldap_read_time_sec` | Time (sec) to send an LDAP read request and receive a response | counter | `name` |
| `windows_exchange_rpc_users` | Number of users | gauge | None |
| `windows_exchange_ldap_read_time_seconds_total` | Total time in seconds to send an LDAP read request and receive a response | counter | `name` |
| `windows_exchange_ldap_read_operations_total` | Total number of LDAP read operations | counter | `name` |
| `windows_exchange_ldap_search_time_sec` | Time (sec) to send an LDAP search request and receive a response | counter | `name` |
| `windows_exchange_ldap_search_time_seconds_total` | Total time in seconds to send an LDAP search request and receive a response | counter | `name` |
| `windows_exchange_ldap_search_operations_total` | Total number of LDAP search operations | counter | `name` |
| `windows_exchange_ldap_write_time_sec` | Time (sec) to send an LDAP Add/Modify/Delete request and receive a response | counter | `name` |
| `windows_exchange_ldap_write_time_seconds_total` | Total time in seconds to send an LDAP Add/Modify/Delete request and receive a response | counter | `name` |
| `windows_exchange_ldap_write_operations_total` | Total number of LDAP Add/Modify/Delete operations | counter | `name` |
| `windows_exchange_ldap_timeout_errors_total` | Total number of LDAP timeout errors | counter | `name` |
| `windows_exchange_ldap_long_running_ops_per_sec` | Long Running LDAP operations per second | counter | `name` |
| `windows_exchange_ldap_long_running_operations_per_second` | Long running LDAP operations per second, averaged over the last minute | gauge | `name` |
| `windows_exchange_transport_queues_external_active_remote_delivery` | External Active Remote Delivery Queue length | gauge | `name` |
| `windows_exchange_transport_queues_internal_active_remote_delivery` | Internal Active Remote Delivery Queue length | gauge | `name` |
| `windows_exchange_transport_queues_active_mailbox_delivery` | Active Mailbox Delivery Queue length | gauge | `name` |
@@ -53,25 +53,25 @@ Supported values are `ADAccessProcesses`, `TransportQueues`, `HttpProxy`, `Activ
| `windows_exchange_transport_queues_items_queued_for_delivery_expired_total` | Items Queued For Delivery Expired Total | counter | `name` |
| `windows_exchange_transport_queues_items_queued_for_delivery_total` | Items Queued For Delivery Total | counter | `name` |
| `windows_exchange_transport_queues_items_resubmitted_total` | Items Resubmitted Total | counter | `name` |
| `windows_exchange_http_proxy_mailbox_server_locator_avg_latency_sec` | Average latency (sec) of MailboxServerLocator web service calls | gauge | `name` |
| `windows_exchange_http_proxy_avg_auth_latency` | Average time spent authenticating CAS requests over the last 200 samples | gauge | `name` |
| `windows_exchange_http_proxy_mailbox_server_locator_avg_latency_seconds` | Average latency in seconds of MailboxServerLocator web service calls | gauge | `name` |
| `windows_exchange_http_proxy_avg_auth_latency_seconds` | Average time in seconds spent authenticating CAS requests over the last 200 samples | gauge | `name` |
| `windows_exchange_http_proxy_outstanding_proxy_requests` | Number of concurrent outstanding proxy requests | gauge | `name` |
| `windows_exchange_http_proxy_requests_total` | Number of proxy requests processed each second | counter | `name` |
| `windows_exchange_availability_service_requests_per_sec` | Number of requests serviced per second | counter | None |
| `windows_exchange_availability_service_requests_total` | Total number of requests serviced | counter | None |
| `windows_exchange_owa_current_unique_users` | Number of unique users currently logged on to Outlook Web App | gauge | None |
| `windows_exchange_owa_requests_total` | Number of requests handled by Outlook Web App per second | counter | None |
| `windows_exchange_autodiscover_requests_total` | Number of autodiscover service requests processed each second | counter | None |
| `windows_exchange_workload_active_tasks` | Number of active tasks currently running in the background for workload management | gauge | `name` |
| `windows_exchange_workload_completed_tasks` | Number of workload management tasks that have been completed | counter | `name` |
| `windows_exchange_workload_queued_tasks` | Number of workload management tasks that are currently queued up waiting to be processed | counter | `name` |
| `windows_exchange_workload_yielded_tasks` | The total number of tasks that have been yielded by a workload | counter | `name` |
| `windows_exchange_workload_completed_tasks_total` | Number of workload management tasks that have been completed | counter | `name` |
| `windows_exchange_workload_queued_tasks` | Number of workload management tasks that are currently queued up waiting to be processed | gauge | `name` |
| `windows_exchange_workload_yielded_tasks_total` | The total number of tasks that have been yielded by a workload | counter | `name` |
| `windows_exchange_workload_is_active` | Active indicates whether the workload is in an active (1) or paused (0) state | gauge | `name` |
| `windows_exchange_activesync_requests_total` | Num HTTP requests received from the client via ASP.NET per sec. Shows Current user load | counter | None |
| `windows_exchange_http_proxy_avg_cas_processing_latency_sec` | Average latency (sec) of CAS processing time over the last 200 reqs | gauge | `name` |
| `windows_exchange_http_proxy_mailbox_proxy_failure_rate` | % of failures between this CAS and MBX servers over the last 200 sample | gauge | `name` |
| `windows_exchange_http_proxy_avg_cas_processing_latency_seconds` | Average latency in seconds of CAS processing time over the last 200 reqs | gauge | `name` |
| `windows_exchange_http_proxy_mailbox_proxy_failure_ratio` | Ratio (0-1) of failures between this CAS and MBX servers over the last 200 sample | gauge | `name` |
| `windows_exchange_activesync_ping_cmds_pending` | Number of ping commands currently pending in the queue | gauge | None |
| `windows_exchange_activesync_sync_cmds_total` | Number of sync commands processed per second. Clients use this command to synchronize items within a folder | counter | None |
| `windows_exchange_mapihttp_emsmdb_active_user_count` | Number of unique outlook users that have shown some kind of activity in the last 2 minutes | gauge | None |
| `windows_exchange_mapihttp_emsmdb_active_users` | Number of unique outlook users that have shown some kind of activity in the last 2 minutes | gauge | None |
### Example metric
_This collector does not yet have explained examples, we would appreciate your help adding them!_
docs/collector.fsrmquota.md
+1 -1
View File
@@ -18,7 +18,7 @@ None
Name | Description | Type | Labels
-----|-------------|------|-------
`windows_fsrmquota_count` | Number of Quotas | gauge |None
`windows_fsrmquota_quotas` | Number of Quotas | gauge |None
`windows_fsrmquota_description` | A string up to 1KB in size. Optional. The default value is an empty string. (Description) | gauge |`path`, `template`,`description`
`windows_fsrmquota_disabled` | If 1, the quota is disabled. The default value is 0. (Disabled) | gauge |`path`, `template`
`windows_fsrmquota_matchestemplate` | If 1, the property values of this quota match those values of the template from which it was derived. (MatchesTemplate) | gauge |`path`, `template`
docs/collector.gpu.md
+7 -7
View File
@@ -61,13 +61,13 @@ logged at debug level and never fail the scrape.
| `windows_gpu_engine_frequency_max_hertz` | Maximum clock frequency of the GPU engine in hertz, while not overclocked | gauge | `device_id`,`luid`,`phys`,`eng` |
The engine frequency metrics are only exposed for engines that report a maximum frequency, typically the 3D engine. The
`eng` label matches the `eng` label of `windows_gpu_engine_time_seconds`.
`eng` label matches the `eng` label of `windows_gpu_engine_time_seconds_total`.
### Per-process Metrics
| Name | Description | Type | Labels |
|----------------------------------------------|-------------------------------------------------|---------|-----------------------------------------------------------|
| `windows_gpu_engine_time_seconds` | Total running time of the GPU engine in seconds | counter | `device_id`,`luid`,`phys`, `eng`, `engtype`, `process_id` |
| `windows_gpu_engine_time_seconds_total` | Total running time of the GPU engine in seconds | counter | `device_id`,`luid`,`phys`, `eng`, `engtype`, `process_id` |
| `windows_gpu_process_memory_committed_bytes` | Total committed GPU memory in bytes per process | gauge | `device_id`,`luid`,`phys`,`process_id` |
| `windows_gpu_process_memory_dedicated_bytes` | Dedicated GPU memory usage in bytes per process | gauge | `device_id`,`luid`,`phys`,`process_id` |
| `windows_gpu_process_memory_local_bytes` | Local GPU memory usage in bytes per process | gauge | `device_id`,`luid`,`phys`,`process_id` |
@@ -118,7 +118,7 @@ windows_gpu_adapter_memory_dedicated_bytes{phys="0"}
```promql
sum by (phys) (
rate(windows_gpu_engine_time_seconds{phys="0", engtype="3D"}[1m])
rate(windows_gpu_engine_time_seconds_total{phys="0", engtype="3D"}[1m])
) * 100
```
@@ -126,7 +126,7 @@ sum by (phys) (
```promql
sum by (phys, process_id) (
rate(windows_gpu_engine_time_seconds{process_id="1234", engtype="3D"}[1m])
rate(windows_gpu_engine_time_seconds_total{process_id="1234", engtype="3D"}[1m])
) * 100
```
@@ -144,7 +144,7 @@ sum by (luid, process_id) (
```promql
topk(5, sum by (process_id) (
rate(windows_gpu_engine_time_seconds[1m])
rate(windows_gpu_engine_time_seconds_total[1m])
) * 100)
```
@@ -159,7 +159,7 @@ sum by (phys) (
Show GPU engine time with process owner and command line:
```promql
windows_gpu_engine_time_seconds * on(process_id) group_left(owner, cmdline) windows_process_info
windows_gpu_engine_time_seconds_total * on(process_id) group_left(owner, cmdline) windows_process_info
```
**Show the engine clock as a ratio of its maximum clock:**
@@ -177,7 +177,7 @@ windows_gpu_engine_frequency_hertz / windows_gpu_engine_frequency_max_hertz
- alert: HighGpuUtilization
expr: |
sum by (process_id) (
rate(windows_gpu_engine_time_seconds[1m])
rate(windows_gpu_engine_time_seconds_total[1m])
) * 100 > 80
for: 10m
labels:
docs/collector.hyperv.md
+74 -85
View File
@@ -54,37 +54,37 @@ prefixed with `windows_hyperv_datastore`.
| `windows_hyperv_datastore_table_data_size_bytes` | Represents the table data size in bytes of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_names_size_bytes` | Represents the names size in bytes of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_number_of_keys` | Represents the number of keys in the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_reconnect_latency_microseconds` | Represents the reconnect latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_disconnect_count` | Represents the disconnect count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_write_to_file_byte_latency_microseconds` | Represents the write-to-file byte latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_write_to_file_byte_count` | Represents the write-to-file byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_write_to_file_count` | Represents the write-to-file count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_read_from_file_byte_latency_microseconds` | Represents the read-from-file byte latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_read_from_file_byte_count` | Represents the read-from-file byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_read_from_file_count` | Represents the read-from-file count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_write_to_storage_byte_latency_microseconds` | Represents the write-to-storage byte latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_write_to_storage_byte_count` | Represents the write-to-storage byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_write_to_storage_count` | Represents the write-to-storage count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_read_from_storage_byte_latency_microseconds` | Represents the read-from-storage byte latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_read_from_storage_byte_count` | Represents the read-from-storage byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_read_from_storage_count` | Represents the read-from-storage count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_commit_byte_latency_microseconds` | Represents the commit byte latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_commit_byte_count` | Represents the commit byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_commit_count` | Represents the commit count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_cache_update_operation_latency_microseconds` | Represents the cache update operation latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_cache_update_operation_count` | Represents the cache update operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_commit_operation_latency_microseconds` | Represents the commit operation latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_commit_operation_count` | Represents the commit operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_compact_operation_latency_microseconds` | Represents the compact operation latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_compact_operation_count` | Represents the compact operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_load_file_operation_latency_microseconds` | Represents the load file operation latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_load_file_operation_count` | Represents the load file operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_remove_operation_latency_microseconds` | Represents the remove operation latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_remove_operation_count` | Represents the remove operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_query_size_operation_latency_microseconds` | Represents the query size operation latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_query_size_operation_count` | Represents the query size operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_set_operation_latency_microseconds` | Represents the set operation latency in microseconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_set_operation_count` | Represents the set operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_reconnect_latency_seconds` | Represents the reconnect latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_disconnects_total` | Represents the disconnect count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_write_to_file_byte_latency_seconds` | Represents the write-to-file byte latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_write_to_file_bytes_total` | Represents the write-to-file byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_write_to_file_operations_total` | Represents the write-to-file count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_read_from_file_byte_latency_seconds` | Represents the read-from-file byte latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_read_from_file_bytes_total` | Represents the read-from-file byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_read_from_file_operations_total` | Represents the read-from-file count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_write_to_storage_byte_latency_seconds` | Represents the write-to-storage byte latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_write_to_storage_bytes_total` | Represents the write-to-storage byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_write_to_storage_operations_total` | Represents the write-to-storage count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_read_from_storage_byte_latency_seconds` | Represents the read-from-storage byte latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_read_from_storage_bytes_total` | Represents the read-from-storage byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_read_from_storage_operations_total` | Represents the read-from-storage count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_commit_byte_latency_seconds` | Represents the commit byte latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_commit_bytes_total` | Represents the commit byte count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_commits_total` | Represents the commit count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_cache_update_operation_latency_seconds` | Represents the cache update operation latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_cache_update_operations_total` | Represents the cache update operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_commit_operation_latency_seconds` | Represents the commit operation latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_commit_operations_total` | Represents the commit operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_compact_operation_latency_seconds` | Represents the compact operation latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_compact_operations_total` | Represents the compact operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_load_file_operation_latency_seconds` | Represents the load file operation latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_load_file_operations_total` | Represents the load file operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_remove_operation_latency_seconds` | Represents the remove operation latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_remove_operations_total` | Represents the remove operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_query_size_operation_latency_seconds` | Represents the query size operation latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_query_size_operations_total` | Represents the query size operation count of the DataStore. | counter | datastore |
| `windows_hyperv_datastore_set_operation_latency_seconds` | Represents the set operation latency in seconds of the DataStore. | gauge | datastore |
| `windows_hyperv_datastore_set_operations_total` | Represents the set operation count of the DataStore. | counter | datastore |
### Hyper-V Dynamic Memory Balancer
@@ -129,14 +129,14 @@ is skipped with a warning.
| Metric Name | Description | Type | Labels |
|-------------------------------------------------|------------------------------------------------------------------------|-------|--------------------|
| `windows_hyperv_host_logical_processor_count` | Number of logical processors on the host | gauge | None |
| `windows_hyperv_vm_processor_count` | Number of virtual processors assigned to the VM | gauge | `vm_id`, `vm` |
| `windows_hyperv_total_vm_processor_count` | Total number of virtual processors assigned to all VMs | gauge | None |
| `windows_hyperv_host_logical_processors` | Number of logical processors on the host | gauge | None |
| `windows_hyperv_vm_processors` | Number of virtual processors assigned to the VM | gauge | `vm_id`, `vm` |
| `windows_hyperv_assigned_vm_processors` | Total number of virtual processors assigned to all VMs | gauge | None |
The CPU allocation ratio can be computed in PromQL. Virtual cores per **logical** host core:
```
windows_hyperv_total_vm_processor_count / windows_hyperv_host_logical_processor_count
windows_hyperv_assigned_vm_processors / windows_hyperv_host_logical_processors
```
Where hyper-threading (SMT) is enabled, the host reports two logical cores per physical core.
@@ -147,8 +147,8 @@ Multiply by the number of threads per core to get the ratio per **physical** cor
| Name | Description | Type | Labels |
|----------------------------------------------------------------------|------------------------------------------------------------------------|---------|----------------|
| `windows_hyperv_hypervisor_logical_processor_time_total` | Time that processor spent in different modes (hypervisor, guest, idle) | counter | `core`,`state` |
| `windows_hyperv_hypervisor_logical_processor_total_run_time_total` | Time that processor spent | counter | `core` |
| `windows_hyperv_hypervisor_logical_processor_time_seconds_total` | Time that processor spent in different modes (hypervisor, guest, idle) | counter | `core`,`state` |
| `windows_hyperv_hypervisor_logical_processor_total_run_time_seconds_total` | Time that processor spent | counter | `core` |
| `windows_hyperv_hypervisor_logical_processor_context_switches_total` | The rate of virtual processor context switches on the processor. | counter | `core` |
### Hyper-V Hypervisor Root Partition
@@ -168,12 +168,12 @@ Multiply by the number of threads per core to get the ratio per **physical** cor
| `windows_hyperv_root_partition_io_tlb_flushes_total` | The number of flushes of I/O TLBs of the partition | counter | None |
| `windows_hyperv_root_partition_recommended_virtual_tlb_size` | The recommended number of pages to be deposited for the virtual TLB | gauge | None |
| `windows_hyperv_root_partition_skipped_timer_ticks_total` | The number of timer interrupts skipped for the partition | counter | None |
| `windows_hyperv_root_partition_1G_device_pages` | The number of 1G pages present in the device space of the partition | gauge | None |
| `windows_hyperv_root_partition_1G_gpa_pages` | The number of 1G pages present in the GPA space of the partition | gauge | None |
| `windows_hyperv_root_partition_2M_device_pages` | The number of 2M pages present in the device space of the partition | gauge | None |
| `windows_hyperv_root_partition_2M_gpa_pages` | The number of 2M pages present in the GPA space of the partition | gauge | None |
| `windows_hyperv_root_partition_4K_device_pages` | The number of 4K pages present in the device space of the partition | gauge | None |
| `windows_hyperv_root_partition_4K_gpa_pages` | The number of 4K pages present in the GPA space of the partition | gauge | None |
| `windows_hyperv_root_partition_1g_device_pages` | The number of 1G pages present in the device space of the partition | gauge | None |
| `windows_hyperv_root_partition_1g_gpa_pages` | The number of 1G pages present in the GPA space of the partition | gauge | None |
| `windows_hyperv_root_partition_2m_device_pages` | The number of 2M pages present in the device space of the partition | gauge | None |
| `windows_hyperv_root_partition_2m_gpa_pages` | The number of 2M pages present in the GPA space of the partition | gauge | None |
| `windows_hyperv_root_partition_4k_device_pages` | The number of 4K pages present in the device space of the partition | gauge | None |
| `windows_hyperv_root_partition_4k_gpa_pages` | The number of 4K pages present in the GPA space of the partition | gauge | None |
| `windows_hyperv_root_partition_virtual_tlb_flush_entries_total` | The number of flushes of the entire virtual TLB | counter | None |
| `windows_hyperv_root_partition_virtual_tlb_pages` | The number of pages used by the virtual TLB of the partition | gauge | None |
@@ -182,8 +182,8 @@ Multiply by the number of threads per core to get the ratio per **physical** cor
| Name | Description | Type | Labels |
|---------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------|---------|----------------|
| `windows_hyperv_hypervisor_root_virtual_processor_time_total` | Time in seconds that processor spent in different modes (`state`: `guest_run`, `hypervisor`, `remote`) | counter | `core`,`state` |
| `windows_hyperv_hypervisor_root_virtual_processor_total_run_time_total` | Time in seconds that processor spent running | counter | `core` |
| `windows_hyperv_hypervisor_root_virtual_processor_time_seconds_total` | Time in seconds that processor spent in different modes (`state`: `guest_run`, `hypervisor`, `remote`) | counter | `core`,`state` |
| `windows_hyperv_hypervisor_root_virtual_processor_total_run_time_seconds_total` | Time in seconds that processor spent running | counter | `core` |
| `windows_hyperv_hypervisor_root_virtual_processor_cpu_wait_seconds_total` | The time spent waiting for a virtual processor to be dispatched onto a logical processor. Divide its rate by the rate of `windows_hyperv_hypervisor_root_virtual_processor_dispatches_total` for the average wait per dispatch | counter | `core` |
| `windows_hyperv_hypervisor_root_virtual_processor_dispatches_total` | The number of times the virtual processor was dispatched onto a logical processor | counter | `core` |
@@ -277,12 +277,10 @@ Example alert:
| Name | Description | Type | Labels |
|--------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------|---------|-----------------------|
| `windows_hyperv_hypervisor_virtual_processor_mode_time_total` | Time in seconds that processor spent in different modes (`state`: `hypervisor`, `guest`, `remote`) | counter | `vm`, `core`, `state` |
| `windows_hyperv_hypervisor_virtual_processor_run_time_total` | Time in seconds that processor spent running | counter | `vm`, `core` |
| `windows_hyperv_hypervisor_virtual_processor_mode_time_seconds_total` | Time in seconds that processor spent in different modes (`state`: `hypervisor`, `guest`, `remote`) | counter | `vm`, `core`, `state` |
| `windows_hyperv_hypervisor_virtual_processor_run_time_seconds_total` | Time in seconds that processor spent running | counter | `vm`, `core` |
| `windows_hyperv_hypervisor_virtual_processor_cpu_wait_seconds_total` | The time spent waiting for a virtual processor to be dispatched onto a logical processor. Divide its rate by the rate of `windows_hyperv_hypervisor_virtual_processor_dispatches_total` for the average wait per dispatch | counter | `vm`, `core` |
| `windows_hyperv_hypervisor_virtual_processor_dispatches_total` | The number of times the virtual processor was dispatched onto a logical processor | counter | `vm`, `core` |
| `windows_hyperv_hypervisor_virtual_processor_time_total` | **Deprecated:** use `windows_hyperv_hypervisor_virtual_processor_mode_time_total`. Time in seconds that processor spent in different modes (`state`: `hypervisor`, `guest`, `remote`) | counter | `vm`, `core`, `state` |
| `windows_hyperv_hypervisor_virtual_processor_total_run_time_total` | **Deprecated:** use `windows_hyperv_hypervisor_virtual_processor_run_time_total`. Time in seconds that processor spent running | counter | `vm`, `core` |
### Hyper-V Virtual Network Adapter
@@ -299,7 +297,7 @@ Example alert:
| Name | Description | Type | Labels |
|-------------------------------------------------------|----------------------------------------------|---------|--------------------------------|
| `windows_hyperv_virtual_network_adapter_drop_reasons` | Hyper-V Virtual Network Adapter Drop Reasons | counter | `adapter`,`reason`,`direction` |
| `windows_hyperv_virtual_network_adapter_drop_reasons_total` | Number of packets dropped by a Hyper-V virtual network adapter, by drop reason and direction | counter | `adapter`,`reason`,`direction` |
### Hyper-V Virtual SMB
@@ -307,21 +305,21 @@ Example alert:
|-------------------------------------------------------|-----------------------------------------------------------------------------------|---------|------------|
| `windows_hyperv_virtual_smb_direct_mapped_sections` | Represents the number of direct-mapped sections in the virtual SMB` | gauge | `instance` |
| `windows_hyperv_virtual_smb_direct_mapped_pages` | Represents the number of direct-mapped pages in the virtual SMB` | gauge | `instance` |
| `windows_hyperv_virtual_smb_write_bytes_rdma` | Represents the number of bytes written per second using RDMA in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_write_bytes` | Represents the number of bytes written per second in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_read_bytes_rdma` | Represents the number of bytes read per second using RDMA in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_read_bytes` | Represents the number of bytes read per second in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_flush_requests` | Represents the number of flush requests per second in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_write_requests_rdma` | Represents the number of write requests per second using RDMA in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_write_requests` | Represents the number of write requests per second in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_read_requests_rdma` | Represents the number of read requests per second using RDMA in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_read_requests` | Represents the number of read requests per second in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_rdma_write_bytes_total` | Represents the total number of bytes written using RDMA in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_write_bytes_total` | Represents the total number of bytes written in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_rdma_read_bytes_total` | Represents the total number of bytes read using RDMA in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_read_bytes_total` | Represents the total number of bytes read in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_flush_requests_total` | Represents the total number of flush requests in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_rdma_write_requests_total` | Represents the total number of write requests using RDMA in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_write_requests_total` | Represents the total number of write requests in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_rdma_read_requests_total` | Represents the total number of read requests using RDMA in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_read_requests_total` | Represents the total number of read requests in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_current_pending_requests` | Represents the current number of pending requests in the virtual SMB` | gauge | `instance` |
| `windows_hyperv_virtual_smb_current_open_file_count` | Represents the current number of open files in the virtual SMB` | gauge | `instance` |
| `windows_hyperv_virtual_smb_tree_connect_count` | Represents the number of tree connects in the virtual SMB` | gauge | `instance` |
| `windows_hyperv_virtual_smb_requests` | Represents the number of requests per second in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_sent_bytes` | Represents the number of bytes sent per second in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_received_bytes` | Represents the number of bytes received per second in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_open_files` | Represents the current number of open files in the virtual SMB` | gauge | `instance` |
| `windows_hyperv_virtual_smb_tree_connects_total` | Represents the total number of tree connects in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_requests_total` | Represents the total number of requests in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_sent_bytes_total` | Represents the total number of bytes sent in the virtual SMB` | counter | `instance` |
| `windows_hyperv_virtual_smb_received_bytes_total` | Represents the total number of bytes received in the virtual SMB` | counter | `instance` |
### Hyper-V Virtual Switch
@@ -354,32 +352,23 @@ Example alert:
| Name | Description | Type | Labels |
|------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------|
| `windows_hyperv_virtual_storage_device_error_count_total` | Represents the total number of errors that have occurred on this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_queue_length` | **Deprecated:** use `rate(windows_hyperv_virtual_storage_device_io_latency_seconds_total)`. Cumulative queue length in 100ns ticks, see below. | gauge | `device` |
| `windows_hyperv_virtual_storage_device_bytes_read` | Represents the total number of bytes that have been read on this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_errors_total` | Represents the total number of errors that have occurred on this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_read_bytes_total` | Represents the total number of bytes that have been read on this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_operations_read_total` | Represents the total number of read operations that have occurred on this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_bytes_written` | Represents the total number of bytes that have been written on this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_written_bytes_total` | Represents the total number of bytes that have been written on this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_operations_written_total` | Represents the total number of write operations that have occurred on this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_io_latency_seconds_total` | Represents the total IO transfer latency for this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_latency_seconds` | **Deprecated:** use `windows_hyperv_virtual_storage_device_io_latency_seconds_total`. Cumulative IO transfer latency in 100ns ticks, see below. | gauge | `device` |
| `windows_hyperv_virtual_storage_device_throughput_total` | Represents the total number of IO transfers completed by this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_normalized_throughput_total` | Represents the total number of IO transfers completed by this virtual device, normalized to 8KB transfers. | counter | `device` |
| `windows_hyperv_virtual_storage_device_lower_io_latency_seconds_total` | Represents the total IO transfer latency on the underlying storage subsystem for this virtual device. | counter | `device` |
| `windows_hyperv_virtual_storage_device_lower_queue_length` | **Deprecated:** use `rate(windows_hyperv_virtual_storage_device_lower_io_latency_seconds_total)`. Cumulative queue length in 100ns ticks, see below. | gauge | `device` |
| `windows_hyperv_virtual_storage_device_lower_latency_seconds` | **Deprecated:** use `windows_hyperv_virtual_storage_device_lower_io_latency_seconds_total`. Cumulative IO transfer latency in 100ns ticks, see below. | gauge | `device` |
| `windows_hyperv_virtual_storage_device_io_quota_replenishment_total` | Represents the IO quota replenishment counter for this virtual device. Use `rate()` for the replenishment rate. | counter | `device` |
#### Deprecated latency and queue length metrics
#### Latency and queue length
The `Latency`, `Lower Latency`, `Queue Length` and `Lower Queue Length` performance counters
are averages that Windows computes from two samples. windows_exporter reads their raw values,
which only grow: the sum of all IO latencies in 100ns ticks. The raw queue length values are
the same as the raw latency values.
`windows_hyperv_virtual_storage_device_latency_seconds`, `windows_hyperv_virtual_storage_device_lower_latency_seconds`,
`windows_hyperv_virtual_storage_device_queue_length` and `windows_hyperv_virtual_storage_device_lower_queue_length`
keep exposing these raw values as gauges for compatibility. They are deprecated and will be removed in a future release.
Use the `*_io_latency_seconds_total` counters instead:
are averages that Windows computes from two samples. Their raw values only grow: the sum of
all IO latencies in 100ns ticks, and the raw queue length values are the same as the raw
latency values. windows_exporter publishes them as the `*_io_latency_seconds_total` counters:
```promql
# Average IO latency in seconds
@@ -491,7 +480,7 @@ Disks that could not be read, and stale data:
| Name | Description | Type | Labels |
|------------------------------------------------------|-------------------------------------------------------|-------|--------|
| `windows_hyperv_virtual_machine_health_total_count` | Represents the number of virtual machines with health | gauge | `state` |
| `windows_hyperv_virtual_machines` | Number of virtual machines by health state | gauge | `state` |
### Example metric
@@ -500,19 +489,19 @@ _This collector does not yet have explained examples, we would appreciate your h
## Useful queries
Percent of physical CPU resources used per VM (on instance "localhost")
```
sum by (vm) (rate(windows_hyperv_hypervisor_virtual_processor_run_time_total{instance="localhost"}[1m])) / ignoring(vm) group_left max (windows_cpu_logical_processor{instance="localhost"}) * 100
sum by (vm) (rate(windows_hyperv_hypervisor_virtual_processor_run_time_seconds_total{instance="localhost"}[1m])) / ignoring(vm) group_left max (windows_cpu_logical_processor{instance="localhost"}) * 100
```
Percent of physical CPU resources used by all VMs (on all monitored hosts)
```
(sum by (instance)(rate(windows_hyperv_hypervisor_virtual_processor_run_time_total{}[1m]))) / max by (instance)(windows_cpu_logical_processor{}) * 100
(sum by (instance)(rate(windows_hyperv_hypervisor_virtual_processor_run_time_seconds_total{}[1m]))) / max by (instance)(windows_cpu_logical_processor{}) * 100
```
Percent of physical CPU resources by the hosts themselves (on all monitored hosts)
```
(sum by (instance)(rate(windows_hyperv_hypervisor_root_virtual_processor_total_run_time_total{}[1m]))) / sum by (instance)(windows_cpu_logical_processor{}) * 100
(sum by (instance)(rate(windows_hyperv_hypervisor_root_virtual_processor_total_run_time_seconds_total{}[1m]))) / sum by (instance)(windows_cpu_logical_processor{}) * 100
```
Percent of physical CPU resources by the hypervisor (on all monitored hosts)
```
(sum by (instance)(rate(windows_hyperv_hypervisor_logical_processor_time_total{state="hypervisor"}[1m]))) / sum by (instance)(windows_cpu_logical_processor{}) * 100
(sum by (instance)(rate(windows_hyperv_hypervisor_logical_processor_time_seconds_total{state="hypervisor"}[1m]))) / sum by (instance)(windows_cpu_logical_processor{}) * 100
```
## Alerting examples
docs/collector.iis.md
+10 -10
View File
@@ -55,7 +55,7 @@ See [#2698](https://github.com/prometheus-community/windows_exporter/issues/2698
| `windows_iis_current_connections` | The number of active connections to the web service | gauge | `site` |
| `windows_iis_current_isapi_extension_requests` | The number of [ISAPI extension](https://docs.microsoft.com/en-us/previous-versions/iis/6.0-sdk/ms525172(v=vs.90)) requests that are being processed simultaneously by the web service | gauge | `site` |
| `windows_iis_current_non_anonymous_users` | The number of users who currently have a nonanonymous request pending with the web service | gauge | `site` |
| `windows_iis_service_uptime` | The uptime for the web service or a site (seconds) | gauge | `site` |
| `windows_iis_service_uptime_seconds` | The uptime for the web service or a site (seconds) | gauge | `site` |
| `windows_iis_received_bytes_total` | The total bytes of data that have been received by the web service since the service started | counter | `site` |
| `windows_iis_sent_bytes_total` | The number of data bytes that have been sent by the web service since the service started | counter | `site` |
| `windows_iis_anonymous_users_total` | The number of users who have established an anonymous request since the web service started | counter | `site` |
@@ -65,7 +65,7 @@ See [#2698](https://github.com/prometheus-community/windows_exporter/issues/2698
| `windows_iis_requests_total` | The number of requests that have been made since the web service was started | counter | `site`, `method` |
| `windows_iis_files_received_total` | The total number of files that have been received by the FTP service since the service started | counter | `site` |
| `windows_iis_files_sent_total` | The total number of files that have been sent by the FTP service since the service started | counter | `site` |
| `windows_iis_ipapi_extension_requests_total` | The number of ISAPI extension requests that have been made since the web service started | counter | `site` |
| `windows_iis_isapi_extension_requests_total` | The number of ISAPI extension requests that have been made since the web service started | counter | `site` |
| `windows_iis_locked_errors_total` | The number of requests that have been made since the service started that could not be satisfied by the server because the requested document was locked. Usually reported as HTTP error 423 | counter | `site` |
| `windows_iis_logon_attempts_total` | The number of attempts to log on to the web service that have occurred since the service started | counter | `site` |
| `windows_iis_non_anonymous_users_total` | The number of users who have made nonanonymous requests to the web service since the service started | counter | `site` |
@@ -77,16 +77,16 @@ See [#2698](https://github.com/prometheus-community/windows_exporter/issues/2698
| `windows_iis_maximum_worker_processes` | The maximum number of worker processes that have been created for the application pool since Windows Process Activation Service (WAS) started | gauge | `app` |
| `windows_iis_recent_worker_process_failures` | The number of times that worker processes for the application pool failed during the rapid-fail protection interval | gauge | `app` |
| `windows_iis_time_since_last_worker_process_failure_seconds` | The length of time, in seconds, since the last worker process failure occurred for the application pool. Equals the pool uptime if no worker process failed | gauge | `app` |
| `windows_iis_total_application_pool_recycles` | The number of times that the application pool has been recycled since Windows Process Activation Service (WAS) started | counter | `app` |
| `windows_iis_application_pool_recycles_total` | The number of times that the application pool has been recycled since Windows Process Activation Service (WAS) started | counter | `app` |
| `windows_iis_total_application_pool_uptime_seconds` | The time, in seconds, since the application pool was first started after the Windows Process Activation Service (WAS) started | gauge | `app` |
| `windows_iis_total_worker_processes_created` | The number of worker processes created for the application pool since Windows Process Activation Service (WAS) started | counter | `app` |
| `windows_iis_total_worker_process_failures` | The number of times that worker processes have crashed since the application pool was started | counter | `app` |
| `windows_iis_total_worker_process_ping_failures` | The number of times that Windows Process Activation Service (WAS) did not receive a response to ping messages sent to a worker process | counter | `app` |
| `windows_iis_total_worker_process_shutdown_failures` | The number of times that Windows Process Activation Service (WAS) failed to shut down a worker process | counter | `app` |
| `windows_iis_total_worker_process_startup_failures` | The number of times that Windows Process Activation Service (WAS) failed to start a worker process | counter | `app` |
| `windows_iis_worker_processes_created_total` | The number of worker processes created for the application pool since Windows Process Activation Service (WAS) started | counter | `app` |
| `windows_iis_worker_process_failures_total` | The number of times that worker processes have crashed since the application pool was started | counter | `app` |
| `windows_iis_worker_process_ping_failures_total` | The number of times that Windows Process Activation Service (WAS) did not receive a response to ping messages sent to a worker process | counter | `app` |
| `windows_iis_worker_process_shutdown_failures_total` | The number of times that Windows Process Activation Service (WAS) failed to shut down a worker process | counter | `app` |
| `windows_iis_worker_process_startup_failures_total` | The number of times that Windows Process Activation Service (WAS) failed to start a worker process | counter | `app` |
| `windows_iis_worker_cache_active_flushed_entries` | Number of file handles cached that will be closed when all current transfers complete | gauge | `app`, `pid` |
| `windows_iis_worker_file_cache_memory_bytes` | Current number of bytes used by file cache | gauge | `app`, `pid` |
| `windows_iis_worker_file_cache_max_memory_bytes` | Maximum number of bytes used by file cache | counter | `app`, `pid` |
| `windows_iis_worker_file_cache_max_memory_bytes` | Maximum number of bytes used by file cache | gauge | `app`, `pid` |
| `windows_iis_worker_file_cache_flushes_total` | Total number of file cache flushes (since service startup) | counter | `app`, `pid` |
| `windows_iis_worker_file_cache_queries_total` | Total file cache queries (hits + misses) | counter | `app`, `pid` |
| `windows_iis_worker_file_cache_hits_total` | Total number of successful lookups in the user-mode file cache | counter | `app`, `pid` |
@@ -123,7 +123,7 @@ See [#2698](https://github.com/prometheus-community/windows_exporter/issues/2698
| `windows_iis_worker_websocket_connection_rejected_total` | Total number of WebSocket connections rejected since the worker process started | counter | `app`, `pid` |
| `windows_iis_server_cache_active_flushed_entries` | Number of file handles cached that will be closed when all current transfers complete | gauge | None |
| `windows_iis_server_file_cache_memory_bytes` | Current number of bytes used by file cache | gauge | None |
| `windows_iis_server_file_cache_max_memory_bytes` | Maximum number of bytes used by file cache | counter | None |
| `windows_iis_server_file_cache_max_memory_bytes` | Maximum number of bytes used by file cache | gauge | None |
| `windows_iis_server_file_cache_flushes_total` | Total number of file cache flushes (since service startup) | counter | None |
| `windows_iis_server_file_cache_queries_total` | Total number of file cache queries (hits + misses) | counter | None |
| `windows_iis_server_file_cache_hits_total` | Total number of successful lookups in the file cache | counter | None |
docs/collector.mscluster.md
+36 -38
View File
@@ -30,27 +30,27 @@ Matching is case-sensitive. All of these subcollectors are enabled by default.
| Name | Description | Type | Labels |
|-------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------|--------|
| `windows_mscluster_cluster_add_evict_delay` | Provides access to the cluster's AddEvictDelay property, which is the number a seconds that a new node is delayed after an eviction of another node. | gauge | `name` |
| `windows_mscluster_cluster_add_evict_delay_seconds` | Provides access to the cluster's AddEvictDelay property, which is the number of seconds that a new node is delayed after an eviction of another node. | gauge | `name` |
| `windows_mscluster_cluster_admin_access_point` | The type of the cluster administrative access point. | gauge | `name` |
| `windows_mscluster_cluster_auto_assign_node_site` | Determines whether or not the cluster will attempt to automatically assign nodes to sites based on networks and Active Directory Site information. | gauge | `name` |
| `windows_mscluster_cluster_auto_balancer_level` | Determines the level of aggressiveness of AutoBalancer. | gauge | `name` |
| `windows_mscluster_cluster_auto_balancer_mode` | Determines whether or not the auto balancer is enabled. | gauge | `name` |
| `windows_mscluster_cluster_backup_in_progress` | Indicates whether a backup is in progress. | gauge | `name` |
| `windows_mscluster_cluster_block_cache_size` | CSV BlockCache Size in MB. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_hang_timeout` | Controls how long the cluster network driver waits between Failover Cluster Service heartbeats before it determines that the Failover Cluster Service has stopped responding. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_regroup_opening_timeout` | Controls how long a node will wait on other nodes in the opening stage before deciding that they failed. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_regroup_pruning_timeout` | Controls how long the membership leader will wait to reach full connectivity between cluster nodes. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_regroup_stage_timeout` | Controls how long a node will wait on other nodes in a membership stage before deciding that they failed. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_regroup_tick_in_milliseconds` | Controls how frequently the membership algorithm is sending periodic membership messages. | gauge | `name` |
| `windows_mscluster_cluster_block_cache_size_bytes` | CSV BlockCache size in bytes. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_hang_timeout_seconds` | Controls how long, in seconds, the cluster network driver waits between Failover Cluster Service heartbeats before it determines that the Failover Cluster Service has stopped responding. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_regroup_opening_timeout_seconds` | Controls how long, in seconds, a node will wait on other nodes in the opening stage before deciding that they failed. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_regroup_pruning_timeout_seconds` | Controls how long, in seconds, the membership leader will wait to reach full connectivity between cluster nodes. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_regroup_stage_timeout_seconds` | Controls how long, in seconds, a node will wait on other nodes in a membership stage before deciding that they failed. | gauge | `name` |
| `windows_mscluster_cluster_clus_svc_regroup_tick_seconds` | Controls how frequently, in seconds, the membership algorithm is sending periodic membership messages. | gauge | `name` |
| `windows_mscluster_cluster_cluster_enforced_anti_affinity` | Enables or disables hard enforcement of group anti-affinity classes. | gauge | `name` |
| `windows_mscluster_cluster_cluster_functional_level` | The functional level the cluster is currently running in. | gauge | `name` |
| `windows_mscluster_cluster_cluster_group_wait_delay` | Maximum time in seconds that a group waits for its preferred node to come online during cluster startup before coming online on a different node. | gauge | `name` |
| `windows_mscluster_cluster_cluster_group_wait_delay_seconds` | Maximum time in seconds that a group waits for its preferred node to come online during cluster startup before coming online on a different node. | gauge | `name` |
| `windows_mscluster_cluster_cluster_log_level` | Controls the level of cluster logging. | gauge | `name` |
| `windows_mscluster_cluster_cluster_log_size` | Controls the maximum size of the cluster log files on each of the nodes. | gauge | `name` |
| `windows_mscluster_cluster_cluster_log_size_bytes` | Controls the maximum size, in bytes, of the cluster log files on each of the nodes. | gauge | `name` |
| `windows_mscluster_cluster_cluster_upgrade_version` | Specifies the upgrade version the cluster is currently running in. | gauge | `name` |
| `windows_mscluster_cluster_cross_site_delay` | Controls how long the cluster network driver waits in milliseconds between sending Cluster Service heartbeats across sites. | gauge | `name` |
| `windows_mscluster_cluster_cross_site_delay_seconds` | Controls how long the cluster network driver waits in seconds between sending Cluster Service heartbeats across sites. | gauge | `name` |
| `windows_mscluster_cluster_cross_site_threshold` | Controls how many Cluster Service heartbeats can be missed across sites before it determines that Cluster Service has stopped responding. | gauge | `name` |
| `windows_mscluster_cluster_cross_subnet_delay` | Controls how long the cluster network driver waits in milliseconds between sending Cluster Service heartbeats across subnets. | gauge | `name` |
| `windows_mscluster_cluster_cross_subnet_delay_seconds` | Controls how long the cluster network driver waits in seconds between sending Cluster Service heartbeats across subnets. | gauge | `name` |
| `windows_mscluster_cluster_cross_subnet_threshold` | Controls how many Cluster Service heartbeats can be missed across subnets before it determines that Cluster Service has stopped responding. | gauge | `name` |
| `windows_mscluster_cluster_csv_balancer` | Whether automatic balancing for CSV is enabled. | gauge | `name` |
| `windows_mscluster_cluster_database_read_write_mode` | Sets the database read and write mode. | gauge | `name` |
@@ -64,8 +64,8 @@ Matching is case-sensitive. All of these subcollectors are enabled by default.
| `windows_mscluster_cluster_enable_shared_volumes` | Enables or disables cluster shared volumes on this cluster. | gauge | `name` |
| `windows_mscluster_cluster_fix_quorum` | Provides access to the cluster's FixQuorum property, which specifies if the cluster is in a fix quorum state. | gauge | `name` |
| `windows_mscluster_cluster_grace_period_enabled` | Whether the node grace period feature of this cluster is enabled. | gauge | `name` |
| `windows_mscluster_cluster_grace_period_timeout` | The grace period timeout in milliseconds. | gauge | `name` |
| `windows_mscluster_cluster_group_dependency_timeout` | The timeout after which a group will be brought online despite unsatisfied dependencies | gauge | `name` |
| `windows_mscluster_cluster_grace_period_timeout_seconds` | The grace period timeout in seconds. | gauge | `name` |
| `windows_mscluster_cluster_group_dependency_timeout_seconds` | The timeout in seconds after which a group will be brought online despite unsatisfied dependencies | gauge | `name` |
| `windows_mscluster_cluster_hang_recovery_action` | Controls the action to take if the user-mode processes have stopped responding. | gauge | `name` |
| `windows_mscluster_cluster_ignore_persistent_state_on_startup` | Provides access to the cluster's IgnorePersistentStateOnStartup property, which specifies whether the cluster will bring online groups that were online when the cluster was shut down. | gauge | `name` |
| `windows_mscluster_cluster_log_resource_controls` | Controls the logging of resource controls. | gauge | `name` |
@@ -78,35 +78,33 @@ Matching is case-sensitive. All of these subcollectors are enabled by default.
| `windows_mscluster_cluster_placement_options` | Various option flags to modify default placement behavior. | gauge | `name` |
| `windows_mscluster_cluster_plumb_all_cross_subnet_routes` | Plumbs all possible cross subnet routes to all nodes. | gauge | `name` |
| `windows_mscluster_cluster_prevent_quorum` | Whether the cluster will ignore group persistent state on startup. | gauge | `name` |
| `windows_mscluster_cluster_quarantine_duration` | The quarantine period timeout in milliseconds. | gauge | `name` |
| `windows_mscluster_cluster_quarantine_duration_seconds` | The quarantine period timeout in seconds. | gauge | `name` |
| `windows_mscluster_cluster_quarantine_threshold` | Number of node failures before it will be quarantined. | gauge | `name` |
| `windows_mscluster_cluster_quorum_arbitration_time_max` | Controls the maximum time necessary to decide the Quorum owner node. | gauge | `name` |
| `windows_mscluster_cluster_quorum_arbitration_time_min` | Controls the minimum time necessary to decide the Quorum owner node. | gauge | `name` |
| `windows_mscluster_cluster_quorum_log_file_size` | This property is obsolete. | gauge | `name` |
| `windows_mscluster_cluster_quorum_arbitration_time_max_seconds` | Controls the maximum time, in seconds, necessary to decide the Quorum owner node. | gauge | `name` |
| `windows_mscluster_cluster_quorum_arbitration_time_min_seconds` | Controls the minimum time, in seconds, necessary to decide the Quorum owner node. | gauge | `name` |
| `windows_mscluster_cluster_quorum_type_value` | Get the current quorum type value. -1: Unknown; 1: Node; 2: FileShareWitness; 3: Storage; 4: None | gauge | `name` |
| `windows_mscluster_cluster_request_reply_timeout` | Controls the request reply time-out period. | gauge | `name` |
| `windows_mscluster_cluster_resiliency_default_period` | The default resiliency period, in seconds, for the cluster. | gauge | `name` |
| `windows_mscluster_cluster_request_reply_timeout_seconds` | Controls the request reply time-out period in seconds. | gauge | `name` |
| `windows_mscluster_cluster_resiliency_default_period_seconds` | The default resiliency period, in seconds, for the cluster. | gauge | `name` |
| `windows_mscluster_cluster_resiliency_level` | The resiliency level for the cluster. | gauge | `name` |
| `windows_mscluster_cluster_resource_dll_deadlock_period` | This property is obsolete. | gauge | `name` |
| `windows_mscluster_cluster_root_memory_reserved` | Controls the amount of memory reserved for the parent partition on all cluster nodes. | gauge | `name` |
| `windows_mscluster_cluster_root_memory_reserved_bytes` | Controls the amount of memory, in bytes, reserved for the parent partition on all cluster nodes. | gauge | `name` |
| `windows_mscluster_cluster_route_history_length` | The history length for routes to help finding network issues. | gauge | `name` |
| `windows_mscluster_cluster_s2d_bus_types` | Bus types for storage spaces direct. | gauge | `name` |
| `windows_mscluster_cluster_s2d_cache_desired_state` | Desired state of the storage spaces direct cache. | gauge | `name` |
| `windows_mscluster_cluster_s2d_cache_flash_reserve_percent` | Percentage of allocated flash space to utilize when caching. | gauge | `name` |
| `windows_mscluster_cluster_s2d_cache_page_size_k_bytes` | Page size in KB used by S2D cache. | gauge | `name` |
| `windows_mscluster_cluster_s2d_cache_flash_reserve_ratio` | Ratio (0-1) of allocated flash space to utilize when caching. | gauge | `name` |
| `windows_mscluster_cluster_s2d_cache_page_size_bytes` | Page size in bytes used by S2D cache. | gauge | `name` |
| `windows_mscluster_cluster_s2d_enabled` | Whether direct attached storage (DAS) is enabled. | gauge | `name` |
| `windows_mscluster_cluster_s2dio_latency_threshold` | The I/O latency threshold for storage spaces direct. | gauge | `name` |
| `windows_mscluster_cluster_s2dio_latency_threshold_seconds` | The I/O latency threshold in seconds for storage spaces direct. | gauge | `name` |
| `windows_mscluster_cluster_s2d_optimizations` | Optimization flags for storage spaces direct. | gauge | `name` |
| `windows_mscluster_cluster_same_subnet_delay` | Controls how long the cluster network driver waits in milliseconds between sending Cluster Service heartbeats on the same subnet. | gauge | `name` |
| `windows_mscluster_cluster_same_subnet_delay_seconds` | Controls how long the cluster network driver waits in seconds between sending Cluster Service heartbeats on the same subnet. | gauge | `name` |
| `windows_mscluster_cluster_same_subnet_threshold` | Controls how many Cluster Service heartbeats can be missed on the same subnet before it determines that Cluster Service has stopped responding. | gauge | `name` |
| `windows_mscluster_cluster_security_level` | Controls the level of security that should apply to intracluster messages. 0: Clear Text; 1: Sign; 2: Encrypt | gauge | `name` |
| `windows_mscluster_cluster_security_level_for_storage` | (SecurityLevelForStorage) | gauge | `name` |
| `windows_mscluster_cluster_shared_volume_vss_writer_operation_timeout` | CSV VSS Writer operation timeout in seconds. | gauge | `name` |
| `windows_mscluster_cluster_shutdown_timeout_in_minutes` | The maximum time in minutes allowed for cluster resources to come offline during cluster service shutdown. | gauge | `name` |
| `windows_mscluster_cluster_shared_volume_vss_writer_operation_timeout_seconds` | CSV VSS Writer operation timeout in seconds. | gauge | `name` |
| `windows_mscluster_cluster_shutdown_timeout_seconds` | The maximum time in seconds allowed for cluster resources to come offline during cluster service shutdown. | gauge | `name` |
| `windows_mscluster_cluster_use_client_access_networks_for_shared_volumes` | Whether the use of client access networks for cluster shared volumes feature of this cluster is enabled. 0: Disabled; 1: Enabled; 2: Auto | gauge | `name` |
| `windows_mscluster_cluster_witness_database_write_timeout` | Controls the maximum time in seconds that a cluster database write to a witness can take before the write is abandoned. | gauge | `name` |
| `windows_mscluster_cluster_witness_database_write_timeout_seconds` | Controls the maximum time in seconds that a cluster database write to a witness can take before the write is abandoned. | gauge | `name` |
| `windows_mscluster_cluster_witness_dynamic_weight` | The weight of the configured witness. | gauge | `name` |
| `windows_mscluster_cluster_witness_restart_interval` | Controls the witness restart interval. | gauge | `name` |
| `windows_mscluster_cluster_witness_restart_interval_seconds` | Controls the witness restart interval in seconds. | gauge | `name` |
### Network
@@ -142,20 +140,20 @@ Matching is case-sensitive. All of these subcollectors are enabled by default.
| Name | Description | Type | Labels |
|---------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------|--------------------------------------------|
| `windows_mscluster_resource_characteristics` | Provides the characteristics of the object. The cluster defines characteristics only for resources. For a description of these characteristics, see [CLUSCTL_RESOURCE_GET_CHARACTERISTICS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-resource-get-characteristics). | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_deadlock_timeout` | Indicates the length of time to wait, in milliseconds, before declaring a deadlock in any call into a resource. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_deadlock_timeout_seconds` | Indicates the length of time to wait, in seconds, before declaring a deadlock in any call into a resource. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_embedded_failure_action` | The time, in milliseconds, that a resource should remain in a failed state before the Cluster service attempts to restart it. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_flags` | Provides access to the flags set for the object. The cluster defines flags only for resources. For a description of these flags, see [CLUSCTL_RESOURCE_GET_FLAGS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-resource-get-flags). | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_is_alive_poll_interval` | Provides access to the resource's IsAlivePollInterval property, which is the recommended interval in milliseconds at which the Cluster Service should poll the resource to determine whether it is operational. If the property is set to 0xFFFFFFFF, the Cluster Service uses the IsAlivePollInterval property for the resource type associated with the resource. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_looks_alive_poll_interval` | Provides access to the resource's LooksAlivePollInterval property, which is the recommended interval in milliseconds at which the Cluster Service should poll the resource to determine whether it appears operational. If the property is set to 0xFFFFFFFF, the Cluster Service uses the LooksAlivePollInterval property for the resource type associated with the resource. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_is_alive_poll_interval_seconds` | Provides access to the resource's IsAlivePollInterval property, which is the recommended interval in seconds at which the Cluster Service should poll the resource to determine whether it is operational. The series is omitted while the resource uses the interval of its resource type (0xFFFFFFFF). | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_looks_alive_poll_interval_seconds` | Provides access to the resource's LooksAlivePollInterval property, which is the recommended interval in seconds at which the Cluster Service should poll the resource to determine whether it appears operational. The series is omitted while the resource uses the interval of its resource type (0xFFFFFFFF). | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_monitor_process_id` | Provides the process ID of the resource host service that is currently hosting the resource. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_owner_node` | The node hosting the resource. 0: Not hosted; 1: Hosted | gauge | `type`, `owner_group`, `node_name`, `name` |
| `windows_mscluster_resource_pending_timeout` | Provides access to the resource's PendingTimeout property. If a resource cannot be brought online or taken offline in the number of milliseconds specified by the PendingTimeout property, the resource is forcibly terminated. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_pending_timeout_seconds` | Provides access to the resource's PendingTimeout property. If a resource cannot be brought online or taken offline in the number of seconds specified by the PendingTimeout property, the resource is forcibly terminated. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_resource_class` | Gets or sets the resource class of a resource. 0: Unknown; 1: Storage; 2: Network; 32768: Unknown | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_restart_action` | Provides access to the resource's RestartAction property, which is the action to be taken by the Cluster Service if the resource fails. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_restart_delay` | Indicates the time delay before a failed resource is restarted. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_restart_period` | Provides access to the resource's RestartPeriod property, which is interval of time, in milliseconds, during which a specified number of restart attempts can be made on a nonresponsive resource. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_restart_delay_seconds` | Indicates the time delay in seconds before a failed resource is restarted. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_restart_period_seconds` | Provides access to the resource's RestartPeriod property, which is interval of time, in seconds, during which a specified number of restart attempts can be made on a nonresponsive resource. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_restart_threshold` | Provides access to the resource's RestartThreshold property which is the maximum number of restart attempts that can be made on a resource within an interval defined by the RestartPeriod property before the Cluster Service initiates the action specified by the RestartAction property. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_retry_period_on_failure` | Provides access to the resource's RetryPeriodOnFailure property, which is the interval of time (in milliseconds) that a resource should remain in a failed state before the Cluster service attempts to restart it. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_retry_period_on_failure_seconds` | Provides access to the resource's RetryPeriodOnFailure property, which is the interval of time (in seconds) that a resource should remain in a failed state before the Cluster service attempts to restart it. | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_state` | The current state of the resource. -1: Unknown; 0: Inherited; 1: Initializing; 2: Online; 3: Offline; 4: Failed; 128: Pending; 129: Online Pending; 130: Offline Pending | gauge | `type`, `owner_group`, `name` |
| `windows_mscluster_resource_subclass` | Provides the list of references to nodes that can be the owner of this resource. | gauge | `type`, `owner_group`, `name` |
@@ -169,13 +167,13 @@ Matching is case-sensitive. All of these subcollectors are enabled by default.
| `windows_mscluster_resourcegroup_default_owner` | Number of the last node the resource group was activated on or explicitly moved to. | gauge | `name` |
| `windows_mscluster_resourcegroup_failback_window_end` | The FailbackWindowEnd property provides the latest time that the group can be moved back to the node identified as its preferred node. | gauge | `name` |
| `windows_mscluster_resourcegroup_failback_window_start` | The FailbackWindowStart property provides the earliest time (that is, local time as kept by the cluster) that the group can be moved back to the node identified as its preferred node. | gauge | `name` |
| `windows_mscluster_resourcegroup_failover_period` | The FailoverPeriod property specifies a number of hours during which a maximum number of failover attempts, specified by the FailoverThreshold property, can occur. | gauge | `name` |
| `windows_mscluster_resourcegroup_failover_period_seconds` | The FailoverPeriod property specifies a number of seconds during which a maximum number of failover attempts, specified by the FailoverThreshold property, can occur. Windows stores it in hours. | gauge | `name` |
| `windows_mscluster_resourcegroup_failover_threshold` | The FailoverThreshold property specifies the maximum number of failover attempts. | gauge | `name` |
| `windows_mscluster_resourcegroup_flags` | Provides access to the flags set for the group. The cluster defines flags only for resources. For a description of these flags, see [CLUSCTL_RESOURCE_GET_FLAGS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-resource-get-flags). | gauge | `name` |
| `windows_mscluster_resourcegroup_group_type` | The Type of the resource group. | gauge | `name` |
| `windows_mscluster_resourcegroup_owner_node` | The node hosting the resource group. 0: Not hosted; 1: Hosted | gauge | `node_name`, `name` |
| `windows_mscluster_resourcegroup_priority` | Priority value of the resource group | gauge | `name` |
| `windows_mscluster_resourcegroup_resiliency_period` | The resiliency period for this group, in seconds. | gauge | `name` |
| `windows_mscluster_resourcegroup_resiliency_period_seconds` | The resiliency period for this group, in seconds. | gauge | `name` |
| `windows_mscluster_resourcegroup_state` | The current state of the resource group. -1: Unknown; 0: Online; 1: Offline; 2: Failed; 3: Partial Online; 4: Pending | gauge | `name` |
### Shared Volumes
docs/collector.msmq.md
+2 -2
View File
@@ -14,8 +14,8 @@ The msmq collector exposes metrics about the queues on a MSMQ server
| Name | Description | Type | Labels |
|------------------------------------------|---------------------------------|-------|--------|
| `windows_msmq_bytes_in_journal_queue` | Size of queue journal in bytes | gauge | `name` |
| `windows_msmq_bytes_in_queue` | Size of queue in bytes | gauge | `name` |
| `windows_msmq_journal_queue_bytes` | Size of queue journal in bytes | gauge | `name` |
| `windows_msmq_queue_bytes` | Size of queue in bytes | gauge | `name` |
| `windows_msmq_messages_in_journal_queue` | Count messages in queue journal | gauge | `name` |
| `windows_msmq_messages_in_queue` | Count messages in queue | gauge | `name` |
docs/collector.mssql.md
+133 -134
View File
@@ -21,164 +21,164 @@ Comma-separated list of MSSQL WMI classes to use. Supported values are `accessme
|--------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-------------------------------|
| `windows_mssql_collector_duration_seconds` | The time taken for each sub-collector to return | gauge | `collector`, `mssql_instance` |
| `windows_mssql_collector_success` | 1 if sub-collector succeeded, 0 otherwise | gauge | `collector`, `mssql_instance` |
| `windows_mssql_accessmethods_au_batch_cleanups` | The total number of batches that were completed successfully by the background task that cleans up deferred dropped allocation units | counter | `mssql_instance` |
| `windows_mssql_accessmethods_au_cleanups` | The total number of allocation units that were successfully dropped the background task that cleans up deferred dropped allocation units. Each allocation unit drop requires multiple batches | counter | `mssql_instance` |
| `windows_mssql_accessmethods_by_reference_lob_creates` | The total count of large object (lob) values that were passed by reference. By-reference lobs are used in certain bulk operations to avoid the cost of passing them by value | counter | `mssql_instance` |
| `windows_mssql_accessmethods_by_reference_lob_uses` | The total count of by-reference lob values that were used. By-reference lobs are used in certain bulk operations to avoid the cost of passing them by-value | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_read_aheads` | The total count of lob pages on which readahead was issued | counter | `mssql_instance` |
| `windows_mssql_accessmethods_column_value_pulls` | The total count of column values that were pulled in-row from off-row | counter | `mssql_instance` |
| `windows_mssql_accessmethods_column_value_pushes` | The total count of column values that were pushed from in-row to off-row | counter | `mssql_instance` |
| `windows_mssql_accessmethods_au_batch_cleanups_total` | The total number of batches that were completed successfully by the background task that cleans up deferred dropped allocation units | counter | `mssql_instance` |
| `windows_mssql_accessmethods_au_cleanups_total` | The total number of allocation units that were successfully dropped the background task that cleans up deferred dropped allocation units. Each allocation unit drop requires multiple batches | counter | `mssql_instance` |
| `windows_mssql_accessmethods_by_reference_lob_creates_total` | The total count of large object (lob) values that were passed by reference. By-reference lobs are used in certain bulk operations to avoid the cost of passing them by value | counter | `mssql_instance` |
| `windows_mssql_accessmethods_by_reference_lob_uses_total` | The total count of by-reference lob values that were used. By-reference lobs are used in certain bulk operations to avoid the cost of passing them by-value | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_read_aheads_total` | The total count of lob pages on which readahead was issued | counter | `mssql_instance` |
| `windows_mssql_accessmethods_column_value_pulls_total` | The total count of column values that were pulled in-row from off-row | counter | `mssql_instance` |
| `windows_mssql_accessmethods_column_value_pushes_total` | The total count of column values that were pushed from in-row to off-row | counter | `mssql_instance` |
| `windows_mssql_accessmethods_deferred_dropped_aus` | The total number of allocation units waiting to be dropped by the background task that cleans up deferred dropped allocation units | gauge | `mssql_instance` |
| `windows_mssql_accessmethods_deferred_dropped_rowsets` | The number of rowsets created as a result of aborted online index build operations that are waiting to be dropped by the background task that cleans up deferred dropped rowsets | gauge | `mssql_instance` |
| `windows_mssql_accessmethods_dropped_rowset_cleanups` | The number of rowsets per second created as a result of aborted online index build operations that were successfully dropped by the background task that cleans up deferred dropped rowsets | counter | `mssql_instance` |
| `windows_mssql_accessmethods_dropped_rowset_skips` | The number of rowsets per second created as a result of aborted online index build operations that were skipped by the background task that cleans up deferred dropped rowsets created | counter | `mssql_instance` |
| `windows_mssql_accessmethods_extent_deallocations` | Number of extents deallocated per second in all databases in this instance of SQL Server | counter | `mssql_instance` |
| `windows_mssql_accessmethods_extent_allocations` | Number of extents allocated per second in all databases in this instance of SQL Server | counter | `mssql_instance` |
| `windows_mssql_accessmethods_au_batch_cleanup_failures` | The number of batches per second that failed and required retry, by the background task that cleans up deferred dropped allocation units. Failure could be due to lack of memory or disk space, hardware failure and other reasons | counter | `mssql_instance` |
| `windows_mssql_accessmethods_leaf_page_cookie_failures` | The number of times that a leaf page cookie could not be used during an index search since changes happened on the leaf page. The cookie is used to speed up index search | counter | `mssql_instance` |
| `windows_mssql_accessmethods_tree_page_cookie_failures` | The number of times that a tree page cookie could not be used during an index search since changes happened on the parent pages of those tree pages. The cookie is used to speed up index search | counter | `mssql_instance` |
| `windows_mssql_accessmethods_forwarded_records` | Number of records per second fetched through forwarded record pointers | counter | `mssql_instance` |
| `windows_mssql_accessmethods_free_space_page_fetches` | Number of pages fetched per second by free space scans. These scans search for free space within pages already allocated to an allocation unit, to satisfy requests to insert or modify record fragments | counter | `mssql_instance` |
| `windows_mssql_accessmethods_free_space_scans` | Number of scans per second that were initiated to search for free space within pages already allocated to an allocation unit to insert or modify record fragment. Each scan may find multiple pages | counter | `mssql_instance` |
| `windows_mssql_accessmethods_full_scans` | Number of unrestricted full scans per second. These can be either base-table or full-index scans | counter | `mssql_instance` |
| `windows_mssql_accessmethods_index_searches` | Number of index searches per second. These are used to start a range scan, reposition a range scan, revalidate a scan point, fetch a single index record, and search down the index to locate where to insert a new row | counter | `mssql_instance` |
| `windows_mssql_accessmethods_insysxact_waits` | Number of times a reader needs to wait for a page because the InSysXact bit is set | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_handle_creates` | Count of temporary lobs created | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_handle_destroys` | Count of temporary lobs destroyed | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_ss_provider_creates` | Count of LOB Storage Service Providers (LobSSP) created. One worktable created per LobSSP | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_ss_provider_destroys` | Count of LobSSP destroyed | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_ss_provider_truncations` | Count of LobSSP truncated | counter | `mssql_instance` |
| `windows_mssql_accessmethods_mixed_page_allocations` | Number of pages allocated per second from mixed extents. These could be used for storing the IAM pages and the first eight pages that are allocated to an allocation unit | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_compression_attempts` | Number of pages evaluated for page-level compression. Includes pages that were not compressed because significant savings could be achieved. Includes all objects in the instance of SQL Server | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_deallocations` | Number of pages deallocated per second in all databases in this instance of SQL Server. These include pages from mixed extents and uniform extents | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_allocations` | Number of pages allocated per second in all databases in this instance of SQL Server. These include pages allocations from both mixed extents and uniform extents | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_compressions` | Number of data pages that are compressed by using PAGE compression. Includes all objects in the instance of SQL Server | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_splits` | Number of page splits per second that occur as the result of overflowing index pages | counter | `mssql_instance` |
| `windows_mssql_accessmethods_probe_scans` | Number of probe scans per second that are used to find at most one single qualified row in an index or base table directly | counter | `mssql_instance` |
| `windows_mssql_accessmethods_range_scans` | Number of qualified range scans through indices per second | counter | `mssql_instance` |
| `windows_mssql_accessmethods_scan_point_revalidations` | Number of times per second that the scan point had to be revalidated to continue the scan | counter | `mssql_instance` |
| `windows_mssql_accessmethods_ghost_record_skips` | Number of ghosted records per second skipped during scans | counter | `mssql_instance` |
| `windows_mssql_accessmethods_table_lock_escalations` | Number of times locks on a table were escalated to the TABLE or HoBT granularity | counter | `mssql_instance` |
| `windows_mssql_accessmethods_leaf_page_cookie_uses` | Number of times a leaf page cookie is used successfully during an index search since no change happened on the leaf page. The cookie is used to speed up index search | counter | `mssql_instance` |
| `windows_mssql_accessmethods_tree_page_cookie_uses` | Number of times a tree page cookie is used successfully during an index search since no change happened on the parent page of the tree page. The cookie is used to speed up index search | counter | `mssql_instance` |
| `windows_mssql_accessmethods_workfile_creates` | Number of work files created per second. For example, work files could be used to store temporary results for hash joins and hash aggregates | counter | `mssql_instance` |
| `windows_mssql_accessmethods_worktables_creates` | Number of work tables created per second. For example, work tables could be used to store temporary results for query spool, lob variables, XML variables, and cursors | counter | `mssql_instance` |
| `windows_mssql_accessmethods_worktables_from_cache_hits` | Number of work tables created where the initial two pages of the work table were not allocated but were immediately available from the work table cache. Numerator of the WorktablesFromCacheRatio counter | counter | `mssql_instance` |
| `windows_mssql_accessmethods_worktables_from_cache_lookups` | Number of work tables created. Denominator (base) of the WorktablesFromCacheRatio counter | counter | `mssql_instance` |
| `windows_mssql_availreplica_received_from_replica_bytes` | Number of bytes received from the availability replica per second. Pings and status updates will generate network traffic even on databases with no user updates | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_sent_to_replica_bytes` | Number of bytes sent to the remote availability replica per second. On the primary replica this is the number of bytes sent to the secondary replica. On the secondary replica this is the number of bytes sent to the primary replica | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_sent_to_transport_bytes` | Actual number of bytes sent per second over the network to the remote availability replica. On the primary replica this is the number of bytes sent to the secondary replica. On the secondary replica this is the number of bytes sent to the primary replica | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_initiated_flow_controls` | Time in milliseconds that log stream messages waited for send flow control, in the last second | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_flow_control_wait_seconds` | Number of times flow-control initiated in the last second. Flow Control Time (ms/sec) divided by Flow Control/sec is the average time per wait | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_receives_from_replica` | Number of Always On messages received from thereplica per second | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_resent_messages` | Number of Always On messages resent in the last second | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_sends_to_replica` | Number of Always On messages sent to this availability replica per second | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_sends_to_transport` | Actual number of Always On messages sent per second over the network to the remote availability replica | counter | `mssql_instance`, `replica` |
| `windows_mssql_bufman_background_writer_pages` | Number of pages flushed to enforce the recovery interval settings | counter | `mssql_instance` |
| `windows_mssql_accessmethods_dropped_rowset_cleanups_total` | The number of rowsets created as a result of aborted online index build operations that were successfully dropped by the background task that cleans up deferred dropped rowsets | counter | `mssql_instance` |
| `windows_mssql_accessmethods_dropped_rowset_skips_total` | The number of rowsets created as a result of aborted online index build operations that were skipped by the background task that cleans up deferred dropped rowsets created | counter | `mssql_instance` |
| `windows_mssql_accessmethods_extent_deallocations_total` | Number of extents deallocated in all databases in this instance of SQL Server | counter | `mssql_instance` |
| `windows_mssql_accessmethods_extent_allocations_total` | Number of extents allocated in all databases in this instance of SQL Server | counter | `mssql_instance` |
| `windows_mssql_accessmethods_au_batch_cleanup_failures_total` | The number of batches that failed and required retry, by the background task that cleans up deferred dropped allocation units. Failure could be due to lack of memory or disk space, hardware failure and other reasons | counter | `mssql_instance` |
| `windows_mssql_accessmethods_leaf_page_cookie_failures_total` | The number of times that a leaf page cookie could not be used during an index search since changes happened on the leaf page. The cookie is used to speed up index search | counter | `mssql_instance` |
| `windows_mssql_accessmethods_tree_page_cookie_failures_total` | The number of times that a tree page cookie could not be used during an index search since changes happened on the parent pages of those tree pages. The cookie is used to speed up index search | counter | `mssql_instance` |
| `windows_mssql_accessmethods_forwarded_records_total` | Number of records fetched through forwarded record pointers | counter | `mssql_instance` |
| `windows_mssql_accessmethods_free_space_page_fetches_total` | Number of pages fetched by free space scans. These scans search for free space within pages already allocated to an allocation unit, to satisfy requests to insert or modify record fragments | counter | `mssql_instance` |
| `windows_mssql_accessmethods_free_space_scans_total` | Number of scans that were initiated to search for free space within pages already allocated to an allocation unit to insert or modify record fragment. Each scan may find multiple pages | counter | `mssql_instance` |
| `windows_mssql_accessmethods_full_scans_total` | Number of unrestricted full scans. These can be either base-table or full-index scans | counter | `mssql_instance` |
| `windows_mssql_accessmethods_index_searches_total` | Number of index searches. These are used to start a range scan, reposition a range scan, revalidate a scan point, fetch a single index record, and search down the index to locate where to insert a new row | counter | `mssql_instance` |
| `windows_mssql_accessmethods_insysxact_waits_total` | Number of times a reader needs to wait for a page because the InSysXact bit is set | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_handle_creates_total` | Count of temporary lobs created | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_handle_destroys_total` | Count of temporary lobs destroyed | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_ss_provider_creates_total` | Count of LOB Storage Service Providers (LobSSP) created. One worktable created per LobSSP | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_ss_provider_destroys_total` | Count of LobSSP destroyed | counter | `mssql_instance` |
| `windows_mssql_accessmethods_lob_ss_provider_truncations_total` | Count of LobSSP truncated | counter | `mssql_instance` |
| `windows_mssql_accessmethods_mixed_page_allocations_total` | Number of pages allocated from mixed extents. These could be used for storing the IAM pages and the first eight pages that are allocated to an allocation unit | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_compression_attempts_total` | Number of pages evaluated for page-level compression. Includes pages that were not compressed because significant savings could be achieved. Includes all objects in the instance of SQL Server | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_deallocations_total` | Number of pages deallocated in all databases in this instance of SQL Server. These include pages from mixed extents and uniform extents | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_allocations_total` | Number of pages allocated in all databases in this instance of SQL Server. These include pages allocations from both mixed extents and uniform extents | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_compressions_total` | Number of data pages that are compressed by using PAGE compression. Includes all objects in the instance of SQL Server | counter | `mssql_instance` |
| `windows_mssql_accessmethods_page_splits_total` | Number of page splits that occur as the result of overflowing index pages | counter | `mssql_instance` |
| `windows_mssql_accessmethods_probe_scans_total` | Number of probe scans that are used to find at most one single qualified row in an index or base table directly | counter | `mssql_instance` |
| `windows_mssql_accessmethods_range_scans_total` | Number of qualified range scans through indices | counter | `mssql_instance` |
| `windows_mssql_accessmethods_scan_point_revalidations_total` | Number of times that the scan point had to be revalidated to continue the scan | counter | `mssql_instance` |
| `windows_mssql_accessmethods_ghost_record_skips_total` | Number of ghosted records skipped during scans | counter | `mssql_instance` |
| `windows_mssql_accessmethods_table_lock_escalations_total` | Number of times locks on a table were escalated to the TABLE or HoBT granularity | counter | `mssql_instance` |
| `windows_mssql_accessmethods_leaf_page_cookie_uses_total` | Number of times a leaf page cookie is used successfully during an index search since no change happened on the leaf page. The cookie is used to speed up index search | counter | `mssql_instance` |
| `windows_mssql_accessmethods_tree_page_cookie_uses_total` | Number of times a tree page cookie is used successfully during an index search since no change happened on the parent page of the tree page. The cookie is used to speed up index search | counter | `mssql_instance` |
| `windows_mssql_accessmethods_workfile_creates_total` | Number of work files created. For example, work files could be used to store temporary results for hash joins and hash aggregates | counter | `mssql_instance` |
| `windows_mssql_accessmethods_worktables_creates_total` | Number of work tables created. For example, work tables could be used to store temporary results for query spool, lob variables, XML variables, and cursors | counter | `mssql_instance` |
| `windows_mssql_accessmethods_worktables_from_cache_hits_total` | Number of work tables created where the initial two pages of the work table were not allocated but were immediately available from the work table cache. Numerator of the WorktablesFromCacheRatio counter | counter | `mssql_instance` |
| `windows_mssql_accessmethods_worktables_from_cache_lookups_total` | Number of work tables created. Denominator (base) of the WorktablesFromCacheRatio counter | counter | `mssql_instance` |
| `windows_mssql_availreplica_received_from_replica_bytes_total` | Number of bytes received from the availability replica. Pings and status updates will generate network traffic even on databases with no user updates | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_sent_to_replica_bytes_total` | Number of bytes sent to the remote availability replica. On the primary replica this is the number of bytes sent to the secondary replica. On the secondary replica this is the number of bytes sent to the primary replica | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_sent_to_transport_bytes_total` | Actual number of bytes sent over the network to the remote availability replica. On the primary replica this is the number of bytes sent to the secondary replica. On the secondary replica this is the number of bytes sent to the primary replica | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_initiated_flow_controls_total` | Number of times flow control was initiated. Flow control wait time divided by this count is the average time per wait | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_flow_control_wait_seconds_total` | Time in seconds that log stream messages waited for send flow control | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_receives_from_replica_total` | Number of Always On messages received from the replica | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_resent_messages_total` | Number of Always On messages resent | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_sends_to_replica_total` | Number of Always On messages sent to this availability replica | counter | `mssql_instance`, `replica` |
| `windows_mssql_availreplica_sends_to_transport_total` | Actual number of Always On messages sent over the network to the remote availability replica | counter | `mssql_instance`, `replica` |
| `windows_mssql_bufman_background_writer_pages_total` | Number of pages flushed to enforce the recovery interval settings | counter | `mssql_instance` |
| `windows_mssql_bufman_buffer_cache_hits` | Number of pages found in the buffer cache without a disk read, in the most recent sampling interval of SQL Server (a few seconds). Numerator of the Buffer cache hit ratio counter | gauge | `mssql_instance` |
| `windows_mssql_bufman_buffer_cache_lookups` | Number of buffer cache lookups in the most recent sampling interval of SQL Server (a few seconds). Base of the Buffer cache hit ratio counter | gauge | `mssql_instance` |
| `windows_mssql_bufman_checkpoint_pages` | Indicates the number of pages flushed to disk per second by a checkpoint or other operation that require all dirty pages to be flushed | counter | `mssql_instance` |
| `windows_mssql_bufman_checkpoint_pages_total` | Indicates the number of pages flushed to disk by a checkpoint or other operation that require all dirty pages to be flushed | counter | `mssql_instance` |
| `windows_mssql_bufman_database_pages` | Indicates the number of pages in the buffer pool with database content | gauge | `mssql_instance` |
| `windows_mssql_bufman_extension_allocated_pages` | Total number of non-free cache pages in the buffer pool extension file | gauge | `mssql_instance` |
| `windows_mssql_bufman_extension_free_pages` | Total number of free cache pages in the buffer pool extension file | gauge | `mssql_instance` |
| `windows_mssql_bufman_extension_in_use_as_percentage` | _Not yet documented_ | gauge | `mssql_instance` |
| `windows_mssql_bufman_extension_in_use_ratio` | Ratio (0-1) of the buffer pool extension file in use | gauge | `mssql_instance` |
| `windows_mssql_bufman_extension_outstanding_io` | Percentage of the buffer pool extension paging file occupied by buffer manager pages | gauge | `mssql_instance` |
| `windows_mssql_bufman_extension_page_evictions` | Number of pages evicted from the buffer pool extension file per second | counter | `mssql_instance` |
| `windows_mssql_bufman_extension_page_reads` | Number of pages read from the buffer pool extension file per second | counter | `mssql_instance` |
| `windows_mssql_bufman_extension_page_evictions_total` | Number of pages evicted from the buffer pool extension file | counter | `mssql_instance` |
| `windows_mssql_bufman_extension_page_reads_total` | Number of pages read from the buffer pool extension file | counter | `mssql_instance` |
| `windows_mssql_bufman_extension_page_unreferenced_seconds` | Average seconds a page will stay in the buffer pool extension without references to it | gauge | `mssql_instance` |
| `windows_mssql_bufman_extension_page_writes` | Number of pages written to the buffer pool extension file per second | counter | `mssql_instance` |
| `windows_mssql_bufman_free_list_stalls` | Indicates the number of requests per second that had to wait for a free page | counter | `mssql_instance` |
| `windows_mssql_bufman_extension_page_writes_total` | Number of pages written to the buffer pool extension file | counter | `mssql_instance` |
| `windows_mssql_bufman_free_list_stalls_total` | Indicates the number of requests that had to wait for a free page | counter | `mssql_instance` |
| `windows_mssql_bufman_integral_controller_slope` | The slope that integral controller for the buffer pool last used, times -10 billion | gauge | `mssql_instance` |
| `windows_mssql_bufman_lazywrites` | Indicates the number of buffers written per second by the buffer manager's lazy writer | counter | `mssql_instance` |
| `windows_mssql_bufman_lazywrites_total` | Indicates the number of buffers written by the buffer manager's lazy writer | counter | `mssql_instance` |
| `windows_mssql_bufman_page_life_expectancy_seconds` | Indicates the number of seconds a page will stay in the buffer pool without references | gauge | `mssql_instance` |
| `windows_mssql_bufman_page_lookups` | Indicates the number of requests per second to find a page in the buffer pool | counter | `mssql_instance` |
| `windows_mssql_bufman_page_reads` | Indicates the number of physical database page reads that are issued per second | counter | `mssql_instance` |
| `windows_mssql_bufman_page_writes` | Indicates the number of physical database page writes that are issued per second | counter | `mssql_instance` |
| `windows_mssql_bufman_read_ahead_pages` | Indicates the number of pages read per second in anticipation of use | counter | `mssql_instance` |
| `windows_mssql_bufman_read_ahead_issuing_seconds` | Total time spent issuing read-ahead, in seconds | counter | `mssql_instance` |
| `windows_mssql_bufman_page_lookups_total` | Indicates the number of requests to find a page in the buffer pool | counter | `mssql_instance` |
| `windows_mssql_bufman_page_reads_total` | Indicates the number of physical database page reads that are issued | counter | `mssql_instance` |
| `windows_mssql_bufman_page_writes_total` | Indicates the number of physical database page writes that are issued | counter | `mssql_instance` |
| `windows_mssql_bufman_read_ahead_pages_total` | Indicates the number of pages read in anticipation of use | counter | `mssql_instance` |
| `windows_mssql_bufman_read_ahead_issuing_seconds_total` | Total time spent issuing read-ahead, in seconds | counter | `mssql_instance` |
| `windows_mssql_bufman_target_pages` | Ideal number of pages in the buffer pool | gauge | `mssql_instance` |
| `windows_mssql_dbreplica_database_flow_control_wait_seconds_total` | Total time spent in database flow control wait, in seconds | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_database_initiated_flow_controls` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_received_file_bytes` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_group_commits` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_database_initiated_flow_controls_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_received_file_bytes_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_group_commits_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_group_commit_stall_seconds_total` | Total time transactions waited for group commit, in seconds | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_apply_pending_queue` | _Not yet documented_ | gauge | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_apply_ready_queue` | _Not yet documented_ | gauge | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_compressed_bytes` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_decompressed_bytes` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_received_bytes` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_compression_cachehits` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_compression_cachemisses` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_compressions` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_decompressions` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_compressed_bytes_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_decompressed_bytes_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_received_bytes_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_compression_cachehits_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_compression_cachemisses_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_compressions_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_decompressions_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_remaining_for_undo_bytes` | The amount of log, in bytes, remaining to complete the undo phase | gauge | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_log_send_queue_bytes` | Amount of log, in bytes, in the log files of the primary database that has not been sent to the secondary replica | gauge | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_mirrored_write_transactions` | Number of transactions that were written to the primary database and then waited to commit until the log was sent to the secondary database, in the last second | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_mirrored_write_transactions_total` | Number of transactions that were written to the primary database and then waited to commit until the log was sent to the secondary database | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_recovery_queue_bytes` | Amount of hardened log, in bytes, in the log files of the secondary replica that has not been redone | gauge | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_redo_blocks` | Number of times the redo thread was blocked on locks held by readers of the database | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_redo_blocks_total` | Number of times the redo thread was blocked on locks held by readers of the database | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_redo_remaining_bytes` | The amount of log, in bytes, remaining to be redone to finish the reverting phase | gauge | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_redone_bytes` | Amount of log records redone on the secondary database in the last second | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_redones` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_redone_bytes_total` | Amount of log records redone on the secondary database | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_redones_total` | _Not yet documented_ | counter | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_total_log_requiring_undo_bytes` | Total amount of log, in bytes, that must be undone | gauge | `mssql_instance`, `replica` |
| `windows_mssql_dbreplica_transaction_delay_seconds_total` | Total time transaction termination waited for commit acknowledgement, in seconds | counter | `mssql_instance`, `replica` |
| `windows_mssql_databases_active_transactions` | Number of active transactions for the database | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_active_parallel_redo_threads` | Number of active parallel redo threads | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_backup_restore_operations` | Read/write throughput for backup and restore operations of a database per second | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_bulk_copy_rows` | Number of rows bulk copied per second | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_bulk_copy_bytes` | Amount of data bulk copied (in kilobytes) per second | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_backup_restore_operations_total` | Read/write throughput for backup and restore operations of a database | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_bulk_copy_rows_total` | Number of rows bulk copied | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_bulk_copy_bytes_total` | Amount of data bulk copied, in bytes | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_commit_table_entries` | he size (row count) of the in-memory portion of the commit table for the database | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_data_files_size_bytes` | Cumulative size (in kilobytes) of all the data files in the database including any automatic growth. Monitoring this counter is useful, for example, for determining the correct size of tempdb | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_dbcc_logical_scan_bytes` | Number of logical read scan bytes per second for database console commands (DBCC) | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_group_commit_stall_seconds` | Total group commit stall time, in seconds | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_flushed_bytes` | Total number of log bytes flushed | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_dbcc_logical_scan_bytes_total` | Number of logical read scan bytes for database console commands (DBCC) | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_group_commit_stall_seconds_total` | Total group commit stall time, in seconds | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_flushed_bytes_total` | Total number of log bytes flushed | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_cache_hits` | Number of log cache reads satisfied from the log cache. Numerator of the Log Cache Hit Ratio counter | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_log_cache_lookups` | Number of log cache lookups. Base of the Log Cache Hit Ratio counter | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_log_cache_reads` | Reads performed per second through the log manager cache | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_cache_reads_total` | Reads performed through the log manager cache | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_files_size_bytes` | Cumulative size (in kilobytes) of all the transaction log files in the database | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_log_files_used_size_bytes` | The cumulative used size of all the log files in the database | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_log_flushes` | Number of log flushes | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_flush_waits` | Number of commits per second waiting for the log flush | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_flushes_total` | Number of log flushes | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_flush_waits_total` | Number of commits waiting for the log flush | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_flush_wait_seconds_total` | Total time commits waited for log flushes, in seconds | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_flush_write_seconds_total` | Total time spent writing log flushes, in seconds | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_growths_total` | Total number of times the transaction log for the database has been expanded | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_cache_misses` | Number of requests for which the log block was not available in the log pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_disk_reads` | Number of disk reads that the log pool issued to fetch log blocks | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_hash_deletes` | Rate of raw hash entry deletes from the Log Pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_hash_inserts` | Rate of raw hash entry inserts into the Log Pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_invalid_hash_entries` | Rate of hash lookups failing due to being invalid | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_log_scan_pushes` | Rate of Log block pushes by log scans, which may come from disk or memory | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_log_writer_pushes` | Rate of Log block pushes by log writer thread | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_empty_free_pool_pushes` | Rate of Log block push fails due to empty free pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_low_memory_pushes` | Rate of Log block push fails due to being low on memory | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_no_free_buffer_pushes` | Rate of Log block push fails due to free buffer unavailable | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_req_behind_trunc` | Log pool cache misses due to block requested being behind truncation LSN | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_requests_old_vlf` | Log Pool requests that were not in the last VLF of the log | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_requests` | The number of log-block requests processed by the log pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_cache_misses_total` | Number of requests for which the log block was not available in the log pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_disk_reads_total` | Number of disk reads that the log pool issued to fetch log blocks | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_hash_deletes_total` | Rate of raw hash entry deletes from the Log Pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_hash_inserts_total` | Rate of raw hash entry inserts into the Log Pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_invalid_hash_entries_total` | Rate of hash lookups failing due to being invalid | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_log_scan_pushes_total` | Rate of Log block pushes by log scans, which may come from disk or memory | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_log_writer_pushes_total` | Rate of Log block pushes by log writer thread | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_empty_free_pool_pushes_total` | Rate of Log block push fails due to empty free pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_low_memory_pushes_total` | Rate of Log block push fails due to being low on memory | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_no_free_buffer_pushes_total` | Rate of Log block push fails due to free buffer unavailable | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_req_behind_trunc_total` | Log pool cache misses due to block requested being behind truncation LSN | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_requests_old_vlf_total` | Log Pool requests that were not in the last VLF of the log | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_requests_total` | The number of log-block requests processed by the log pool | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_total_active_log_bytes` | Current total active log stored in the shared cache buffer manager in bytes | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_log_pool_total_shared_pool_bytes` | Current total memory usage of the shared cache buffer manager in bytes | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_log_shrinks_total` | Total number of log shrinks for this database | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_truncations_total` | The number of times the transaction log has been truncated (in Simple Recovery Model) | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_log_used_percent` | Percentage of space in the log that is in use | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_log_used_ratio` | Ratio (0-1) of space in the log that is in use | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_pending_repl_transactions` | Number of transactions in the transaction log of the publication database marked for replication, but not yet delivered to the distribution database | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_repl_transactions` | Number of transactions per second read out of the transaction log of the publication database and delivered to the distribution database | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_shrink_data_movement_bytes` | Amount of data being moved per second by autoshrink operations, or DBCC SHRINKDATABASE or DBCC SHRINKFILE statements | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_tracked_transactions` | Number of committed transactions recorded in the commit table for the database | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_transactions` | Number of transactions started for the database per second | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_write_transactions` | Number of transactions that wrote to the database and committed, in the last second | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_repl_transactions_total` | Number of transactions read out of the transaction log of the publication database and delivered to the distribution database | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_shrink_data_movement_bytes_total` | Amount of data being moved by autoshrink operations, or DBCC SHRINKDATABASE or DBCC SHRINKFILE statements | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_tracked_transactions_total` | Number of committed transactions recorded in the commit table for the database | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_transactions_total` | Number of transactions started for the database | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_write_transactions_total` | Number of transactions that wrote to the database and committed | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_xtp_controller_dlc_fetch_latency_seconds_total` | Total latency between log blocks entering the Direct Log Consumer and being retrieved by the XTP controller, in seconds. Numerator of the XTP Controller DLC Latency/Fetch counter | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_xtp_controller_dlc_fetches_total` | Total number of fetches from the Direct Log Consumer by the XTP controller. Base of the XTP Controller DLC Latency/Fetch counter | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_xtp_controller_dlc_peak_latency_seconds` | The largest recorded latency, in seconds, of a fetch from the Direct Log Consumer by the XTP controller | gauge | `mssql_instance`, `database` |
| `windows_mssql_databases_xtp_controller_log_processed_bytes` | The amount of log bytes processed by the XTP controller thread, per second | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_xtp_controller_log_processed_bytes_total` | The amount of log bytes processed by the XTP controller thread | counter | `mssql_instance`, `database` |
| `windows_mssql_databases_xtp_memory_used_bytes` | The amount of memory used by XTP in the database | gauge | `mssql_instance`, `database` |
| `windows_mssql_genstats_active_temp_tables` | Number of temporary tables/table variables in use | gauge | `mssql_instance` |
| `windows_mssql_genstats_connection_resets` | Total number of logins started from the connection pool | counter | `mssql_instance` |
| `windows_mssql_genstats_connection_resets_total` | Total number of logins started from the connection pool | counter | `mssql_instance` |
| `windows_mssql_genstats_event_notifications_delayed_drop` | Number of event notifications waiting to be dropped by a system thread | gauge | `mssql_instance` |
| `windows_mssql_genstats_http_authenticated_requests_total` | Total number of authenticated HTTP requests started | counter | `mssql_instance` |
| `windows_mssql_genstats_logical_connections` | Number of logical connections to the system | gauge | `mssql_instance` |
| `windows_mssql_genstats_logins` | Total number of logins started per second. This does not include pooled connections | counter | `mssql_instance` |
| `windows_mssql_genstats_logouts` | Total number of logout operations started per second | counter | `mssql_instance` |
| `windows_mssql_genstats_logins_total` | Total number of logins started. This does not include pooled connections | counter | `mssql_instance` |
| `windows_mssql_genstats_logouts_total` | Total number of logout operations started | counter | `mssql_instance` |
| `windows_mssql_genstats_mars_deadlocks_total` | Total number of MARS deadlocks detected | counter | `mssql_instance` |
| `windows_mssql_genstats_non_atomic_yields` | Number of non-atomic yields per second | counter | `mssql_instance` |
| `windows_mssql_genstats_non_atomic_yields_total` | Number of non-atomic yields | counter | `mssql_instance` |
| `windows_mssql_genstats_blocked_processes` | Number of currently blocked processes | gauge | `mssql_instance` |
| `windows_mssql_genstats_soap_empty_requests_total` | Total number of empty SOAP requests started | counter | `mssql_instance` |
| `windows_mssql_genstats_soap_method_invocations_total` | Total number of SOAP method invocations started | counter | `mssql_instance` |
@@ -189,20 +189,19 @@ Comma-separated list of MSSQL WMI classes to use. Supported values are `accessme
| `windows_mssql_genstats_sql_trace_io_provider_lock_waits_total` | Total number of waits for the File IO Provider lock | counter | `mssql_instance` |
| `windows_mssql_genstats_tempdb_recovery_unit_ids_generated_total` | Total number of duplicate tempdb recovery unit IDs generated | counter | `mssql_instance` |
| `windows_mssql_genstats_tempdb_rowset_ids_generated_total` | Total number of duplicate tempdb rowset IDs generated | counter | `mssql_instance` |
| `windows_mssql_genstats_temp_tables_creations` | Number of temporary tables/table variables created per second | counter | `mssql_instance` |
| `windows_mssql_genstats_temp_tables_creations_total` | Number of temporary tables/table variables created | counter | `mssql_instance` |
| `windows_mssql_genstats_temp_tables_awaiting_destruction` | Number of temporary tables/table variables waiting to be destroyed by the cleanup system thread | gauge | `mssql_instance` |
| `windows_mssql_genstats_trace_event_notification_queue_size` | Number of trace event notification instances waiting in the internal queue to be sent through Service Broker | gauge | `mssql_instance` |
| `windows_mssql_genstats_transactions` | Number of transaction enlistments (local, DTC, bound all combined) | gauge | `mssql_instance` |
| `windows_mssql_genstats_user_connections` | Counts the number of users currently connected to SQL Server | gauge | `mssql_instance` |
| `windows_mssql_instance_info` | A metric with a constant '1' value labeled with mssql instance information | gauge | `edition`, `mssql_instance`, `patch`, `version` |
| `windows_mssql_locks_wait_time_seconds_total` | Total time lock requests waited, in seconds. Numerator of the Average Wait Time (ms) counter | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_count_total` | Total number of lock requests that waited. Base of the Average Wait Time (ms) counter | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_lock_requests` | Number of new locks and lock conversions per second requested from the lock manager | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_lock_timeouts` | Number of lock requests per second that timed out, including requests for NOWAIT locks | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_lock_timeouts_excluding_NOWAIT` | Number of lock requests per second that timed out, but excluding requests for NOWAIT locks | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_lock_waits` | Number of lock requests that required the caller to wait | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_lock_requests_total` | Number of new locks and lock conversions requested from the lock manager | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_lock_timeouts_total` | Number of lock requests that timed out, including requests for NOWAIT locks | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_lock_timeouts_excluding_nowait_total` | Number of lock requests that timed out, but excluding requests for NOWAIT locks | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_lock_waits_total` | Number of lock requests that required the caller to wait | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_lock_wait_seconds_total` | Total time lock requests waited, in seconds | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_deadlocks` | Number of lock requests per second that resulted in a deadlock | counter | `mssql_instance`, `resource` |
| `windows_mssql_locks_deadlocks_total` | Number of lock requests that resulted in a deadlock | counter | `mssql_instance`, `resource` |
| `windows_mssql_memmgr_connection_memory_bytes` | Specifies the total amount of dynamic memory the server is using for maintaining connections | gauge | `mssql_instance` |
| `windows_mssql_memmgr_database_cache_memory_bytes` | Specifies the amount of memory the server is currently using for the database pages cache | gauge | `mssql_instance` |
| `windows_mssql_memmgr_external_benefit_of_memory` | An internal estimation of the performance benefit from adding memory to a specific cache | gauge | `mssql_instance` |
@@ -223,17 +222,17 @@ Comma-separated list of MSSQL WMI classes to use. Supported values are `accessme
| `windows_mssql_memmgr_stolen_server_memory_bytes` | Specifies the amount of memory the server is using for purposes other than database pages | gauge | `mssql_instance` |
| `windows_mssql_memmgr_target_server_memory_bytes` | Indicates the ideal amount of memory the server can consume | gauge | `mssql_instance` |
| `windows_mssql_memmgr_total_server_memory_bytes` | Specifies the amount of memory the server has committed using the memory manager | gauge | `mssql_instance` |
| `windows_mssql_sqlstats_auto_parameterization_attempts` | Number of failed auto-parameterization attempts per second. This should be small. Note that auto-parameterizations are also known as simple parameterizations in later versions of SQL Server | counter | `mssql_instance` |
| `windows_mssql_sqlstats_batch_requests` | _Not yet documented_ | counter | `mssql_instance` |
| `windows_mssql_sqlstats_failed_auto_parameterization_attempts` | _Not yet documented_ | counter | `mssql_instance` |
| `windows_mssql_sqlstats_forced_parameterizations` | Number of successful forced parameterizations per second | counter | `mssql_instance` |
| `windows_mssql_sqlstats_guided_plan_executions` | Number of plan executions per second in which the query plan has been generated by using a plan guide | counter | `mssql_instance` |
| `windows_mssql_sqlstats_misguided_plan_executions` | Number of plan executions per second in which a plan guide could not be honored during plan generation | counter | `mssql_instance` |
| `windows_mssql_sqlstats_safe_auto_parameterization_attempts` | Number of safe auto-parameterization attempts per second | counter | `mssql_instance` |
| `windows_mssql_sqlstats_sql_attentions` | Number of attentions per second | counter | `mssql_instance` |
| `windows_mssql_sqlstats_sql_compilations` | Number of SQL compilations per second | counter | `mssql_instance` |
| `windows_mssql_sqlstats_sql_recompilations` | Number of statement recompiles per second | counter | `mssql_instance` |
| `windows_mssql_sqlstats_unsafe_auto_parameterization_attempts` | Number of unsafe auto-parameterization attempts per second. | counter | `mssql_instance` |
| `windows_mssql_sqlstats_auto_parameterization_attempts_total` | Number of failed auto-parameterization attempts. This should be small. Note that auto-parameterizations are also known as simple parameterizations in later versions of SQL Server | counter | `mssql_instance` |
| `windows_mssql_sqlstats_batch_requests_total` | _Not yet documented_ | counter | `mssql_instance` |
| `windows_mssql_sqlstats_failed_auto_parameterization_attempts_total` | _Not yet documented_ | counter | `mssql_instance` |
| `windows_mssql_sqlstats_forced_parameterizations_total` | Number of successful forced parameterizations | counter | `mssql_instance` |
| `windows_mssql_sqlstats_guided_plan_executions_total` | Number of plan executions in which the query plan has been generated by using a plan guide | counter | `mssql_instance` |
| `windows_mssql_sqlstats_misguided_plan_executions_total` | Number of plan executions in which a plan guide could not be honored during plan generation | counter | `mssql_instance` |
| `windows_mssql_sqlstats_safe_auto_parameterization_attempts_total` | Number of safe auto-parameterization attempts | counter | `mssql_instance` |
| `windows_mssql_sqlstats_sql_attentions_total` | Number of attentions | counter | `mssql_instance` |
| `windows_mssql_sqlstats_sql_compilations_total` | Number of SQL compilations | counter | `mssql_instance` |
| `windows_mssql_sqlstats_sql_recompilations_total` | Number of statement recompiles | counter | `mssql_instance` |
| `windows_mssql_sqlstats_unsafe_auto_parameterization_attempts_total` | Number of unsafe auto-parameterization attempts. | counter | `mssql_instance` |
| `windows_mssql_sql_errors_total` | Information for all errors | counter | `mssql_instance`, `resource` |
| `windows_mssql_transactions_tempdb_free_space_bytes` | The amount of space, in bytes, available in tempdb | gauge | `mssql_instance` |
| `windows_mssql_transactions_longest_transaction_running_seconds` | The length of time (in seconds) since the start of the transaction that has been active longer than any other current transaction | gauge | `mssql_instance` |
@@ -247,8 +246,8 @@ Comma-separated list of MSSQL WMI classes to use. Supported values are `accessme
| `windows_mssql_transactions_version_generation_bytes_total` | Total size of row versions added to the version store in tempdb, in bytes | counter | `mssql_instance` |
| `windows_mssql_transactions_version_store_size_bytes` | The amount of space, in bytes, in tempdb used to store snapshot isolation level row versions | gauge | `mssql_instance` |
| `windows_mssql_transactions_version_store_units` | The number of active allocation units in the snapshot isolation version store in tempdb | gauge | `mssql_instance` |
| `windows_mssql_transactions_version_store_creation_units` | The number of allocation units that have been created in the snapshot isolation store since the instance of the Database Engine was started | counter | `mssql_instance` |
| `windows_mssql_transactions_version_store_truncation_units` | The number of allocation units that have been removed from the snapshot isolation store since the instance of the Database Engine was started | counter | `mssql_instance` |
| `windows_mssql_transactions_version_store_creation_units_total` | The number of allocation units that have been created in the snapshot isolation store since the instance of the Database Engine was started | counter | `mssql_instance` |
| `windows_mssql_transactions_version_store_truncation_units_total` | The number of allocation units that have been removed from the snapshot isolation store since the instance of the Database Engine was started | counter | `mssql_instance` |
| `windows_mssql_waitstats_lock_waits` | Statistics for processes waiting on a lock | gauge | `mssql_instance`, `item` |
| `windows_mssql_waitstats_memory_grant_queue_waits` | Statistics for processes waiting for memory grant to become available | gauge | `mssql_instance`, `item` |
| `windows_mssql_waitstats_thread_safe_memory_objects_waits` | Statistics for processes waiting on thread-safe memory allocators | gauge | `mssql_instance`, `item` |
@@ -267,7 +266,7 @@ Comma-separated list of MSSQL WMI classes to use. Supported values are `accessme
Query Full table scans
```
rate(windows_mssql_accessmethods_full_scans{instance='host:9182'}[$__rate_interval])
rate(windows_mssql_accessmethods_full_scans_total{instance='host:9182'}[$__rate_interval])
```
## Useful queries
@@ -300,10 +299,10 @@ Divide the rates of numerator and base:
```
# Worktables From Cache Ratio
rate(windows_mssql_accessmethods_worktables_from_cache_hits[5m]) / rate(windows_mssql_accessmethods_worktables_from_cache_lookups[5m])
rate(windows_mssql_accessmethods_worktables_from_cache_hits_total[5m]) / rate(windows_mssql_accessmethods_worktables_from_cache_lookups_total[5m])
# Average lock wait time in seconds
rate(windows_mssql_locks_wait_time_seconds_total[5m]) / rate(windows_mssql_locks_count_total[5m])
rate(windows_mssql_locks_wait_time_seconds_total[5m]) / rate(windows_mssql_locks_lock_waits_total[5m])
# Average XTP controller DLC latency per fetch in seconds
rate(windows_mssql_databases_xtp_controller_dlc_fetch_latency_seconds_total[5m]) / rate(windows_mssql_databases_xtp_controller_dlc_fetches_total[5m])
docs/collector.netframework.md
+4 -4
View File
@@ -40,8 +40,8 @@ Comma-separated list of collectors to use. Defaults to all, if not specified. Su
| Name | Description | Type | Labels |
|-----------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-----------|
| `windows_netframework_clrjit_jit_methods_total` | Displays the total number of methods JIT-compiled since the application started. This counter does not include pre-JIT-compiled methods. | counter | `process` |
| `windows_netframework_clrjit_jit_time_percent` | Displays the percentage of time spent in JIT compilation. This counter is updated at the end of every JIT compilation phase. A JIT compilation phase occurs when a method and its dependencies are compiled. | gauge | `process` |
| `windows_netframework_clrjit_jit_standard_failures_total` | Displays the peak number of methods the JIT compiler has failed to compile since the application started. This failure can occur if the MSIL cannot be verified or if there is an internal error in the JIT compiler. | gauge | `process` |
| `windows_netframework_clrjit_jit_time_ratio` | Displays the ratio (0-1) of elapsed time spent in JIT compilation since the last JIT compilation phase. This counter is updated at the end of every JIT compilation phase. A JIT compilation phase occurs when a method and its dependencies are compiled. | gauge | `process` |
| `windows_netframework_clrjit_jit_standard_failures_total` | Displays the peak number of methods the JIT compiler has failed to compile since the application started. This failure can occur if the MSIL cannot be verified or if there is an internal error in the JIT compiler. | counter | `process` |
| `windows_netframework_clrjit_jit_il_bytes_total` | Displays the total number of Microsoft intermediate language (MSIL) bytes compiled by the just-in-time (JIT) compiler since the application started | counter | `process` |
### CLR Loading
@@ -85,7 +85,7 @@ Comma-separated list of collectors to use. Defaults to all, if not specified. Su
| `windows_netframework_clrmemory_number_sink_blocksinuse` | Displays the current number of synchronization blocks in use. Synchronization blocks are per-object data structures allocated for storing synchronization information. They hold weak references to managed objects and must be scanned by the garbage collector. | gauge | `process`, `process_id` |
| `windows_netframework_clrmemory_committed_bytes` | Displays the amount of virtual memory, in bytes, currently committed by the garbage collector. Committed memory is the physical memory for which space has been reserved in the disk paging file. | gauge | `process`, `process_id` |
| `windows_netframework_clrmemory_reserved_bytes` | Displays the amount of virtual memory, in bytes, currently reserved by the garbage collector. Reserved memory is the virtual memory space reserved for the application when no disk or main memory pages have been used. | gauge | `process`, `process_id` |
| `windows_netframework_clrmemory_gc_time_percent` | Displays the percentage of time that was spent performing a garbage collection in the last sample. | gauge | `process`, `process_id` |
| `windows_netframework_clrmemory_gc_time_ratio` | Displays the ratio (0-1) of elapsed time spent performing a garbage collection since the end of the last garbage collection cycle. Left out when Windows reports no base value. | gauge | `process`, `process_id` |
### CLR Remoting
@@ -103,7 +103,7 @@ Comma-separated list of collectors to use. Defaults to all, if not specified. Su
| Name | Description | Type | Labels |
|-----------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|---------|-----------|
| `windows_netframework_clrsecurity_link_time_checks_total` | Displays the total number of link-time code access security checks since the application started. | counter | `process` |
| `windows_netframework_clrsecurity_rt_checks_time_percent` | Displays the percentage of time spent performing runtime code access security checks in the last sample. | gauge | `process` |
| `windows_netframework_clrsecurity_rt_checks_time_ratio` | Displays the ratio (0-1) of time spent performing runtime code access security checks in the last sample. | gauge | `process` |
| `windows_netframework_clrsecurity_stack_walk_depth` | Displays the depth of the stack during that last runtime code access security check. | gauge | `process` |
| `windows_netframework_clrsecurity_runtime_checks_total` | Displays the total number of runtime code access security checks performed since the application started. | counter | `process` |
docs/collector.nps.md
+27 -27
View File
@@ -16,34 +16,34 @@ None
Name | Description | Type | Labels
-----|-------------|------|-------
`windows_nps_access_accepts` | | counter | None
`windows_nps_access_bad_authenticators` | | counter | None
`windows_nps_access_challenges` | | counter | None
`windows_nps_access_dropped_packets` | | counter | None
`windows_nps_access_invalid_requests` | | counter | None
`windows_nps_access_malformed_packets` | | counter | None
`windows_nps_access_packets_received` | | counter | None
`windows_nps_access_packets_sent` | | counter | None
`windows_nps_access_rejects` | | counter | None
`windows_nps_access_requests` | | counter | None
`windows_nps_access_server_reset_time` | | counter | None
`windows_nps_access_server_up_time` | | counter | None
`windows_nps_access_unknown_type` | | counter | None
`windows_nps_accounting_bad_authenticators` | | counter | None
`windows_nps_accounting_dropped_packets` | | counter | None
`windows_nps_accounting_invalid_requests` | | counter | None
`windows_nps_accounting_malformed_packets` | | counter | None
`windows_nps_accounting_no_record` | | counter | None
`windows_nps_accounting_packets_received` | | counter | None
`windows_nps_accounting_packets_sent` | | counter | None
`windows_nps_accounting_requests` | | counter | None
`windows_nps_accounting_responses` | | counter | None
`windows_nps_accounting_server_reset_time` | | counter | None
`windows_nps_accounting_server_up_time` | | counter | None
`windows_nps_accounting_unknown_type` | | counter | None
`windows_nps_access_accepts_total` | | counter | None
`windows_nps_access_bad_authenticators_total` | | counter | None
`windows_nps_access_challenges_total` | | counter | None
`windows_nps_access_dropped_packets_total` | | counter | None
`windows_nps_access_invalid_requests_total` | | counter | None
`windows_nps_access_malformed_packets_total` | | counter | None
`windows_nps_access_packets_received_total` | | counter | None
`windows_nps_access_packets_sent_total` | | counter | None
`windows_nps_access_rejects_total` | | counter | None
`windows_nps_access_requests_total` | | counter | None
`windows_nps_access_server_reset_time_seconds` | Elapsed time in seconds since the NPS server counters were last reset | gauge | None
`windows_nps_access_server_up_time_seconds` | Elapsed time in seconds since the NPS service started | gauge | None
`windows_nps_access_unknown_type_total` | | counter | None
`windows_nps_accounting_bad_authenticators_total` | | counter | None
`windows_nps_accounting_dropped_packets_total` | | counter | None
`windows_nps_accounting_invalid_requests_total` | | counter | None
`windows_nps_accounting_malformed_packets_total` | | counter | None
`windows_nps_accounting_no_record_total` | | counter | None
`windows_nps_accounting_packets_received_total` | | counter | None
`windows_nps_accounting_packets_sent_total` | | counter | None
`windows_nps_accounting_requests_total` | | counter | None
`windows_nps_accounting_responses_total` | | counter | None
`windows_nps_accounting_server_reset_time_seconds` | Elapsed time in seconds since the NPS server counters were last reset | gauge | None
`windows_nps_accounting_server_up_time_seconds` | Elapsed time in seconds since the NPS service started | gauge | None
`windows_nps_accounting_unknown_type_total` | | counter | None
### Example metric
Show current number of processes
```
windows_nps_access_accepts{instance="localhost"}
```
windows_nps_access_accepts_total{instance="localhost"}
```
docs/collector.performancecounter.md
+62 -59
View File
@@ -33,6 +33,7 @@ collector:
object: "Memory"
counters:
- name: "Cache Faults/sec"
metric: windows_performancecounter_memory_cache_faults_total # optional
type: "counter" # optional
```
@@ -50,11 +51,11 @@ YAML:
instance_label: "core"
counters:
- name: "% Processor Time"
metric: windows_performancecounter_processor_information_processor_time # optional
metric: windows_performancecounter_processor_information_processor_time_total # optional
labels:
state: active
- name: "% Idle Time"
metric: windows_performancecounter_processor_information_processor_time # optional
metric: windows_performancecounter_processor_information_processor_time_total # optional
labels:
state: idle
- name: memory
@@ -62,7 +63,8 @@ YAML:
type: "formatted"
counters:
- name: "Cache Faults/sec"
type: "counter" # optional
metric: windows_performancecounter_memory_cache_faults_per_second # optional
type: "gauge" # optional
```
</details>
@@ -82,14 +84,14 @@ YAML:
"counters": [
{
"name": "% Processor Time",
"metric": "windows_performancecounter_processor_information_processor_time",
"metric": "windows_performancecounter_processor_information_processor_time_total",
"labels": {
"state": "active"
}
},
{
"name": "% Idle Time",
"metric": "windows_performancecounter_processor_information_processor_time",
"metric": "windows_performancecounter_processor_information_processor_time_total",
"labels": {
"state": "idle"
}
@@ -103,7 +105,8 @@ YAML:
"counters": [
{
"name": "Cache Faults/sec",
"type": "counter"
"metric": "windows_performancecounter_memory_cache_faults_per_second",
"type": "gauge"
}
]
}
@@ -202,59 +205,59 @@ Otherwise, they would produce identical series and the collector fails to start.
### Example
```
# HELP windows_performancecounter_memory_cache_faults_sec
# TYPE windows_performancecounter_memory_cache_faults_sec counter
windows_performancecounter_memory_cache_faults_sec 7.028097e+06
# HELP windows_performancecounter_processor_information_processor_time
# TYPE windows_performancecounter_processor_information_processor_time counter
windows_performancecounter_processor_information_processor_time{core="0,0",state="active"} 8.3809375e+10
windows_performancecounter_processor_information_processor_time{core="0,0",state="idle"} 8380.9375
windows_performancecounter_processor_information_processor_time{core="0,1",state="active"} 8.2868125e+10
windows_performancecounter_processor_information_processor_time{core="0,1",state="idle"} 8286.8125
windows_performancecounter_processor_information_processor_time{core="0,10",state="active"} 9.720046875e+10
windows_performancecounter_processor_information_processor_time{core="0,10",state="idle"} 9720.046875
windows_performancecounter_processor_information_processor_time{core="0,11",state="active"} 9.994921875e+10
windows_performancecounter_processor_information_processor_time{core="0,11",state="idle"} 9994.921875
windows_performancecounter_processor_information_processor_time{core="0,12",state="active"} 1.014403125e+11
windows_performancecounter_processor_information_processor_time{core="0,12",state="idle"} 10144.03125
windows_performancecounter_processor_information_processor_time{core="0,13",state="active"} 1.0155453125e+11
windows_performancecounter_processor_information_processor_time{core="0,13",state="idle"} 10155.453125
windows_performancecounter_processor_information_processor_time{core="0,14",state="active"} 1.01290625e+11
windows_performancecounter_processor_information_processor_time{core="0,14",state="idle"} 10129.0625
windows_performancecounter_processor_information_processor_time{core="0,15",state="active"} 1.0134890625e+11
windows_performancecounter_processor_information_processor_time{core="0,15",state="idle"} 10134.890625
windows_performancecounter_processor_information_processor_time{core="0,16",state="active"} 1.01405625e+11
windows_performancecounter_processor_information_processor_time{core="0,16",state="idle"} 10140.5625
windows_performancecounter_processor_information_processor_time{core="0,17",state="active"} 1.0153421875e+11
windows_performancecounter_processor_information_processor_time{core="0,17",state="idle"} 10153.421875
windows_performancecounter_processor_information_processor_time{core="0,18",state="active"} 1.0086390625e+11
windows_performancecounter_processor_information_processor_time{core="0,18",state="idle"} 10086.390625
windows_performancecounter_processor_information_processor_time{core="0,19",state="active"} 1.0123453125e+11
windows_performancecounter_processor_information_processor_time{core="0,19",state="idle"} 10123.453125
windows_performancecounter_processor_information_processor_time{core="0,2",state="active"} 8.3548125e+10
windows_performancecounter_processor_information_processor_time{core="0,2",state="idle"} 8354.8125
windows_performancecounter_processor_information_processor_time{core="0,20",state="active"} 1.011703125e+11
windows_performancecounter_processor_information_processor_time{core="0,20",state="idle"} 10117.03125
windows_performancecounter_processor_information_processor_time{core="0,21",state="active"} 1.0140984375e+11
windows_performancecounter_processor_information_processor_time{core="0,21",state="idle"} 10140.984375
windows_performancecounter_processor_information_processor_time{core="0,22",state="active"} 1.014615625e+11
windows_performancecounter_processor_information_processor_time{core="0,22",state="idle"} 10146.15625
windows_performancecounter_processor_information_processor_time{core="0,23",state="active"} 1.0145125e+11
windows_performancecounter_processor_information_processor_time{core="0,23",state="idle"} 10145.125
windows_performancecounter_processor_information_processor_time{core="0,3",state="active"} 8.488953125e+10
windows_performancecounter_processor_information_processor_time{core="0,3",state="idle"} 8488.953125
windows_performancecounter_processor_information_processor_time{core="0,4",state="active"} 9.338234375e+10
windows_performancecounter_processor_information_processor_time{core="0,4",state="idle"} 9338.234375
windows_performancecounter_processor_information_processor_time{core="0,5",state="active"} 9.776453125e+10
windows_performancecounter_processor_information_processor_time{core="0,5",state="idle"} 9776.453125
windows_performancecounter_processor_information_processor_time{core="0,6",state="active"} 9.736265625e+10
windows_performancecounter_processor_information_processor_time{core="0,6",state="idle"} 9736.265625
windows_performancecounter_processor_information_processor_time{core="0,7",state="active"} 9.959375e+10
windows_performancecounter_processor_information_processor_time{core="0,7",state="idle"} 9959.375
windows_performancecounter_processor_information_processor_time{core="0,8",state="active"} 9.939421875e+10
windows_performancecounter_processor_information_processor_time{core="0,8",state="idle"} 9939.421875
windows_performancecounter_processor_information_processor_time{core="0,9",state="active"} 1.0059484375e+11
windows_performancecounter_processor_information_processor_time{core="0,9",state="idle"} 10059.484375
# HELP windows_performancecounter_memory_cache_faults_total
# TYPE windows_performancecounter_memory_cache_faults_total counter
windows_performancecounter_memory_cache_faults_total 7.028097e+06
# HELP windows_performancecounter_processor_information_processor_time_total
# TYPE windows_performancecounter_processor_information_processor_time_total counter
windows_performancecounter_processor_information_processor_time_total{core="0,0",state="active"} 8.3809375e+10
windows_performancecounter_processor_information_processor_time_total{core="0,0",state="idle"} 8380.9375
windows_performancecounter_processor_information_processor_time_total{core="0,1",state="active"} 8.2868125e+10
windows_performancecounter_processor_information_processor_time_total{core="0,1",state="idle"} 8286.8125
windows_performancecounter_processor_information_processor_time_total{core="0,10",state="active"} 9.720046875e+10
windows_performancecounter_processor_information_processor_time_total{core="0,10",state="idle"} 9720.046875
windows_performancecounter_processor_information_processor_time_total{core="0,11",state="active"} 9.994921875e+10
windows_performancecounter_processor_information_processor_time_total{core="0,11",state="idle"} 9994.921875
windows_performancecounter_processor_information_processor_time_total{core="0,12",state="active"} 1.014403125e+11
windows_performancecounter_processor_information_processor_time_total{core="0,12",state="idle"} 10144.03125
windows_performancecounter_processor_information_processor_time_total{core="0,13",state="active"} 1.0155453125e+11
windows_performancecounter_processor_information_processor_time_total{core="0,13",state="idle"} 10155.453125
windows_performancecounter_processor_information_processor_time_total{core="0,14",state="active"} 1.01290625e+11
windows_performancecounter_processor_information_processor_time_total{core="0,14",state="idle"} 10129.0625
windows_performancecounter_processor_information_processor_time_total{core="0,15",state="active"} 1.0134890625e+11
windows_performancecounter_processor_information_processor_time_total{core="0,15",state="idle"} 10134.890625
windows_performancecounter_processor_information_processor_time_total{core="0,16",state="active"} 1.01405625e+11
windows_performancecounter_processor_information_processor_time_total{core="0,16",state="idle"} 10140.5625
windows_performancecounter_processor_information_processor_time_total{core="0,17",state="active"} 1.0153421875e+11
windows_performancecounter_processor_information_processor_time_total{core="0,17",state="idle"} 10153.421875
windows_performancecounter_processor_information_processor_time_total{core="0,18",state="active"} 1.0086390625e+11
windows_performancecounter_processor_information_processor_time_total{core="0,18",state="idle"} 10086.390625
windows_performancecounter_processor_information_processor_time_total{core="0,19",state="active"} 1.0123453125e+11
windows_performancecounter_processor_information_processor_time_total{core="0,19",state="idle"} 10123.453125
windows_performancecounter_processor_information_processor_time_total{core="0,2",state="active"} 8.3548125e+10
windows_performancecounter_processor_information_processor_time_total{core="0,2",state="idle"} 8354.8125
windows_performancecounter_processor_information_processor_time_total{core="0,20",state="active"} 1.011703125e+11
windows_performancecounter_processor_information_processor_time_total{core="0,20",state="idle"} 10117.03125
windows_performancecounter_processor_information_processor_time_total{core="0,21",state="active"} 1.0140984375e+11
windows_performancecounter_processor_information_processor_time_total{core="0,21",state="idle"} 10140.984375
windows_performancecounter_processor_information_processor_time_total{core="0,22",state="active"} 1.014615625e+11
windows_performancecounter_processor_information_processor_time_total{core="0,22",state="idle"} 10146.15625
windows_performancecounter_processor_information_processor_time_total{core="0,23",state="active"} 1.0145125e+11
windows_performancecounter_processor_information_processor_time_total{core="0,23",state="idle"} 10145.125
windows_performancecounter_processor_information_processor_time_total{core="0,3",state="active"} 8.488953125e+10
windows_performancecounter_processor_information_processor_time_total{core="0,3",state="idle"} 8488.953125
windows_performancecounter_processor_information_processor_time_total{core="0,4",state="active"} 9.338234375e+10
windows_performancecounter_processor_information_processor_time_total{core="0,4",state="idle"} 9338.234375
windows_performancecounter_processor_information_processor_time_total{core="0,5",state="active"} 9.776453125e+10
windows_performancecounter_processor_information_processor_time_total{core="0,5",state="idle"} 9776.453125
windows_performancecounter_processor_information_processor_time_total{core="0,6",state="active"} 9.736265625e+10
windows_performancecounter_processor_information_processor_time_total{core="0,6",state="idle"} 9736.265625
windows_performancecounter_processor_information_processor_time_total{core="0,7",state="active"} 9.959375e+10
windows_performancecounter_processor_information_processor_time_total{core="0,7",state="idle"} 9959.375
windows_performancecounter_processor_information_processor_time_total{core="0,8",state="active"} 9.939421875e+10
windows_performancecounter_processor_information_processor_time_total{core="0,8",state="idle"} 9939.421875
windows_performancecounter_processor_information_processor_time_total{core="0,9",state="active"} 1.0059484375e+11
windows_performancecounter_processor_information_processor_time_total{core="0,9",state="idle"} 10059.484375
```
> [!NOTE]
> If you are using a configuration file, the value must be keep as string.
docs/collector.printer.md
+1 -1
View File
@@ -24,5 +24,5 @@ If given, a printer needs to *not* match the exclude regular expression in order
Name | Description | Type | Labels
-----|-------------|---------|-------
`windows_printer_status` | Printer status. 1 for the current status, 0 otherwise | gauge | `printer`, `status`
`windows_printer_job_count` | Number of jobs processed by the printer since the last reset | counter | `printer`
`windows_printer_jobs` | Number of jobs in the queue of the printer | gauge | `printer`
`windows_printer_job_status` | A counter of printer jobs by status | gauge | `printer`, `status`
docs/collector.process.md
+1 -1
View File
@@ -90,7 +90,7 @@ w3wp_Test
|------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|---------------------------------------------------------------------------------------|
| `windows_process_info` | A metric with a constant '1' value labeled with process information | gauge | `process`, `process_id`, `creating_process_id`, `process_group_id`,`owner`, `cmdline` |
| `windows_process_start_time_seconds_timestamp` | Epoch time (seconds since 1970/1/1) of process start. | gauge | `process`, `process_id` |
| `windows_process_cpu_time_total` | Returns elapsed time that all of the threads of this process used the processor to execute instructions by mode (privileged, user). An instruction is the basic unit of execution in a computer, a thread is the object that executes instructions, and a process is the object created when a program is run. Code executed to handle some hardware interrupts and trap conditions is included in this count. | counter | `process`, `process_id`, `mode` |
| `windows_process_cpu_time_seconds_total` | Returns elapsed time that all of the threads of this process used the processor to execute instructions by mode (privileged, user). An instruction is the basic unit of execution in a computer, a thread is the object that executes instructions, and a process is the object created when a program is run. Code executed to handle some hardware interrupts and trap conditions is included in this count. | counter | `process`, `process_id`, `mode` |
| `windows_process_handles` | Total number of handles the process has open. This number is the sum of the handles currently open by each thread in the process. | gauge | `process`, `process_id` |
| `windows_process_io_bytes_total` | Bytes issued to I/O operations in different modes (read, write, other). This property counts all I/O activity generated by the process to include file, network, and device I/Os. Read and write mode includes data operations; other mode includes those that do not involve data, such as control operations. | counter | `process`, `process_id`, `mode` |
| `windows_process_io_operations_total` | I/O operations issued in different modes (read, write, other). This property counts all I/O activity generated by the process to include file, network, and device I/Os. Read and write mode includes data operations; other mode includes those that do not involve data, such as control operations. | counter | `process`, `process_id`, `mode` |
docs/collector.scheduled_task.md
+4 -19
View File
@@ -53,7 +53,6 @@ and an empty table of tasks with missed runs. Default: `false`
Name | Description | Type | Labels
-----|-------------|------|-------
`windows_scheduled_task_last_result` | **Deprecated:** use `windows_scheduled_task_last_result_status`. 1 if the last result code is zero, 0 otherwise; omitted for tasks that have never run | gauge | task
`windows_scheduled_task_last_result_status` | The last result status of a scheduled task, 1 if the current status, 0 otherwise | gauge | task, status
`windows_scheduled_task_missed_runs` | The number of times the registered task missed a scheduled run; only with `--collector.scheduled_task.missed-runs` | gauge | task
`windows_scheduled_task_state` | The current state of a scheduled task | gauge | task, state
@@ -88,18 +87,13 @@ not establish whether the task succeeded or failed.
See [Microsoft's Task Scheduler result codes](https://learn.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-error-and-success-constants)
for details.
### Deprecated metric
### Result status
`windows_scheduled_task_last_result` is deprecated. Use
`windows_scheduled_task_last_result_status` to distinguish success, running,
Use `windows_scheduled_task_last_result_status` to distinguish success, running,
tasks that have never run, and other scheduler statuses. For example, use
`windows_scheduled_task_last_result_status{status="success"} == 1` to select
successful results.
The deprecated metric remains available with its existing labels and values for
compatibility. A running result code still produces 0, which does not necessarily
mean the task failed. `windows_scheduled_task_last_result` and
`windows_scheduled_task_missed_runs` are omitted when the result is `has_not_run`.
successful results. `windows_scheduled_task_missed_runs` is omitted when the
result is `has_not_run`.
### State
@@ -116,7 +110,6 @@ A task can be in the following states:
This Windows task is only reported with `--collector.scheduled_task.exclude=""`.
```
windows_scheduled_task_last_result{task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 1
windows_scheduled_task_last_result_status{status="success",task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 1
windows_scheduled_task_last_result_status{status="ready",task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 0
windows_scheduled_task_last_result_status{status="running",task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 0
@@ -151,14 +144,6 @@ Tasks that have never run:
windows_scheduled_task_last_result_status{status="has_not_run"} == 1
```
For dashboards still using the deprecated success/failure metric, exclude running tasks:
```promql
(windows_scheduled_task_last_result == 0)
unless on (job, instance, task)
(windows_scheduled_task_state{state="running"} == 1)
```
## Alerting examples
This example treats unknown or terminated results as failures. An `unknown`
docs/collector.smb.md
+2 -2
View File
@@ -17,8 +17,8 @@ None
## Metrics
Name | Description | Type | Labels
-----|-------------|------|-------
`windows_smb_server_shares_current_open_file_count` | Current total count open files on the SMB Server Share | gauge | `share`
`windows_smb_server_shares_tree_connect_count` | Count of user connections to the SMB Server Share | gauge | `share`
`windows_smb_server_shares_open_files` | Current total count open files on the SMB Server Share | gauge | `share`
`windows_smb_server_shares_tree_connects` | Count of user connections to the SMB Server Share | gauge | `share`
`windows_smb_server_shares_received_bytes_total` | Received bytes on the SMB Server Share | counter | `share`
`windows_smb_server_shares_write_requests_total` | Writes requests on the SMB Server Share | counter | `share`
`windows_smb_server_shares_read_requests_total` | Read requests on the SMB Server Share | counter | `share`
docs/collector.storage_spaces.md
+2 -2
View File
@@ -50,7 +50,7 @@ Join on `unique_id` to restrict other pool metrics to concrete pools, as shown i
| `windows_storage_spaces_virtual_disk_size_bytes` | Total size of the virtual disk in bytes | gauge | `name`, `unique_id` |
| `windows_storage_spaces_virtual_disk_allocated_size_bytes` | Allocated size of the virtual disk in bytes (capacity actually provisioned, excludes thin-provisioned unused capacity) | gauge | `name`, `unique_id` |
| `windows_storage_spaces_virtual_disk_footprint_on_pool_bytes` | Physical storage consumed by the virtual disk on the storage pool in bytes | gauge | `name`, `unique_id` |
| `windows_storage_spaces_virtual_disk_storage_efficiency_percent` | Storage efficiency percentage (AllocatedSize / FootprintOnPool * 100), omitted while FootprintOnPool is 0 | gauge | `name`, `unique_id` |
| `windows_storage_spaces_virtual_disk_storage_efficiency_ratio` | Storage efficiency ratio (AllocatedSize / FootprintOnPool), omitted while FootprintOnPool is 0 | gauge | `name`, `unique_id` |
### Example metric
@@ -72,7 +72,7 @@ Storage pool usage in percent, excluding the primordial pool
Find virtual disks with low storage efficiency (over-provisioned)
```
windows_storage_spaces_virtual_disk_storage_efficiency_percent < 50
windows_storage_spaces_virtual_disk_storage_efficiency_ratio < 0.5
```
Calculate total virtual disk capacity vs physical usage
docs/collector.tcp.md
+1 -1
View File
@@ -29,7 +29,7 @@ Example: `--collector.tcp.enabled=metrics`
| `windows_tcp_segments_received_total` | Total segments received, including those received in error. This count includes segments received on currently established connections | counter | af |
| `windows_tcp_segments_retransmitted_total` | Total segments retransmitted. That is, segments transmitted that contain one or more previously transmitted bytes | counter | af |
| `windows_tcp_segments_sent_total` | Total segments sent, including those on current connections, but excluding those containing *only* retransmitted bytes | counter | af |
| `windows_tcp_connections_state_count` | Number of TCP connections by state among: CLOSED, LISTENING, SYN_SENT, SYN_RECEIVED, ESTABLISHED, FIN_WAIT1, FIN_WAIT2, CLOSE_WAIT, CLOSING, LAST_ACK, TIME_WAIT, DELETE_TCB | gauge | af, state |
| `windows_tcp_connections` | Number of TCP connections by state among: CLOSED, LISTENING, SYN_SENT, SYN_RECEIVED, ESTABLISHED, FIN_WAIT1, FIN_WAIT2, CLOSE_WAIT, CLOSING, LAST_ACK, TIME_WAIT, DELETE_TCB | gauge | af, state |
### Example metric
_This collector does not yet have explained examples, we would appreciate your help adding them!_
docs/collector.time.md
+1 -1
View File
@@ -25,7 +25,7 @@ Matching is case-sensitive.
| Name | Description | Type | Labels |
|----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|------------|
| `windows_time_clock_frequency_adjustment` | Adjustment made to the local system clock frequency by W32Time in nominal clock units. This counter helps visualize the finer adjustments being made by W32Time to synchronize the local clock. | gauge | None |
| `windows_time_clock_frequency_adjustment_ppb` | Adjustment made to the local system clock frequency by W32Time in parts per billion (PPB) units. 1 PPB adjustment implies the system clock was adjusted at a rate of 1 nanosecond per second (1 ns/s). The smallest possible adjustment can vary and is expected to be in the order of 100's of PPB. | gauge | None |
| `windows_time_clock_frequency_adjustment_ratio` | Adjustment made to the local system clock frequency by W32Time, as a ratio. Windows reports it in parts per billion (PPB); 1 PPB (a ratio of 1e-9) implies the system clock was adjusted at a rate of 1 nanosecond per second (1 ns/s). The smallest possible adjustment can vary and is expected to be in the order of 100's of PPB. | gauge | None |
| `windows_time_computed_time_offset_seconds` | The absolute time offset between the system clock and the chosen time source, as computed by the W32Time service, in seconds. When a new valid sample is available, the computed time is updated with the time offset indicated by the sample. This time is the actual time offset of the local clock. W32Time initiates clock correction by using this offset and updates the computed time in between samples with the remaining time offset that needs to be applied to the local clock. Clock accuracy can be tracked by using this performance counter with a low polling interval (for example, 256 seconds or less) and looking for the counter value to be smaller than the desired clock accuracy limit. | gauge | None |
| `windows_time_ntp_client_time_sources` | Active number of NTP Time sources being used by the client. This is a count of active, distinct IP addresses of time servers that are responding to this client's requests. | gauge | None |
| `windows_time_ntp_round_trip_delay_seconds` | Total roundtrip delay experienced by the NTP client in receiving a response from the server for the most recent request, in seconds. This is the time elapsed on the NTP client between transmitting a request to the NTP server and receiving a valid response from the server. | gauge | None |
docs/collector.vmware.md
+4 -4
View File
@@ -28,13 +28,13 @@ None
| `windows_vmware_mem_swapped_bytes` | The amount of memory associated with this virtual machine that has been swapped by ESX. | gauge | None |
| `windows_vmware_mem_target_size_bytes` | Memory Target Size | gauge | None |
| `windows_vmware_mem_used_bytes` | The estimated amount of physical host memory currently consumed for this virtual machine’s physical memory. | gauge | None |
| `windows_vmware_cpu_limit_mhz` | The maximum processing power in MHz allowed to the virtual machine. Assigning a CPU Limit ensures that this virtual machine never consumes more than a certain amount of the available processor power. By limiting the amount of processing power consumed, a portion of the processing power becomes available to other virtual machines. | gauge | None |
| `windows_vmware_cpu_reservation_mhz` | The minimum processing power in MHz available to the virtual machine. Assigning a CPU Reservation ensures that even as other virtual machines on the same host consume shared processing power, there is still a certain minimum amount for this virtual machine. | gauge | None |
| `windows_vmware_cpu_limit_hertz` | The maximum processing power in hertz allowed to the virtual machine. Assigning a CPU Limit ensures that this virtual machine never consumes more than a certain amount of the available processor power. By limiting the amount of processing power consumed, a portion of the processing power becomes available to other virtual machines. | gauge | None |
| `windows_vmware_cpu_reservation_hertz` | The minimum processing power in hertz available to the virtual machine. Assigning a CPU Reservation ensures that even as other virtual machines on the same host consume shared processing power, there is still a certain minimum amount for this virtual machine. | gauge | None |
| `windows_vmware_cpu_shares` | The number of CPU shares allocated to the virtual machine. | gauge | None |
| `windows_vmware_cpu_stolen_seconds_total` | The time that the VM was runnable but not scheduled to run | counter | None |
| `windows_vmware_cpu_time_seconds_total` | Current load of the VM’s virtual processor | counter | None |
| `windows_vmware_cpu_effective_vm_speed_mhz_total` | The effective speed of the VM’s virtual CPU | gauge | None |
| `windows_vmware_host_processor_speed_mhz` | Host Processor speed | gauge | None |
| `windows_vmware_cpu_effective_vm_speed_hertz` | The effective speed of the VM’s virtual CPU in hertz | gauge | None |
| `windows_vmware_host_processor_speed_hertz` | Host processor speed in hertz | gauge | None |
### Example metric
_This collector does not yet have explained examples, we would appreciate your help adding them!_