---
title: Data Service Metrics
description: A list of the metrics provided by the Data Service.
pubDate: 2026-08-17T09:53:44.266Z
antora:
  editUrl: https://github.com/couchbase/docs-server/edit/release/7.6/modules/metrics-reference/pages/data-service-metrics.adoc
  xref: xref:7.6@server:metrics-reference:data-service-metrics.adoc[]
---

[Consult the llms.txt file for a full list of contents](/llms.txt)
[View original HTML](/server/7.6/metrics-reference/data-service-metrics.html)

# Data Service Metrics

> A list of the metrics provided by the Data Service. 

The following Data Service metrics can be queried by means of the REST APIs described in [Statistics](../rest-api/rest-statistics.md).

See [Data Service Metrics Cross Reference](data-service-metrics-cross-reference.md) if you are looking for a metric name you know from an alternative supported or legacy tool.

Histograms

Note that each histogram metric will generate three time series, with the following suffixes:

* `_count`
* `_sum`
* `_bucket`

Please refer to [Prometheus Histograms and Summaries](https://prometheus.io/docs/practices/histograms/) for more information.

> [!TIP]
> * The x.y.z badge shows the Couchbase Server version the metric was added in.
> * The type / unit badge shows shows the Prometheus [type](https://prometheus.io/docs/tutorials/understanding%5Fmetric%5Ftypes/) and [unit](https://prometheus.io/docs/practices/naming/#base-units) (if present).

| kv\_audit\_dropped\_events7.0.0counter The number of audit events dropped due to errors while trying to insert them to the audit trail                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| kv\_audit\_enabled7.0.0gauge Boolean value to indicate if audit is enabled or not                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_auth\_cmds7.0.0gauge The number of authentication commands                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_auth\_errors7.0.0gauge The number of failed authentication requests                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_bg\_batch\_size7.0.0histogram Batch size for background fetches                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_bg\_load\_seconds7.0.0histogram / seconds Background fetches waiting for disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_bg\_wait\_seconds7.0.0histogram / seconds Background fetches waiting in the dispatcher queue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_clients7.6.0gauge The number of references to the bucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_cmd\_duration\_seconds7.0.0histogram / seconds Per-opcode histogram of time taken to execute operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_cmd\_lookup7.0.0counter The number of lookup operations. This includes operations such as Get, Gat, Getk, Getq, GetLocked, GetRandomKey, GetReplica, SubdocMultiLookup, SubdocGet and SubdocExists                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_cmd\_lookup\_10s\_count7.0.0gauge The number of lookup operations performed within the last 10 seconds. This aggregates operations like Get, Gat, Getk, Getq, and various Sub-Document lookups                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_cmd\_lookup\_10s\_duration\_seconds7.0.0gauge / seconds The total duration of lookup operations performed over the last 10 seconds. This aggregates the time for operations like Get, Gat, Getk, Getq, and various Sub-Document lookups                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_cmd\_mutation7.0.0counter The number of mutation operations. This includes operations such as Add, Append, Decrement, Delete, Gat, Increment, Prepend, Replace, Set, Touch, and various Sub-Document mutations (e.g., SubdocArrayAddUnique, SubdocCounter, SubdocDelete, etc.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_cmd\_mutation\_10s\_count7.0.0gauge The number of mutation operations performed within the last 10 seconds. This includes operations like Add, Append, Delete, Replace, and various Sub-Document mutations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_cmd\_mutation\_10s\_duration\_seconds7.0.0gauge / seconds The total duration of mutation operations performed over the last 10 seconds. This includes time spent on operations like Add, Append, Delete, Replace, and various Sub-Document mutations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_collection\_data\_size\_bytes7.0.0gauge / bytes Per-collection data size on disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_collection\_history7.2.0gauge Whether history (CDC) is enabled for each collection                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_collection\_item\_count7.0.0gauge Per-collection item count                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_collection\_maxTTL\_seconds7.0.0gauge / seconds Per-collection maxTTL (maximum expiry) if configured                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_collection\_mem\_used\_bytes7.0.0gauge / bytes Per-collection memory usage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_collection\_ops7.0.0counter Per-collection counters of sets/gets/deletes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_conflicts\_resolved7.2.0counter Counter of all SetWithMeta/DelWithMeta conflict resolution results. The result may be that the incoming operation was: accepted as it is 'ahead', rejected as it is 'behind', or rejected as it appears identical (by metadata, not comparing document bodies)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_conn\_timeslice\_yields7.6.0counter The total number all clients in this bucket yield due to using their entire timeslice                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_conn\_yields7.0.0counter The total number all clients in this bucket yield due to consuming the number of ops allowed for the current timeslice                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_connection\_structures7.0.0gauge Current number of allocated connection structures                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_cookie\_notification\_histogram\_seconds7.6.10histogram / seconds Histogram containing the time taken to schedule a notification for a cookie until it is run                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_curr\_connections7.0.0gauge The current number of connections. This includes user, system and daemon connections                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_curr\_items7.0.0gauge Count of alive (non-deleted) items in active vbuckets, including non-resident items                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_curr\_items\_tot7.0.0gauge Total number of items                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_curr\_temp\_items7.0.0gauge Number of temporary items in memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_current\_external\_client\_connections7.6.5gauge The current number of authenticated connections using the labelled SDK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_daemon\_connections7.0.0gauge The number of server sockets currently in use                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_daemon\_memory\_allocated\_bytes7.1.0gauge / bytes Total amount of memory allocated (outside the context of a bucket)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_daemon\_memory\_resident\_bytes7.1.0gauge / bytes Total amount of memory resident (outside the context of a bucket)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_datatype\_count7.0.2gauge Count of items in memory with a given datatype combination                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_dcp\_backoff7.0.0gauge Number of times Consumer DCP connections (i.e., replica) have paused consuming items because memory usage is too high                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_dcp\_connection\_count7.0.0gauge Current number of DCP connections (Consumers or Producers)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_dcp\_count7.0.0gauge Current number of DCP connections                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_dcp\_items\_backfilled7.2.1gauge Number of items pushed into the DCP stream ready queue from a backfill                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_dcp\_items\_remaining7.0.0gauge Current total number of items remaining for to be sent for all outgoing DCP streams (approximate)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_dcp\_items\_sent7.0.0gauge Total number of items sent out by all _currently existing_ outgoing DCP streams, since each stream was created                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_dcp\_max\_running\_backfills7.0.2gauge Maximum number of backfills across all DCP connections                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_dcp\_num\_running\_backfills7.0.2gauge Total number of running backfills across all DCP connections                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_dcp\_paused\_count7.6.0gauge Count of how many times the DCP connection has been paused                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_dcp\_ready\_queue\_size\_bytes7.1.0gauge / bytes Estimated memory usage of items waiting to be sent across all _existing_ DCP connections                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_dcp\_stream\_count7.6.0gauge Current number of Streams (Active or Passive)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_dcp\_total\_data\_size\_bytes7.0.0gauge / bytes Total data sent across all _existing_ DCP connections                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_dcp\_total\_uncompressed\_data\_size\_bytes7.0.0gauge / bytes Total equivalent uncompressed size of data sent across all _existing_ DCP connections                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_dcp\_unpaused\_count7.6.0gauge Count of how many times the DCP connection has been unpaused                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_disk\_seconds7.0.0histogram / seconds time spent waiting for disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_dispatch\_socket\_histogram\_seconds7.6.10histogram / seconds Histogram containing the time taken to dispatch a newly created socket to its worker thread                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_domain\_memory\_used\_bytes7.1.0gauge / bytes Current memory used in KV for primary/secondary domain                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_access\_scanner\_enabled7.0.0gauge True if access scanner task is enabled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_access\_scanner\_last\_runtime\_seconds7.0.0gauge / seconds Number of seconds that last Access Scanner task run took to complete.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_access\_scanner\_num\_items7.0.0gauge Number of items that last Access Scanner task run wrote to the Access Log.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_access\_scanner\_task\_time7.0.0gauge Time of the next access scanner task (GMT), NOT\_SCHEDULED if access scanner has been disabled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_ahead\_exceptions7.0.0counter Total number of times a vbucket saw an item with a HLC CAS from too far in the future (indicating the clock is behind)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_allow\_sanitize\_value\_in\_deletion7.0.0gauge Let EPE delete/prepare/del\_with\_meta prune any invalid body in the payload instead of failing                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_alog\_block\_size7.0.0gauge Logging block size.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_alog\_max\_stored\_items7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_alog\_resident\_ratio\_threshold7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_alog\_sleep\_time7.0.0gauge Number of minutes between each sweep for the access log                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_alog\_task\_time7.0.0gauge Hour in GMT time when access scanner task is scheduled to run                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_arena\_memory\_allocated\_bytes7.6.0gauge / bytes The total memory allocated from the engine's arena                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_arena\_memory\_resident\_bytes7.6.0gauge / bytes The resident set size of the engine's arena                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_backfill\_mem\_threshold7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_behind\_exceptions7.0.0counter Total number of times a vbucket saw an item with a HLC CAS from too far in the past (indicating the clock is ahead)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_bfilter\_enabled7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_bfilter\_fp\_prob7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_bfilter\_key\_count7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_bfilter\_residency\_threshold7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_bg\_fetch\_avg\_read\_amplification\_ratio7.0.0gauge / ratio Average read amplification for all background fetch operations - ratio of read()s to documents fetched.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_bg\_fetched7.0.0counter Number of items fetched from disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_bg\_fetched\_compaction7.1.5counter The number of bgfetches which are triggered by compaction                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_bg\_load\_avg\_seconds7.0.0gauge / seconds The average time for an item to be loaded from disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_bg\_load\_seconds7.0.0counter / seconds The total elapsed time for items to be loaded from disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_bg\_max\_load\_seconds7.0.0gauge / seconds The longest load time when loading from disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_bg\_max\_wait\_seconds7.0.0gauge / seconds The longest time in the queue waiting to be loaded from disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_bg\_meta\_fetched7.0.0counter Number of metadata fetches from disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_bg\_min\_load\_seconds7.0.0gauge / seconds The shortest load time when loading from disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_bg\_min\_wait\_seconds7.0.0gauge / seconds The shortest time in the queue waiting to be loaded from disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_bg\_num\_samples7.0.0gauge The number of samples included in the average                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_bg\_remaining\_items7.0.0gauge Number of remaining bg fetch items                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_bg\_remaining\_jobs7.0.0gauge Number of remaining bg fetch jobs                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_bg\_wait\_avg\_seconds7.0.0gauge / seconds The average wait time for an item before it's serviced by the dispatcher                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_bg\_wait\_seconds7.0.0gauge / seconds The total elapse time for the wait queue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_blob\_num7.0.0gauge The number of blob objects in the cache                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_blob\_num\_allocated\_total7.6.0counter The number of blob object allocations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_blob\_num\_freed\_total7.6.0counter The number of blob object deallocations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_bucket\_quota\_change\_task\_poll\_interval7.0.0gauge Time in seconds between the BucketQuotaChangeTask polling memory usage to attempt to reduce the bucket quota                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_cache\_size7.0.0gauge Memory quota (in bytes) for this bucket.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_checkpoint\_computed\_max\_size\_bytes7.1.0gauge / bytes Actual max size in bytes of a single Checkpoint                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_checkpoint\_consumer\_limit\_bytes7.6.2gauge / bytes Max allocation allowed in all checkpoints (including the dcp consumer buffer quota)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_checkpoint\_destruction\_tasks7.0.0gauge Number of tasks responsible for destroying closed unreferenced checkpoints.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_checkpoint\_max\_size7.0.0gauge Max size (in bytes) of a single checkpoint. '0' for EPEngine auto-setup.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_checkpoint\_memory\_bytes7.0.0gauge / bytes Memory of items in all checkpoints                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_checkpoint\_memory\_pending\_destruction\_bytes7.1.0gauge / bytes Memory of checkpoint structures awaiting destruction by a background task                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_checkpoint\_memory\_quota\_bytes7.1.0gauge / bytes Max allocation allowed in all checkpoints                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_checkpoint\_memory\_ratio7.0.0gauge Max ratio of the bucket quota that can be allocated in checkpoints. The system enters a TempOOM phase if hit.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_checkpoint\_memory\_recovery\_lower\_mark7.0.0gauge Fraction of the checkpoint quota (as computed by checkpoint\_memory\_ratio) that represents the target of checkpoint memory recovery. Memory recovery yields when reached.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_checkpoint\_memory\_recovery\_lower\_mark\_bytes7.1.0gauge Fraction of the checkpoint quota (as computed by checkpoint\_memory\_ratio) that represents the target of checkpoint memory recovery. Memory recovery yields when reached                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_checkpoint\_memory\_recovery\_upper\_mark7.0.0gauge Fraction of the checkpoint quota (as computed by checkpoint\_memory\_ratio) that triggers attempt of memory releasing from checkpoint.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_checkpoint\_memory\_recovery\_upper\_mark\_bytes7.1.0gauge Fraction of the checkpoint quota (as computed by checkpoint\_memory\_ratio) that triggers attempt of memory releasing from checkpoint                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_checkpoint\_remover\_task\_count7.0.0gauge Number of concurrent tasks performing ItemExpel and CursorDrop/CheckpointRemoval                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_chk\_expel\_enabled7.0.0gauge Enable the ability to expel (remove from memory) items from a checkpoint. An item can be expelled if all cursors in the checkpoint have iterated past the item.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_chk\_persistence\_remains7.0.0gauge Number of remaining vbuckets for checkpoint persistence                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_chk\_remover\_stime7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_clock\_cas\_drift\_threshold\_exceeded7.0.0gauge ep\_active\_ahead\_exceptions + ep\_replica\_ahead\_exceptions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_collections\_drop\_compaction\_delay7.0.0gauge How many milliseconds before compaction runs following the drop of a collection                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_collections\_enabled7.0.0gauge Enable the collections functionality, enabling the storage of collection metadata                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_commit\_num7.0.0gauge Total number of write commits                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_commit\_time\_seconds7.0.0gauge / seconds Number of milliseconds of most recent commit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_commit\_time\_total\_seconds7.0.0gauge / seconds Cumulative milliseconds spent committing                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_compaction\_aborted7.1.0gauge Counter of how many times compaction aborted, e.g. the vbucket is required to rollback, so compaction is aborted                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_compaction\_expire\_from\_start7.0.0gauge Should compaction expire items that were logically deleted at the start of the compaction (true) or at the point in time at which they were visited (false)?                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_compaction\_expiry\_fetch\_inline7.0.0gauge If compaction requires a bgfetch before attempting expiry to ensure it does not expire an older version of the document, true: fetch it in the compaction thread. false: queue a bgfetch for the bgfetcher task to complete                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_compaction\_failed7.1.0gauge Counter of how many times compaction has failed, e.g. a system call error caused compaction to fail                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_compaction\_max\_concurrent\_ratio7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_concurrent\_pagers7.0.0gauge Number of eviction pager tasks to create when memory usage is high                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_connection\_cleanup\_interval7.0.0gauge How often connection manager task should release dead connections (in seconds).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_connection\_manager\_interval7.0.0gauge How often connection manager task should be run (in seconds).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_couchstore\_file\_cache\_max\_size7.0.0gauge Maximum number of couchstore files that we will keep open. Default value is 30 \* 1024 (i.e. one file for each vBucket and 30 Buckets - the supported limit).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_couchstore\_midpoint\_rollback\_optimisation7.0.0gauge Should we have to rollback more than half of the seqnos seen by this vBucket we will instead rollback to 0 and re-stream from the active if set to true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_couchstore\_mprotect7.0.0gauge Enable couchstore to mprotect the iobuffer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_couchstore\_tracing7.0.0gauge Enable couchstore tracing                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_couchstore\_write\_validation7.0.0gauge Validate couchstore writes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_cross\_bucket\_ht\_quota\_sharing7.0.0gauge Allow this Bucket's HashTable quota to be shared with other Buckets which have this setting enabled.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_cursors\_dropped7.0.0gauge Number of cursors dropped by the checkpoint remover                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_data\_read\_failed7.0.0gauge Total number of get failures                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_data\_traffic\_enabled7.0.0gauge True if we want to enable data traffic after warmup is complete                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_data\_write\_failed7.0.0gauge Total compaction and commit failures                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_db\_data\_size\_bytes7.0.0gauge / bytes Total size of valid data in db files                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_db\_file\_size\_bytes7.0.0gauge / bytes Total size of the db files                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_db\_history\_file\_size\_bytes7.2.0gauge / bytes The total size of all history currently stored by the bucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_db\_history\_start\_timestamp\_seconds7.2.0gauge / seconds The timestamp of the oldest document stored in the history window, oldest of all vbuckets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_db\_prepare\_size\_bytes7.0.0gauge / bytes Total size of SyncWrite prepares in db files                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_db\_tombstones7.6.10gauge The number of tombstones in db files (currently tracked only in couchstore)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_dcp\_backfill\_byte\_drain\_ratio7.0.0gauge What ratio of the dcp\_backfill\_byte\_limit must be drained for un-pausing a paused backfill                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_dcp\_backfill\_byte\_limit7.0.0gauge Max bytes a connection can backfill into memory before backfill is paused                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_dcp\_backfill\_in\_progress\_per\_connection\_limit7.0.0gauge The maximum number of backfills each connection can have in-progress (i.e. KVStore snapshot open and reading data from)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_dcp\_consumer\_buffer\_ratio7.0.0gauge Ratio of the BucketQuota that can be allocated by all DCP consumers for buffered messages                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_dcp\_consumer\_flow\_control\_ack\_ratio7.0.0gauge Ratio of freed bytes in the DCP Consumer buffer that triggers a BufferAck message to the Producer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_dcp\_consumer\_flow\_control\_ack\_seconds7.0.0gauge Max seconds after which a Consumer acks all the remaining freed bytes, regardless of whether dcp\_consumer\_flow\_control\_ack\_ratio has kicked-in or not                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_dcp\_consumer\_flow\_control\_enabled7.0.0gauge Whether DCP Consumer on this node enable flow control                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_dcp\_consumer\_process\_unacked\_bytes\_yield\_limit7.0.0gauge The number of DcpConsumerTask iterations before forcing the task to yield.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_dcp\_enable\_noop7.0.0gauge Whether DCP Consumer connections should attempt to negotiate no-ops with the Producer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_dcp\_idle\_timeout7.0.0gauge The maximum number of seconds between dcp messages before a connection is disconnected                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_dcp\_min\_compression\_ratio7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_dcp\_noop\_mandatory\_for\_v5\_features7.0.0gauge Forces clients to enable noop for v5 features                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_dcp\_noop\_tx\_interval7.0.0gauge The time interval in seconds between noop messages being sent to the consumer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_dcp\_oso\_backfill\_large\_value\_ratio7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_dcp\_oso\_backfill\_small\_item\_size\_threshold7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_dcp\_oso\_backfill\_small\_value\_ratio7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_dcp\_oso\_max\_collections\_per\_backfill7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_dcp\_producer\_catch\_exceptions7.0.0gauge If true, ActiveStream will catch exceptions during item processing and close the stream's related connection (and thus all streams for that connection). If false, exception will be re-thrown.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_dcp\_producer\_processor\_run\_duration\_us7.0.0gauge The approximate maximum runtime in microseconds for ActiveStreamCheckpointProcessorTask                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_dcp\_producer\_snapshot\_marker\_yield\_limit7.0.0gauge Not in use - replaced by dcp\_producer\_processor\_run\_duration\_us                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_dcp\_scan\_byte\_limit7.0.0gauge Max bytes that can be read in a single backfill scan before yielding                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_dcp\_scan\_item\_limit7.0.0gauge Max items that can be read in a single backfill scan before yielding                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_dcp\_takeover\_max\_time7.0.0gauge Max amount of time for takeover send (in seconds) after which front end ops would return ETMPFAIL                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_defragmenter\_age\_threshold7.0.0gauge How old (measured in number of DefragmenterVisitor passes) must a document be to be considered for defragmentation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_defragmenter\_auto\_lower\_threshold7.0.0gauge When mode is not static and scored fragmentation is above this value, a sleep time between defragmenter\_auto\_min\_sleep and defragmenter\_auto\_max\_sleep will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_defragmenter\_auto\_max\_sleep7.0.0gauge The maximum sleep that the auto controller can set                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_defragmenter\_auto\_min\_sleep7.0.0gauge The minimum sleep that the auto controller can set                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_defragmenter\_auto\_pid\_d7.0.0gauge The d term for the PID controller                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_defragmenter\_auto\_pid\_dt7.0.0gauge The dt (interval) term for the PID controller. Value represents milliseconds                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_defragmenter\_auto\_pid\_i7.0.0gauge The i term for the PID controller                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_defragmenter\_auto\_pid\_p7.0.0gauge The p term for the PID controller                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_defragmenter\_auto\_upper\_threshold7.0.0gauge When mode is auto\_linear and scored fragmentation is above this value, the defragmenter will use defragmenter\_auto\_min\_sleep                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_defragmenter\_chunk\_duration7.0.0gauge Maximum time (in ms) defragmentation task will run for before being paused (and resumed at the next defragmenter\_interval).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_defragmenter\_enabled7.0.0gauge True if defragmenter task is enabled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_defragmenter\_interval7.0.0gauge How often defragmenter task should be run (in seconds).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_defragmenter\_num\_moved7.0.0gauge Number of items moved by the defragmentater task.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_defragmenter\_num\_visited7.0.0gauge Number of items visited (considered for defragmentation) by the defragmenter task.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_defragmenter\_sleep\_time\_seconds7.6.0gauge / seconds The amount of time the defragmenter task will sleep before it is scheduled to run again.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_defragmenter\_stored\_value\_age\_threshold7.0.0gauge How old (measured in number of DefragmenterVisitor passes) must a StoredValue be to be considered for defragmentation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_defragmenter\_sv\_num\_moved7.0.0gauge Number of StoredValues moved by the defragmentater task.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_degraded\_mode7.0.0gauge True if the engine is either warming up or data traffic is disabled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_diskqueue\_drain7.0.0gauge Total drained items on disk queue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_diskqueue\_fill7.0.0gauge Total enqueued items on disk queue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_diskqueue\_items7.0.0gauge Total items in disk queue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_diskqueue\_memory\_bytes7.0.0gauge / bytes Total memory used in disk queue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_diskqueue\_pending7.0.0gauge Total bytes of pending writes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_ephemeral\_metadata\_mark\_stale\_chunk\_duration7.0.0gauge Maximum time (in ms) ephemeral hash table cleaner task will run for before being paused (and resumed at the next ephemeral\_metadata\_purge\_interval).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_ephemeral\_metadata\_purge\_age7.0.0gauge Age in seconds after which Ephemeral metadata is purged entirely from memory. Purging disabled if set to -1.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_ephemeral\_metadata\_purge\_interval7.0.0gauge Time in seconds between automatic, periodic runs of the Ephemeral metadata purge task. Periodic purging disabled if set to 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_ephemeral\_metadata\_purge\_stale\_chunk\_duration7.0.0gauge Maximum time (in ms) ephemeral stale metadata purge task will run for before being paused (and resumed at the next ephemeral\_metadata\_purge\_interval).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_exp\_pager\_enabled7.0.0gauge True if expiry pager task is enabled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_exp\_pager\_initial\_run\_time7.0.0gauge Hour in GMT time when expiry pager can be scheduled for initial run                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_exp\_pager\_stime7.0.0gauge Number of seconds between expiry pager runs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_expired\_access7.0.0gauge Number of times an item was expired on application access                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_expired\_compactor7.0.0gauge Number of times an item was expired by the compactor                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_expired\_pager7.0.0gauge Number of times an item was expired by the item pager                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_expiry\_pager\_concurrency7.0.0gauge Number of tasks which are created to scan for and delete expired items                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_expiry\_pager\_task\_time7.0.0gauge Time of the next expiry pager task (GMT), NOT\_SCHEDULED if expiry pager has been disabled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_failpartialwarmup7.0.0gauge If true then do not allow traffic to be enabled to the bucket if warmup didn't complete successfully                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_flush\_batch\_max\_bytes7.0.0gauge Max size (in bytes) of a single flush-batch passed to the KVStore for persistence.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_flush\_duration\_total\_seconds7.0.0gauge / seconds Cumulative milliseconds spent flushing                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_flusher\_todo7.0.0gauge Number of items currently being written                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_flusher\_total\_batch\_limit7.0.0gauge Number of items that all flushers can be currently flushing. Each flusher has flusher\_total\_batch\_limit / num\_writer\_threads individual batch size. Individual batches may be larger than this value, as we cannot split Memory checkpoints across multiple commits.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_freq\_counter\_increment\_factor7.0.0gauge The increment factor of the ProbabilisticCounter being used for the frequency counter. The default value of 0.012 is set such that it allows an 8-bit ProbabilisticCounter to mimic a uint16 counter. See the comment on the ProbabilisticCounter class for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_fsync\_after\_every\_n\_bytes\_written7.0.0gauge Perform a file sync() operation after every N bytes written. Disabled if set to 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_getl\_default\_timeout7.0.0gauge The default timeout for a getl lock in (s)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_getl\_max\_timeout7.0.0gauge The maximum timeout for a getl lock in (s)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_history\_retention\_bytes7.0.0gauge Max bytes of history a bucket should aim to retain on disk.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_history\_retention\_seconds7.0.0gauge Seconds of history the bucket should aim to retain on disk.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_hlc\_drift\_ahead\_threshold\_us7.0.0gauge The μs threshold of drift at which we will increment a vbucket's ahead counter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_hlc\_drift\_behind\_threshold\_us7.0.0gauge The μs threshold of drift at which we will increment a vbucket's behind counter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_hlc\_drift\_count7.0.0gauge The accumulated number of times the corresponding kv\_ep\_hlc\_drift\_count has been updated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_hlc\_drift\_seconds7.0.0gauge / seconds The accumulated drift between this node's HLC and the remote node. For active vbucket's this represents the difference in CAS and local HLC for withMeta operations, for replica vbucket's this represents the difference in CAS and local HLC from DCP replication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_ht\_item\_memory\_bytes7.1.0gauge / bytes The total byte size of all items, no matter the vbucket's state, no matter if an item's value is ejected. Tracks the same value as ep\_total\_cache\_size                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_ht\_locks7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_ht\_resize\_interval7.0.0gauge Interval in seconds to wait between HashtableResizerTask executions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_ht\_size7.0.0gauge The initial and minimum number of slots in HashTable objects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_ht\_temp\_items\_allowed\_percent7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_io\_bg\_fetch\_read\_count7.0.0gauge Accumulated count of read system calls issued by BG fetches, only maintained by couchstore buckets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_io\_compaction\_read\_bytes\_bytes7.0.0gauge / bytes Total number of bytes read during compaction                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_io\_compaction\_write\_bytes\_bytes7.0.0gauge / bytes Total number of bytes written during compaction                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_io\_document\_write\_bytes\_bytes7.0.0gauge / bytes Total number of bytes written. Only maintained by couchstore buckets and includes Couchstore B-Tree and other overheads                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_io\_total\_read\_bytes\_bytes7.0.0gauge / bytes Total number of bytes read                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_io\_total\_write\_bytes\_bytes7.0.0gauge / bytes Total number of bytes written                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_item\_begin\_failed7.0.0gauge Number of times a transaction failed to start due to storage errors                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_item\_commit\_failed7.0.0gauge Number of times a transaction failed to commit due to storage errors                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_item\_compressor\_chunk\_duration7.0.0gauge Maximum time (in ms) item compression task will run for before being paused (and resumed at the next item\_compressor\_interval).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_item\_compressor\_interval7.0.0gauge How often the item compressor task should run (in milliseconds)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_item\_compressor\_num\_compressed7.0.0gauge Number of items compressed by the item compressor task.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_item\_compressor\_num\_visited7.0.0gauge Number of items visited (considered for compression) by the item compressor task.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_item\_eviction\_age\_percentage7.0.0gauge The age percentage used when determining the age threshold in the learning\_age\_and\_mfu eviction policy.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_item\_eviction\_freq\_counter\_age\_threshold7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_item\_eviction\_initial\_mfu\_percentile7.0.0gauge Percentile of existing item MFU distribution to use to determine the MFU to give to new items (0 would insert new items with MFU equal to that of the coldest item present; 100 to that of hottest item present) for the upfront\_mfu\_only eviction strategy.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_item\_eviction\_initial\_mfu\_update\_interval7.0.0gauge Time between updates of the initial MFU given to new items (seconds)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_item\_flush\_expired7.0.0gauge Number of times an item is not flushed due to the expiry of the item                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_item\_flush\_failed7.0.0gauge Number of times an item failed to flush due to storage errors                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_item\_freq\_decayer\_chunk\_duration7.0.0gauge Maximum time (in ms) itemFreqDecayer task will run for before being paused.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_item\_freq\_decayer\_percent7.0.0gauge The percent that the frequency counter of a document is decayed when visited by item\_freq\_decayer.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_item\_num7.0.0gauge The number of item objects allocated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_item\_num\_allocated\_total7.6.0counter The number of item object allocations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_item\_num\_freed\_total7.6.0counter The number of item object deallocations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_items\_expelled\_from\_checkpoints7.0.0counter Number of items expelled from checkpoints. Expelled refers to items that have been ejected from memory but are still considered to be part of the checkpoint.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_items\_rm\_from\_checkpoints7.0.0counter Number of items removed from closed unreferenced checkpoints                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_key\_value\_size\_bytes7.0.0gauge / bytes Memory used to store items metadata, keys and values in the system, no matter the vbucket's state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_magma\_active\_disk\_usage\_bytes7.2.0gauge / bytes Compressed disk size of latest version of the LSM Trees. This includes history                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_magma\_block\_cache\_hits7.1.0gauge Number of block cache hits                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_magma\_block\_cache\_mem\_used\_bytes7.1.0gauge / bytes Memory used by block cache. Accounts for allocated size of blocks that includes allocator internal fragmentation and any internal cache overheads due to auxilliary structures                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_block\_cache\_misses7.1.0gauge Number of block cache misses                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_magma\_bloom\_filter\_accuracy7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_magma\_bloom\_filter\_accuracy\_for\_bottom\_level7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_magma\_bloom\_filter\_mem\_used\_bytes7.1.0gauge / bytes Bloom filter memory usage in all versions of the LSM Trees                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_magma\_buffer\_mem\_used\_bytes7.1.0gauge / bytes Memory usage for some buffers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_magma\_bytes\_incoming\_bytes7.1.0gauge / bytes Data written to key, seq, local index as part of the KV frontend writes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_magma\_bytes\_outgoing\_bytes7.1.0gauge / bytes Total bytes returned via get (excluding bytes returned from sequence iterator)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_magma\_bytes\_per\_read\_ratio7.1.0gauge / ratio Bytes read by get / number of Gets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_magma\_checkpoint\_disk\_usage\_bytes7.2.0gauge / bytes Checkpoint overhead                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_magma\_checkpoint\_interval7.0.0gauge Frequency of checkpoint interval; in seconds. A checkpoint provides a rollback point to which the data store can rollback to in the event of a failure.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_magma\_checkpoint\_threshold7.0.0gauge Threshold of data written before a checkpoint is created; threshold is based on a fraction of the total data size. Checkpoints require data to be retained in order to provide rollback capability. If the amount of data written during a checkpoint interval is large, we need to do more frequent checkpoints to reduce space amplification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_compactions7.1.0gauge Count of Magma compactions in key, seq and local index.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_magma\_data\_blocks\_compressed\_size7.2.0gauge Data blocks compressed size; actual size in storage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_magma\_data\_blocks\_compression\_ratio\_ratio7.2.0gauge / ratio The compression ratio calculated by dividing the uncompressed data size by the compressed data size                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_magma\_data\_blocks\_space\_reduction\_estimate\_pct\_ratio7.2.0gauge / ratio Estimated percentage of space savings in compressed data blocks (0-100)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_magma\_data\_blocks\_uncompressed\_size7.2.0gauge Data blocks uncompressed size                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_magma\_delete\_frag\_ratio7.0.0gauge Magma compaction always removes duplicate keys but not all sstables are visited during compaction.. This is the minimum fragmentation ratio threshold for when a compaction will be triggerred.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_magma\_delete\_memtable\_writecache7.0.0gauge Magma uses a lazy update model to maintain the sequence index. It maintains a list of deleted seq #s that were deleted from the key Index.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_magma\_enable\_block\_cache7.0.0gauge The block cache is an LRU policy driven cache that is used to maintain index blocks for the sstable's btrees.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_magma\_enable\_direct\_io7.0.0gauge Using direct IO tells magma to bypass the file system cache when writing or reading sstables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_magma\_enable\_group\_commit7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_enable\_memory\_optimized\_writes7.0.0gauge When enabled, if copying a write batch into memtable results in exceeding the write cache quota, Magma avoids the copy and instead flushes the batch to disk on the writer thread itself. This tradeoffs an increase in write latency for reduced memory consumption and obeys quota limits. If copying a batch keeps us under the quota, Magma will to continue to copy and do the flush in background.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_magma\_enable\_upsert7.0.0gauge When true, the kv\_engine will utilize Magma's upsert capabiltiy but accurate document counts for the data store or collections can not be maintained.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_enable\_wal7.0.0gauge WAL ensures Magma's atomicity, durability. Disabling it is useful in performance analysis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_magma\_expiry\_frag\_threshold7.0.0gauge All compactions perform expiry but not all sstables are visited by compaction. Magma maintains an expiry histogram across the kvstore to help determine which range of sstables need to have compaction run on them because there are a significant number of expired items. The frag threshold is the number of expired keys vs keys in the data store.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_magma\_expiry\_purger\_interval7.0.0gauge Magma maintains statistics about expired documents to run compaction based on magma\_expiry\_frag\_threshold. This config determines the the expiry purger polling interval in seconds to trigger compaction on eligible sstables                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_magma\_filecount\_compactions7.1.0gauge Number of compactions triggered by file count                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_magma\_flusher\_thread\_percentage7.0.0gauge Percentage of storage threads that are flusher threads (i.e. with a value of 20 we will allocate 4 (1/5th) of the storage threads to flushers and the remaining 16 (4/5ths) threads will be compactors).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_magma\_flushes7.1.0gauge Number of write cache flushes performed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_magma\_fragmentation\_percentage7.0.0gauge The percentage of fragmentation a magma bucket aims to maintain. A 100 value will disable sequence tree compactions by setting the desired fragmentation percentage to 100%. Smaller compactions of the key and local indexes will still run.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_magma\_fragmentation\_ratio7.1.0gauge / ratio Fragmentation on disk (excludes history)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_gets7.1.0gauge Number of get operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_magma\_group\_commit\_max\_sync\_wait\_duration\_ms7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_magma\_group\_commit\_max\_transaction\_count7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_magma\_heartbeat\_interval7.0.0gauge Frequency of heartbeat interval; in seconds. A heartbeat task is scheduled to provide cleanup and maintenance when magma is idle.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_histogram\_mem\_used\_bytes7.1.0gauge / bytes Memory usage for MagmaHistogramStats and file histograms                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_magma\_history\_logical\_data\_size\_bytes7.2.0gauge / bytes The logical data size of history                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_magma\_history\_logical\_disk\_size\_bytes7.2.0gauge / bytes The logical disk size of history                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_magma\_history\_size\_evicted\_bytes7.2.0gauge / bytes History eviction bytes based on size                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_magma\_history\_time\_evicted\_bytes7.2.0gauge / bytes History eviction bytes based on time                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_magma\_index\_resident\_ratio\_ratio7.1.0gauge / ratio Proportion of keyIndex (data+index blocks) and seqIndex (index blocks) in memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_magma\_initial\_wal\_buffer\_size7.0.0gauge The WAL buffer is used to stage items to the write ahead log along with control information like begin and end transaction. This parameter refers to the initial WAL buffer size. The WAL buffer will adjust its size up to a maximum of 4MB or down to a minimum of 64KB depending on the transaction batch size with consideration for other magma components which consume memory such as the block cache, bloom filters, write cache and meta data overhead.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_magma\_inserts7.1.0gauge Number of DocInsert operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_magma\_key\_tree\_data\_block\_size7.0.0gauge Magma uses SSTables for storage. SSTables are made up of different types of blocks. Data blocks contain the bulk of the data and contain the key and metadata for each of the items in the block. Larger block sizes can decrease storage space by better block compression but they require more memory, cpu and io bandwidth to read and write them.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_magma\_key\_tree\_index\_block\_size7.0.0gauge Magma uses SSTables for storage. SSTables are made up of different types of blocks. Index blocks contain keys that help traverse the SSTable to locate the data item. Larger block sizes can decrease storage space by better block compression but they require more memory, cpu and io bandwidth to read and write them.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_magma\_keyindex\_filecount\_compactions7.2.0gauge Number of compactions triggered by file count for the KeyIndex                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_magma\_keyindex\_writer\_compactions7.2.0gauge Number of compaction performed on the writer thread for the KeyIndex                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_magma\_logical\_data\_size\_bytes7.1.0gauge / bytes The logical data size, including history                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_magma\_logical\_disk\_size\_bytes7.1.0gauge / bytes The logical disk size, including history                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_magma\_lsmtree\_object\_mem\_used\_bytes7.1.0gauge / bytes Memory used by LSMTree objects                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_magma\_max\_checkpoints7.0.0gauge Maximum # of checkpoints retained for rollback.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_magma\_max\_default\_storage\_threads7.0.0gauge If the number of storage threads = 0, then we set the number of storage threads based on the number of writer threads up to a maximum of 20 threads and use magma\_flusher\_thread\_percentage to determine the ratio of flusher and compactor threads.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_magma\_max\_level\_0\_ttl7.0.0gauge Maximum time (in seconds) that data is kept in level 0 before it is merged.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_magma\_max\_recovery\_bytes7.0.0gauge Maximum amount of data that is replayed from the WAL during magma recovery. When this threshold is reached magma, creates a temporary checkpoint to recover at. This is per kvstore and in bytes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_magma\_max\_write\_cache7.0.0gauge Magma uses a common skiplist to buffer all items at the shard level called the write cache. The write cache contains items from all the kvstores that are part of the shard and when it is flushed, each kvstore will receive a few items each. Regardless of how much memory might be available, this would be the maximum amount that could be allocated.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_magma\_mem\_quota\_low\_watermark\_ratio7.0.0gauge Fraction of memory quota used by magma as it's low water mark. Magma uses this low watermark to size it's write cache and block cache. This sizing includes bloom filters memory usage but bloom filter eviction is based on the memory quota                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_magma\_mem\_quota\_ratio7.0.0gauge Magma total memory ratio of the Bucket Quota across all shards and Magma limit's it's memory usage to this value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_magma\_min\_checkpoint\_interval7.0.0gauge Minimum interval between two checkpoints; in seconds. Prevents excessive creation of checkpoints.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_magma\_min\_value\_block\_size\_threshold7.0.0gauge Magma creates value blocks for values larger than this size. Value blocks only contain a single KV item and their reads/writes are optimised for lesser memory consumption as it avoids many value copies. For example, magma block compression is turned off for them as compression requires an output buffer as large as the input buffer. This is fine since for such large docs, per document Snappy compression already should give good enough space savings. This setting should be >= SeqIndex data block size or else it won't take effect.                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_magma\_per\_document\_compression\_enabled7.0.0gauge Apply Snappy compression to each document when persisted (magma only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_magma\_read\_ahead\_buffer\_mem\_used\_bytes7.1.0gauge / bytes Memory consumed by read ahead buffers. They are used for compactions and sequence iterators. This is included in BufferMemUsed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_magma\_read\_bytes\_bytes7.1.0gauge / bytes Total bytes read from disk as per Magma's manual accounting in various code paths                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_magma\_read\_bytes\_compact\_bytes7.1.0gauge / bytes Total bytes read from disk by compactors                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_magma\_read\_bytes\_get\_bytes7.1.0gauge / bytes Total bytes read from disk by gets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_magma\_readamp\_get\_ratio7.1.0gauge / ratio Bytes Read from disk by only Get threads / Bytes outgoing                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_readamp\_ratio7.1.0gauge / ratio Bytes read from disk / bytes outgoing. Bytes read from disk includes Gets and compactors (excluding WAL)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_magma\_readio7.1.0gauge Number of read IOs performed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_magma\_readioamp\_ratio7.1.0gauge / ratio Number of read IOs performed by GetDocs divided by the number of GetDocs                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_magma\_seq\_tree\_data\_block\_size7.0.0gauge Magma uses SSTables for storage. SSTables are made up of different types of blocks. Data blocks contain the bulk of the data and contain the key, metadata and value for each of the items in the block. Larger block sizes can decrease storage space by better block compression but they require more memory, cpu and io bandwidth to read and write them. If this is less than magma\_min\_value\_block\_size\_threshold, Magma will internally auto configure the value block size to be as large as this.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_magma\_seq\_tree\_index\_block\_size7.0.0gauge Magma uses SSTables for storage. SSTables are made up of different types of blocks. Index blocks contain keys that help traverse the SSTable to locate the data item. Larger block sizes can decrease storage space by better block compression but they require more memory, cpu and io bandwidth to read and write them.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_magma\_seqindex\_data\_compactions7.6.0gauge Count of Magma compactions in seq index that compact the data level. This are already accounted in ep\_magma\_seqindex\_compactions hence not part of the magma\_compactions Prometheus stat family.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_magma\_seqindex\_delta\_bytes\_incoming\_bytes7.6.0gauge / bytes Data written to seq index delta levels as part of frontend update operations. This is already accounted in ep\_magma\_seqindex\_bytes\_incoming hence not part of Prometheus stat family magma\_bytes\_incoming.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_magma\_seqindex\_delta\_write\_bytes\_bytes7.6.0gauge / bytes Bytes written by Magma flushes, compactions of the seq index delta levels. This is already accounted into ep\_magma\_sequndex\_write\_bytes hence not part of the Prometheus stat family magma\_write\_bytes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_magma\_seqindex\_filecount\_compactions7.2.0gauge Number of compactions triggered by file count for the SeqIndex                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_magma\_seqindex\_writer\_compactions7.2.0gauge Number of compaction performed on the writer thread for the SeqIndex                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_magma\_sets7.1.0gauge Number of set operations (DocUpsert)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_magma\_sync\_every\_batch7.0.0gauge Couchstore generates a commit point at the end of every batch of items. During normal operation, Magma checkpoints are taken at every magma\_checkpoint\_interval. Many of the tests require more frequent checkpoints so this configuration parameter makes sure every batch generates a checkpoint. Each checkpoint generated in this way is a "Sync" checkpoint and isn't going to be useful for rollback as it only the latest checkpoint is a "Sync" checkpoiont. A "Rollback" checkpoint will be made instead if we set magma\_checkpoint\_interval to 0\. The "Rollback" checkpoints are stored in the checkpoint queue as potential rollback points. Should be used for testing only!                                                                                                                                                                                                                                                                               |
| kv\_ep\_magma\_syncs7.1.0gauge Number of fsyncs performed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_magma\_table\_meta\_mem\_used\_bytes7.1.0gauge / bytes Memory used by sstable metadata                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_table\_object\_mem\_used\_bytes7.1.0gauge / bytes Memory used by SSTable objects                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_magma\_tables7.1.0gauge Number of files used for tables                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_magma\_tables\_created7.1.0gauge Number of table files created                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_magma\_tables\_deleted7.1.0gauge Number of table files deleted                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_magma\_total\_disk\_usage\_bytes7.1.0gauge / bytes Compressed size of all SSTables in all checkpoints, WAL and any other files on disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_total\_mem\_used\_bytes7.1.0gauge / bytes Total memory used by bloom filters, write cache, block cache and index blocks This account for all versions of the trees                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_magma\_tree\_snapshot\_mem\_used\_bytes7.6.0gauge / bytes Memory consumed by all LSMTree TreeSnapshots                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_ttl\_compactions7.1.0gauge Number of time-to-live based compactions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_magma\_wal\_disk\_usage\_bytes7.1.0gauge / bytes Disk usage by the WAL                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_magma\_wal\_mem\_used\_bytes7.1.0gauge / bytes Total WAL memory used, including WAL buffer and any auxiliary memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_magma\_write\_bytes\_bytes7.1.0gauge / bytes Bytes written by Magma flushes, compactions and WAL writes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_magma\_write\_bytes\_compact\_bytes7.1.0gauge / bytes Bytes written by Magma compactions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_magma\_write\_cache\_mem\_used\_bytes7.1.0gauge / bytes Memory usage of the write cache                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_magma\_write\_cache\_ratio7.0.0gauge Memory is maintained across 3 magma components; Bloom filters, Block cache and Write cache. The least important of these is the write cache. If there is insufficent memory for the write cache, the write cache will grow to the size of the batch and then be immediately flushed and freed. If there is available memory, the write cache is limited to 20% of the available memory (after bloom filter and block cache get their memory up to magma\_max\_write\_cache (128MB). Bloom filters are the most important and are never paged out. Bloom filter memory can cause magma to go above the memory quota. To allevaite this, the bottom layer where the majority of bloom filter memory is, won't use bloom filters when OptimizeBloomFilterForMisses is on (which it is by default). The block cache grows each time the index sizes change. But its growth is bounded by the available memory or what's left over after the bloom filter memory is subtracted. |
| kv\_ep\_magma\_writer\_compactions7.1.0gauge Number of compaction performed on the writer thread                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_max\_checkpoints7.0.0gauge The expected max number of checkpoints in each VBucket on a balanced system. Note: That is not a hard limit on the single vbucket. That is used (together with checkpoint\_memory\_ratio) for computing checkpoint\_max\_size, which triggers checkpoint creation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_max\_failover\_entries7.0.0gauge maximum number of failover log entries                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_max\_item\_privileged\_bytes7.0.0gauge Maximum number of bytes allowed for 'privileged' (system) data for an item in addition to the max\_item\_size bytes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_max\_item\_size7.0.0gauge Maximum number of bytes allowed for an item                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_max\_num\_bgfetchers7.0.0gauge Maximum number of bg fetcher objects (the number of concurrent bg fetch tasks we can run). 0 = auto-configure which means we use the same number as the number of shards (max\_num\_shards - for historic reasons). See also num\_reader\_threads.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_max\_num\_flushers7.0.0gauge Maximum number of flusher objects (the number of concurrent flusher tasks we can run). 0 = auto-configure which means we use the same number as the number of shards (max\_num\_shards - for historic reasons). See also num\_writer\_threads.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_max\_num\_shards7.0.0gauge Maximum mumber of shards (0 = auto-configure)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_max\_num\_workers7.0.0gauge Bucket Priority relative to other buckets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_max\_size7.0.0gauge Memory quota (in bytes) for this bucket.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_max\_threads7.0.0gauge Maximum number of threads of any single class (0 = automatically select based on core count)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_max\_ttl7.0.0gauge A maximum TTL (in seconds) that will apply to all new documents, documents set with no TTL will be given this value. A value of 0 means this is disabled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_max\_vbuckets7.0.0gauge Maximum number of vbuckets expected                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_mem\_freed\_by\_checkpoint\_item\_expel\_bytes7.1.0gauge / bytes Memory recovered from Checkpoint by expelling clean items (i.e. items processed by all cursors) from the queue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_mem\_freed\_by\_checkpoint\_removal\_bytes7.1.0gauge / bytes Amount of memory freed through ckpt removal                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_mem\_high\_wat7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_mem\_high\_wat\_percent\_ratio7.0.0gauge / ratio High water mark (as a percentage)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_mem\_low\_wat7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_mem\_low\_wat\_percent\_ratio7.0.0gauge / ratio Low water mark (as a percentage)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_mem\_tracker\_enabled7.0.0gauge True if memory usage tracker is enabled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_mem\_used\_merge\_threshold\_percent7.0.0gauge What percent of max\_data size should we allow the estimated total memory to lag by (EPStats::getEstimatedTotalMemoryUsed)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_meta\_data\_disk\_bytes7.0.0gauge / bytes Estimate of how much metadata has been written to disk since startup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_meta\_data\_memory\_bytes7.0.0gauge / bytes Total memory used by meta data, including the key                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_min\_compression\_ratio7.0.0gauge specifies a minimum compression ratio below which storing the document will be stored as uncompressed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_mutation\_mem\_ratio7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_not\_locked\_returns\_tmpfail7.0.0gauge Controls which error code should be returned when attempting to unlock an item that is not locked. When value is true, the legacy temporary\_failure is used instead of not\_locked.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_num\_access\_scanner\_runs7.0.0gauge Number of times we ran accesss scanner to snapshot working set                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_num\_access\_scanner\_skips7.0.0gauge Number of times accesss scanner task decided not to generate access log                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_num\_checkpoints7.1.0gauge The number of checkpoint objects allocated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_num\_checkpoints\_allocated\_total7.6.0counter The number of checkpoint object allocations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_num\_checkpoints\_freed\_total7.6.0counter The number of checkpoint object deallocations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_num\_checkpoints\_pending\_destruction7.6.0gauge Number of checkpoints detached from CM and owned by Destroyers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_num\_eject\_failures7.0.0counter Number of items that could not be ejected                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_num\_expiry\_pager\_runs7.0.0counter Number of times we ran expiry pager loops to purge expired items from memory/disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_num\_freq\_decayer\_runs7.0.0counter Number of times we ran the freq decayer task because a frequency counter has become saturated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_num\_non\_resident7.0.0gauge The number of non-resident items                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_num\_not\_my\_vbuckets7.0.0counter Number of times Not My VBucket exception happened during runtime                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_num\_pager\_runs7.0.0counter Number of times we ran pager loops to seek additional memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_num\_value\_ejects7.0.0counter Number of times item values got ejected from memory to disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_num\_workers7.0.0gauge Global number of shared worker threads                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_oom\_errors7.0.0gauge Number of times unrecoverable OOMs happened while processing operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_pageable\_mem\_bytes7.6.11gauge / bytes Current pageable memory usage (used in paging management)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_pager\_sleep\_time\_ms7.0.0gauge How long in milliseconds the ItemPager will sleep for when not being requested to run                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_paging\_visitor\_pause\_check\_count7.0.0gauge Expected number of times the PagingVisitor will check the pause condition per vBucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_pending\_compactions7.0.0gauge For persistent buckets, the count of compaction tasks.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_pending\_ops7.0.0gauge Number of ops awaiting pending vbuckets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_pending\_ops\_max7.0.0gauge Max ops seen awaiting 1 pending vbucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_pending\_ops\_max\_duration\_seconds7.0.0gauge / seconds Max time (µs) used waiting on pending vbuckets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_pending\_ops\_total7.0.0counter Total blocked pending ops since reset                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_persist\_vbstate\_total7.0.0gauge Total VB persist state to disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_persistent\_metadata\_purge\_age7.0.0gauge Age in seconds after which tombstones may be purged. Defaults to 3 days. Max of 60 days. If this is dynamically changed for a magma bucket then magma may not trigger compactions when it should, this can be avoided by running a full manual compaction after changing this parameter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_pitr\_enabled7.0.0gauge Is PiTR enabled or not                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_pitr\_granularity7.0.0gauge The granularity (interval between each rollback point) in seconds (up to 5 hours)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_pitr\_max\_history\_age7.0.0gauge The number of seconds of the oldest entry to keep as part of compaction (up to 48 hours)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_queue\_size7.0.0gauge Number of items queued for storage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_range\_scan\_kv\_store\_scan\_ratio7.0.0gauge The ratio for calculating how many RangeScans can exist, a ratio of total KVStore scans.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_range\_scan\_max\_continue\_tasks7.0.0gauge The maximum number of range scan tasks that can exist concurrently. Setting to 0 results in num\_auxio\_threads - 1 tasks                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_range\_scan\_max\_lifetime7.0.0gauge The maximum lifetime in seconds for a range-scan. Scans that don't complete before this limit are cancelled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_range\_scan\_read\_buffer\_send\_size7.0.0gauge The size of a buffer used to store data read during the I/O phase of a range-scan-continue. Once the buffer size is >= to this value the data is sent to the connection                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_retain\_erroneous\_tombstones7.0.0gauge whether erroneous tombstones need to be retain during compaction. Erroneous tombstones are those that have invalid meta data in it. For example, a delete time of 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_ep\_rollback\_count7.0.0gauge Number of rollbacks on consumer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_seqno\_persistence\_timeout7.0.0gauge Timeout in seconds after which a pending SeqnoPersistence operation is temp-failed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_startup\_time\_seconds7.0.0gauge / seconds System-generated engine startup time                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_storedval\_num7.0.0gauge The number of storedval objects allocated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_storedval\_num\_allocated\_total7.6.0counter The number of storedval object allocations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_storedval\_num\_freed\_total7.6.0counter The number of blob object deallocations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_storedval\_size\_allocated\_total\_bytes7.6.0counter / bytes The total number of bytes ever allocated for storedval objects                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_storedval\_size\_freed\_total\_bytes7.6.0counter / bytes The total number of bytes ever freed by deallocated storedval objects                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ep\_sync\_writes\_max\_allowed\_replicas7.0.0gauge The maximum number of supported replicas for SyncWrites. Attempts to issue SyncWrites against a topology with more replicas than this setting will fail with DurabilityImpossible.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_ep\_tmp\_oom\_errors7.0.0counter Number of times temporary OOMs happened while processing operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_total\_cache\_size\_bytes7.0.0gauge / bytes The total byte size of all items, no matter the vbucket's state, no matter if an item's value is ejected. Tracks the same value as ep\_ht\_item\_memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_total\_deduplicated7.0.0gauge Total number of items de-duplicated when queued to CheckpointManager                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_total\_deduplicated\_flusher7.2.0gauge Total number of items de-duplicated when flushed to disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_total\_del\_items7.0.0gauge Total number of persisted deletions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_total\_enqueued7.0.0gauge Total number of items queued for persistence                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ep\_total\_new\_items7.0.0gauge Total number of persisted new items                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_ep\_total\_persisted7.0.0gauge Total number of items persisted                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_uncommitted\_items7.0.0gauge The amount of items that have not been written to disk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_value\_size\_allocated\_total\_bytes7.6.0counter / bytes The total number of bytes ever allocated for blob objects                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_value\_size\_freed\_total\_bytes7.6.0counter / bytes The total number of bytes ever freed by deallocated blob objects                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_vb\_total7.0.0gauge Total vBuckets (count)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_vbucket\_del7.0.0gauge Number of vbucket deletion events                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_ep\_vbucket\_del\_avg\_walltime\_seconds7.0.0gauge / seconds Avg wall time (µs) spent by deleting a vbucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_vbucket\_del\_fail7.0.0gauge Number of failed vbucket deletion events                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_vbucket\_del\_max\_walltime\_seconds7.0.0gauge / seconds Max wall time (µs) spent by deleting a vbucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_vbucket\_mapping\_sanity\_checking7.0.0gauge Are vBucket mappings (key -> vBucket) checked by the server? This is a sanity checking mode which crc32 hashes the key to ensure that the client is supplying the expected vBucket for each key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_warmup7.0.0gauge Is Warmup of existing data enabled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_ep\_warmup\_backfill\_scan\_chunk\_duration7.0.0gauge The duration (in ms) after which warmup's backfill scans will yield and re-schedule; allowing other tasks on the same threads to run.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_ep\_warmup\_batch\_size7.0.0gauge The size of each batch loaded during warmup.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_ep\_warmup\_dups7.0.0gauge Duplicates encountered during warmup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_ep\_warmup\_min\_items\_threshold7.0.0gauge Percentage of total items warmed up before we enable traffic.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_ep\_warmup\_min\_memory\_threshold7.0.0gauge Percentage of max mem warmed up before we enable traffic.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_ep\_warmup\_oom7.0.0gauge OOMs encountered during warmup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_warmup\_status7.2.0gauge The current status of the warmup thread                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_ep\_warmup\_thread7.0.0gauge Warmup thread status                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_ep\_warmup\_time\_seconds7.0.0gauge / seconds Time (µs) spent by warming data                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_ep\_workload\_monitor\_enabled7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_ep\_xattr\_enabled7.0.0gauge                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_item\_alloc\_sizes\_bytes7.0.0histogram / bytes Item allocation size counters for front-end mutations (in bytes)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_items\_in\_transit7.6.0gauge The number of items currently in transit (with a reference into the engine)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_lock\_errors7.0.0gauge The number of times an operation failed due to accessing a locked document                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_logical\_data\_size\_bytes7.6.0gauge / bytes The logical size of all user data on disk (per-bucket), with compression applied                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_magma\_bytes\_incoming\_bytes7.6.0gauge / bytes Data written as part of the KV frontend writes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_magma\_compactions7.2.0gauge Count of Magma compactions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_magma\_flusher\_thread\_percentage7.6.10gauge Percent of magma flusher threads out of total magma threads                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_magma\_itr7.6.0gauge Number of items returned by iterators                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_magma\_max\_default\_storage\_threads7.6.10gauge The number of total magma threads                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_magma\_write\_bytes\_bytes7.6.0gauge / bytes Bytes written by Magma flushes, compactions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_magma\_write\_bytes\_filecount\_compact\_bytes7.6.0gauge / bytes Bytes written by Magma compactions due to file count triggers.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_max\_system\_connections7.6.0gauge Maximum number of connections to the interfaces marked as system only                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_max\_user\_connections7.6.0gauge Maximum number of connections to the interfaces marked as user                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_mem\_used\_bytes7.0.0gauge / bytes Engine's total memory usage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_mem\_used\_estimate\_bytes7.0.0gauge / bytes Engine's total estimated memory usage (this is a faster stat to read, but lags mem\_used as it's only updated when a threshold is crossed see mem\_used\_merge\_threshold)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_memcache\_curr\_items7.0.0gauge Number of active items in memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_memcache\_engine\_maxbytes7.0.0gauge The max size of the bucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_memcache\_evictions7.0.0gauge Number of items evicted from the bucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_memcache\_mem\_size\_bytes7.0.0gauge / bytes Engine's total memory usage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_memcache\_reclaimed7.0.0gauge Number of items allocated by reusing expired objects                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_memcache\_total\_items7.0.0gauge Total number of items in the bucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_memory\_overhead\_bytes7.0.0gauge / bytes The "unused" memory caused by the allocator returning bigger chunks than requested                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_memory\_used\_bytes7.0.0gauge / bytes Memory used for various objects                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_num\_high\_pri\_requests7.0.0gauge Num of async high priority requests                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_num\_vbuckets7.0.0gauge Number of vBuckets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kv\_ops7.0.0gauge Number of operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_ops\_failed7.0.0gauge Number of operations failed due to conflict resolution                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_read\_bytes7.0.0gauge / bytes The number bytes received from all connections bound to this bucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_rollback\_item\_count7.0.0gauge Num of items rolled back                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_stat\_reset7.0.0gauge Timestamp when the stats was reset                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_stat\_timings\_mem\_usage\_bytes7.1.0gauge / bytes The memory footprint for tracing times spent processing stat requests                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_subdoc\_lookup\_extracted\_bytes7.0.0gauge / bytes The total number of bytes from the documents being returned as part of subdoc lookup operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_subdoc\_lookup\_searched\_bytes7.0.0gauge / bytes The total size of all documents used for subdoc lookup operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_subdoc\_mutation\_inserted\_bytes7.0.0gauge / bytes The total number of bytes inserted into the documents via subdoc                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_subdoc\_mutation\_updated\_bytes7.0.0gauge / bytes The total number of bytes for the documents mutated via subdoc                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_subdoc\_ops7.0.0gauge The number of subdoc operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_subdoc\_update\_races7.6.0gauge The number of times a subdoc mutation had to be retried as the document was changed by a different actor while performing the operation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_sync\_write\_commit\_duration\_seconds7.0.0histogram / seconds Commit duration for SyncWrites                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_system\_connections7.0.0gauge The number of connections to system ports in memcached                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_task\_duration\_seconds7.6.2histogram / seconds Per-task histogram of time taken to run a task                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_thread\_cpu\_usage\_seconds7.6.0gauge / seconds Number of seconds the given thread has spent running according to the OS                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_time\_seconds7.0.0gauge / seconds The servers current time (seconds since January 1st, 1970 at 00:00:00 UTC)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_total\_connections7.0.0counter The total number of connections to this system since the process started (or reset)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_total\_memory\_overhead\_bytes7.0.0gauge / bytes Extra memory used by transient data like persistence queue, replication queues, checkpoints, etc                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_total\_memory\_used\_bytes7.0.0gauge / bytes Engine's total memory usage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_total\_resp\_errors7.0.0gauge The number of error messages returned                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_uptime\_seconds7.0.0gauge / seconds The number of seconds elapsed since process start                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| kv\_user\_connections7.6.0gauge The number of connections to user ports in memcached                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_vb\_auto\_delete\_count7.0.0gauge Cumulative count of documents auto-deleted due to NRU ejection (Ephemeral Buckets only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_vb\_bloom\_filter\_memory\_bytes7.1.0gauge / bytes The memory usage in bytes of the per-vBucket Bloom filters                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_vb\_checkpoint\_memory\_bytes7.0.0gauge / bytes Total memory in checkpoints, sum of kv\_vb\_\_checkpoint\_memory\_overhead\_bytes and kv\_vb\_checkpoint\_memory\_queue\_bytes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_vb\_checkpoint\_memory\_overhead\_bytes7.0.0gauge / bytes Checkpoints memory overhead. That is the sum of kv\_vb\_checkpoint\_memory\_overhead\_index\_bytes and kv\_vb\_checkpoint\_memory\_overhead\_queue\_bytes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_vb\_checkpoint\_memory\_overhead\_index\_bytes7.1.0gauge / bytes Memory overhead in the checkpoints key-index. For every index entry, that accounts the internal structure allocation plus the key-size.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_vb\_checkpoint\_memory\_overhead\_queue\_bytes7.1.0gauge / bytes Memory overhead in the checkpoints internal items queue. For every item in the queue, that accounts the internal structure allocation for holding the item's reference.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_vb\_checkpoint\_memory\_queue\_bytes7.1.0gauge / bytes Total memory of all the items queued in checkpoints. For every item in the queue, that accounts the item's key, metadata and value size. The value allocation may have shared ownership HashTable and DCP Stream readyQ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_vb\_curr\_items7.0.0gauge Count of alive (non-deleted) items in the vbucket, including non-resident items                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_vb\_dm\_mem\_used\_bytes7.2.1gauge / bytes The memory usage in bytes of the per-VBucket Durability Monitor (in-progress SyncWrites)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_vb\_dm\_num\_tracked7.2.1gauge The number of items tracked in the per-VBucket Durability Monitor (in-progress SyncWrites)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| kv\_vb\_eject7.0.0gauge Cumulative count of the number of items whose values have been ejected for this vBucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_vb\_expired7.0.0gauge Cumulative count of the number of items which have been expired for this vBucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_vb\_ht\_avg\_size7.2.5gauge The average size (number of slots) of the HashTable across all vbuckets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_vb\_ht\_item\_memory\_bytes7.1.0gauge / bytes The memory usage of items stored in the HashTable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_vb\_ht\_item\_memory\_uncompressed\_bytes7.1.0gauge / bytes The memory usage of items stored in the HashTable, if the values were not compressed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_vb\_ht\_max\_size7.2.5gauge The maximum HashTable size (number of slots) across all vbuckets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_vb\_ht\_memory\_bytes7.0.0gauge / bytes Memory overhead of the HashTable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| kv\_vb\_ht\_tombstone\_purged\_count7.0.0gauge Number of purged tombstones (Ephemeral)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_vb\_max\_history\_disk\_size\_bytes7.2.0gauge / bytes The total size of history stored per-vBucket (the largest size reported by any vBucket)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_vb\_mem\_freed\_by\_checkpoint\_item\_expel\_bytes7.1.0gauge / bytes Memory recovered from Checkpoint by expelling clean items (i.e. items processed by all cursors) from the queue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_vb\_mem\_freed\_by\_checkpoint\_removal\_bytes7.1.0gauge / bytes Amount of memory freed through ckpt removal                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_vb\_meta\_data\_disk\_bytes7.0.0gauge / bytes Estimate of how much metadata has been written to disk since startup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_vb\_meta\_data\_memory\_bytes7.0.0gauge / bytes Total memory used by meta data, including the key                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_vb\_num\_non\_resident7.0.0gauge The number of non-resident items                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_vb\_ops\_create7.0.0gauge Number of operations where an item has been flushed to disk that did not previously exist                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_vb\_ops\_delete7.0.0gauge Number of operations where a delete has been persisted                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_vb\_ops\_get7.0.0gauge Number of successful front-end get operations                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kv\_vb\_ops\_reject7.0.0gauge Number of fatal errors in persisting a mutation (including deletion)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_vb\_ops\_update7.0.0gauge Number of operations where a new version of an item has been persisted                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| kv\_vb\_perc\_mem\_resident\_ratio7.0.0gauge / ratio Percentage of items which are resident in memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_vb\_queue\_age\_seconds7.0.0gauge / seconds Sum of disk queue item age in seconds                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_vb\_queue\_drain7.0.0gauge Total drained items                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_vb\_queue\_fill7.0.0gauge Total items enqueued on disk queues                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| kv\_vb\_queue\_memory\_bytes7.0.0gauge / bytes Total memory used by the disk queues                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_vb\_queue\_pending\_bytes7.0.0gauge / bytes Total bytes of pending writes in the disk queue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| kv\_vb\_queue\_size7.0.0gauge Number of items in the disk queues                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_vb\_rollback\_item\_count7.0.0gauge Total number of mutations discarded during rollback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_vb\_seqlist\_count7.0.0gauge Number of items in the sequence list                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kv\_vb\_seqlist\_deleted\_count7.0.0gauge Number of deleted items in the sequence list                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_vb\_seqlist\_purged\_count7.0.0gauge Number of tombstones purged from the sequence list                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| kv\_vb\_seqlist\_read\_range\_count7.0.0gauge Number of sequence numbers visible according to the sequence list read range                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| kv\_vb\_seqlist\_stale\_count7.0.0gauge Number of stale items in the sequence list                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kv\_vb\_seqlist\_stale\_metadata\_bytes7.0.0gauge / bytes Total bytes of stale metadata (key + fixed metadata) in the sequence list                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_vb\_seqlist\_stale\_value\_bytes7.0.0gauge / bytes Total bytes of stale values in the sequence list                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| kv\_vb\_sync\_write\_aborted\_count7.0.0gauge Total number of aborted SyncWrites                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| kv\_vb\_sync\_write\_accepted\_count7.0.0gauge Total number of accepted SyncWrites (in-progress, aborted or committed)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| kv\_vb\_sync\_write\_committed\_count7.0.0gauge Total number of comitted SyncWrites                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| kv\_written\_bytes7.0.0gauge / bytes The number bytes sent to all connections bound to this bucket                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |