--- title: Vault description: Vault is a secrets management service application breadcrumbs: Docs > Integrations > Vault --- # Vault Supported OS Integration version7.4.1 ## Overview{% #overview %} This check monitors [Vault](https://www.vaultproject.io) cluster health and leader changes. **Minimum Agent version:** 6.3.2 ## Setup{% #setup %} ### Installation{% #installation %} The Vault check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. Starting with version 3.4.0, this OpenMetrics-based integration has a *latest* mode (`use_openmetrics`: true) and a *legacy* mode (`use_openmetrics`: false). To get all the most up-to-date features, Datadog recommends enabling the *latest* mode. Note that *latest* mode requires Python 3. For more information, see [Latest and Legacy Versioning For OpenMetrics-based Integrations](https://docs.datadoghq.com/integrations/guide/versions-for-openmetrics-based-integrations.md). 1. Ensure you have enabled [Prometheus metrics in the Vault configuration](https://www.vaultproject.io/docs/configuration/telemetry#prometheus). 1. For the Vault check to work properly, you need to either enable unauthenticated access to Vault metrics (using Vault version 1.3.0 or later) or provide a Vault client token: - To enable unauthenticated access, set Vault's [`unauthenticated_metrics_access`](https://www.vaultproject.io/docs/configuration/listener/tcp#unauthenticated_metrics_access) configuration to `true`. This allows unauthenticated access to the `/v1/sys/metrics` endpoint. **Note**: The `/sys/metrics` endpoint requires Vault v1.1.0 or later to collect metrics. - To use a Vault client token, follow the example below. The example uses the JWT auth method, but you can also use additional [auth methods](https://www.vaultproject.io/docs/auth). The Vault integration requires the following capabilities: - Content of `metrics_policy.hcl`: ```text path "sys/metrics*" { capabilities = ["read", "list"] } ``` - Setup policy and role: ```text $ vault policy write metrics /path/to/metrics_policy.hcl $ vault auth enable jwt $ vault write auth/jwt/config jwt_supported_algs=RS256 jwt_validation_pubkeys=@ $ vault write auth/jwt/role/datadog role_type=jwt bound_audiences= user_claim=name token_policies=metrics $ vault agent -config=/path/to/agent_config.hcl ``` - Content of `agent_config.hcl`: ``` exit_after_auth = true pid_file = "/tmp/agent_pid" auto_auth { method "jwt" { config = { path = "" role = "datadog" } } sink "file" { config = { path = "" } } } vault { address = "http://0.0.0.0:8200" } ``` ### Configuration{% #configuration %} {% tab title="Host" %} #### Host{% #host %} To configure this check for an Agent running on a host: 1. Edit the `vault.d/conf.yaml` file, in the `conf.d/` folder at the root of your [Agent's configuration directory](https://docs.datadoghq.com/agent/guide/agent-configuration-files.md#agent-configuration-directory) to start collecting your vault performance data. See the [sample vault.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/vault/datadog_checks/vault/data/conf.yaml.example) for all available configuration options. Configuration for running the integration without a token (with the Vault configuration `unauthenticated_metrics_access` set to true): ```yaml init_config: instances: ## @param api_url - string - required ## URL of the Vault to query. # - api_url: http://localhost:8200/v1 ## @param no_token - boolean - optional - default: false ## Attempt metric collection without a token. # no_token: true ``` Configuration for running the integration with a client token: ```yaml init_config: instances: ## @param api_url - string - required ## URL of the Vault to query. # - api_url: http://localhost:8200/v1 ## @param client_token - string - optional ## Client token necessary to collect metrics. # client_token: ## @param client_token_path - string - optional ## Path to a file containing the client token. Overrides `client_token`. ## The token will be re-read after every authorization error. # # client_token_path: ``` 1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands.md#start-stop-restart-the-agent). {% /tab %} {% tab title="Containerized" %} #### Containerized{% #containerized %} For containerized environments, see the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations.md) for guidance on applying the parameters below. | Parameter | Value | | -------------------- | ---------------------------------------- | | `` | `vault` | | `` | blank or `{}` | | `` | `{"api_url": "http://%%host%%:8200/v1"}` | `INSTANCE_CONFIG` needs to be customized depending on your vault authentication config. See example in Host section above. #### Log collection{% #log-collection %} *Available for Agent versions >6.0* 1. Collecting logs is disabled by default in the Datadog Agent, enable it in your `datadog.yaml` file: ```yaml logs_enabled: true ``` 1. Configure Vault to enable audit and server logs. - Audit logs must be enabled by a privileged user with the appropriate policies. See [Enabling audit devices](https://learn.hashicorp.com/vault/operations/troubleshooting-vault#enabling-audit-devices) for more information. ```shell vault audit enable file file_path=/vault/vault-audit.log ``` - Make sure that [server logs](https://learn.hashicorp.com/vault/operations/troubleshooting-vault#vault-server-logs) are written to file. You can configure static server logs in the [Vault systemd startup script](https://learn.hashicorp.com/vault/operations/troubleshooting-vault#not-finding-the-server-logs). The following script is outputting the logs to `/var/log/vault.log`. ```text ... [Service] ... ExecStart=/bin/sh -c '/home/vagrant/bin/vault server -config=/home/vagrant/vault_nano/config/vault -log-level="trace" > /var/log/vault.log' ... ``` 1. Add this configuration block to your `vault.d/conf.yaml` file to start collecting your Vault logs: ```yaml logs: - type: file path: /vault/vault-audit.log source: vault service: "" - type: file path: /var/log/vault.log source: vault service: "" ``` {% /tab %} ### Validation{% #validation %} Run the [Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands.md#agent-status-and-information) and look for `vault` under the Checks section. ## Data Collected{% #data-collected %} ### Metrics{% #metrics %} | | | | | **vault.core.active**(gauge) | PLACEHOLDER | | **vault.core.mount\_table.num\_entries**(gauge) | PLACEHOLDER | | **vault.core.mount\_table.size**(gauge) | PLACEHOLDER | | **vault.core.performance\_standby**(gauge) | PLACEHOLDER | | **vault.core.replication.dr.primary**(gauge) | PLACEHOLDER | | **vault.core.replication.dr.secondary**(gauge) | PLACEHOLDER | | **vault.core.replication.performance.primary**(gauge) | PLACEHOLDER | | **vault.core.replication.performance.secondary**(gauge) | PLACEHOLDER | | **vault.core.unsealed**(gauge) | PLACEHOLDER | | **vault.database.Close.count**(count) | Number of samples of vault.database.Close. | | **vault.database.Close.error**(count) | Number of database secrets engine close operation errors across all database secrets engines.*Shown as error* | | **vault.database.Close.quantile**(gauge) | Time taken to close a database secret engine across all database secrets engines quantile.*Shown as millisecond* | | **vault.database.Close.sum**(count) | Total time taken to close a database secret engine across all database secrets engines.*Shown as millisecond* | | **vault.database.CreateUser.count**(count) | Number of samples of vault.database.CreateUser. | | **vault.database.CreateUser.error**(count) | Number of user creation operation errors across all database secrets engines.*Shown as error* | | **vault.database.CreateUser.quantile**(gauge) | Time taken to create a user across all database secrets engine quantile.*Shown as millisecond* | | **vault.database.CreateUser.sum**(count) | Total time taken to create a user across all database secrets engine.*Shown as millisecond* | | **vault.database.Initialize.count**(count) | Number of samples of vault.database.Initialize. | | **vault.database.Initialize.error**(count) | Number of databases secrets engine initialization operation errors across all database secrets engines.*Shown as error* | | **vault.database.Initialize.quantile**(gauge) | Time taken to initialize a database secret engine across all database secrets engines quantile.*Shown as millisecond* | | **vault.database.Initialize.sum**(count) | Total time taken to initialize a database secret engine across all database secrets engines.*Shown as millisecond* | | **vault.database.RenewUser.count**(count) | Number of samples of vault.database.RenewUser. | | **vault.database.RenewUser.error**(count) | Number of user renewal operation errors across all database secrets engines.*Shown as error* | | **vault.database.RenewUser.quantile**(gauge) | Time taken to renew a user across all database secrets engines quantile.*Shown as millisecond* | | **vault.database.RenewUser.sum**(count) | Total time taken to renew a user across all database secrets engines.*Shown as millisecond* | | **vault.database.RevokeUser.count**(count) | Number of samples of vault.database.RevokeUser. | | **vault.database.RevokeUser.error**(count) | Number of user revocation operation errors across all database secrets engines.*Shown as error* | | **vault.database.RevokeUser.quantile**(gauge) | Time taken to revoke a user across all database secrets engines quantile.*Shown as millisecond* | | **vault.database.RevokeUser.sum**(count) | Total time taken to revoke a user across all database secrets engines.*Shown as millisecond* | | **vault.expire.num\_irrevocable\_leases**(gauge) | PLACEHOLDER | | **vault.go.gc.duration.seconds.count**(count) | Number of samples of vault.go.gc.duration.seconds. | | **vault.go.gc.duration.seconds.quantile**(gauge) | GC invocation duration quantile.*Shown as second* | | **vault.go.gc.duration.seconds.sum**(count) | GC invocation duration total.*Shown as second* | | **vault.go.goroutines**(gauge) | Number of goroutines that currently exist. | | **vault.go.info**(gauge) | Information about the Go environment. | | **vault.go.memstats.alloc.bytes**(gauge) | Number of bytes allocated and still in use. | | **vault.go.memstats.alloc.bytes.count**(count) | Total number of bytes allocated, even if freed. | | **vault.go.memstats.alloc.bytes.total**(count) | [Legacy] Total number of bytes allocated, even if freed. | | **vault.go.memstats.buck\_hash.sys.bytes**(gauge) | Number of bytes used by the profiling bucket hash table. | | **vault.go.memstats.frees.count**(count) | Total number of frees. | | **vault.go.memstats.frees.total**(count) | [Legacy] Total number of frees. | | **vault.go.memstats.gc.cpu.fraction**(gauge) | The fraction of this program's available CPU time used by the GC since the program started. | | **vault.go.memstats.gc.sys.bytes**(gauge) | Number of bytes used for garbage collection system metadata. | | **vault.go.memstats.heap.alloc.bytes**(gauge) | Number of heap bytes allocated and still in use. | | **vault.go.memstats.heap.idle.bytes**(gauge) | Number of heap bytes waiting to be used. | | **vault.go.memstats.heap.inuse.bytes**(gauge) | Number of heap bytes that are in use. | | **vault.go.memstats.heap.objects**(gauge) | Number of allocated objects. | | **vault.go.memstats.heap.released.bytes**(gauge) | Number of heap bytes released to OS. | | **vault.go.memstats.heap.sys.bytes**(gauge) | Number of heap bytes obtained from system. | | **vault.go.memstats.last.gc.time.seconds**(gauge) | Number of seconds since 1970 of last garbage collection. | | **vault.go.memstats.lookups.count**(count) | Total number of pointer lookups. | | **vault.go.memstats.lookups.total**(count) | [Legacy] Total number of pointer lookups. | | **vault.go.memstats.mallocs.count**(count) | Total number of mallocs. | | **vault.go.memstats.mallocs.total**(count) | [Legacy] Total number of mallocs. | | **vault.go.memstats.mcache.inuse.bytes**(gauge) | Number of bytes in use by mcache structures. | | **vault.go.memstats.mcache.sys.bytes**(gauge) | Number of bytes used for mcache structures obtained from system. | | **vault.go.memstats.mspan.inuse.bytes**(gauge) | Number of bytes in use by mspan structures. | | **vault.go.memstats.mspan.sys.bytes**(gauge) | Number of bytes used for mspan structures obtained from system. | | **vault.go.memstats.next.gc.bytes**(gauge) | Number of heap bytes when next garbage collection will take place. | | **vault.go.memstats.other.sys.bytes**(gauge) | Number of bytes used for other system allocations. | | **vault.go.memstats.stack.inuse.bytes**(gauge) | Number of bytes in use by the stack allocator. | | **vault.go.memstats.stack.sys.bytes**(gauge) | Number of bytes obtained from system for stack allocator. | | **vault.go.memstats.sys.bytes**(gauge) | Number of bytes obtained from system. | | **vault.go.threads**(gauge) | Number of OS threads created. | | **vault.identity.upsert\_entity\_txn.count**(count) | PLACEHOLDER | | **vault.identity.upsert\_entity\_txn.sum**(count) | PLACEHOLDER | | **vault.is\_leader**(gauge) | 1 if leader 0 otherwise. | | **vault.logshipper.streamWALs.guard\_found**(count) | Number of incidences where the starting Merkle Tree index used to begin streaming WAL entries is matched/found.*Shown as unit* | | **vault.logshipper.streamWALs.missing\_guard**(count) | Number of incidences where the starting Merkle Tree index used to begin streaming WAL entries is not matched/found.*Shown as unit* | | **vault.process.cpu.seconds.count**(count) | Total user and system CPU time spent in seconds. | | **vault.process.cpu.seconds.total**(count) | Total user and system CPU time spent in seconds. | | **vault.process.max.fds**(gauge) | Maximum number of open file descriptors. | | **vault.process.open.fds**(gauge) | Number of open file descriptors. | | **vault.process.resident\_memory.bytes**(gauge) | Resident memory size in bytes. | | **vault.process.start\_time.seconds**(gauge) | Start time of the process since unix epoch in seconds. | | **vault.process.virtual\_memory.bytes**(gauge) | Virtual memory size in bytes. | | **vault.process.virtual\_memory.max.bytes**(gauge) | Maximum amount of virtual memory available in bytes. | | **vault.replication.fetchRemoteKeys.count**(count) | Number of samples of vault.replication.fetchRemoteKeys. | | **vault.replication.fetchRemoteKeys.quantile**(gauge) | Time taken to fetch keys from a remote cluster participating in replication prior to Merkle Tree based delta generation quantile.*Shown as millisecond* | | **vault.replication.fetchRemoteKeys.sum**(count) | Total time taken to fetch keys from a remote cluster participating in replication prior to Merkle Tree based delta generation.*Shown as millisecond* | | **vault.replication.fsm.last\_remote\_wal**(gauge) | The index of the last remote WAL.*Shown as index* | | **vault.replication.merkle.commit\_index**(gauge) | The last committed index in the Merkle Tree.*Shown as index* | | **vault.replication.merkleDiff.count**(count) | Number of samples of vault.replication.merkleDiff. | | **vault.replication.merkleDiff.quantile**(gauge) | Time taken to perform a Merkle Tree based delta generation between the clusters participating in replication quantile.*Shown as millisecond* | | **vault.replication.merkleDiff.sum**(count) | Total time taken to perform a Merkle Tree based delta generation between the clusters participating in replication.*Shown as millisecond* | | **vault.replication.merkleSync.count**(count) | Number of samples of vault.replication.merkleSync. | | **vault.replication.merkleSync.quantile**(gauge) | Time taken to perform a Merkle Tree based synchronization using the last delta generated between the clusters participating in replication quantile.*Shown as millisecond* | | **vault.replication.merkleSync.sum**(count) | Total time taken to perform a Merkle Tree based synchronization using the last delta generated between the clusters participating in replication.*Shown as millisecond* | | **vault.replication.rpc.client.conflicting\_pages.count**(count) | Number of samples of vault.replication.rpc.client.conflicting_pages. | | **vault.replication.rpc.client.conflicting\_pages.quantile**(gauge) | Duration of time taken by client conflicting pages request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.conflicting\_pages.sum**(count) | Total duration of time taken by client conflicting pages request.*Shown as millisecond* | | **vault.replication.rpc.client.fetch\_keys.count**(count) | Number of samples of vault.replication.rpc.client.fetch_keys. | | **vault.replication.rpc.client.fetch\_keys.quantile**(gauge) | Duration of time taken by client fetch keys request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.fetch\_keys.sum**(count) | Total duration of time taken by client fetch keys request.*Shown as millisecond* | | **vault.replication.rpc.client.forward.count**(count) | Number of samples of vault.replication.rpc.client.forward. | | **vault.replication.rpc.client.forward.quantile**(gauge) | Duration of time taken by client forward request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.forward.sum**(count) | Total duration of time taken by client forward request.*Shown as millisecond* | | **vault.replication.rpc.client.guard\_hash.count**(count) | Number of samples of vault.replication.rpc.client.guard_hash. | | **vault.replication.rpc.client.guard\_hash.quantile**(gauge) | Duration of time taken by client guard hash request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.guard\_hash.sum**(count) | Total duration of time taken by client guard hash request.*Shown as millisecond* | | **vault.replication.rpc.client.persist\_alias.count**(count) | Number of samples of vault.replication.rpc.client.persist_alias. | | **vault.replication.rpc.client.persist\_alias.quantile**(gauge) | Duration of time taken by client persist alias request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.persist\_alias.sum**(count) | Total duration of time taken by client persist alias request.*Shown as millisecond* | | **vault.replication.rpc.client.register\_auth.count**(count) | Number of samples of vault.replication.rpc.client.register_auth. | | **vault.replication.rpc.client.register\_auth.quantile**(gauge) | Duration of time taken by client register auth request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.register\_auth.sum**(count) | Total duration of time taken by client register auth request.*Shown as millisecond* | | **vault.replication.rpc.client.register\_lease.count**(count) | Number of samples of vault.replication.rpc.client.register_lease. | | **vault.replication.rpc.client.register\_lease.quantile**(gauge) | Duration of time taken by client register lease request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.register\_lease.sum**(count) | Total duration of time taken by client register lease request.*Shown as millisecond* | | **vault.replication.rpc.client.stream\_wals.count**(count) | Number of samples of vault.replication.rpc.client.stream_wals. | | **vault.replication.rpc.client.stream\_wals.quantile**(gauge) | Duration of time taken by client stream wals request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.stream\_wals.sum**(count) | Total duration of time taken by client stream wals request.*Shown as millisecond* | | **vault.replication.rpc.client.sub\_page\_hashes.count**(count) | Number of samples of vault.replication.rpc.client.sub_page_hashes. | | **vault.replication.rpc.client.sub\_page\_hashes.quantile**(gauge) | Duration of time taken by client sub page hashes request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.sub\_page\_hashes.sum**(count) | Total duration of time taken by client sub page hashes request.*Shown as millisecond* | | **vault.replication.rpc.client.sync\_counter.count**(count) | Number of samples of vault.replication.rpc.client.sync_counter. | | **vault.replication.rpc.client.sync\_counter.quantile**(gauge) | Duration of time taken by client sync counter request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.sync\_counter.sum**(count) | Total duration of time taken by client sync counter request.*Shown as millisecond* | | **vault.replication.rpc.client.upsert\_group.count**(count) | Number of samples of vault.replication.rpc.client.upsert_group. | | **vault.replication.rpc.client.upsert\_group.quantile**(gauge) | Duration of time taken by client upsert group request quantile.*Shown as millisecond* | | **vault.replication.rpc.client.upsert\_group.sum**(count) | Total duration of time taken by client upsert group request.*Shown as millisecond* | | **vault.replication.rpc.client.wrap\_in\_cubbyhole.count**(count) | Number of samples of vault.replication.rpc.client.wrap_in_cubbyhole. | | **vault.replication.rpc.client.wrap\_in\_cubbyhole.quantile**(gauge) | Duration of time taken by client wrap in cubbyhole request.*Shown as millisecond* | | **vault.replication.rpc.client.wrap\_in\_cubbyhole.sum**(count) | Total duration of time taken by client wrap in cubbyhole request.*Shown as millisecond* | | **vault.replication.rpc.dr.server.echo.count**(count) | Number of samples of vault.replication.rpc.dr.server.echo. | | **vault.replication.rpc.dr.server.echo.quantile**(gauge) | Duration of time taken by DR echo request quantile.*Shown as millisecond* | | **vault.replication.rpc.dr.server.echo.sum**(count) | Total duration of time taken by DR echo request.*Shown as millisecond* | | **vault.replication.rpc.dr.server.fetch\_keys\_request.count**(count) | Number of samples of vault.replication.rpc.dr.server.fetch_keys_request. | | **vault.replication.rpc.dr.server.fetch\_keys\_request.quantile**(gauge) | Duration of time taken by DR fetch keys request quantile.*Shown as millisecond* | | **vault.replication.rpc.dr.server.fetch\_keys\_request.sum**(count) | Total duration of time taken by DR fetch keys request.*Shown as millisecond* | | **vault.replication.rpc.server.auth\_request.count**(count) | Number of samples of vault.replication.rpc.server.auth_request. | | **vault.replication.rpc.server.auth\_request.quantile**(gauge) | Duration of time taken by auth request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.auth\_request.sum**(count) | Total duration of time taken by auth request.*Shown as millisecond* | | **vault.replication.rpc.server.bootstrap\_request.count**(count) | Number of samples of vault.replication.rpc.server.bootstrap_request. | | **vault.replication.rpc.server.bootstrap\_request.quantile**(gauge) | Duration of time taken by bootstrap request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.bootstrap\_request.sum**(count) | Total duration of time taken by bootstrap request.*Shown as millisecond* | | **vault.replication.rpc.server.conflicting\_pages\_request.count**(count) | Number of samples of vault.replication.rpc.server.conflicting_pages_request. | | **vault.replication.rpc.server.conflicting\_pages\_request.quantile**(gauge) | Duration of time taken by conflicting pages request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.conflicting\_pages\_request.sum**(count) | Total duration of time taken by conflicting pages request.*Shown as millisecond* | | **vault.replication.rpc.server.echo.count**(count) | Number of samples of vault.replication.rpc.server.echo. | | **vault.replication.rpc.server.echo.quantile**(gauge) | Duration of time taken by echo quantile.*Shown as millisecond* | | **vault.replication.rpc.server.echo.sum**(count) | Total duration of time taken by echo.*Shown as millisecond* | | **vault.replication.rpc.server.forwarding\_request.count**(count) | Number of samples of vault.replication.rpc.server.forwarding_request. | | **vault.replication.rpc.server.forwarding\_request.quantile**(gauge) | Duration of time taken by forwarding request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.forwarding\_request.sum**(count) | Total duration of time taken by forwarding request.*Shown as millisecond* | | **vault.replication.rpc.server.guard\_hash\_request.count**(count) | Number of samples of vault.replication.rpc.server.guard_hash_request. | | **vault.replication.rpc.server.guard\_hash\_request.quantile**(gauge) | Duration of time taken by guard hash request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.guard\_hash\_request.sum**(count) | Total duration of time taken by guard hash request.*Shown as millisecond* | | **vault.replication.rpc.server.persist\_alias\_request.count**(count) | Number of samples of vault.replication.rpc.server.persist_alias_request. | | **vault.replication.rpc.server.persist\_alias\_request.quantile**(gauge) | Duration of time talen by persist alias request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.persist\_alias\_request.sum**(count) | Total duration of time talen by persist alias request.*Shown as millisecond* | | **vault.replication.rpc.server.persist\_persona\_request.count**(count) | Number of samples of vault.replication.rpc.server.persist_persona_request. | | **vault.replication.rpc.server.persist\_persona\_request.quantile**(gauge) | Duration of time taken by persist persona request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.persist\_persona\_request.sum**(count) | Total duration of time taken by persist persona request.*Shown as millisecond* | | **vault.replication.rpc.server.stream\_wals\_request.count**(count) | Number of samples of vault.replication.rpc.server.stream_wals_request. | | **vault.replication.rpc.server.stream\_wals\_request.quantile**(gauge) | Duration of time taken by stream wals request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.stream\_wals\_request.sum**(count) | Total duration of time taken by stream wals request.*Shown as millisecond* | | **vault.replication.rpc.server.sub\_page\_hashes\_request.count**(count) | Number of samples of vault.replication.rpc.server.sub_page_hashes_request. | | **vault.replication.rpc.server.sub\_page\_hashes\_request.quantile**(gauge) | Duration of time taken by sub page hashes request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.sub\_page\_hashes\_request.sum**(count) | Total duration of time taken by sub page hashes request.*Shown as millisecond* | | **vault.replication.rpc.server.sync\_counter\_request.count**(count) | Number of samples of vault.replication.rpc.server.sync_counter_request. | | **vault.replication.rpc.server.sync\_counter\_request.quantile**(gauge) | Duration of time taken by sync counter request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.sync\_counter\_request.sum**(count) | Total duration of time taken by sync counter request.*Shown as millisecond* | | **vault.replication.rpc.server.upsert\_group\_request.count**(count) | Number of samples of vault.replication.rpc.server.upsert_group_request. | | **vault.replication.rpc.server.upsert\_group\_request.quantile**(gauge) | Duration of time taken by upsert group request quantile.*Shown as millisecond* | | **vault.replication.rpc.server.upsert\_group\_request.sum**(count) | Total duration of time taken by upsert group request.*Shown as millisecond* | | **vault.replication.rpc.standby.server.echo.count**(count) | Number of samples of vault.replication.rpc.standby.server.echo. | | **vault.replication.rpc.standby.server.echo.quantile**(gauge) | Duration of time taken by standby echo request quantile.*Shown as millisecond* | | **vault.replication.rpc.standby.server.echo.sum**(count) | Total duration of time taken by standby echo request.*Shown as millisecond* | | **vault.replication.rpc.standby.server.register\_auth\_request.count**(count) | Number of samples of vault.replication.rpc.standby.server.register_auth_request. | | **vault.replication.rpc.standby.server.register\_auth\_request.quantile**(gauge) | Duration of time taken by standby register auth request quantile.*Shown as millisecond* | | **vault.replication.rpc.standby.server.register\_auth\_request.sum**(count) | Total duration of time taken by standby register auth request.*Shown as millisecond* | | **vault.replication.rpc.standby.server.register\_lease\_request.count**(count) | Number of samples of vault.replication.rpc.standby.server.register_lease_request. | | **vault.replication.rpc.standby.server.register\_lease\_request.quantile**(gauge) | Duration of time taken by standby register lease request quantile.*Shown as millisecond* | | **vault.replication.rpc.standby.server.register\_lease\_request.sum**(count) | Total duration of time taken by standby register lease request.*Shown as millisecond* | | **vault.replication.rpc.standby.server.wrap\_token\_request.count**(count) | Number of samples of vault.replication.rpc.standby.server.wrap_token_request. | | **vault.replication.rpc.standby.server.wrap\_token\_request.quantile**(gauge) | Duration of time taken by standby wrap token request quantile.*Shown as millisecond* | | **vault.replication.rpc.standby.server.wrap\_token\_request.sum**(count) | Total duration of time taken by standby wrap token request.*Shown as millisecond* | | **vault.replication.wal.gc.count**(count) | Time taken to complete one run of the WAL garbage collection process*Shown as millisecond* | | **vault.replication.wal.gc.quantile**(gauge) | Time taken to complete one run of the WAL garbage collection process*Shown as millisecond* | | **vault.replication.wal.gc.sum**(count) | Time taken to complete one run of the WAL garbage collection process*Shown as millisecond* | | **vault.replication.wal.last\_dr\_wal**(gauge) | The index of the last DR WAL.*Shown as index* | | **vault.replication.wal.last\_performance\_wal**(gauge) | The index of the last Performance WAL.*Shown as index* | | **vault.replication.wal.last\_wal**(gauge) | The index of the last WAL.*Shown as index* | | **vault.route.create.auth.jwt.count**(count) | [Legacy] Number of samples of vault.route.create.auth.jwt. | | **vault.route.create.auth.jwt.quantile**(gauge) | [Legacy] Time taken to perform a rollback operation for the JWT auth method quantile.*Shown as millisecond* | | **vault.route.create.auth.jwt.sum**(gauge) | [Legacy] Total time taken to perform a rollback operation for the JWT auth method.*Shown as millisecond* | | **vault.route.create.count**(count) | [Legacy] Number of samples of vault.route.create. | | **vault.route.create.quantile**(gauge) | [Legacy] Quantile time taken to dispatch a create operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.route.create.sum**(gauge) | [Legacy] Total time taken to dispatch and process a create operation.*Shown as millisecond* | | **vault.route.delete.count**(count) | [Legacy] Number of samples of vault.route.delete. | | **vault.route.delete.quantile**(gauge) | [Legacy] Quantile time taken to dispatch a delete operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.route.delete.sum**(gauge) | [Legacy] Total time taken to dispatch and process a delete operation.*Shown as millisecond* | | **vault.route.list.count**(count) | [Legacy] Number of samples of vault.route.list. | | **vault.route.list.quantile**(gauge) | [Legacy] Quantile time taken to dispatch a list operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.route.list.sum**(gauge) | [Legacy] Total time taken to dispatch and process a list operation.*Shown as millisecond* | | **vault.route.read.auth.token.count**(count) | [Legacy] Number of samples of vault.route.auth.token | | **vault.route.read.auth.token.quantile**(gauge) | [Legacy] Quantile time taken to dispatch a read operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.route.read.auth.token.sum**(gauge) | [Legacy] Total time taken to dispatch and process a read operation.*Shown as millisecond* | | **vault.route.read.count**(count) | [Legacy] Number of samples of vault.route.read. | | **vault.route.read.create.auth.token.count**(count) | [Legacy] Number of samples of vault.route.read.auth.token | | **vault.route.read.create.auth.token.quantile**(gauge) | [Legacy] Quantile time taken to dispatch a read operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.route.read.create.auth.token.sum**(gauge) | [Legacy] Total time taken to dispatch and process a read operation.*Shown as millisecond* | | **vault.route.read.quantile**(gauge) | [Legacy] Quantile time taken to dispatch a read operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.route.read.sum**(gauge) | [Legacy] Total time taken to dispatch and process a read operation.*Shown as millisecond* | | **vault.route.rollback.auth.jwt.count**(count) | [Legacy] Number of samples of vault.route.rollback.auth.jwt. | | **vault.route.rollback.auth.jwt.quantile**(gauge) | [Legacy] Time taken to perform a rollback operation for the JWT auth method quantile.*Shown as millisecond* | | **vault.route.rollback.auth.jwt.sum**(gauge) | [Legacy] Total time taken to perform a rollback operation for the JWT auth method.*Shown as millisecond* | | **vault.route.rollback.auth.token.count**(count) | [Legacy] Number of samples of vault.route.rollback.auth.token. | | **vault.route.rollback.auth.token.quantile**(gauge) | [Legacy] Time taken to perform a route rollback operation for the token auth method quantile.*Shown as millisecond* | | **vault.route.rollback.auth.token.sum**(gauge) | [Legacy] Total time taken to perform a route rollback operation for the token auth method.*Shown as millisecond* | | **vault.route.rollback.count**(count) | [Legacy] Number of samples of vault.route.rollback. | | **vault.route.rollback.quantile**(gauge) | [Legacy] Quantile time taken to dispatch a rollback operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.route.rollback.sum**(gauge) | [Legacy] Total time taken to dispatch and process a rollback operation.*Shown as millisecond* | | **vault.secrets.pki.tidy.cert\_store\_current\_entry**(gauge) | The index of the current entry in the certificate store being verified by the tidy operation | | **vault.secrets.pki.tidy.cert\_store\_deleted\_count**(count) | Number of entries deleted from the certificate store | | **vault.secrets.pki.tidy.cert\_store\_total\_entries**(gauge) | Number of entries in the certificate store to verify during the tidy operation | | **vault.secrets.pki.tidy.cert\_store\_total\_entries\_remaining**(gauge) | Number of entries in the certificate store that are left after the tidy operation (checked but not removed). | | **vault.secrets.pki.tidy.duration.count**(count) | Duration of time taken by the PKI tidy operation | | **vault.secrets.pki.tidy.duration.sum**(count) | Duration of time taken by the PKI tidy operation*Shown as millisecond* | | **vault.secrets.pki.tidy.failure**(count) | Number of times the PKI tidy operation has not completed due to errors | | **vault.secrets.pki.tidy.revoked\_cert\_current\_entry**(gauge) | The index of the current revoked certificate entry in the certificate store being verified by the tidy operation | | **vault.secrets.pki.tidy.revoked\_cert\_deleted\_count**(count) | Number of entries deleted from the certificate store for revoked certificates | | **vault.secrets.pki.tidy.revoked\_cert\_total\_entries**(gauge) | Number of entries in the certificate store for revoked certificates to verify during the tidy operation | | **vault.secrets.pki.tidy.revoked\_cert\_total\_entries\_fixed\_issuers**(gauge) | Number of entries in the certificate store which had incorrect issuer information that was fixed during this tidy operation. | | **vault.secrets.pki.tidy.revoked\_cert\_total\_entries\_incorrect\_issuers**(gauge) | Number of entries in the certificate store which had incorrect issuer information (total). | | **vault.secrets.pki.tidy.revoked\_cert\_total\_entries\_remaining**(gauge) | Number of entries in the certificate store for revoked certificates that are left after the tidy operation (checked but not removed). | | **vault.secrets.pki.tidy.start\_time\_epoch**(gauge) | Start time (as seconds since Jan 1 1970) when the PKI tidy operation is active, 0 otherwise | | **vault.secrets.pki.tidy.success**(count) | Number of times the PKI tidy operation has been completed successfully | | **vault.vault.audit.log.request.count**(count) | Number of samples of vault.vault.audit.log.request. | | **vault.vault.audit.log.request.failure**(count) | Number of audit log request failures.*Shown as unit* | | **vault.vault.audit.log.request.failure.count**(count) | [Legacy] Number of audit log request failures.*Shown as unit* | | **vault.vault.audit.log.request.quantile**(gauge) | Duration of time taken by all audit log requests across all audit log devices.*Shown as millisecond* | | **vault.vault.audit.log.request.sum**(count) | Total duration of time taken by all audit log requests across all audit log devices.*Shown as millisecond* | | **vault.vault.audit.log.response.count**(count) | Number of samples of vault.vault.audit.log.response. | | **vault.vault.audit.log.response.failure**(count) | Number of audit log response failures.*Shown as unit* | | **vault.vault.audit.log.response.failure.count**(count) | Number of audit log response failures.*Shown as unit* | | **vault.vault.audit.log.response.quantile**(gauge) | Duration of time taken by audit log responses across all audit log devices quantile.*Shown as millisecond* | | **vault.vault.audit.log.response.sum**(count) | Total duration of time taken by audit log responses across all audit log devices.*Shown as millisecond* | | **vault.vault.azure.delete.count**(count) | Number of samples of vault.vault.azure.delete. | | **vault.vault.azure.delete.quantile**(gauge) | Duration of a DELETE operation against the Azure storage backend quantile.*Shown as millisecond* | | **vault.vault.azure.delete.sum**(count) | Total duration of a DELETE operation against the Azure storage backend.*Shown as millisecond* | | **vault.vault.azure.get.count**(count) | Number of samples of vault.vault.azure.get. | | **vault.vault.azure.get.quantile**(gauge) | Duration of a GET operation against the Azure storage backend quantile.*Shown as millisecond* | | **vault.vault.azure.get.sum**(count) | Total duration of a GET operation against the Azure storage backend.*Shown as millisecond* | | **vault.vault.azure.list.count**(count) | Number of samples of vault.vault.azure.list. | | **vault.vault.azure.list.quantile**(gauge) | Duration of a LIST operation against the Azure storage backend quantile.*Shown as millisecond* | | **vault.vault.azure.list.sum**(count) | Total duration of a LIST operation against the Azure storage backend.*Shown as millisecond* | | **vault.vault.azure.put.count**(count) | Number of samples of vault.vault.azure.put. | | **vault.vault.azure.put.quantile**(gauge) | Duration of a PUT operation against Azure storage backend quantile.*Shown as millisecond* | | **vault.vault.azure.put.sum**(count) | Total duration of a PUT operation against Azure storage backend.*Shown as millisecond* | | **vault.vault.barrier.delete.count**(count) | Number of samples of vault.vault.barrier.delete. | | **vault.vault.barrier.delete.quantile**(gauge) | Duration of time taken by DELETE operations at the barrier quantile.*Shown as millisecond* | | **vault.vault.barrier.delete.sum**(count) | Total duration of time taken by DELETE operations at the barrier.*Shown as millisecond* | | **vault.vault.barrier.get.count**(count) | Number of samples of vault.vault.barrier.get. | | **vault.vault.barrier.get.quantile**(gauge) | Duration of time taken by GET operations at the barrier quantile.*Shown as millisecond* | | **vault.vault.barrier.get.sum**(count) | Total duration of time taken by GET operations at the barrier.*Shown as millisecond* | | **vault.vault.barrier.list.count**(count) | Number of samples of vault.vault.barrier.list. | | **vault.vault.barrier.list.quantile**(gauge) | Duration of time taken by LIST operations at the barrier quantile.*Shown as millisecond* | | **vault.vault.barrier.list.sum**(count) | Total duration of time taken by LIST operations at the barrier.*Shown as millisecond* | | **vault.vault.barrier.put.count**(count) | Number of samples of vault.vault.barrier.put. | | **vault.vault.barrier.put.quantile**(gauge) | Duration of time taken by PUT operations at the barrier.*Shown as millisecond* | | **vault.vault.barrier.put.sum**(count) | Total duration of time taken by PUT operations at the barrier.*Shown as millisecond* | | **vault.vault.cache.delete**(count) | Number of times a value was deleted from the LRU cache. This does not count cache expirations. | | **vault.vault.cache.hit**(count) | [Legacy] Number of times a value was retrieved from the LRU cache. | | **vault.vault.cache.hit.count**(count) | Number of times a value was retrieved from the LRU cache. | | **vault.vault.cache.miss**(count) | [Legacy] Number of times a value was not in the LRU cache. The results in a read from the configured storage. | | **vault.vault.cache.miss.count**(count) | Number of times a value was not in the LRU cache. The results in a read from the configured storage. | | **vault.vault.cache.write**(count) | [Legacy] Number of times a value was written to the LRU cache. | | **vault.vault.cache.write.count**(count) | Number of times a value was written to the LRU cache. | | **vault.vault.cassandra.delete.count**(count) | Number of samples of vault.vault.cassandra.delete. | | **vault.vault.cassandra.delete.quantile**(gauge) | Duration of a DELETE operation against the Cassandra storage backend quantile.*Shown as millisecond* | | **vault.vault.cassandra.delete.sum**(count) | Total duration of a DELETE operation against the Cassandra storage backend.*Shown as millisecond* | | **vault.vault.cassandra.get.count**(count) | Number of samples of vault.vault.cassandra.get. | | **vault.vault.cassandra.get.quantile**(gauge) | Duration of a GET operation against the Cassandra storage backend.*Shown as millisecond* | | **vault.vault.cassandra.get.sum**(count) | Total duration of a GET operation against the Cassandra storage backend.*Shown as millisecond* | | **vault.vault.cassandra.list.count**(count) | Number of samples of vault.vault.cassandra.list. | | **vault.vault.cassandra.list.quantile**(gauge) | Duration of a LIST operation against the Cassandra storage backend quantile.*Shown as millisecond* | | **vault.vault.cassandra.list.sum**(count) | Total duration of a LIST operation against the Cassandra storage backend.*Shown as millisecond* | | **vault.vault.cassandra.put.count**(count) | Number of samples of vault.vault.cassandra.put. | | **vault.vault.cassandra.put.quantile**(gauge) | Duration of a PUT operation against the Cassandra storage backend quantile.*Shown as millisecond* | | **vault.vault.cassandra.put.sum**(count) | Total duration of a PUT operation against the Cassandra storage backend.*Shown as millisecond* | | **vault.vault.cockroachdb.delete.count**(count) | Number of samples of vault.vault.cockroachdb.delete. | | **vault.vault.cockroachdb.delete.quantile**(gauge) | Duration of a DELETE operation against the CockroachDB storage backend quantile.*Shown as millisecond* | | **vault.vault.cockroachdb.delete.sum**(count) | Total duration of a DELETE operation against the CockroachDB storage backend.*Shown as millisecond* | | **vault.vault.cockroachdb.get.count**(count) | Number of samples of vault.vault.cockroachdb.get. | | **vault.vault.cockroachdb.get.quantile**(gauge) | Duration of a GET operation against the CockroachDB storage backend quantile.*Shown as millisecond* | | **vault.vault.cockroachdb.get.sum**(count) | Total duration of a GET operation against the CockroachDB storage backend.*Shown as millisecond* | | **vault.vault.cockroachdb.list.count**(count) | Number of samples of vault.vault.cockroachdb.list. | | **vault.vault.cockroachdb.list.quantile**(gauge) | Duration of a LIST operation against the CockroachDB storage backend quantile.*Shown as millisecond* | | **vault.vault.cockroachdb.list.sum**(count) | Total duration of a LIST operation against the CockroachDB storage backend.*Shown as millisecond* | | **vault.vault.cockroachdb.put.count**(count) | Number of samples of vault.vault.cockroachdb.put. | | **vault.vault.cockroachdb.put.quantile**(gauge) | Duration of a PUT operation against the CockroachDB storage backend quantile.*Shown as millisecond* | | **vault.vault.cockroachdb.put.sum**(count) | Total duration of a PUT operation against the CockroachDB storage backend.*Shown as millisecond* | | **vault.vault.consul.delete.count**(count) | Number of samples of vault.vault.consul.delete. | | **vault.vault.consul.delete.quantile**(gauge) | Duration of DELETE operation against the Consul storage backend quantile.*Shown as millisecond* | | **vault.vault.consul.delete.sum**(count) | Total duration of DELETE operation against the Consul storage backend.*Shown as millisecond* | | **vault.vault.consul.get.count**(count) | Number of samples of vault.vault.consul.get. | | **vault.vault.consul.get.quantile**(gauge) | Duration of a GET operation against the Consul storage backend quantile.*Shown as millisecond* | | **vault.vault.consul.get.sum**(count) | Total duration of a GET operation against the Consul storage backend.*Shown as millisecond* | | **vault.vault.consul.list.count**(count) | Number of samples of vault.vault.consul.list. | | **vault.vault.consul.list.quantile**(gauge) | Duration of a LIST operation against the Consul storage backend quantile.*Shown as millisecond* | | **vault.vault.consul.list.sum**(count) | Total duration of a LIST operation against the Consul storage backend.*Shown as millisecond* | | **vault.vault.consul.put.count**(count) | Number of samples of vault.vault.consul.put. | | **vault.vault.consul.put.quantile**(gauge) | Duration of a PUT operation against the Consul storage backend quantile.*Shown as millisecond* | | **vault.vault.consul.put.sum**(count) | Total duration of a PUT operation against the Consul storage backend.*Shown as millisecond* | | **vault.vault.core.check.token.count**(count) | Number of samples of vault.vault.core.check.token. | | **vault.vault.core.check.token.quantile**(gauge) | Duration of time taken by token checks handled by Vault core quantile.*Shown as millisecond* | | **vault.vault.core.check.token.sum**(count) | Total duration of time taken by token checks handled by Vault core.*Shown as millisecond* | | **vault.vault.core.fetch.acl\_and\_token.count**(count) | Number of samples of vault.vault.core.fetch.acl_and_token. | | **vault.vault.core.fetch.acl\_and\_token.quantile**(gauge) | Duration of time taken by ACL and corresponding token entry fetches handled by Vault core quantile.*Shown as millisecond* | | **vault.vault.core.fetch.acl\_and\_token.sum**(count) | Total duration of time taken by ACL and corresponding token entry fetches handled by Vault core.*Shown as millisecond* | | **vault.vault.core.handle.login\_request.count**(count) | Number of samples of vault.vault.core.handle.login_request. | | **vault.vault.core.handle.login\_request.quantile**(gauge) | Duration of time taken by login requests handled by Vault core quantile.*Shown as millisecond* | | **vault.vault.core.handle.login\_request.sum**(count) | Total duration of time taken by login requests handled by Vault core.*Shown as millisecond* | | **vault.vault.core.handle.request.count**(count) | Number of samples of vault.vault.core.handle.request. | | **vault.vault.core.handle.request.quantile**(gauge) | Duration of time taken by requests handled by Vault core quantile.*Shown as millisecond* | | **vault.vault.core.handle.request.sum**(count) | Total duration of time taken by requests handled by Vault core.*Shown as millisecond* | | **vault.vault.core.leadership.lost.count**(count) | Number of samples of vault.vault.core.leadership.lost. | | **vault.vault.core.leadership.lost.quantile**(gauge) | Duration of time taken by cluster leadership losses which have occurred in a highly available Vault cluster quantile.*Shown as millisecond* | | **vault.vault.core.leadership.lost.sum**(count) | Total duration of time taken by cluster leadership losses which have occurred in a highly available Vault cluster.*Shown as millisecond* | | **vault.vault.core.leadership.setup\_failed.count**(count) | Number of samples of vault.vault.core.leadership.setup_failed. | | **vault.vault.core.leadership.setup\_failed.quantile**(gauge) | Duration of time taken by cluster leadership setup failures which have occurred in a highly available Vault cluster quantile.*Shown as millisecond* | | **vault.vault.core.leadership.setup\_failed.sum**(count) | Total duration of time taken by cluster leadership setup failures which have occurred in a highly available Vault cluster.*Shown as millisecond* | | **vault.vault.core.post\_unseal**(gauge) | Duration of time taken by post-unseal operations handled by Vault core.*Shown as millisecond* | | **vault.vault.core.post\_unseal.count**(count) | Number of samples of vault.vault.core.post_unseal. | | **vault.vault.core.post\_unseal.sum**(count) | Duration of time taken by post-unseal operations handled by Vault core.*Shown as millisecond* | | **vault.vault.core.pre\_seal**(gauge) | Duration of time taken by pre-seal operations.*Shown as millisecond* | | **vault.vault.core.seal**(gauge) | Duration of time taken by seal operations.*Shown as millisecond* | | **vault.vault.core.seal\_internal**(gauge) | Duration of time taken by internal seal operations.*Shown as millisecond* | | **vault.vault.core.seal\_with\_request**(gauge) | Duration of time taken by requested seal operations.*Shown as millisecond* | | **vault.vault.core.step\_down.count**(count) | Number of samples of vault.vault.core.step_down. | | **vault.vault.core.step\_down.quantile**(gauge) | Duration of time taken by cluster leadership step downs quantile.*Shown as millisecond* | | **vault.vault.core.step\_down.sum**(count) | Total duration of time taken by cluster leadership step downs.*Shown as millisecond* | | **vault.vault.core.unseal.count**(count) | Number of samples of vault.vault.core.unseal. | | **vault.vault.core.unseal.quantile**(gauge) | Duration of time taken by unseal operations quantile.*Shown as millisecond* | | **vault.vault.core.unseal.sum**(count) | Total duration of time taken by unseal operations.*Shown as millisecond* | | **vault.vault.couchdb.delete.count**(count) | Number of samples of vault.vault.couchdb.delete. | | **vault.vault.couchdb.delete.quantile**(gauge) | Duration of a DELETE operation against the CouchDB storage backend quantile.*Shown as millisecond* | | **vault.vault.couchdb.delete.sum**(count) | Total duration of a DELETE operation against the CouchDB storage backend.*Shown as millisecond* | | **vault.vault.couchdb.get.count**(count) | Number of samples of vault.vault.couchdb.get. | | **vault.vault.couchdb.get.quantile**(gauge) | Duration of a GET operation against the CouchDB storage backend quantile.*Shown as millisecond* | | **vault.vault.couchdb.get.sum**(count) | Total duration of a GET operation against the CouchDB storage backend.*Shown as millisecond* | | **vault.vault.couchdb.list.count**(count) | Number of samples of vault.vault.couchdb.list. | | **vault.vault.couchdb.list.quantile**(gauge) | Duration of a LIST operation against the CouchDB storage backend quantile.*Shown as millisecond* | | **vault.vault.couchdb.list.sum**(count) | Total duration of a LIST operation against the CouchDB storage backend.*Shown as millisecond* | | **vault.vault.couchdb.put.count**(count) | Number of samples of vault.vault.couchdb.put. | | **vault.vault.couchdb.put.quantile**(gauge) | Duration of a PUT operation against the CouchDB storage backend quantile.*Shown as millisecond* | | **vault.vault.couchdb.put.sum**(count) | Total duration of a PUT operation against the CouchDB storage backend.*Shown as millisecond* | | **vault.vault.dynamodb.delete.count**(count) | Number of samples of vault.vault.dynamodb.delete. | | **vault.vault.dynamodb.delete.quantile**(gauge) | Duration of a DELETE operation against the DynamoDB storage backend quantile.*Shown as millisecond* | | **vault.vault.dynamodb.delete.sum**(count) | Total duration of a DELETE operation against the DynamoDB storage backend.*Shown as millisecond* | | **vault.vault.dynamodb.get.count**(count) | Number of samples of vault.vault.dynamodb.get. | | **vault.vault.dynamodb.get.quantile**(gauge) | Duration of a GET operation against the DynamoDB storage backend quantile.*Shown as millisecond* | | **vault.vault.dynamodb.get.sum**(count) | Total duration of a GET operation against the DynamoDB storage backend.*Shown as millisecond* | | **vault.vault.dynamodb.list.count**(count) | Number of samples of vault.vault.dynamodb.list. | | **vault.vault.dynamodb.list.quantile**(gauge) | Duration of a LIST operation against the DynamoDB storage backend quantile.*Shown as millisecond* | | **vault.vault.dynamodb.list.sum**(count) | Total duration of a LIST operation against the DynamoDB storage backend.*Shown as millisecond* | | **vault.vault.dynamodb.put.count**(count) | Number of samples of vault.vault.dynamodb.put. | | **vault.vault.dynamodb.put.quantile**(gauge) | Duration of a PUT operation against the DynamoDB storage backend quantile.*Shown as millisecond* | | **vault.vault.dynamodb.put.sum**(count) | Total duration of a PUT operation against the DynamoDB storage backend.*Shown as millisecond* | | **vault.vault.etcd.delete.count**(count) | Number of samples of vault.vault.etcd.delete. | | **vault.vault.etcd.delete.quantile**(gauge) | Duration of a DELETE operation against the etcd storage backend quantile.*Shown as millisecond* | | **vault.vault.etcd.delete.sum**(count) | Total duration of a DELETE operation against the etcd storage backend.*Shown as millisecond* | | **vault.vault.etcd.get.count**(count) | Number of samples of vault.vault.etcd.get. | | **vault.vault.etcd.get.quantile**(gauge) | Duration of a GET operation against the etcd storage backend quantile.*Shown as millisecond* | | **vault.vault.etcd.get.sum**(count) | Total duration of a GET operation against the etcd storage backend.*Shown as millisecond* | | **vault.vault.etcd.list.count**(count) | Number of samples of vault.vault.etcd.list. | | **vault.vault.etcd.list.quantile**(gauge) | Duration of a LIST operation against the etcd storage backend quantile.*Shown as millisecond* | | **vault.vault.etcd.list.sum**(count) | Total duration of a LIST operation against the etcd storage backend.*Shown as millisecond* | | **vault.vault.etcd.put.count**(count) | Number of samples of vault.vault.etcd.put. | | **vault.vault.etcd.put.quantile**(gauge) | Duration of a PUT operation against the etcd storage backend.*Shown as millisecond* | | **vault.vault.etcd.put.sum**(count) | Total duration of a PUT operation against the etcd storage backend.*Shown as millisecond* | | **vault.vault.expire.fetch.lease.times.by\_token.count**(count) | Number of samples of vault.vault.expire.fetch.lease.times.by_token. | | **vault.vault.expire.fetch.lease.times.by\_token.quantile**(gauge) | Time taken to fetch lease times by token quantile.*Shown as millisecond* | | **vault.vault.expire.fetch.lease.times.by\_token.sum**(count) | Total time taken to fetch lease times by token.*Shown as millisecond* | | **vault.vault.expire.fetch.lease.times.count**(count) | Number of samples of vault.vault.expire.fetch.lease.times. | | **vault.vault.expire.fetch.lease.times.quantile**(gauge) | Time taken to fetch lease times quantile.*Shown as millisecond* | | **vault.vault.expire.fetch.lease.times.sum**(count) | Total time taken to fetch lease times.*Shown as millisecond* | | **vault.vault.expire.job\_manager.queue\_length**(gauge) | Total pending revocation jobs by auth method. | | **vault.vault.expire.job\_manager.queue\_length.count**(count) | Total pending revocation jobs by auth method. | | **vault.vault.expire.job\_manager.queue\_length.sum**(count) | Total pending revocation jobs by auth method. | | **vault.vault.expire.job\_manager.total\_jobs**(gauge) | Total pending revocation jobs. | | **vault.vault.expire.job\_manager.total\_jobs.count**(count) | Total pending revocation jobs. | | **vault.vault.expire.job\_manager.total\_jobs.sum**(count) | Total pending revocation jobs. | | **vault.vault.expire.lease\_expiration**(count) | Number of lease expirations. | | **vault.vault.expire.lease\_expiration.error**(count) | Count of lease expiration errors. | | **vault.vault.expire.lease\_expiration.time\_in\_queue.count**(count) | Number of samples of vault.vault.expire.lease_expiration.time_in_queue. | | **vault.vault.expire.lease\_expiration.time\_in\_queue.quantile**(gauge) | Time taken for lease to get to the front of the revoke queue.*Shown as millisecond* | | **vault.vault.expire.lease\_expiration.time\_in\_queue.sum**(count) | Time taken for lease to get to the front of the revoke queue.*Shown as millisecond* | | **vault.vault.expire.leases.by\_expiration**(gauge) | Number of leases set to expire grouped by a time interval. | | **vault.vault.expire.num\_leases**(gauge) | vault_expire_num_leases.*Shown as unit* | | **vault.vault.expire.register.auth.count**(count) | Number of samples of vault.vault.expire.register.auth. | | **vault.vault.expire.register.auth.quantile**(gauge) | Time taken for register authentication operations which create lease entries without lease ID quantile.*Shown as millisecond* | | **vault.vault.expire.register.auth.sum**(count) | Total time taken for register authentication operations which create lease entries without lease ID.*Shown as millisecond* | | **vault.vault.expire.register.count**(count) | Number of samples of vault.vault.expire.register. | | **vault.vault.expire.register.quantile**(gauge) | Time taken for register operations quantile.*Shown as millisecond* | | **vault.vault.expire.register.sum**(count) | Total time taken for register operations.*Shown as millisecond* | | **vault.vault.expire.renew.count**(count) | Number of samples of vault.vault.expire.renew. | | **vault.vault.expire.renew.quantile**(gauge) | Time taken to renew a lease quantile.*Shown as millisecond* | | **vault.vault.expire.renew.sum**(count) | Total time taken to renew a lease.*Shown as millisecond* | | **vault.vault.expire.renew\_token.count**(count) | Number of samples of vault.vault.expire.renew_token. | | **vault.vault.expire.renew\_token.quantile**(gauge) | Time taken to renew a token which does not need to invoke a logical backend quantile.*Shown as millisecond* | | **vault.vault.expire.renew\_token.sum**(count) | Total time taken to renew a token which does not need to invoke a logical backend.*Shown as millisecond* | | **vault.vault.expire.revoke.by\_token.count**(count) | Number of samples of vault.vault.expire.revoke.by_token. | | **vault.vault.expire.revoke.by\_token.quantile**(gauge) | Time taken to revoke all secrets issued with a given token quantile.*Shown as millisecond* | | **vault.vault.expire.revoke.by\_token.sum**(count) | Total time taken to revoke all secrets issued with a given token.*Shown as millisecond* | | **vault.vault.expire.revoke.count**(count) | Number of samples of vault.vault.expire.revoke. | | **vault.vault.expire.revoke.force.count**(count) | Number of samples of vault.vault.expire.revoke.force. | | **vault.vault.expire.revoke.force.quantile**(gauge) | Time taken to forcibly revoke a token quantile.*Shown as millisecond* | | **vault.vault.expire.revoke.force.sum**(count) | Total time taken to forcibly revoke a token.*Shown as millisecond* | | **vault.vault.expire.revoke.prefix.count**(count) | Number of samples of vault.vault.expire.revoke.prefix. | | **vault.vault.expire.revoke.prefix.quantile**(gauge) | Time taken to revoke tokens on a prefix quantile.*Shown as millisecond* | | **vault.vault.expire.revoke.prefix.sum**(count) | Total time taken to revoke tokens on a prefix.*Shown as millisecond* | | **vault.vault.expire.revoke.quantile**(gauge) | Time taken to revoke a token quantile.*Shown as millisecond* | | **vault.vault.expire.revoke.sum**(count) | Total time taken to revoke a token.*Shown as millisecond* | | **vault.vault.gcs.delete.count**(count) | Number of samples of vault.vault.gcs.delete. | | **vault.vault.gcs.delete.quantile**(gauge) | Duration of a DELETE operation against the Google Cloud Storage storage backend quantile.*Shown as millisecond* | | **vault.vault.gcs.delete.sum**(count) | Total duration of a DELETE operation against the Google Cloud Storage storage backend.*Shown as millisecond* | | **vault.vault.gcs.get.count**(count) | Number of samples of vault.vault.gcs.get. | | **vault.vault.gcs.get.quantile**(gauge) | Duration of a GET operation against the Google Cloud Storage storage backend quantile.*Shown as millisecond* | | **vault.vault.gcs.get.sum**(count) | Total duration of a GET operation against the Google Cloud Storage storage backend.*Shown as millisecond* | | **vault.vault.gcs.list.count**(count) | Number of samples of vault.vault.gcs.list. | | **vault.vault.gcs.list.quantile**(gauge) | Duration of a LIST operation against the Google Cloud Storage storage backend quantile.*Shown as millisecond* | | **vault.vault.gcs.list.sum**(count) | Total duration of a LIST operation against the Google Cloud Storage storage backend.*Shown as millisecond* | | **vault.vault.gcs.lock.lock.count**(count) | Number of samples of vault.vault.gcs.lock.lock. | | **vault.vault.gcs.lock.lock.quantile**(gauge) | Duration of a LOCK operation against the Google Cloud Storage storage backend in HA mode quantile.*Shown as millisecond* | | **vault.vault.gcs.lock.lock.sum**(count) | Total duration of a LOCK operation against the Google Cloud Storage storage backend in HA mode.*Shown as millisecond* | | **vault.vault.gcs.lock.unlock.count**(count) | Number of samples of vault.vault.gcs.lock.unlock. | | **vault.vault.gcs.lock.unlock.quantile**(gauge) | Duration of an UNLOCK operation against the Google Cloud Storage storage backend in HA mode quantile.*Shown as millisecond* | | **vault.vault.gcs.lock.unlock.sum**(count) | Total duration of an UNLOCK operation against the Google Cloud Storage storage backend in HA mode.*Shown as millisecond* | | **vault.vault.gcs.lock.value.count**(count) | Number of samples of vault.vault.gcs.lock.value. | | **vault.vault.gcs.lock.value.quantile**(gauge) | Duration of a VALUE operation against the Google Cloud Storage storage backend in HA mode quantile.*Shown as millisecond* | | **vault.vault.gcs.lock.value.sum**(count) | Total duration of a VALUE operation against the Google Cloud Storage storage backend in HA mode.*Shown as millisecond* | | **vault.vault.gcs.put.count**(count) | Number of samples of vault.vault.gcs.put. | | **vault.vault.gcs.put.quantile**(gauge) | Duration of a PUT operation against the Google Cloud Storage storage backend quantile.*Shown as millisecond* | | **vault.vault.gcs.put.sum**(count) | Total duration of a PUT operation against the Google Cloud Storage storage backend.*Shown as millisecond* | | **vault.vault.identity.entity.alias.count**(gauge) | Number of samples of vault.vault.identity.entity.alias. | | **vault.vault.identity.entity.count**(gauge) | Number of samples of vault.vault.identity.entity. | | **vault.vault.identity.entity.creation**(count) | [Legacy] A new entity was created either manually or automatically upon login. | | **vault.vault.identity.entity.creation.count**(count) | A new entity was created either manually or automatically upon login. | | **vault.vault.merkle.flushdirty.count**(count) | Number of samples of vault.vault.merkle.flushdirty. | | **vault.vault.merkle.flushdirty.quantile**(gauge) | Time taken flush any dirty pages to cold storage quantile.*Shown as millisecond* | | **vault.vault.merkle.flushdirty.sum**(count) | Total time taken flush any dirty pages to cold storage.*Shown as millisecond* | | **vault.vault.merkle.savecheckpoint.count**(count) | Number of samples of vault.vault.merkle.savecheckpoint. | | **vault.vault.merkle.savecheckpoint.quantile**(gauge) | Time taken to save the checkpoint quantile.*Shown as millisecond* | | **vault.vault.merkle.savecheckpoint.sum**(count) | Total time taken to save the checkpoint.*Shown as millisecond* | | **vault.vault.mssql.delete.count**(count) | Number of samples of vault.vault.mssql.delete. | | **vault.vault.mssql.delete.quantile**(gauge) | Duration of a GET operation against the MS-SQL storage backend quantile.*Shown as millisecond* | | **vault.vault.mssql.delete.sum**(count) | Total duration of a GET operation against the MS-SQL storage backend.*Shown as millisecond* | | **vault.vault.mssql.get.count**(count) | Number of samples of vault.vault.mssql.get. | | **vault.vault.mssql.get.quantile**(gauge) | Duration of a GET operation against the MS-SQL storage backend quantile.*Shown as millisecond* | | **vault.vault.mssql.get.sum**(count) | Total duration of a GET operation against the MS-SQL storage backend.*Shown as millisecond* | | **vault.vault.mssql.list.count**(count) | Number of samples of vault.vault.mssql.list. | | **vault.vault.mssql.list.quantile**(gauge) | Duration of a LIST operation against the MS-SQL storage backend quantile.*Shown as millisecond* | | **vault.vault.mssql.list.sum**(count) | Total duration of a LIST operation against the MS-SQL storage backend.*Shown as millisecond* | | **vault.vault.mssql.put.count**(count) | Number of samples of vault.vault.mssql.put. | | **vault.vault.mssql.put.quantile**(gauge) | Duration of a PUT operation against the MS-SQL storage backend quantile.*Shown as millisecond* | | **vault.vault.mssql.put.sum**(count) | Total duration of a PUT operation against the MS-SQL storage backend.*Shown as millisecond* | | **vault.vault.mysql.delete.count**(count) | Number of samples of vault.vault.mysql.delete. | | **vault.vault.mysql.delete.quantile**(gauge) | Duration of a DELETE operation against the MySQL storage backend quantile.*Shown as millisecond* | | **vault.vault.mysql.delete.sum**(count) | Total duration of a DELETE operation against the MySQL storage backend.*Shown as millisecond* | | **vault.vault.mysql.get.count**(count) | Number of samples of vault.vault.mysql.get. | | **vault.vault.mysql.get.quantile**(gauge) | Duration of a GET operation against the MySQL storage backend quantile.*Shown as millisecond* | | **vault.vault.mysql.get.sum**(count) | Total duration of a GET operation against the MySQL storage backend.*Shown as millisecond* | | **vault.vault.mysql.list.count**(count) | Number of samples of vault.vault.mysql.list. | | **vault.vault.mysql.list.quantile**(gauge) | Duration of a LIST operation against the MySQL storage backend quantile.*Shown as millisecond* | | **vault.vault.mysql.list.sum**(count) | Total duration of a LIST operation against the MySQL storage backend sum .*Shown as millisecond* | | **vault.vault.mysql.put.count**(count) | Number of samples of vault.vault.mysql.put. | | **vault.vault.mysql.put.quantile**(gauge) | Duration of a PUT operation against the MySQL storage backend quantile.*Shown as millisecond* | | **vault.vault.mysql.put.sum**(count) | Total duration of a PUT operation against the MySQL storage backend.*Shown as millisecond* | | **vault.vault.policy.delete\_policy.count**(count) | Number of samples of vault.vault.policy.delete_policy. | | **vault.vault.policy.delete\_policy.quantile**(gauge) | Time taken to delete policy quantile.*Shown as millisecond* | | **vault.vault.policy.delete\_policy.sum**(count) | Total time taken to delete policy.*Shown as millisecond* | | **vault.vault.policy.get\_policy.count**(count) | Number of samples of vault.vault.policy.get_policy. | | **vault.vault.policy.get\_policy.quantile**(gauge) | Time taken to get a policy quantile.*Shown as millisecond* | | **vault.vault.policy.get\_policy.sum**(count) | Total time taken to get a policy.*Shown as millisecond* | | **vault.vault.policy.list\_policies.count**(count) | Number of samples of vault.vault.policy.list_policies. | | **vault.vault.policy.list\_policies.quantile**(gauge) | Time taken to list policies quantile.*Shown as millisecond* | | **vault.vault.policy.list\_policies.sum**(count) | Total time taken to list policies.*Shown as millisecond* | | **vault.vault.policy.set\_policy.count**(count) | Number of samples of vault.vault.policy.set_policy. | | **vault.vault.policy.set\_policy.quantile**(gauge) | Time to set a policy quantile.*Shown as millisecond* | | **vault.vault.policy.set\_policy.sum**(count) | Total time to set a policy.*Shown as millisecond* | | **vault.vault.postgres.delete.count**(count) | Number of samples of vault.vault.postgres.delete. | | **vault.vault.postgres.delete.quantile**(gauge) | Duration of a DELETE operation against the PostgreSQL storage backend quantile.*Shown as millisecond* | | **vault.vault.postgres.delete.sum**(count) | Total duration of a DELETE operation against the PostgreSQL storage backend.*Shown as millisecond* | | **vault.vault.postgres.get.count**(count) | Number of samples of vault.vault.postgres.get. | | **vault.vault.postgres.get.quantile**(gauge) | Duration of a GET operation against the PostgreSQL storage backend quantile.*Shown as millisecond* | | **vault.vault.postgres.get.sum**(count) | Total duration of a GET operation against the PostgreSQL storage backend.*Shown as millisecond* | | **vault.vault.postgres.list.count**(count) | Number of samples of vault.vault.postgres.list. | | **vault.vault.postgres.list.quantile**(gauge) | Duration of a LIST operation against the PostgreSQL storage backend quantile.*Shown as millisecond* | | **vault.vault.postgres.list.sum**(count) | Total duration of a LIST operation against the PostgreSQL storage backend.*Shown as millisecond* | | **vault.vault.postgres.put.count**(count) | Number of samples of vault.vault.postgres.put. | | **vault.vault.postgres.put.quantile**(gauge) | Duration of a PUT operation against the PostgreSQL storage backend quantile.*Shown as millisecond* | | **vault.vault.postgres.put.sum**(count) | Total duration of a PUT operation against the PostgreSQL storage backend.*Shown as millisecond* | | **vault.vault.quota.lease\_count.violation**(count) | Total number of lease count quota violations | | **vault.vault.quota.rate\_limit.violation**(count) | Total number of rate limit quota violations | | **vault.vault.raft.delete.count**(count) | Number of samples of vault.vault.raft.delete. | | **vault.vault.raft.delete.quantile**(gauge) | Duration of DELETE operation against the Raft storage backend quantile.*Shown as millisecond* | | **vault.vault.raft.delete.sum**(count) | Total duration of DELETE operation against the Raft storage backend.*Shown as millisecond* | | **vault.vault.raft.get.count**(count) | Number of samples of vault.vault.raft.get. | | **vault.vault.raft.get.quantile**(gauge) | Duration of a GET operation against the Raft storage backend quantile.*Shown as millisecond* | | **vault.vault.raft.get.sum**(count) | Total duration of a GET operation against the Raft storage backend.*Shown as millisecond* | | **vault.vault.raft.leader.lastContact.count**(count) | Number of samples of vault.vault.raft.leader.lastContact. | | **vault.vault.raft.leader.lastContact.quantile**(gauge) | Duration since the leader was last able to contact the follower nodes when checking its leader lease*Shown as millisecond* | | **vault.vault.raft.leader.lastContact.sum**(count) | Total duration since the leader was last able to contact the follower nodes when checking its leader lease*Shown as millisecond* | | **vault.vault.raft.list.count**(count) | Number of samples of vault.vault.raft.list. | | **vault.vault.raft.list.quantile**(gauge) | Duration of a LIST operation against the Raft storage backend quantile.*Shown as millisecond* | | **vault.vault.raft.list.sum**(count) | Total duration of a LIST operation against the Raft storage backend.*Shown as millisecond* | | **vault.vault.raft.put.count**(count) | Number of samples of vault.vault.raft.put. | | **vault.vault.raft.put.quantile**(gauge) | Duration of a PUT operation against the CouchDB storage backend quantile.*Shown as millisecond* | | **vault.vault.raft.put.sum**(count) | Total duration of a PUT operation against the Raft storage backend.*Shown as millisecond* | | **vault.vault.raft.state.candidate**(count) | Increments whenever raft server starts an election | | **vault.vault.raft.state.leader**(count) | Increments whenever raft server becomes a leader | | **vault.vault.rollback.attempt.auth.jwt.count**(count) | Number of samples of vault.vault.rollback.attempt.auth.jwt. | | **vault.vault.rollback.attempt.auth.jwt.quantile**(gauge) | Time taken to perform a rollback operation for the JWT auth method quantile.*Shown as millisecond* | | **vault.vault.rollback.attempt.auth.jwt.sum**(count) | Total time taken to perform a rollback operation for the JWT auth method.*Shown as millisecond* | | **vault.vault.rollback.attempt.auth.ldap.count**(count) | Number of samples of vault.vault.rollback.attempt.auth.ldap. | | **vault.vault.rollback.attempt.auth.ldap.quantile**(gauge) | Time taken to perform a rollback operation for the LDAP auth method quantile.*Shown as millisecond* | | **vault.vault.rollback.attempt.auth.ldap.sum**(count) | Total time taken to perform a rollback operation for the LDAP auth method.*Shown as millisecond* | | **vault.vault.rollback.attempt.auth.token.count**(count) | Number of samples of vault.vault.rollback.attempt.auth.token. | | **vault.vault.rollback.attempt.auth.token.quantile**(gauge) | Time taken to perform a rollback operation for the token auth method quantile.*Shown as millisecond* | | **vault.vault.rollback.attempt.auth.token.sum**(count) | Total time taken to perform a rollback operation for the token auth method.*Shown as millisecond* | | **vault.vault.rollback.attempt.cubbyhole.count**(count) | Number of samples of vault.vault.rollback.attempt.cubbyhole. | | **vault.vault.rollback.attempt.cubbyhole.quantile**(gauge) | Time taken to perform a rollback operation for the Cubbyhole secret backend quantile.*Shown as millisecond* | | **vault.vault.rollback.attempt.cubbyhole.sum**(count) | Total time taken to perform a rollback operation for the Cubbyhole secret backend.*Shown as millisecond* | | **vault.vault.rollback.attempt.identity.count**(count) | Number of samples of vault.vault.rollback.attempt.identity. | | **vault.vault.rollback.attempt.identity.quantile**(gauge) | Time taken to perform a rollback operation for the identity backend quantile.*Shown as millisecond* | | **vault.vault.rollback.attempt.identity.sum**(count) | Total time taken to perform a rollback operation for the identity backend.*Shown as millisecond* | | **vault.vault.rollback.attempt.secret.count**(count) | Number of samples of vault.vault.rollback.attempt.secret. | | **vault.vault.rollback.attempt.secret.quantile**(gauge) | Time taken to perform a rollback operation for the K/V secret backend quantile.*Shown as millisecond* | | **vault.vault.rollback.attempt.secret.sum**(count) | Total time taken to perform a rollback operation for the K/V secret backend.*Shown as millisecond* | | **vault.vault.rollback.attempt.sys.count**(count) | Number of samples of vault.vault.rollback.attempt.sys. | | **vault.vault.rollback.attempt.sys.quantile**(gauge) | Time taken to perform a rollback operation for the system backend quantile.*Shown as millisecond* | | **vault.vault.rollback.attempt.sys.sum**(count) | Total time taken to perform a rollback operation for the system backend.*Shown as millisecond* | | **vault.vault.route.create.count**(count) | Number of samples of vault.vault.route.create. | | **vault.vault.route.create.quantile**(gauge) | Quantile time taken to dispatch a create operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.vault.route.create.sum**(count) | Total time taken to dispatch and process a create operation.*Shown as millisecond* | | **vault.vault.route.delete.count**(count) | Number of samples of vault.vault.route.delete. | | **vault.vault.route.delete.quantile**(gauge) | Quantile time taken to dispatch a delete operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.vault.route.delete.sum**(count) | Total time taken to dispatch and process a delete operation.*Shown as millisecond* | | **vault.vault.route.list.count**(count) | Number of samples of vault.vault.route.list. | | **vault.vault.route.list.quantile**(gauge) | Quantile time taken to dispatch a list operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.vault.route.list.sum**(count) | Total time taken to dispatch and process a list operation.*Shown as millisecond* | | **vault.vault.route.read.count**(count) | Number of samples of vault.vault.route.read. | | **vault.vault.route.read.quantile**(gauge) | Quantile time taken to dispatch a read operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.vault.route.read.sum**(count) | Total time taken to dispatch and process a read operation.*Shown as millisecond* | | **vault.vault.route.rollback.auth.jwt.count**(count) | [Legacy] Number of samples of vault.vault.route.rollback.auth.jwt. | | **vault.vault.route.rollback.auth.jwt.quantile**(gauge) | [Legacy] Time taken to perform a rollback operation for the JWT auth method quantile.*Shown as millisecond* | | **vault.vault.route.rollback.auth.jwt.sum**(gauge) | [Legacy] Total time taken to perform a rollback operation for the JWT auth method.*Shown as millisecond* | | **vault.vault.route.rollback.auth.ldap.count**(count) | [Legacy] Number of samples of vault.vault.route.rollback.auth.ldap. | | **vault.vault.route.rollback.auth.ldap.quantile**(gauge) | [Legacy] Time taken to perform a rollback operation for the LDAP auth method quantile.*Shown as millisecond* | | **vault.vault.route.rollback.auth.ldap.sum**(gauge) | [Legacy] Total time taken to perform a rollback operation for the LDAP auth method.*Shown as millisecond* | | **vault.vault.route.rollback.auth.token.count**(count) | [Legacy] Number of samples of vault.vault.route.rollback.auth.token. | | **vault.vault.route.rollback.auth.token.quantile**(gauge) | [Legacy] Time taken to perform a route rollback operation for the token auth method quantile.*Shown as millisecond* | | **vault.vault.route.rollback.auth.token.sum**(gauge) | [Legacy] Total time taken to perform a route rollback operation for the token auth method.*Shown as millisecond* | | **vault.vault.route.rollback.count**(count) | Number of samples of vault.vault.route.rollback. | | **vault.vault.route.rollback.cubbyhole.count**(count) | [Legacy] Number of samples of vault.vault.route.rollback.cubbyhole. | | **vault.vault.route.rollback.cubbyhole.quantile**(gauge) | [Legacy] Time taken to perform a route rollback operation for the Cubbyhole secret backend quantile.*Shown as millisecond* | | **vault.vault.route.rollback.cubbyhole.sum**(gauge) | [Legacy] Total time taken to perform a route rollback operation for the Cubbyhole secret backend.*Shown as millisecond* | | **vault.vault.route.rollback.identity.count**(count) | [Legacy] Number of samples of vault.vault.route.rollback.identity. | | **vault.vault.route.rollback.identity.quantile**(gauge) | [Legacy] Time taken to perform a route rollback operation for the identity backend quantile.*Shown as millisecond* | | **vault.vault.route.rollback.identity.sum**(gauge) | [Legacy] Total time taken to perform a route rollback operation for the identity backend.*Shown as millisecond* | | **vault.vault.route.rollback.quantile**(gauge) | Quantile time taken to dispatch a rollback operation to a backend, and for that backend to process it.*Shown as millisecond* | | **vault.vault.route.rollback.secret.count**(count) | [Legacy] Number of samples of vault.vault.route.rollback.secret. | | **vault.vault.route.rollback.secret.quantile**(gauge) | [Legacy] Time taken to perform a route rollback operation for the K/V secret backend quantile.*Shown as millisecond* | | **vault.vault.route.rollback.secret.sum**(gauge) | [Legacy] Total time taken to perform a route rollback operation for the K/V secret backend.*Shown as millisecond* | | **vault.vault.route.rollback.sum**(count) | Total time taken to dispatch and process a rollback operation.*Shown as millisecond* | | **vault.vault.route.rollback.sys.count**(count) | [Legacy] Number of samples of vault.vault.route.rollback.sys. | | **vault.vault.route.rollback.sys.quantile**(gauge) | [Legacy] Time taken to perform a route rollback operation for the system backend quantile.*Shown as millisecond* | | **vault.vault.route.rollback.sys.sum**(gauge) | [Legacy] Total time taken to perform a route rollback operation for the system backend.*Shown as millisecond* | | **vault.vault.runtime.alloc.bytes**(gauge) | Number of bytes allocated by the Vault process.*Shown as byte* | | **vault.vault.runtime.free.count**(gauge) | Number of samples of vault.vault.runtime.free.*Shown as object* | | **vault.vault.runtime.gc.pause\_ns.count**(count) | Number of samples of vault.vault.runtime.gc.pause_ns. | | **vault.vault.runtime.gc.pause\_ns.quantile**(gauge) | The garbage collector pause time since Vault was last started quantile.*Shown as nanosecond* | | **vault.vault.runtime.gc.pause\_ns.sum**(count) | Total the garbage collector pause time since Vault was last started.*Shown as nanosecond* | | **vault.vault.runtime.heap.objects**(gauge) | Number of objects on the heap.*Shown as object* | | **vault.vault.runtime.malloc.count**(gauge) | Number of samples of vault.vault.runtime.malloc.*Shown as object* | | **vault.vault.runtime.num\_goroutines**(gauge) | Number of goroutines.*Shown as unit* | | **vault.vault.runtime.sys.bytes**(gauge) | Number of bytes allocated to Vault.*Shown as byte* | | **vault.vault.runtime.total.gc.pause\_ns**(gauge) | The total garbage collector pause time since Vault was last started.*Shown as nanosecond* | | **vault.vault.runtime.total.gc.runs**(gauge) | Total number of garbage collection runs since Vault was last started.*Shown as operation* | | **vault.vault.s3.delete.count**(count) | Number of samples of vault.vault.s3.delete. | | **vault.vault.s3.delete.quantile**(gauge) | Duration of a DELETE operation against the Amazon S3 storage backend quantile.*Shown as millisecond* | | **vault.vault.s3.delete.sum**(count) | Total duration of a DELETE operation against the Amazon S3 storage backend.*Shown as millisecond* | | **vault.vault.s3.get.count**(count) | Number of samples of vault.vault.s3.get. | | **vault.vault.s3.get.quantile**(gauge) | Duration of a GET operation against the Amazon S3 storage backend quantile.*Shown as millisecond* | | **vault.vault.s3.get.sum**(count) | Total duration of a GET operation against the Amazon S3 storage backend.*Shown as millisecond* | | **vault.vault.s3.list.count**(count) | Number of samples of vault.vault.s3.list. | | **vault.vault.s3.list.quantile**(gauge) | Duration of a LIST operation against the Amazon S3 storage backend quantile.*Shown as millisecond* | | **vault.vault.s3.list.sum**(count) | Total duration of a LIST operation against the Amazon S3 storage backend.*Shown as millisecond* | | **vault.vault.s3.put.count**(count) | Number of samples of vault.vault.s3.put. | | **vault.vault.s3.put.quantile**(gauge) | Duration of a PUT operation against the Amazon S3 storage backend quantile.*Shown as millisecond* | | **vault.vault.s3.put.sum**(count) | Total duration of a PUT operation against the Amazon S3 storage backend.*Shown as millisecond* | | **vault.vault.secret.kv.count**(gauge) | Number of samples of vault.vault.secret.kv. | | **vault.vault.secret.lease.creation**(count) | A lease was created by a secret engine (excluding leases created internally for token expiration). | | **vault.vault.spanner.delete.count**(count) | Number of samples of vault.vault.spanner.delete. | | **vault.vault.spanner.delete.quantile**(gauge) | Duration of a DELETE operation against the Google Cloud Spanner storage backend quantile.*Shown as millisecond* | | **vault.vault.spanner.delete.sum**(count) | Total duration of a DELETE operation against the Google Cloud Spanner storage backend.*Shown as millisecond* | | **vault.vault.spanner.get.count**(count) | Number of samples of vault.vault.spanner.get. | | **vault.vault.spanner.get.quantile**(gauge) | Duration of a GET operation against the Google Cloud Spanner storage backend quantile.*Shown as millisecond* | | **vault.vault.spanner.get.sum**(count) | Total duration of a GET operation against the Google Cloud Spanner storage backend.*Shown as millisecond* | | **vault.vault.spanner.list.count**(count) | Number of samples of vault.vault.spanner.list. | | **vault.vault.spanner.list.quantile**(gauge) | Duration of a LIST operation against the Google Cloud Spanner storage backend quantile.*Shown as millisecond* | | **vault.vault.spanner.list.sum**(count) | Total duration of a LIST operation against the Google Cloud Spanner storage backend.*Shown as millisecond* | | **vault.vault.spanner.lock.lock.count**(count) | Number of samples of vault.vault.spanner.lock.lock. | | **vault.vault.spanner.lock.lock.quantile**(gauge) | Duration of an LOCK operation against the Google Cloud Spanner storage backend in HA mode quantile.*Shown as millisecond* | | **vault.vault.spanner.lock.lock.sum**(count) | Total duration of an LOCK operation against the Google Cloud Spanner storage backend in HA mode.*Shown as millisecond* | | **vault.vault.spanner.lock.unlock.count**(count) | Number of samples of vault.vault.spanner.lock.unlock. | | **vault.vault.spanner.lock.unlock.quantile**(gauge) | Duration of an UNLOCK operation against the Google Cloud Spanner storage backend in HA mode.*Shown as millisecond* | | **vault.vault.spanner.lock.unlock.sum**(count) | Total duration of an UNLOCK operation against the Google Cloud Spanner storage backend in HA mode.*Shown as millisecond* | | **vault.vault.spanner.lock.value.count**(count) | Number of samples of vault.vault.spanner.lock.value. | | **vault.vault.spanner.lock.value.quantile**(gauge) | Duration of a VALUE operation against the Google Cloud Spanner backend in HA mode quantile.*Shown as millisecond* | | **vault.vault.spanner.lock.value.sum**(count) | Total duration of a VALUE operation against the Google Cloud Spanner backend in HA mode.*Shown as millisecond* | | **vault.vault.spanner.put.count**(count) | Number of samples of vault.vault.spanner.put. | | **vault.vault.spanner.put.quantile**(gauge) | Duration of a PUT operation against the Google Cloud Spanner storage backend quantile.*Shown as millisecond* | | **vault.vault.spanner.put.sum**(count) | Total duration of a PUT operation against the Google Cloud Spanner storage backend.*Shown as millisecond* | | **vault.vault.swift.delete.count**(count) | Number of samples of vault.vault.swift.delete. | | **vault.vault.swift.delete.quantile**(gauge) | Duration of a DELETE operation against the Swift storage backend quantile.*Shown as millisecond* | | **vault.vault.swift.delete.sum**(count) | Total duration of a DELETE operation against the Swift storage backend.*Shown as millisecond* | | **vault.vault.swift.get.count**(count) | Number of samples of vault.vault.swift.get. | | **vault.vault.swift.get.quantile**(gauge) | Duration of a GET operation against the Swift storage backend quantile.*Shown as millisecond* | | **vault.vault.swift.get.sum**(count) | Total duration of a GET operation against the Swift storage backend.*Shown as millisecond* | | **vault.vault.swift.list.count**(count) | Number of samples of vault.vault.swift.list. | | **vault.vault.swift.list.quantile**(gauge) | Duration of a LIST operation against the Swift storage backend quantile.*Shown as millisecond* | | **vault.vault.swift.list.sum**(count) | Total duration of a LIST operation against the Swift storage backend.*Shown as millisecond* | | **vault.vault.swift.put.count**(count) | Number of samples of vault.vault.swift.put. | | **vault.vault.swift.put.quantile**(gauge) | Duration of a PUT operation against the Swift storage backend quantile.*Shown as millisecond* | | **vault.vault.swift.put.sum**(count) | Total duration of a PUT operation against the Swift storage backend.*Shown as millisecond* | | **vault.vault.token.count**(gauge) | Number of samples of vault.vault.token. | | **vault.vault.token.count.by\_auth**(gauge) | Number of existing tokens broken down by auth method used to create them. | | **vault.vault.token.count.by\_policy**(gauge) | Number of existing tokens counted in each policy assigned (so this metric adds to >=100% of tokens). | | **vault.vault.token.count.by\_ttl**(gauge) | Number of existing tokens aggregated by their TTL at creation. | | **vault.vault.token.create.count**(count) | Number of samples of vault.vault.token.create. | | **vault.vault.token.create.quantile**(gauge) | Time taken to create a token quantile.*Shown as millisecond* | | **vault.vault.token.create.sum**(count) | Total time taken to create a token.*Shown as millisecond* | | **vault.vault.token.createAccessor.count**(count) | Number of samples of vault.vault.token.createAccessor. | | **vault.vault.token.createAccessor.quantile**(gauge) | Time taken create a token accessor quantile.*Shown as millisecond* | | **vault.vault.token.createAccessor.sum**(count) | Total time taken create a token accessor.*Shown as millisecond* | | **vault.vault.token.creation**(count) | [Legacy] A new service or batch token was created. (Always 1. Name chosen to be distinct from vault.token.create - an existing sample metric.) | | **vault.vault.token.creation.count**(count) | A new service or batch token was created. (Always 1. Name chosen to be distinct from vault.token.create - an existing sample metric.) | | **vault.vault.token.lookup.count**(count) | Number of samples of vault.vault.token.lookup. | | **vault.vault.token.lookup.quantile**(gauge) | The time taken to look up a token quantile.*Shown as millisecond* | | **vault.vault.token.lookup.sum**(count) | Total the time taken to look up a token.*Shown as millisecond* | | **vault.vault.token.revoke.count**(count) | Number of samples of vault.vault.token.revoke. | | **vault.vault.token.revoke.quantile**(gauge) | The time taken to revoke a token quantile.*Shown as millisecond* | | **vault.vault.token.revoke.sum**(count) | Total the time taken to revoke a token.*Shown as millisecond* | | **vault.vault.token.revoke.tree.count**(count) | Number of samples of vault.vault.token.revoke.tree. | | **vault.vault.token.revoke.tree.quantile**(gauge) | The time taken to revoke a token tree quantile.*Shown as millisecond* | | **vault.vault.token.revoke.tree.sum**(count) | Total the time taken to revoke a token tree.*Shown as millisecond* | | **vault.vault.token.store.count**(count) | Number of samples of vault.vault.token.store. | | **vault.vault.token.store.quantile**(gauge) | The time taken to store an updated token entry without writing to the secondary index quantile.*Shown as millisecond* | | **vault.vault.token.store.sum**(count) | Total the time taken to store an updated token entry without writing to the secondary index.*Shown as millisecond* | | **vault.vault.wal.deletewals.count**(count) | Number of samples of vault.vault.wal.deletewals. | | **vault.vault.wal.deletewals.quantile**(gauge) | Time taken to delete a Write Ahead Log (WAL) quantile.*Shown as millisecond* | | **vault.vault.wal.deletewals.sum**(count) | Total time taken to delete a Write Ahead Log (WAL).*Shown as millisecond* | | **vault.vault.wal.flushready.count**(count) | Number of samples of vault.vault.wal.flushready. | | **vault.vault.wal.flushready.quantile**(gauge) | Time taken to flush a ready Write Ahead Log (WAL) to storage quantile.*Shown as millisecond* | | **vault.vault.wal.flushready.sum**(count) | Total time taken to flush a ready Write Ahead Log (WAL) to storage.*Shown as millisecond* | | **vault.vault.wal.gc.deleted**(gauge) | Number of Write Ahead Logs (WAL) deleted during each garbage collection run.*Shown as unit* | | **vault.vault.wal.gc.total**(gauge) | Total Number of Write Ahead Logs (WAL) on disk.*Shown as unit* | | **vault.vault.wal.loadWAL.count**(count) | Number of samples of vault.vault.wal.loadWAL. | | **vault.vault.wal.loadWAL.quantile**(gauge) | Time taken to load a Write Ahead Log (WAL) quantile.*Shown as millisecond* | | **vault.vault.wal.loadWAL.sum**(count) | Total time taken to load a Write Ahead Log (WAL).*Shown as millisecond* | | **vault.vault.wal.persistwals.count**(count) | Number of samples of vault.vault.wal.persistwals. | | **vault.vault.wal.persistwals.quantile**(gauge) | Time taken to persist a Write Ahead Log (WAL) quantile.*Shown as millisecond* | | **vault.vault.wal.persistwals.sum**(count) | Total time taken to persist a Write Ahead Log (WAL).*Shown as millisecond* | | **vault.vault.zookeeper.delete.count**(count) | Number of samples of vault.vault.zookeeper.delete. | | **vault.vault.zookeeper.delete.quantile**(gauge) | Duration of a DELETE operation against the ZooKeeper storage backend quantile.*Shown as millisecond* | | **vault.vault.zookeeper.delete.sum**(count) | Total duration of a DELETE operation against the ZooKeeper storage backend.*Shown as millisecond* | | **vault.vault.zookeeper.get.count**(count) | Number of samples of vault.vault.zookeeper.get. | | **vault.vault.zookeeper.get.quantile**(gauge) | Duration of a GET operation against the ZooKeeper storage backend quantile.*Shown as millisecond* | | **vault.vault.zookeeper.get.sum**(count) | Total duration of a GET operation against the ZooKeeper storage backend.*Shown as millisecond* | | **vault.vault.zookeeper.list.count**(count) | Number of samples of vault.vault.zookeeper.list. | | **vault.vault.zookeeper.list.quantile**(gauge) | Duration of a LIST operation against the ZooKeeper storage backend quantile.*Shown as millisecond* | | **vault.vault.zookeeper.list.sum**(count) | Total duration of a LIST operation against the ZooKeeper storage backend.*Shown as millisecond* | | **vault.vault.zookeeper.put.count**(count) | Number of samples of vault.vault.zookeeper.put. | | **vault.vault.zookeeper.put.quantile**(gauge) | Duration of a PUT operation against the ZooKeeper storage backend quantile.*Shown as millisecond* | | **vault.vault.zookeeper.put.sum**(count) | Total duration of a PUT operation against the ZooKeeper storage backend.*Shown as millisecond* | [Metrics starting with `vault.replication.fetchRemoteKeys`, `vault.replication.merkleDiff`, and `vault.replication.merkleSync`] are not reported unless the replication is in an unhealthy state. ### Events{% #events %} `vault.leader_change`: This event fires when the cluster leader changes. ### Service Checks{% #service-checks %} **vault.can\_connect** Returns Critical if the Agent cannot connect to the Vault endpoint, OK otherwise. *Statuses: ok, critical* **vault.unsealed** Returns Critical if the vault is sealed, OK otherwise. *Statuses: ok, critical* **vault.initialized** Returns Critical if the vault isn't initialized, OK otherwise. *Statuses: ok, critical* **vault.prometheus.health** Returns `CRITICAL` if the check cannot access the Metrics endpoint. Returns `OK` otherwise. This service check is only available with the legacy mode (`use_openmetrics: false`). *Statuses: ok, critical* **vault.openmetrics.health** Returns `CRITICAL` if the Agent is unable to connect to the OpenMetrics endpoint, otherwise returns `OK`. This service check is only available with the latest mode (`use_openmetrics: true`). *Statuses: ok, critical* ## Troubleshooting{% #troubleshooting %} Need help? Contact [Datadog support](https://docs.datadoghq.com/help/). ## Further Reading{% #further-reading %} - [Monitor HashiCorp Vault with Datadog](https://www.datadoghq.com/blog/monitor-hashicorp-vault-with-datadog) - [Monitor HashiCorp Vault metrics and logs](https://www.datadoghq.com/blog/monitor-vault-metrics-and-logs/) - [Tools for HashiCorp Vault monitoring](https://www.datadoghq.com/blog/vault-monitoring-tools) - [How to monitor HashiCorp Vault with Datadog](https://www.datadoghq.com/blog/vault-monitoring-with-datadog)