---
title: Google Cloud Redis
description: >-
  A managed in-memory data store service on scalable, secure, and highly
  available infrastructure.
breadcrumbs: Docs > Integrations > Google Cloud Redis
---

> For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt).

# Google Cloud Redis

{% callout %}
# Important note for users on the following Datadog sites: us2.ddog-gov.com

{% alert level="info" %}
To find out if this integration is available in your organization, see your [Datadog Integrations](https://app.datadoghq.com/integrations) page or ask your organization administrator.

To initiate an exception request to enable this integration for your organization, email [support@ddog-gov.com](mailto:support@ddog-gov.com).
{% /alert %}

{% /callout %}

## Overview{% #overview %}

Google Cloud Memorystore for Redis provides a fully managed in-memory data store service built on scalable, secure, and highly available infrastructure.

Use the Datadog Google Cloud Platform integration to collect metrics from Google Cloud Memorystore for Redis.

## Setup{% #setup %}

### Installation{% #installation %}

If you haven't already, set up the [Google Cloud Platform integration](https://docs.datadoghq.com/integrations/google-cloud-platform.md) first. There are no other installation steps.

### Log collection{% #log-collection %}

Google Cloud Memorystore for Redis logs are collected with Google Cloud Logging and sent to a Dataflow job through a Cloud Pub/Sub topic. If you haven't already, [set up logging with the Datadog Dataflow template](https://docs.datadoghq.com/integrations/google-cloud-platform.md#log-collection).

Once this is done, export your Google Cloud Memorystore for Redis logs from Google Cloud Logging to the Pub/Sub topic:

1. Go to the [Google Cloud Logging page](https://console.cloud.google.com/logs/viewer) and filter the Google Cloud Memorystore for Redis logs.
1. Click **Create Export** and name the sink.
1. Choose "Cloud Pub/Sub" as the destination and select the Pub/Sub topic that was created for that purpose. **Note**: The Pub/Sub topic can be located in a different project.
1. Click **Create** and wait for the confirmation message to show up.

## Data Collected{% #data-collected %}

### Metrics{% #metrics %}

|  |
|  |
| **gcp.redis.clients.blocked**(gauge)                                                                   | Number of blocked clients.                                                                                                                                                                                                   |
| **gcp.redis.clients.connected**(gauge)                                                                 | Number of client connections.                                                                                                                                                                                                |
| **gcp.redis.cluster.clients.average_connected_clients**(gauge)                                       | Mean current number of client connections across the cluster.                                                                                                                                                                |
| **gcp.redis.cluster.clients.maximum_connected_clients**(gauge)                                       | Maximum current number of client connections across the cluster.                                                                                                                                                             |
| **gcp.redis.cluster.clients.total_connected_clients**(gauge)                                         | Current number of client connections to the cluster.                                                                                                                                                                         |
| **gcp.redis.cluster.commandstats.total_calls_count**(count)                                          | Count of Redis commands.                                                                                                                                                                                                     |
| **gcp.redis.cluster.commandstats.total_usec_count**(count)                                           | The total time consumed per command.*Shown as microsecond*                                                                                                                                                                   |
| **gcp.redis.cluster.cpu.average_utilization**(gauge)                                                  | Mean CPU utilization across the cluster from 0.0 to 1.0.*Shown as percent*                                                                                                                                                   |
| **gcp.redis.cluster.cpu.maximum_utilization**(gauge)                                                  | Maximum CPU utilization across the cluster from 0.0 to 1.0.*Shown as percent*                                                                                                                                                |
| **gcp.redis.cluster.cross_cluster_replication.secondary_average_replication_offset_diff**(gauge) | Average replication offset difference between primary shards and secondary shards.*Shown as byte*                                                                                                                            |
| **gcp.redis.cluster.cross_cluster_replication.secondary_maximum_replication_offset_diff**(gauge) | Maximum replication offset difference between primary shards and secondary shards.*Shown as byte*                                                                                                                            |
| **gcp.redis.cluster.cross_cluster_replication.secondary_replication_links**(gauge)                 | Number of replication links between a primary cluster and a secondary cluster.                                                                                                                                               |
| **gcp.redis.cluster.keyspace.total_keys**(gauge)                                                      | Number of keys stored in the cluster instance.                                                                                                                                                                               |
| **gcp.redis.cluster.memory.average_utilization**(gauge)                                               | Mean memory utilization across the cluster from 0.0 to 1.0.*Shown as percent*                                                                                                                                                |
| **gcp.redis.cluster.memory.maximum_utilization**(gauge)                                               | Maximum memory utilization across the cluster from 0.0 to 1.0.*Shown as percent*                                                                                                                                             |
| **gcp.redis.cluster.memory.size**(gauge)                                                               | Memory size of the cluster.*Shown as byte*                                                                                                                                                                                   |
| **gcp.redis.cluster.memory.total_used_memory**(gauge)                                                | Total memory usage of the cluster.*Shown as byte*                                                                                                                                                                            |
| **gcp.redis.cluster.node.clients.blocked_clients**(gauge)                                             | Number of client connections blocked by the cluster node.                                                                                                                                                                    |
| **gcp.redis.cluster.node.clients.connected_clients**(gauge)                                           | Number of clients connected to the cluster node.                                                                                                                                                                             |
| **gcp.redis.cluster.node.commandstats.calls_count**(count)                                            | Total number of calls for this command on the cluster node in one minute.                                                                                                                                                    |
| **gcp.redis.cluster.node.commandstats.usec_count**(count)                                             | The total time consumed per command in the cluster node.*Shown as microsecond*                                                                                                                                               |
| **gcp.redis.cluster.node.cpu.utilization**(gauge)                                                      | CPU utilization for the cluster node from 0.0 to 1.0.*Shown as percent*                                                                                                                                                      |
| **gcp.redis.cluster.node.cross_cluster_replication.follower_replication_offset_diff**(gauge)      | Replication offset diff in bytes between a replicator node and its follower node, reported by the replicator node.*Shown as byte*                                                                                            |
| **gcp.redis.cluster.node.cross_cluster_replication.role**(gauge)                                     | Cross cluster replication role of the node.                                                                                                                                                                                  |
| **gcp.redis.cluster.node.keyspace.total_keys**(gauge)                                                 | Number of keys stored in the cluster node.                                                                                                                                                                                   |
| **gcp.redis.cluster.node.memory.usage**(gauge)                                                         | Total memory usage of the cluster node.*Shown as byte*                                                                                                                                                                       |
| **gcp.redis.cluster.node.memory.utilization**(gauge)                                                   | Memory utilization within the cluster node from 0.0 to 1.0.*Shown as percent*                                                                                                                                                |
| **gcp.redis.cluster.node.persistence.aof_fsync_errors_count**(count)                                | Count of AOF fsync errors on the cluster node.                                                                                                                                                                               |
| **gcp.redis.cluster.node.persistence.aof_fsync_lag**(gauge)                                          | AOF lag between memory and persistent store on the cluster node.*Shown as second*                                                                                                                                            |
| **gcp.redis.cluster.node.persistence.aof_last_bgrewrite_status**(gauge)                             | Indicates the success of the last AOF bgrewrite operation on the cluster node.                                                                                                                                               |
| **gcp.redis.cluster.node.persistence.aof_last_write_status**(gauge)                                 | Indicates the success of the last AOF write operation on the cluster node.                                                                                                                                                   |
| **gcp.redis.cluster.node.persistence.aof_rewrites_count**(count)                                     | AOF rewrites count on the cluster node.                                                                                                                                                                                      |
| **gcp.redis.cluster.node.persistence.auto_restore_count**(count)                                     | Count of restores from dumpfile on the cluster node.                                                                                                                                                                         |
| **gcp.redis.cluster.node.persistence.current_save_keys_total**(gauge)                               | Number of keys at the beginning of the current save operation.                                                                                                                                                               |
| **gcp.redis.cluster.node.persistence.rdb_bgsave_in_progress**(gauge)                                | Indicates if a RDB BGSAVE is currently in progress on the cluster node.                                                                                                                                                      |
| **gcp.redis.cluster.node.persistence.rdb_last_bgsave_status**(gauge)                                | Indicates the success of the last BGSAVE on the cluster node.                                                                                                                                                                |
| **gcp.redis.cluster.node.persistence.rdb_last_save_age**(gauge)                                     | Measures the time in seconds, since the last successful snapshot.*Shown as second*                                                                                                                                           |
| **gcp.redis.cluster.node.persistence.rdb_next_save_time_until**(gauge)                             | Measures the time in seconds, remaining until the next snapshot.*Shown as second*                                                                                                                                            |
| **gcp.redis.cluster.node.persistence.rdb_saves_count**(count)                                        | Count of RDB saves in the cluster node.                                                                                                                                                                                      |
| **gcp.redis.cluster.node.replication.offset**(gauge)                                                   | Measures the replication offset bytes of the cluster node.*Shown as byte*                                                                                                                                                    |
| **gcp.redis.cluster.node.server.uptime**(gauge)                                                        | Measures the uptime of the cluster node.*Shown as second*                                                                                                                                                                    |
| **gcp.redis.cluster.node.stats.connections_received_count**(count)                                   | Count of total client connections created in the last one minute on the cluster node.                                                                                                                                        |
| **gcp.redis.cluster.node.stats.evicted_keys_count**(count)                                           | Count of evicted keys by the cluster node.                                                                                                                                                                                   |
| **gcp.redis.cluster.node.stats.expired_keys_count**(count)                                           | Count of key expiration events in the cluster node.                                                                                                                                                                          |
| **gcp.redis.cluster.node.stats.keyspace_hits_count**(count)                                          | Count of successful lookup of keys in the cluster node.                                                                                                                                                                      |
| **gcp.redis.cluster.node.stats.keyspace_misses_count**(count)                                        | Count of failed lookup of keys in the cluster node.                                                                                                                                                                          |
| **gcp.redis.cluster.node.stats.net_input_bytes_count**(count)                                       | Count of incoming network bytes received by the cluster node.*Shown as byte*                                                                                                                                                 |
| **gcp.redis.cluster.node.stats.net_output_bytes_count**(count)                                      | Count of outgoing network bytes sent from the cluster node.*Shown as byte*                                                                                                                                                   |
| **gcp.redis.cluster.node.stats.rejected_connections_count**(count)                                   | Number of connections rejected because of maxclients limit by the cluster node.                                                                                                                                              |
| **gcp.redis.cluster.persistence.aof_fsync_lags.avg**(gauge)                                          | Distribution of AOF lag between memory and persistent store across the cluster.*Shown as second*                                                                                                                             |
| **gcp.redis.cluster.persistence.aof_fsync_lags.samplecount**(gauge)                                  | Distribution of AOF lag between memory and persistent store across the cluster.                                                                                                                                              |
| **gcp.redis.cluster.persistence.aof_fsync_lags.sumsqdev**(gauge)                                     | Distribution of AOF lag between memory and persistent store across the cluster.                                                                                                                                              |
| **gcp.redis.cluster.persistence.aof_rewrite_count**(count)                                           | Count of AOF rewrites across the cluster.                                                                                                                                                                                    |
| **gcp.redis.cluster.persistence.rdb_last_success_ages.avg**(gauge)                                  | Age of RDB snapshots across cluster.*Shown as second*                                                                                                                                                                        |
| **gcp.redis.cluster.persistence.rdb_last_success_ages.samplecount**(gauge)                          | Age of RDB snapshots across cluster.                                                                                                                                                                                         |
| **gcp.redis.cluster.persistence.rdb_last_success_ages.sumsqdev**(gauge)                             | Age of RDB snapshots across cluster.                                                                                                                                                                                         |
| **gcp.redis.cluster.persistence.rdb_saves_count**(count)                                             | Count of RDB saves across the cluster.                                                                                                                                                                                       |
| **gcp.redis.cluster.replication.average_ack_lag**(gauge)                                             | Mean replication acknowledge lag (in seconds) of replica across the cluster.*Shown as second*                                                                                                                                |
| **gcp.redis.cluster.replication.average_offset_diff**(gauge)                                         | Mean replication offset diff (in bytes) across the cluster.*Shown as byte*                                                                                                                                                   |
| **gcp.redis.cluster.replication.maximum_ack_lag**(gauge)                                             | Maximum replication acknowledge lag (in seconds) of replica across the cluster.*Shown as second*                                                                                                                             |
| **gcp.redis.cluster.replication.maximum_offset_diff**(gauge)                                         | Maximum replication offset diff (in bytes) across the cluster.*Shown as byte*                                                                                                                                                |
| **gcp.redis.cluster.stats.average_evicted_keys**(gauge)                                              | Mean number of evicted keys due to memory capacity.                                                                                                                                                                          |
| **gcp.redis.cluster.stats.average_expired_keys**(gauge)                                              | Mean number of key expiration events.                                                                                                                                                                                        |
| **gcp.redis.cluster.stats.average_keyspace_hits**(gauge)                                             | Mean number of successful lookup of keys across the cluster.                                                                                                                                                                 |
| **gcp.redis.cluster.stats.average_keyspace_misses**(gauge)                                           | Mean number of failed lookup of keys across the cluster.                                                                                                                                                                     |
| **gcp.redis.cluster.stats.maximum_evicted_keys**(gauge)                                              | Maximum number of evicted keys due to memory capacity.                                                                                                                                                                       |
| **gcp.redis.cluster.stats.maximum_expired_keys**(gauge)                                              | Maximum number of key expiration events.                                                                                                                                                                                     |
| **gcp.redis.cluster.stats.maximum_keyspace_hits**(gauge)                                             | Maximum number of successful lookup of keys across the cluster.                                                                                                                                                              |
| **gcp.redis.cluster.stats.maximum_keyspace_misses**(gauge)                                           | Maximum number of failed lookup of keys across the cluster.                                                                                                                                                                  |
| **gcp.redis.cluster.stats.total_connections_received_count**(count)                                 | Count of client connections created in the last one minute.                                                                                                                                                                  |
| **gcp.redis.cluster.stats.total_evicted_keys_count**(count)                                         | Total number of evicted keys due to memory capacity.                                                                                                                                                                         |
| **gcp.redis.cluster.stats.total_expired_keys_count**(count)                                         | Total number of key expiration events.                                                                                                                                                                                       |
| **gcp.redis.cluster.stats.total_keyspace_hits_count**(count)                                        | Total number of successful lookup of keys across the cluster.                                                                                                                                                                |
| **gcp.redis.cluster.stats.total_keyspace_misses_count**(count)                                      | Total number of failed lookup of keys across the cluster.                                                                                                                                                                    |
| **gcp.redis.cluster.stats.total_net_input_bytes_count**(count)                                     | Count of incoming network bytes received by the cluster.*Shown as byte*                                                                                                                                                      |
| **gcp.redis.cluster.stats.total_net_output_bytes_count**(count)                                    | Count of outgoing network bytes sent from the cluster.*Shown as byte*                                                                                                                                                        |
| **gcp.redis.cluster.stats.total_rejected_connections_count**(count)                                 | Count of client connections rejected because of maxclients limit.                                                                                                                                                            |
| **gcp.redis.commands.calls**(count)                                                                    | Total number of calls for this command in one minute.                                                                                                                                                                        |
| **gcp.redis.commands.total_time**(gauge)                                                              | The amount of time in microseconds that this command took in the last second.*Shown as microsecond*                                                                                                                          |
| **gcp.redis.commands.usec_per_call**(gauge)                                                          | Average time per call over 1 minute by command.                                                                                                                                                                              |
| **gcp.redis.keyspace.avg_ttl**(gauge)                                                                 | Average TTL for keys in this database.*Shown as millisecond*                                                                                                                                                                 |
| **gcp.redis.keyspace.keys**(gauge)                                                                     | Number of keys stored in this database.                                                                                                                                                                                      |
| **gcp.redis.keyspace.keys_with_expiration**(gauge)                                                   | Number of keys with an expiration in this database.                                                                                                                                                                          |
| **gcp.redis.persistence.rdb.bgsave_in_progress**(gauge)                                              | Flag indicating a RDB save is on-going.                                                                                                                                                                                      |
| **gcp.redis.rdb.enabled**(gauge)                                                                       | Indicates if the snapshot is in RDB mode.                                                                                                                                                                                    |
| **gcp.redis.rdb.recovery.attempts_since_last_success**(gauge)                                       | Indicates number of recovery attempts since the last successful recovery attempt.                                                                                                                                            |
| **gcp.redis.rdb.recovery.elapsed_time**(gauge)                                                        | Indicates increasing time elapsed for an in-progress recovery from an RDB snapshot. 0 means the recovery is idle or completed.*Shown as second*                                                                              |
| **gcp.redis.rdb.recovery.estimated_recovery_time**(gauge)                                            | Indicates the expected recovery time when using the last successful snapshot for recovery.*Shown as second*                                                                                                                  |
| **gcp.redis.rdb.recovery.estimated_remaining_time**(gauge)                                           | Indicates remaining time to finish recovery from an RDB snapshot. 0 means the recovery is idle or completed.*Shown as second*                                                                                                |
| **gcp.redis.rdb.recovery.in_progress**(gauge)                                                         | Indicates if recovery from an RDB snapshot is in progress. When the metric value is true, then a recovery is in progress.                                                                                                    |
| **gcp.redis.rdb.recovery.last_duration**(gauge)                                                       | Indicates time it took to restore the last snapshot.*Shown as second*                                                                                                                                                        |
| **gcp.redis.rdb.recovery.last_status**(gauge)                                                         | Indicates status of the most recent recovery.                                                                                                                                                                                |
| **gcp.redis.rdb.recovery.loaded_bytes_count**(count)                                                 | During a recovery, indicates how many bytes have loaded. 0 if the recovery is not active.*Shown as byte*                                                                                                                     |
| **gcp.redis.rdb.recovery.total_bytes_count**(count)                                                  | Indicates the size in bytes of the snapshot.*Shown as byte*                                                                                                                                                                  |
| **gcp.redis.rdb.snapshot.attempt_count**(count)                                                       | Indicates number of snapshot attempts every minute.                                                                                                                                                                          |
| **gcp.redis.rdb.snapshot.elapsed_time**(gauge)                                                        | Indicates increasing time elapsed while creating the current snapshot.*Shown as second*                                                                                                                                      |
| **gcp.redis.rdb.snapshot.in_progress**(gauge)                                                         | Indicates if RDB snapshot is in progress. When the metric value is true, then an RDB snapshot is in progress.                                                                                                                |
| **gcp.redis.rdb.snapshot.last_status**(gauge)                                                         | Indicates status of the most recent snapshot attempt.                                                                                                                                                                        |
| **gcp.redis.rdb.snapshot.last_success_age**(gauge)                                                   | Indicates time elapsed since the start of the last successful snapshot.*Shown as second*                                                                                                                                     |
| **gcp.redis.rdb.snapshot.last_success_duration**(gauge)                                              | Indicates the total time required to write the last successful snapshot, not including failed attempts.*Shown as second*                                                                                                     |
| **gcp.redis.rdb.snapshot.time_until_next_run**(gauge)                                               | Seconds until the next scheduled snapshot.*Shown as second*                                                                                                                                                                  |
| **gcp.redis.replication.master.slaves.lag**(gauge)                                                     | The number of seconds that replica is lagging behind primary.*Shown as second*                                                                                                                                               |
| **gcp.redis.replication.master.slaves.offset**(gauge)                                                  | The number of bytes that have been acknowledged by replicas.*Shown as byte*                                                                                                                                                  |
| **gcp.redis.replication.master_repl_offset**(gauge)                                                  | The number of bytes that master has produced and sent to replicas. To be compared with replication byte offset of replica.*Shown as byte*                                                                                    |
| **gcp.redis.replication.offset_diff**(gauge)                                                          | The largest number of bytes that have not been replicated across all replicas. This is the biggest difference between replication byte offset (master) and replication byte offset (replica) of all replicas.*Shown as byte* |
| **gcp.redis.replication.role**(gauge)                                                                  | Returns a value indicating the node role. 1 indicates primary and 0 indicates replica.                                                                                                                                       |
| **gcp.redis.search.attributes**(gauge)                                                                 | Indicates the number of attributes in vector search.                                                                                                                                                                         |
| **gcp.redis.search.background_indexing_in_progress**(gauge)                                         | Indicates if the background indexing is in progress. When the metric value is true, then the background indexing is in progress.                                                                                             |
| **gcp.redis.search.indexed_hash_keys**(gauge)                                                        | Indicates the number of indexed hash keys in vector search.                                                                                                                                                                  |
| **gcp.redis.search.indexes**(gauge)                                                                    | Indicates the number of indexes in vector search.                                                                                                                                                                            |
| **gcp.redis.search.query_requests_count**(count)                                                     | Indicates the number of query requests count.                                                                                                                                                                                |
| **gcp.redis.search.used_memory_bytes**(gauge)                                                        | Indicates the used memory in bytes in vector search.*Shown as byte*                                                                                                                                                          |
| **gcp.redis.server.uptime**(gauge)                                                                     | Uptime in seconds.*Shown as second*                                                                                                                                                                                          |
| **gcp.redis.stats.cache_hit_ratio**(gauge)                                                           | Cache Hit ratio as a fraction.                                                                                                                                                                                               |
| **gcp.redis.stats.connections.total**(gauge)                                                           | Total number of connections accepted by the server.*Shown as connection*                                                                                                                                                     |
| **gcp.redis.stats.cpu_utilization**(gauge)                                                            | CPU, in seconds of utilization, consumed by the Redis server broken down by System/User and Parent/Child relationship.*Shown as second*                                                                                      |
| **gcp.redis.stats.cpu_utilization_main_thread**(count)                                              | CPU-seconds consumed by the Redis server main thread, broken down by system/user space and parent/child relationship.*Shown as second*                                                                                       |
| **gcp.redis.stats.evicted_keys**(count)                                                               | Number of evicted keys due to maxmemory limit.                                                                                                                                                                               |
| **gcp.redis.stats.expired_keys**(count)                                                               | Total number of key expiration events.                                                                                                                                                                                       |
| **gcp.redis.stats.keyspace_hits**(count)                                                              | Number of successful lookup of keys in the main dictionary.                                                                                                                                                                  |
| **gcp.redis.stats.keyspace_misses**(count)                                                            | Number of failed lookup of keys in the main dictionary.                                                                                                                                                                      |
| **gcp.redis.stats.memory.maxmemory**(gauge)                                                            | Maximum amount of memory Redis can consume.*Shown as byte*                                                                                                                                                                   |
| **gcp.redis.stats.memory.system_memory_overload_duration**(count)                                   | The amount of time in microseconds the instance is in system memory overload mode.*Shown as microsecond*                                                                                                                     |
| **gcp.redis.stats.memory.system_memory_usage_ratio**(gauge)                                         | Memory usage as a ratio of maximum system memory.                                                                                                                                                                            |
| **gcp.redis.stats.memory.usage**(gauge)                                                                | Total number of bytes allocated by Redis.*Shown as byte*                                                                                                                                                                     |
| **gcp.redis.stats.memory.usage_ratio**(gauge)                                                         | Memory usage as a ratio of maximum memory.                                                                                                                                                                                   |
| **gcp.redis.stats.network_traffic**(count)                                                            | Total number of bytes sent to/from redis (includes bytes from commands themselves, payload data, and delimiters).*Shown as byte*                                                                                             |
| **gcp.redis.stats.pubsub.channels**(gauge)                                                             | Global number of pub/sub channels with client subscriptions.                                                                                                                                                                 |
| **gcp.redis.stats.pubsub.patterns**(gauge)                                                             | Global number of pub/sub pattern with client subscriptions.                                                                                                                                                                  |
| **gcp.redis.stats.reject_connections_count**(count)                                                  | Number of connections rejected because of maxclients limit.                                                                                                                                                                  |

### Events{% #events %}

The Google Cloud Memorystore for Redis integration does not include any events.

### Service Checks{% #service-checks %}

The Google Cloud Memorystore for Redis integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).