{
"schema_version": 2,
"id": "integrate/prometheus-with-redis-enterprise/prometheus-metrics-v1-to-v2",
"title": "Transition from Prometheus v1 to Prometheus v2",
"url": "https://redis.io/docs/latest/integrate/prometheus-with-redis-enterprise/prometheus-metrics-v1-to-v2/",
"summary": "Transition from v1 metrics to v2 PromQL equivalents.",
"tags": [
"docs",
"integrate",
"rs"
],
"last_updated": "2026-09-17T14:54:30+01:00",
"page_type": "content",
"content_hash": "576efc9798d50f71fc12bd193802df74406d5e959a5b6fe40608d0fdacbdcb81",
"sections": [
{
"id": "overview",
"title": "Overview",
"role": "overview",
"text": "You can [integrate Redis Software with Prometheus and Grafana](https://redis.io/docs/latest/integrate/prometheus-with-redis-enterprise) to create dashboards for important metrics.\n\nAs of Redis Software version 7.8.2, [PromQL (Prometheus Query Language)](https://prometheus.io/docs/prometheus/latest/querying/basics/) metrics are available. V1 metrics are deprecated but still available.\n\nTo transition from v1 metrics to v2 metrics, you need to change the `metrics_path` in your Prometheus configuration file from `/` to `/v2` to use the new scraping endpoint.\n\nHere's an example of the updated scraping configuration in `prometheus.yml`:\n\n[code example]\n\n> [!NOTE]\n> **Use a single scrape target.** The v2 endpoint is cluster-wide. Every node aggregates metrics from all nodes and returns the same complete result, so one target is enough. If you list one target per node, Prometheus stores every series once per target and multiplies each `sum()`-based dashboard panel by the number of targets. This produces no error. Prometheus reports every target as up and Grafana renders normally. Use your cluster FQDN as the single target so metrics remain available if a node goes down.\n\nThe reason for a single target changed in v2. On v1, only the cluster master served the metrics endpoint and other nodes returned a redirect, so the protocol effectively forced one target. On v2, every node returns the full cluster view and no redirects are involved. If your v1 configuration listed multiple node targets, reduce it to one.\n\nIf you prefer a per-node scrape topology, scrape `/v2/node`, which returns only that node's own metrics. Aggregation adds the `cluster` and `node` labels, so `/v2/node` responses omit them. Add `relabel_configs` to supply those labels before using `/v2/node` with the Redis Software Grafana dashboards.\n\nIt is possible to scrape both v1 and v2 endpoints simultaneously during the transition period to prepare dashboards and ensure a smooth transition.\n\nYou can use the following tables to transition from v1 metrics to equivalent v2 PromQL. For a list of all available v2 PromQL metrics, see [Prometheus metrics v2](https://redis.io/docs/latest/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions)."
},
{
"id": "database-metrics",
"title": "Database metrics",
"role": "content",
"text": "| V1 metric | Equivalent V2 PromQL | Description |\n| --------- | :------------------- | :---------- |\n| bdb_avg_latency | `(sum by (db)(irate(endpoint_read_requests_latency_histogram_sum{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_write_requests_latency_histogram_sum{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_other_requests_latency_histogram_sum{db=\"\"$db\"\"}[$__rate_interval])))/(sum by (db)(irate(endpoint_read_requests{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_write_requests{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_other_requests{db=\"\"$db\"\"}[$__rate_interval])))/1000000` | Average latency of operations on the database (seconds); returned only when there is traffic |\n| bdb_avg_latency_max | `avg(histogram_quantile(1, sum by (le, db) (irate(endpoint_read_requests_latency_histogram_bucket{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_write_requests_latency_histogram_bucket{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_other_requests_latency_histogram_bucket{db=\"\"$db\"\"}[$__rate_interval])))) / 1000000` | Highest value of average latency of operations on the database (seconds); returned only when there is traffic |\n| bdb_avg_read_latency | `(sum(irate(endpoint_read_requests_latency_histogram_sum{db=\"\"$db\"\"}[$__rate_interval]))/sum(irate(endpoint_read_requests{db=\"\"$db\"\"}[$__rate_interval])))/1000000` | Average latency of read operations (seconds); returned only when there is traffic |\n| bdb_avg_read_latency_max | `histogram_quantile(1, sum by (le) (irate(endpoint_read_requests_latency_histogram_bucket{db=\"\"$db\"\"}[$__rate_interval]))) / 1000000` | Highest value of average latency of read operations (seconds); returned only when there is traffic |\n| bdb_avg_write_latency | `(sum(irate(endpoint_write_requests_latency_histogram_sum{db=\"\"$db\"\"}[$__rate_interval]))/sum(irate(endpoint_write_requests{db=\"\"$db\"\"}[$__rate_interval])))/1000000` | Average latency of write operations (seconds); returned only when there is traffic |\n| bdb_avg_write_latency_max | `histogram_quantile(1, sum by (le) (irate(endpoint_write_requests_latency_histogram_bucket{db=\"\"$db\"\"}[$__rate_interval]))) / 1000000` | Highest value of average latency of write operations (seconds); returned only when there is traffic |\n| bdb_bigstore_shard_count | `sum((sum(label_replace(label_replace(namedprocess_namegroup_thread_count{groupname=~\"redis-\\d+\", threadname=~\"(speedb\\|rocksdb).*\"}, \"redis\", \"$1\", \"groupname\", \"redis-(\\d+)\"), \"driver\", \"$1\", \"threadname\", \"(speedb\\|rocksdb).*\")) by (redis, driver) > bool 0) * on (redis) group_left(db) redis_server_up) by (db, driver)` | Shard count by database and by storage engine (driver - rocksdb / speedb); Only for databases with Auto Tiering enabled |\n| bdb_conns | `sum(endpoint_client_connections{cluster=\"$cluster\", db=\"$db\"} - endpoint_client_disconnections{cluster=\"$cluster\", db=\"$db\"} - endpoint_proxy_disconnections{cluster=\"$cluster\", db=\"$db\"})` | Number of client connections to database |\n| bdb_egress_bytes | `sum by(db) (irate(endpoint_egress{db=\"$db\"}[$__rate_interval]))` | Rate of outgoing network traffic from the database (bytes/sec) |\n| bdb_egress_bytes_max | `max_over_time (sum by(db) (irate(endpoint_egress{db=\"$db\"}[$__rate_interval]))[$__range:])` | Highest value of the rate of outgoing network traffic from the database (bytes/sec) |\n| bdb_evicted_objects | `sum by (db) (irate(redis_server_evicted_keys{role=\"master\"}[$__rate_interval]))` | Rate of key evictions from database (evictions/sec) |\n| bdb_evicted_objects_max | `sum by (db) (irate(redis_server_evicted_keys{role=\"master\"}[$__rate_interval]))` | Highest value of the rate of key evictions from database (evictions/sec) |\n| bdb_expired_objects | `sum by (db) (irate(redis_server_expired_keys{role=\"master\"}[$__rate_interval]))` | Rate of keys expired in database (expirations/sec) |\n| bdb_expired_objects_max | `sum by (db) (irate(redis_server_expired_keys{role=\"master\"}[$__rate_interval]))` | Highest value of the rate of keys expired in database (expirations/sec) |\n| bdb_fork_cpu_system | `sum by (db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"system\"}[$__rate_interval]))` | Cores utilization in system mode for all Redis shard fork child processes of this database |\n| bdb_fork_cpu_system_max | `sum by (db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"system\"}[$__rate_interval]))` | Highest value of cores utilization in system mode for all Redis shard fork child processes of this database |\n| bdb_fork_cpu_user | `sum by (db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"user\"}[$__rate_interval]))` | Cores utilization in user mode for all Redis shard fork child processes of this database |\n| bdb_fork_cpu_user_max | `sum by (db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"user\"}[$__rate_interval]))` | Highest value of cores utilization in user mode for all Redis shard fork child processes of this database |\n| bdb_ingress_bytes | `sum by(db) (irate(endpoint_ingress{db=\"$db\"}[$__rate_interval]))` | Rate of incoming network traffic to database (bytes/sec) |\n| bdb_ingress_bytes_max | `max_over_time (sum by(db) (irate(endpoint_ingress{db=\"$db\"}[$__rate_interval]))[$__range:])` | Highest value of the rate of incoming network traffic to database (bytes/sec) |\n| bdb_instantaneous_ops_per_sec | `sum by(db) (redis_server_instantaneous_ops_per_sec)` | Request rate handled by all shards of database (ops/sec) |\n| bdb_main_thread_cpu_system | `sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"system\", threadname=~\"redis-server.*\"}[$__rate_interval]))` | Cores utilization in system mode for all Redis shard main threads of this database |\n| bdb_main_thread_cpu_system_max | `sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"system\", threadname=~\"redis-server.*\"}[$__rate_interval]))` | Highest value of cores utilization in system mode for all Redis shard main threads of this database |\n| bdb_main_thread_cpu_user | `sum by(irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"user\", threadname=~\"redis-server.*\"}[$__rate_interval]))` | Cores utilization in user mode for all Redis shard main threads of this database |\n| bdb_main_thread_cpu_user_max | `sum by(irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"user\", threadname=~\"redis-server.*\"}[$__rate_interval]))` | Highest value of cores utilization in user mode for all Redis shard main threads of this database |\n| bdb_mem_frag_ratio | `avg(redis_server_mem_fragmentation_ratio)` | RAM fragmentation ratio (RSS / allocated RAM) |\n| bdb_mem_size_lua | `sum by(db) (redis_server_used_memory_lua)` | Redis lua scripting heap size (bytes) |\n| bdb_memory_limit | `db_memory_limit_bytes` | Configured RAM limit for the database |\n| bdb_monitor_sessions_count | `sum by(db) (endpoint_monitor_sessions_count)` | Number of clients connected in monitor mode to the database |\n| bdb_no_of_keys | `sum by (db) (redis_server_db_keys{role=\"master\"})` | Number of keys in database |\n| bdb_other_req | `sum by(db) (irate(endpoint_other_requests{db=\"$db\"}[$__rate_interval]))` | Rate of other (non read/write) requests on the database (ops/sec) |\n| bdb_other_req_max | `max_over_time (sum by(db) (irate(endpoint_other_requests{db=\"$db\"}[$__rate_interval]))[$__range:])` | Highest value of the rate of other (non read/write) requests on the database (ops/sec) |\n| bdb_other_res | `sum by(db) (irate(endpoint_other_responses{db=\"$db\"}[$__rate_interval]))` | Rate of other (non read/write) responses on the database (ops/sec) |\n| bdb_other_res_max | `max_over_time (sum by(db) (irate(endpoint_other_responses{db=\"$db\"}[$__rate_interval]))[$__range:])` | Highest value of the rate of other (non read/write) responses on the database (ops/sec) |\n| bdb_pubsub_channels | `sum by(db) (redis_server_pubsub_channels)` | Count the pub/sub channels with subscribed clients |\n| bdb_pubsub_channels_max | `sum by(db) (redis_server_pubsub_channels)` | Highest value of count the pub/sub channels with subscribed clients |\n| bdb_pubsub_patterns | `sum by(db) (redis_server_pubsub_patterns)` | Count the pub/sub patterns with subscribed clients |\n| bdb_pubsub_patterns_max | `sum by(db) (redis_server_pubsub_patterns)` | Highest value of count the pub/sub patterns with subscribed clients |\n| bdb_read_hits | `sum by (db) (irate(redis_server_keyspace_read_hits{role=\"master\"}[$__rate_interval]))` | Rate of read operations accessing an existing key (ops/sec) |\n| bdb_read_hits_max | `sum by (db) (irate(redis_server_keyspace_read_hits{role=\"master\"}[$__rate_interval]))` | Highest value of the rate of read operations accessing an existing key (ops/sec) |\n| bdb_read_misses | `sum by (db) (irate(redis_server_keyspace_read_misses{role=\"master\"}[$__rate_interval]))` | Rate of read operations accessing a non-existing key (ops/sec) |\n| bdb_read_misses_max | `sum by (db) (irate(redis_server_keyspace_read_misses{role=\"master\"}[$__rate_interval]))` | Highest value of the rate of read operations accessing a non-existing key (ops/sec) |\n| bdb_read_req | `sum by (db) (irate(endpoint_read_requests{db=\"$db\"}[$__rate_interval]))` | Rate of read requests on the database (ops/sec) |\n| bdb_read_req_max | `max_over_time (sum by(db) (irate(endpoint_read_requests{db=\"$db\"}[$__rate_interval]))[$__range:])` | Highest value of the rate of read requests on the database (ops/sec) |\n| bdb_read_res | `sum by (db) (irate(endpoint_read_responses{\"$db\"}[$__rate_interval]))` | Rate of read responses on the database (ops/sec) |\n| bdb_read_res_max | `max_over_time (sum by(db) (irate(endpoint_read_responses{db=\"$db\"}[$__rate_interval]))[$__range:])` | Highest value of the rate of read responses on the database (ops/sec) |\n| bdb_shard_cpu_system | `sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"system\", role=\"master\"}[$__rate_interval]))` | Cores utilization in system mode for all Redis shard processes of this database |\n| bdb_shard_cpu_system_max | `sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"system\", role=\"master\"}[$__rate_interval]))` | Highest value of cores utilization in system mode for all Redis shard processes of this database |\n| bdb_shard_cpu_user | `sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"user\", role=\"master\"}[$__rate_interval]))` | Cores utilization in user mode for the Redis shard process |\n| bdb_shard_cpu_user_max | `sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode=\"user\", role=\"master\"}[$__rate_interval]))` | Highest value of cores utilization in user mode for the Redis shard process |\n| bdb_shards_used | `sum((sum(label_replace(label_replace(label_replace(namedprocess_namegroup_thread_count{groupname=~\"redis-\\d+\"}, \"redis\", \"$1\", \"groupname\", \"redis-(\\d+)\"), \"shard_type\", \"flash\", \"threadname\", \"(bigstore).*\"), \"shard_type\", \"ram\", \"shard_type\", \"\")) by (redis, shard_type) > bool 0) * on (redis) group_left(db) redis_server_up) by (db, shard_type)` | Used shard count by database and by shard type (ram / flash) |\n| bdb_total_connections_received | `sum by(db) (irate(endpoint_client_connections{db=\"$db\"}[$__rate_interval]))` | Rate of new client connections to database (connections/sec) |\n| bdb_total_connections_received_max | `max_over_time (sum by(db) (irate(endpoint_client_connections{db=\"$db\"}[$__rate_interval]))[$__range:])` | Highest value of the rate of new client connections to database (connections/sec) |\n| bdb_total_req | `sum by (db) (irate(endpoint_read_requests{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_write_requests{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_other_requests{db=\"\"$db\"\"}[$__rate_interval]))` | Rate of all requests on the database (ops/sec) |\n| bdb_total_req_max | `max_over_time(sum by (db) (irate(endpoint_read_requests{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_write_requests{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_other_requests{db=\"\"$db\"\"}[$__rate_interval])) [$__range:])` | Highest value of the rate of all requests on the database (ops/sec) |\n| bdb_total_res | `sum by (db) (irate(endpoint_read_responses{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_write_responses{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_other_responses{db=\"\"$db\"\"}[$__rate_interval]))` | Rate of all responses on the database (ops/sec) |\n| bdb_total_res_max | `max_over_time(sum by (db) (irate(endpoint_read_responses{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_write_responses{db=\"\"$db\"\"}[$__rate_interval]) + irate(endpoint_other_responses{db=\"\"$db\"\"}[$__rate_interval])) [$__range:])` | Highest value of the rate of all responses on the database (ops/sec) |\n| bdb_up | `min by(db) (redis_server_up)` | Database is up and running |\n| bdb_used_memory | `sum by (db) (redis_server_used_memory)` | Memory used by database (in BigRedis this includes flash) (bytes) |\n| bdb_write_hits | `sum by (db) (irate(redis_server_keyspace_write_hits{role=\"master\"}[$__rate_interval]))` | Rate of write operations accessing an existing key (ops/sec) |\n| bdb_write_hits_max | `sum by (db) (irate(redis_server_keyspace_write_hits{role=\"master\"}[$__rate_interval]))` | Highest value of the rate of write operations accessing an existing key (ops/sec) |\n| bdb_write_misses | `sum by (db) (irate(redis_server_keyspace_write_misses{role=\"master\"}[$__rate_interval]))` | Rate of write operations accessing a non-existing key (ops/sec) |\n| bdb_write_misses_max | `sum by (db) (irate(redis_server_keyspace_write_misses{role=\"master\"}[$__rate_interval]))` | Highest value of the rate of write operations accessing a non-existing key (ops/sec) |\n| bdb_write_req | `sum by (db) (irate(endpoint_write_requests{db=\"$db\"}[$__rate_interval]))` | Rate of write requests on the database (ops/sec) |\n| bdb_write_req_max | `max_over_time(sum by (db) (irate(endpoint_write_requests{db=\"$db\"}[$__rate_interval]))[$__range:])` | Highest value of the rate of write requests on the database (ops/sec) |\n| bdb_write_res | `sum by(db) (irate(endpoint_write_responses{db=\"$db\"}[$__rate_interval]))` | Rate of write responses on the database (ops/sec) |\n| bdb_write_res_max | `max_over_time(sum by (db) (irate(endpoint_write_responses{db=\"$db\"}[$__rate_interval]))[$__range:])` | Highest value of the rate of write responses on the database (ops/sec) |\n| bdb_no_of_expires | `sum by(db) (redis_server_db_expires{role=\"master\"})` | Current number of volatile keys in the database |"
},
{
"id": "node-metrics",
"title": "Node metrics",
"role": "content",
"text": "| V1 metric | Equivalent V2 PromQL | Description |\n| --------- | :------------------- | :---------- |\n| node_available_flash | `node_available_flash_bytes` | Available flash in the node (bytes) |\n| node_available_flash_no_overbooking | `node_available_flash_no_overbooking_bytes` | Available flash in the node (bytes), without taking into account overbooking |\n| node_available_memory | `node_available_memory_bytes` | Amount of free memory in the node (bytes) that is available for database provisioning |\n| node_available_memory_no_overbooking | `node_available_memory_no_overbooking_bytes` | Available RAM in the node (bytes) without taking into account overbooking |\n| node_avg_latency | `sum by (proxy) (irate(endpoint_acc_latency[$__rate_interval])) / sum by (proxy) (irate(endpoint_total_started_res[$__rate_interval]))` | Average latency of requests handled by endpoints on the node in microseconds; returned only when there is traffic |\n| node_bigstore_free | `node_bigstore_free_bytes` | Sum of free space of back-end flash (used by flash database's [BigRedis]) on all cluster nodes (bytes); returned only when BigRedis is enabled |\n| node_bigstore_iops | `node_flash_reads_total + node_flash_writes_total` | Rate of I/O operations against back-end flash for all shards which are part of a flash-based database (BigRedis) in the cluster (ops/sec); returned only when BigRedis is enabled |\n| node_bigstore_kv_ops | `sum by (node) (irate(redis_server_big_io_dels[$__rate_interval]) + irate(redis_server_big_io_reads[$__rate_interval]) + irate(redis_server_big_io_writes[$__rate_interval]))` | Rate of value read/write operations against back-end flash for all shards which are part of a flash-based database (BigRedis) in the cluster (ops/sec); returned only when BigRedis is enabled |\n| node_bigstore_throughput | `sum by (node) (irate(redis_server_big_io_read_bytes[$__rate_interval]) + irate(redis_server_big_io_write_bytes[$__rate_interval]))` | Throughput I/O operations against back-end flash for all shards which are part of a flash-based database (BigRedis) in the cluster (bytes/sec); returned only when BigRedis is enabled |\n| node_cert_expiration_seconds | `node_cert_expires_in_seconds` | Certificate expiration (in seconds) per given node; read more about [certificates in Redis Software](https://redis.io/docs/latest/operate/rs/security/certificates) and [monitoring certificates](https://redis.io/docs/latest/operate/rs/security/certificates/monitor-certificates) |\n| node_conns | `sum by (node) (endpoint_client_connections)` | Number of clients connected to endpoints on node |\n| node_cpu_idle | `avg by (node) (irate(node_cpu_seconds_total{mode=\"idle\"}[$__rate_interval]))` | CPU idle time portion (0-1, multiply by 100 to get percent) |\n| node_cpu_idle_max | N/A | Highest value of CPU idle time portion (0-1, multiply by 100 to get percent) |\n| node_cpu_idle_median | N/A | Median value of CPU idle time portion (0-1, multiply by 100 to get percent) |\n| node_cpu_idle_min | N/A | Lowest value of CPU idle time portion (0-1, multiply by 100 to get percent) |\n| node_cpu_system | `avg by (node) (irate(node_cpu_seconds_total{mode=\"system\"}[$__rate_interval]))` | CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |\n| node_cpu_system_max | N/A | Highest value of CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |\n| node_cpu_system_median | N/A | Median value of CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |\n| node_cpu_system_min | N/A | Lowest value of CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |\n| node_cpu_user | `avg by (node) (irate(node_cpu_seconds_total{mode=\"user\"}[$__rate_interval]))` | CPU time portion spent by user-space processes (0-1, multiply by 100 to get percent) |\n| node_cpu_user_max | N/A | Highest value of CPU time portion spent by user-space processes (0-1, multiply by 100 to get percent) |\n| node_cpu_user_median | N/A | Median value of CPU time portion spent by user-space processes (0-1, multiply by 100 to get percent) |\n| node_cpu_user_min | N/A | Lowest value of CPU time portion spent by user-space processes (0-1, multiply by 100 to get percent) |\n| node_cur_aof_rewrites | `sum by (cluster, node) (redis_server_aof_rewrite_in_progress)` | Number of AOF rewrites that are currently performed by shards on this node |\n| node_egress_bytes | `irate(node_network_transmit_bytes_total{device=\"\"}[$__rate_interval])` | Rate of outgoing network traffic to node (bytes/sec) |\n| node_egress_bytes_max | N/A | Highest value of the rate of outgoing network traffic to node (bytes/sec) |\n| node_egress_bytes_median | N/A | Median value of the rate of outgoing network traffic to node (bytes/sec) |\n| node_egress_bytes_min | N/A | Lowest value of the rate of outgoing network traffic to node (bytes/sec) |\n| node_ephemeral_storage_avail | `node_ephemeral_storage_avail_bytes` | Disk space available to RLEC processes on configured ephemeral disk (bytes) |\n| node_ephemeral_storage_free | `node_ephemeral_storage_free_bytes` | Free disk space on configured ephemeral disk (bytes) |\n| node_free_memory | `node_memory_MemFree_bytes` | Free memory in the node (bytes) |\n| node_ingress_bytes | `irate(node_network_receive_bytes_total{device=\"\"}[$__rate_interval])` | Rate of incoming network traffic to node (bytes/sec) |\n| node_ingress_bytes_max | N/A | Highest value of the rate of incoming network traffic to node (bytes/sec) |\n| node_ingress_bytes_median | N/A | Median value of the rate of incoming network traffic to node (bytes/sec) |\n| node_ingress_bytes_min | N/A | Lowest value of the rate of incoming network traffic to node (bytes/sec) |\n| node_persistent_storage_avail | `node_persistent_storage_avail_bytes` | Disk space available to RLEC processes on configured persistent disk (bytes) |\n| node_persistent_storage_free | `node_persistent_storage_free_bytes` | Free disk space on configured persistent disk (bytes) |\n| node_provisional_flash | `node_provisional_flash_bytes` | Amount of flash available for new shards on this node, taking into account overbooking, max Redis servers, reserved flash, and provision and migration thresholds (bytes) |\n| node_provisional_flash_no_overbooking | `node_provisional_flash_no_overbooking_bytes` | Amount of flash available for new shards on this node, without taking into account overbooking, max Redis servers, reserved flash, and provision and migration thresholds (bytes) |\n| node_provisional_memory | `node_provisional_memory_bytes` | Amount of RAM that is available for provisioning to databases out of the total RAM allocated for databases |\n| node_provisional_memory_no_overbooking | `node_provisional_memory_no_overbooking_bytes` | Amount of RAM that is available for provisioning to databases out of the total RAM allocated for databases, without taking into account overbooking |\n| node_total_req | `sum by (cluster, node) (irate(endpoint_read_requests[$__rate_interval]) + irate(endpoint_write_requests[$__rate_interval]) + irate(endpoint_other_requests[$__rate_interval]) )` | Request rate handled by endpoints on node (ops/sec) |\n| node_up | `node_metrics_up` | Node is part of the cluster and is connected |"
},
{
"id": "cluster-metrics",
"title": "Cluster metrics",
"role": "content",
"text": "| V1 metric | Equivalent V2 PromQL | Description |\n| --------- | :------------------- | :---------- |\n| cluster_shards_limit | `license_shards_limit` | Total shard limit by the license by shard type (ram / flash) |"
},
{
"id": "proxy-metrics",
"title": "Proxy metrics",
"role": "content",
"text": "| V1 metric | Equivalent V2 PromQL | Description |\n| --------- | :------------------- | :---------- |\n| listener_acc_latency | N/A | Accumulative latency (sum of the latencies) of all types of commands on the database. For the average latency, divide this value by listener_total_res |\n| listener_acc_latency_max | N/A | Highest value of accumulative latency of all types of commands on the database |\n| listener_acc_other_latency | N/A | Accumulative latency (sum of the latencies) of commands that are a type \"other\" on the database. For the average latency, divide this value by listener_other_res |\n| listener_acc_other_latency_max | N/A | Highest value of accumulative latency of commands that are a type \"other\" on the database |\n| listener_acc_read_latency | N/A | Accumulative latency (sum of the latencies) of commands that are a type \"read\" on the database. For the average latency, divide this value by listener_read_res |\n| listener_acc_read_latency_max | N/A | Highest value of accumulative latency of commands that are a type \"read\" on the database |\n| listener_acc_write_latency | N/A | Accumulative latency (sum of the latencies) of commands that are a type \"write\" on the database. For the average latency, divide this value by listener_write_res |\n| listener_acc_write_latency_max | N/A | Highest value of accumulative latency of commands that are a type \"write\" on the database |\n| listener_auth_cmds | N/A | Number of memcached AUTH commands sent to the database |\n| listener_auth_cmds_max | N/A | Highest value of the number of memcached AUTH commands sent to the database |\n| listener_auth_errors | N/A | Number of error responses to memcached AUTH commands |\n| listener_auth_errors_max | N/A | Highest value of the number of error responses to memcached AUTH commands |\n| listener_cmd_flush | N/A | Number of memcached FLUSH_ALL commands sent to the database |\n| listener_cmd_flush_max | N/A | Highest value of the number of memcached FLUSH_ALL commands sent to the database |\n| listener_cmd_get | N/A | Number of memcached GET commands sent to the database |\n| listener_cmd_get_max | N/A | Highest value of the number of memcached GET commands sent to the database |\n| listener_cmd_set | N/A | Number of memcached SET commands sent to the database |\n| listener_cmd_set_max | N/A | Highest value of the number of memcached SET commands sent to the database |\n| listener_cmd_touch | N/A | Number of memcached TOUCH commands sent to the database |\n| listener_cmd_touch_max | N/A | Highest value of the number of memcached TOUCH commands sent to the database |\n| listener_conns | N/A | Number of clients connected to the endpoint |\n| listener_egress_bytes | N/A | Rate of outgoing network traffic to the endpoint (bytes/sec) |\n| listener_egress_bytes_max | N/A | Highest value of the rate of outgoing network traffic to the endpoint (bytes/sec) |\n| listener_ingress_bytes | N/A | Rate of incoming network traffic to the endpoint (bytes/sec) |\n| listener_ingress_bytes_max | N/A | Highest value of the rate of incoming network traffic to the endpoint (bytes/sec) |\n| listener_last_req_time | N/A | Time of last command sent to the database |\n| listener_last_res_time | N/A | Time of last response sent from the database |\n| listener_max_connections_exceeded | `irate(endpoint_maximal_connections_exceeded[$__rate_interval])` | Number of times the number of clients connected to the database at the same time has exceeded the max limit |\n| listener_max_connections_exceeded_max | N/A | Highest value of the number of times the number of clients connected to the database at the same time has exceeded the max limit |\n| listener_monitor_sessions_count | N/A | Number of clients connected in monitor mode to the endpoint |\n| listener_other_req | N/A | Rate of other (non-read/write) requests on the endpoint (ops/sec) |\n| listener_other_req_max | N/A | Highest value of the rate of other (non-read/write) requests on the endpoint (ops/sec) |\n| listener_other_res | N/A | Rate of other (non-read/write) responses on the endpoint (ops/sec) |\n| listener_other_res_max | N/A | Highest value of the rate of other (non-read/write) responses on the endpoint (ops/sec) |\n| listener_other_started_res | N/A | Number of responses sent from the database of type \"other\" |\n| listener_other_started_res_max | N/A | Highest value of the number of responses sent from the database of type \"other\" |\n| listener_read_req | `irate(endpoint_read_requests[$__rate_interval])` | Rate of read requests on the endpoint (ops/sec) |\n| listener_read_req_max | N/A | Highest value of the rate of read requests on the endpoint (ops/sec) |\n| listener_read_res | `irate(endpoint_read_responses[$__rate_interval])` | Rate of read responses on the endpoint (ops/sec) |\n| listener_read_res_max | N/A | Highest value of the rate of read responses on the endpoint (ops/sec) |\n| listener_read_started_res | N/A | Number of responses sent from the database of type \"read\" |\n| listener_read_started_res_max | N/A | Highest value of the number of responses sent from the database of type \"read\" |\n| listener_total_connections_received | `irate(endpoint_total_connections_received[$__rate_interval])` | Rate of new client connections to the endpoint (connections/sec) |\n| listener_total_connections_received_max | N/A | Highest value of the rate of new client connections to the endpoint (connections/sec) |\n| listener_total_req | N/A | Request rate handled by the endpoint (ops/sec) |\n| listener_total_req_max | N/A | Highest value of the rate of all requests on the endpoint (ops/sec) |\n| listener_total_res | N/A | Rate of all responses on the endpoint (ops/sec) |\n| listener_total_res_max | N/A | Highest value of the rate of all responses on the endpoint (ops/sec) |\n| listener_total_started_res | N/A | Number of responses sent from the database of all types |\n| listener_total_started_res_max | N/A | Highest value of the number of responses sent from the database of all types |\n| listener_write_req | `irate(endpoint_write_requests[$__rate_interval])` | Rate of write requests on the endpoint (ops/sec) |\n| listener_write_req_max | N/A | Highest value of the rate of write requests on the endpoint (ops/sec) |\n| listener_write_res | `irate(endpoint_write_responses[$__rate_interval])` | Rate of write responses on the endpoint (ops/sec) |\n| listener_write_res_max | N/A | Highest value of the rate of write responses on the endpoint (ops/sec) |\n| listener_write_started_res | N/A | Number of responses sent from the database of type \"write\" |\n| listener_write_started_res_max | N/A | Highest value of the number of responses sent from the database of type \"write\" |"
},
{
"id": "replication-metrics",
"title": "Replication metrics",
"role": "content",
"text": "| V1 metric | Equivalent V2 PromQL | Description |\n| --------- | :------------------- | :---------- |\n| bdb_replicaof_syncer_ingress_bytes | `rate(replica_src_ingress_bytes[$__rate_interval])` | Rate of compressed incoming network traffic to a Replica Of database (bytes/sec) |\n| bdb_replicaof_syncer_ingress_bytes_decompressed | `rate(replica_src_ingress_bytes_decompressed[$__rate_interval])` | Rate of decompressed incoming network traffic to a Replica Of database (bytes/sec) |\n| bdb_replicaof_syncer_local_ingress_lag_time | `database_syncer_lag_ms{syncer_type=\"replicaof\"}` | Lag time between the source and the destination for Replica Of traffic (ms) |\n| bdb_replicaof_syncer_status | `database_syncer_current_status{syncer_type=\"replicaof\"}` | Syncer status for Replica Of traffic; 0 = in-sync, 1 = syncing, 2 = out of sync |\n| bdb_crdt_syncer_ingress_bytes | `rate(crdt_src_ingress_bytes[$__rate_interval])` | Rate of compressed incoming network traffic to CRDB (bytes/sec) |\n| bdb_crdt_syncer_ingress_bytes_decompressed | `rate(crdt_src_ingress_bytes_decompressed[$__rate_interval])` | Rate of decompressed incoming network traffic to CRDB (bytes/sec) |\n| bdb_crdt_syncer_local_ingress_lag_time | `database_syncer_lag_ms{syncer_type=\"crdt\"}` | Lag time between the source and the destination (ms) for CRDB traffic |\n| bdb_crdt_syncer_status | `database_syncer_current_status{syncer_type=\"crdt\"}` | Syncer status for CRDB traffic; 0 = in-sync, 1 = syncing, 2 = out of sync |"
},
{
"id": "shard-metrics",
"title": "Shard metrics",
"role": "content",
"text": "| V1 metric | Equivalent V2 PromQL | Description |\n| --------- | :------------------- | :---------- |\n| redis_active_defrag_running | `redis_server_active_defrag_running` | Automatic memory defragmentation current aggressiveness (% cpu) |\n| redis_allocator_active | `redis_server_allocator_active` | Total used memory, including external fragmentation |\n| redis_allocator_allocated | `redis_server_allocator_allocated` | Total allocated memory |\n| redis_allocator_resident | `redis_server_allocator_resident` | Total resident memory (RSS) |\n| redis_aof_last_cow_size | `redis_server_aof_last_cow_size` | Last AOFR, CopyOnWrite memory |\n| redis_aof_rewrite_in_progress | `redis_server_aof_rewrite_in_progress` | Indicates whether an AOF rewrite is in progress (1 = in progress, 0 = otherwise) |\n| redis_aof_rewrites | `redis_server_aof_rewrites` | Number of AOF rewrites this process executed |\n| redis_aof_delayed_fsync | `redis_server_aof_delayed_fsync` | Number of times an AOF fsync caused delays in the main Redis thread (inducing latency); this can indicate that the disk is slow or overloaded |\n| redis_blocked_clients | `redis_server_blocked_clients` | Count the clients waiting on a blocking call |\n| redis_connected_clients | `redis_server_connected_clients` | Number of client connections to the specific shard |\n| redis_connected_slaves | `redis_server_connected_slaves` | Number of connected replicas |\n| redis_db0_avg_ttl | `redis_server_db0_avg_ttl` | Average TTL of all volatile keys |\n| redis_db0_expires | `redis_server_expired_keys` | Total count of volatile keys |\n| redis_db0_keys | `redis_server_db0_keys` | Total key count |\n| redis_evicted_keys | `redis_server_evicted_keys` | Keys evicted so far (since restart) |\n| redis_expire_cycle_cpu_milliseconds | `redis_server_expire_cycle_cpu_milliseconds` | The cumulative amount of time spent on active expiry cycles |\n| redis_expired_keys | `redis_server_expired_keys` | Keys expired so far (since restart) |\n| redis_forwarding_state | `redis_server_forwarding_state` | Shard forwarding state (1 = on, 0 = off) |\n| redis_keys_trimmed | `redis_server_keys_trimmed` | The number of keys that were trimmed in the current or last resharding process |\n| redis_keyspace_read_hits | `redis_server_keyspace_read_hits` | Number of read operations accessing an existing keyspace |\n| redis_keyspace_read_misses | `redis_server_keyspace_read_misses` | Number of read operations accessing a non-existing keyspace |\n| redis_keyspace_write_hits | `redis_server_keyspace_write_hits` | Number of write operations accessing an existing keyspace |\n| redis_keyspace_write_misses | `redis_server_keyspace_write_misses` | Number of write operations accessing a non-existing keyspace |\n| redis_master_link_status | `redis_server_master_link_status` | Indicates if the replica is connected to its master (1 = up, 2 = down, 3 = none, 99 = unknown) |\n| redis_master_repl_offset | `redis_server_master_repl_offset` | Number of bytes sent to replicas by the shard; calculate the throughput for a time period by comparing the value at different times |\n| redis_master_sync_in_progress | `redis_server_master_sync_in_progress` | The master shard is synchronizing (1 true; 0 false) |\n| redis_max_process_mem | `redis_server_max_process_mem` | Current memory limit configured by redis_mgr according to node free memory |\n| redis_maxmemory | `redis_server_maxmemory` | Current memory limit configured by redis_mgr according to database memory limits.
To calculate the percent memory usage:
`sum by (cluster,db)(redis_server_used_memory{role=\"master\"}) / (avg by(cluster,db)(db_memory_limit_bytes) / max by(cluster,db)(db_replication_factor))` |\n| redis_mem_aof_buffer | `redis_server_mem_aof_buffer` | Current size of AOF buffer |\n| redis_mem_clients_normal | `redis_server_mem_clients_normal` | Current memory used for input and output buffers of non-replica clients |\n| redis_mem_clients_slaves | `redis_server_mem_clients_slaves` | Current memory used for input and output buffers of replica clients |\n| redis_mem_fragmentation_ratio | `redis_server_mem_fragmentation_ratio` | Memory fragmentation ratio (1.3 means 30% overhead) |\n| redis_mem_not_counted_for_evict | `redis_server_mem_not_counted_for_evict` | Portion of used_memory (in bytes) that's not counted for eviction and OOM error |\n| redis_mem_replication_backlog | `redis_server_mem_replication_backlog` | Size of replication backlog |\n| redis_module_fork_in_progress | `redis_server_module_fork_in_progress` | A binary value that indicates if there is an active fork spawned by a module (1) or not (0) |\n| redis_process_cpu_system_seconds_total | `namedprocess_namegroup_cpu_seconds_total{mode=\"system\"}` | Shard process system CPU time spent in seconds |\n| redis_process_cpu_usage_percent | `namedprocess_namegroup_cpu_seconds_total{mode=~\"system\\|user\"}` | Shard process CPU usage percentage |\n| redis_process_cpu_user_seconds_total | `namedprocess_namegroup_cpu_seconds_total{mode=\"user\"}` | Shard user CPU time spent in seconds |\n| redis_process_main_thread_cpu_system_seconds_total | `namedprocess_namegroup_thread_cpu_seconds_total{mode=\"system\",threadname=\"redis-server\"}` | Shard main thread system CPU time spent in seconds |\n| redis_process_main_thread_cpu_user_seconds_total | `namedprocess_namegroup_thread_cpu_seconds_total{mode=\"user\",threadname=\"redis-server\"}` | Shard main thread user CPU time spent in seconds |\n| redis_process_max_fds | `max(namedprocess_namegroup_open_filedesc)` | Shard maximum number of open file descriptors |\n| redis_process_open_fds | `namedprocess_namegroup_open_filedesc` | Shard number of open file descriptors |\n| redis_process_resident_memory_bytes | `namedprocess_namegroup_memory_bytes{memtype=\"resident\"}` | Shard resident memory size in bytes |\n| redis_process_start_time_seconds | `namedprocess_namegroup_oldest_start_time_seconds` | Shard start time of the process since unix epoch in seconds |\n| redis_process_virtual_memory_bytes | `namedprocess_namegroup_memory_bytes{memtype=\"virtual\"}` | Shard virtual memory in bytes |\n| redis_rdb_bgsave_in_progress | `redis_server_rdb_bgsave_in_progress` | Indicates whether bgsave is currently in progress (1 = in progress, 0 = otherwise) |\n| redis_rdb_last_cow_size | `redis_server_rdb_last_cow_size` | Last bgsave (or SYNC fork) used CopyOnWrite memory |\n| redis_rdb_saves | `redis_server_rdb_saves` | Total count of bgsaves since the process was restarted (including replica fullsync and persistence) |\n| redis_repl_touch_bytes | `redis_server_repl_touch_bytes` | Number of bytes sent to replicas as TOUCH commands by the shard as a result of a READ command that was processed; calculate the throughput for a time period by comparing the value at different times |\n| redis_total_commands_processed | `redis_server_total_commands_processed` | Number of commands processed by the shard; calculate the number of commands for a time period by comparing the value at different times |\n| redis_total_connections_received | `redis_server_total_connections_received` | Number of connections received by the shard; calculate the number of connections for a time period by comparing the value at different times |\n| redis_total_net_input_bytes | `redis_server_total_net_input_bytes` | Number of bytes received by the shard; calculate the throughput for a time period by comparing the value at different times |\n| redis_total_net_output_bytes | `redis_server_total_net_output_bytes` | Number of bytes sent by the shard; calculate the throughput for a time period by comparing the value at different times |\n| redis_up | `redis_server_up` | Shard is up and running |\n| redis_used_memory | `redis_server_used_memory` | Memory used by shard (in BigRedis this includes flash) (bytes) |"
}
],
"examples": [
{
"id": "overview-ex0",
"language": "yaml",
"code": "scrape_configs:\n # Scrape Redis Software\n - job_name: redis-enterprise\n scrape_interval: 30s\n scrape_timeout: 30s\n metrics_path: /v2\n scheme: https\n tls_config:\n insecure_skip_verify: true\n static_configs:\n - targets: [\":8070\"]",
"section_id": "overview"
}
]
}