---
title: Google Cloud Memorystore for Valkey
description: >-
  Monitor performance, memory usage, replication, and persistence for Google
  Cloud Memorystore for Valkey.
breadcrumbs: Docs > Integrations > Google Cloud Memorystore for Valkey
---

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

# Google Cloud Memorystore for Valkey
Integration version1.0.0
{% 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 Valkey is a fully managed service for Valkey, an open source, in-memory data store that can be used for caching, gaming leaderboards, real-time analytics, and other low-latency use cases.

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

## 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.

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

### Metrics{% #metrics %}

|  |
|  |
| **gcp.memorystore.instance.backup.last_backup_duration**(gauge)                                              | The duration of the last backup operation as milliseconds.*Shown as millisecond*                                                                                               |
| **gcp.memorystore.instance.backup.last_backup_size**(gauge)                                                  | The size of the last backup in bytes.*Shown as byte*                                                                                                                           |
| **gcp.memorystore.instance.backup.last_backup_start_time**(gauge)                                           | The start time of the last backup operation.*Shown as second*                                                                                                                  |
| **gcp.memorystore.instance.backup.last_backup_status**(gauge)                                                | The status of the last backup operation as 1/0 (success/failure).                                                                                                              |
| **gcp.memorystore.instance.clients.average_connected_clients**(gauge)                                        | Mean current number of client connections across the instance.                                                                                                                 |
| **gcp.memorystore.instance.clients.maximum_connected_clients**(gauge)                                        | Maximum current number of client connections across the instance.                                                                                                              |
| **gcp.memorystore.instance.clients.total_connected_clients**(gauge)                                          | Current number of client connections to the instance.                                                                                                                          |
| **gcp.memorystore.instance.commandstats.total_calls_count**(count)                                           | Count of Engine commands.                                                                                                                                                      |
| **gcp.memorystore.instance.commandstats.total_usec_count**(count)                                            | The total time consumed per command.*Shown as microsecond*                                                                                                                     |
| **gcp.memorystore.instance.cpu.average_utilization**(gauge)                                                   | Mean CPU utilization across the instance from 0.0 to 1.0.*Shown as percent*                                                                                                    |
| **gcp.memorystore.instance.cpu.maximum_utilization**(gauge)                                                   | Maximum CPU utilization across the instance from 0.0 to 1.0.*Shown as percent*                                                                                                 |
| **gcp.memorystore.instance.cross_instance_replication.secondary_average_replication_offset_diff**(gauge) | Average replication offset difference between primary shards and secondary shards.*Shown as byte*                                                                              |
| **gcp.memorystore.instance.cross_instance_replication.secondary_maximum_replication_offset_diff**(gauge) | Maximum replication offset difference between primary shards and secondary shards.*Shown as byte*                                                                              |
| **gcp.memorystore.instance.cross_instance_replication.secondary_replication_links**(gauge)                 | Number of replication links between a primary instance and a secondary instance.                                                                                               |
| **gcp.memorystore.instance.import.last_import_duration**(gauge)                                              | The duration of the last import operation as milliseconds.*Shown as millisecond*                                                                                               |
| **gcp.memorystore.instance.import.last_import_start_time**(gauge)                                           | The start time of the last import operation.*Shown as second*                                                                                                                  |
| **gcp.memorystore.instance.keyspace.total_keys**(gauge)                                                       | Number of keys stored in the instance.                                                                                                                                         |
| **gcp.memorystore.instance.memory.average_utilization**(gauge)                                                | Mean memory utilization across the instance from 0.0 to 1.0.*Shown as percent*                                                                                                 |
| **gcp.memorystore.instance.memory.maximum_utilization**(gauge)                                                | Maximum memory utilization across the instance from 0.0 to 1.0.*Shown as percent*                                                                                              |
| **gcp.memorystore.instance.memory.size**(gauge)                                                                | Memory size of the instance.*Shown as byte*                                                                                                                                    |
| **gcp.memorystore.instance.memory.total_used_memory**(gauge)                                                 | Total memory usage of the instance.*Shown as byte*                                                                                                                             |
| **gcp.memorystore.instance.migration_status**(gauge)                                                          | Represents the migration status of the instance. It is HEALTHY if expected number of primary nodes are migrating and healthy.                                                  |
| **gcp.memorystore.instance.node.bloomfilter.objects_count**(gauge)                                            | Number of bloom filter object in the instance node.                                                                                                                            |
| **gcp.memorystore.instance.node.bloomfilter.used_memory**(gauge)                                              | Memory consumed by the bloom filter objects in the instance node.*Shown as byte*                                                                                               |
| **gcp.memorystore.instance.node.clients.blocked_clients**(gauge)                                              | Number of client connections blocked by the instance node.                                                                                                                     |
| **gcp.memorystore.instance.node.clients.connected_clients**(gauge)                                            | Number of clients connected to the instance node.                                                                                                                              |
| **gcp.memorystore.instance.node.clients.maxclients**(gauge)                                                    | Max clients configuration from valkey conf.                                                                                                                                    |
| **gcp.memorystore.instance.node.clients.pubsub_clients**(gauge)                                               | Number of clients in pubsub mode.                                                                                                                                              |
| **gcp.memorystore.instance.node.clients.recent_max_input_buffer**(gauge)                                    | Max input buffer in bytes among current client connections.*Shown as byte*                                                                                                     |
| **gcp.memorystore.instance.node.clients.recent_max_output_buffer**(gauge)                                   | Max output buffer in bytes among current client connections.*Shown as byte*                                                                                                    |
| **gcp.memorystore.instance.node.clients.tracking_clients**(gauge)                                             | Number of clients that are being tracked by the server.                                                                                                                        |
| **gcp.memorystore.instance.node.clients.watching_clients**(gauge)                                             | Number of clients in watching mode.                                                                                                                                            |
| **gcp.memorystore.instance.node.commandstats.calls_count**(count)                                             | Total number of calls for this command on the instance node in one minute.                                                                                                     |
| **gcp.memorystore.instance.node.commandstats.failed_calls_count**(count)                                     | Total number of failed calls for this command.                                                                                                                                 |
| **gcp.memorystore.instance.node.commandstats.rejected_calls_count**(count)                                   | Total number of rejected calls for this command.                                                                                                                               |
| **gcp.memorystore.instance.node.commandstats.usec_count**(count)                                              | The total time consumed per command in the instance node.*Shown as microsecond*                                                                                                |
| **gcp.memorystore.instance.node.cpu.utilization**(gauge)                                                       | CPU utilization for the instance node from 0.0 to 1.0.*Shown as percent*                                                                                                       |
| **gcp.memorystore.instance.node.cross_instance_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.memorystore.instance.node.cross_instance_replication.role**(gauge)                                     | Cross instance replication role of the node.                                                                                                                                   |
| **gcp.memorystore.instance.node.errorstats.errors_count**(count)                                              | Different error counters for errors that occur within the engine. The engine field name is errorstat_XXX, where XXX can be MOVED, ERR, or OOM.                                 |
| **gcp.memorystore.instance.node.json.documents_count**(gauge)                                                 | Number of JSON documents in the instance node.                                                                                                                                 |
| **gcp.memorystore.instance.node.json.used_memory**(gauge)                                                     | Memory consumed by the JSON documents in the instance node.*Shown as byte*                                                                                                     |
| **gcp.memorystore.instance.node.keyspace.keys_with_expiration**(gauge)                                       | Number of keys with an expiration.                                                                                                                                             |
| **gcp.memorystore.instance.node.keyspace.total_keys**(gauge)                                                  | Number of keys stored in the instance node.                                                                                                                                    |
| **gcp.memorystore.instance.node.memory.dataset_usage**(gauge)                                                 | Actual dataset memory usage. The engine field name is used_memory_dataset.*Shown as byte*                                                                                      |
| **gcp.memorystore.instance.node.memory.lua_usage**(gauge)                                                     | Number of bytes used by the Lua engine.*Shown as byte*                                                                                                                         |
| **gcp.memorystore.instance.node.memory.maxmemory**(gauge)                                                      | Maximum amount of memory valkey can consume, 0 means ram capping is disabled.*Shown as byte*                                                                                   |
| **gcp.memorystore.instance.node.memory.maxmemory_policy**(gauge)                                              | The maxmemory policy configuration on the node level.                                                                                                                          |
| **gcp.memorystore.instance.node.memory.mem_not_counted_for_evict**(gauge)                                  | Used memory that's not counted for key eviction. This is basically a transient replica and AOF buffers.*Shown as byte*                                                         |
| **gcp.memorystore.instance.node.memory.normal_clients_usage**(gauge)                                         | Total number of bytes used by normal clients.*Shown as byte*                                                                                                                   |
| **gcp.memorystore.instance.node.memory.number_of_cached_scripts**(gauge)                                    | The number of EVAL scripts cached by the server.                                                                                                                               |
| **gcp.memorystore.instance.node.memory.number_of_functions**(gauge)                                          | The number of functions.                                                                                                                                                       |
| **gcp.memorystore.instance.node.memory.peak_usage**(gauge)                                                    | Peak memory consumed by Valkey ever (in bytes).*Shown as byte*                                                                                                                 |
| **gcp.memorystore.instance.node.memory.replica_clients_usage**(gauge)                                        | Total number of bytes used by replica clients.*Shown as byte*                                                                                                                  |
| **gcp.memorystore.instance.node.memory.rss_usage**(gauge)                                                     | Number of bytes that Valkey allocated as seen by the operating system (a.k.a resident set size). This is the number reported by tools such as top(1) and ps(1).*Shown as byte* |
| **gcp.memorystore.instance.node.memory.scripts_usage**(gauge)                                                 | Number of bytes overhead by the EVAL scripts and Function scripts (part of used memory). The engine field name is used_memory_scripts.*Shown as byte*                          |
| **gcp.memorystore.instance.node.memory.usage**(gauge)                                                          | Total memory usage of the instance node.*Shown as byte*                                                                                                                        |
| **gcp.memorystore.instance.node.memory.utilization**(gauge)                                                    | Memory utilization within the instance node from 0.0 to 1.0.*Shown as percent*                                                                                                 |
| **gcp.memorystore.instance.node.migration_link_reconnect_count**(count)                                     | Number of migration link reconnections.                                                                                                                                        |
| **gcp.memorystore.instance.node.migration_received_bytes_size**(count)                                      | Number of migration bytes received.*Shown as byte*                                                                                                                             |
| **gcp.memorystore.instance.node.migration_status**(gauge)                                                     | Represents the migration status of the node. For example, if a primary node is in migrating state and replication link is up, it is HEALTHY.                                   |
| **gcp.memorystore.instance.node.persistence.aof_enabled**(gauge)                                              | Flag indicating if AOF is enabled.                                                                                                                                             |
| **gcp.memorystore.instance.node.persistence.aof_fsync_errors_count**(count)                                 | Count of AOF fsync errors on the instance node.                                                                                                                                |
| **gcp.memorystore.instance.node.persistence.aof_fsync_lag**(gauge)                                           | AOF lag between memory and persistent store on the instance node.*Shown as second*                                                                                             |
| **gcp.memorystore.instance.node.persistence.aof_last_bgrewrite_status**(gauge)                              | Indicates the success of the last AOF bgrewrite operation on the instance node.                                                                                                |
| **gcp.memorystore.instance.node.persistence.aof_last_cow_size**(gauge)                                      | The size in bytes of the copy-on-write memory during the last AOF rewrite operation.*Shown as byte*                                                                            |
| **gcp.memorystore.instance.node.persistence.aof_last_rewrite_time_sec**(gauge)                             | Duration of the last AOF rewrite operation in seconds.*Shown as second*                                                                                                        |
| **gcp.memorystore.instance.node.persistence.aof_last_write_status**(gauge)                                  | Indicates the success of the last AOF write operation on the instance node.                                                                                                    |
| **gcp.memorystore.instance.node.persistence.aof_rewrite_in_progress**(gauge)                                | Flag indicating if an AOF rewrite is in progress.                                                                                                                              |
| **gcp.memorystore.instance.node.persistence.aof_rewrites_count**(count)                                      | AOF rewrites count on the instance node.                                                                                                                                       |
| **gcp.memorystore.instance.node.persistence.async_loading**(gauge)                                            | Flag indicating if async loading is in progress.                                                                                                                               |
| **gcp.memorystore.instance.node.persistence.auto_restore_count**(count)                                      | Count of restores from dumpfile on the instance node.                                                                                                                          |
| **gcp.memorystore.instance.node.persistence.current_cow_peak**(gauge)                                        | Peak size in bytes of the copy-on-write memory during the current fork operation.*Shown as byte*                                                                               |
| **gcp.memorystore.instance.node.persistence.current_cow_size**(gauge)                                        | The size in bytes of the copy-on-write memory during the current fork operation.*Shown as byte*                                                                                |
| **gcp.memorystore.instance.node.persistence.current_fork_percentage**(gauge)                                 | The percentage of the current fork operation progress (0-100).                                                                                                                 |
| **gcp.memorystore.instance.node.persistence.current_save_keys_total**(gauge)                                | Number of keys at the beginning of the current save operation.                                                                                                                 |
| **gcp.memorystore.instance.node.persistence.loading**(gauge)                                                   | Flag indicating if loading is in progress.                                                                                                                                     |
| **gcp.memorystore.instance.node.persistence.rdb_bgsave_in_progress**(gauge)                                 | Indicates if a RDB BGSAVE is currently in progress on the instance node.                                                                                                       |
| **gcp.memorystore.instance.node.persistence.rdb_last_bgsave_status**(gauge)                                 | Indicates the success of the last BGSAVE on the instance node.                                                                                                                 |
| **gcp.memorystore.instance.node.persistence.rdb_last_bgsave_time_sec**(gauge)                              | Duration of the last RDB save operation in seconds.*Shown as second*                                                                                                           |
| **gcp.memorystore.instance.node.persistence.rdb_last_cow_size**(gauge)                                      | The size in bytes of the copy-on-write memory during the last RDB save operation.*Shown as byte*                                                                               |
| **gcp.memorystore.instance.node.persistence.rdb_last_save_age**(gauge)                                      | Measures the time in seconds, since the last successful snapshot.*Shown as second*                                                                                             |
| **gcp.memorystore.instance.node.persistence.rdb_next_save_time_until**(gauge)                              | Measures the time in seconds, remaining until the next snapshot.*Shown as second*                                                                                              |
| **gcp.memorystore.instance.node.persistence.rdb_saves_count**(count)                                         | Count of RDB saves in the instance node.                                                                                                                                       |
| **gcp.memorystore.instance.node.replication.offset**(gauge)                                                    | Measures the replication offset bytes of the instance node.*Shown as byte*                                                                                                     |
| **gcp.memorystore.instance.node.replication.primary_sync_in_progress**(gauge)                               | Flag indicating if a primary syncing to replica is in progress.                                                                                                                |
| **gcp.memorystore.instance.node.replication.sync_full_count**(count)                                         | The total number of full resyncs with replicas.                                                                                                                                |
| **gcp.memorystore.instance.node.replication.sync_partial_err_count**(count)                                 | The number of denied partial resync requests.                                                                                                                                  |
| **gcp.memorystore.instance.node.replication.sync_partial_ok_count**(count)                                  | The number of accepted partial resync requests.                                                                                                                                |
| **gcp.memorystore.instance.node.server.healthy**(gauge)                                                        | Indicates if Instance Node is healthy and available.                                                                                                                           |
| **gcp.memorystore.instance.node.server.uptime**(gauge)                                                         | Measures the uptime of the instance node.*Shown as second*                                                                                                                     |
| **gcp.memorystore.instance.node.stats.acl_access_denied_auths_count**(count)                               | Total number of ACL access denied authentication failures.                                                                                                                     |
| **gcp.memorystore.instance.node.stats.client_output_buffer_limit_disconnections_count**(count)            | Total number of disconnections due to client reaching output buffer limit.                                                                                                     |
| **gcp.memorystore.instance.node.stats.client_query_buffer_limit_disconnections_count**(count)             | Total number of disconnections due to client reaching query buffer limit.                                                                                                      |
| **gcp.memorystore.instance.node.stats.connections_received_count**(count)                                    | Count of total client connections created in the last one minute on the instance node.                                                                                         |
| **gcp.memorystore.instance.node.stats.evicted_clients_count**(count)                                         | Total number of client connections evicted due to client memory over eviction limit.                                                                                           |
| **gcp.memorystore.instance.node.stats.evicted_keys_count**(count)                                            | Count of evicted keys by the instance node.                                                                                                                                    |
| **gcp.memorystore.instance.node.stats.evicted_scripts_count**(count)                                         | Number of evicted EVAL scripts due to LRU policy.                                                                                                                              |
| **gcp.memorystore.instance.node.stats.expire_cycle_cpu_millisecond_count**(count)                          | The total cumulative amount of time spent on active expiry cycles.*Shown as millisecond*                                                                                       |
| **gcp.memorystore.instance.node.stats.expired_keys_count**(count)                                            | Count of key expiration events in the instance node.                                                                                                                           |
| **gcp.memorystore.instance.node.stats.expired_keys_percentage**(gauge)                                       | The percentage of keys probably expired.*Shown as percent*                                                                                                                     |
| **gcp.memorystore.instance.node.stats.expired_time_cap_reached_count**(count)                              | The total count of times that active expiry cycles have stopped early.                                                                                                         |
| **gcp.memorystore.instance.node.stats.keyspace_hits_count**(count)                                           | Count of successful lookup of keys in the instance node.                                                                                                                       |
| **gcp.memorystore.instance.node.stats.keyspace_misses_count**(count)                                         | Count of failed lookup of keys in the instance node.                                                                                                                           |
| **gcp.memorystore.instance.node.stats.latest_fork_usec**(gauge)                                              | Duration of the latest fork operation in microseconds.*Shown as microsecond*                                                                                                   |
| **gcp.memorystore.instance.node.stats.net_input_bytes_count**(count)                                        | Count of incoming network bytes received by the instance node.*Shown as byte*                                                                                                  |
| **gcp.memorystore.instance.node.stats.net_output_bytes_count**(count)                                       | Count of outgoing network bytes sent from the instance node.*Shown as byte*                                                                                                    |
| **gcp.memorystore.instance.node.stats.pubsub_channels**(gauge)                                                | Global number of pub/sub channels with client subscriptions.                                                                                                                   |
| **gcp.memorystore.instance.node.stats.pubsub_patterns**(gauge)                                                | Global number of pub/sub patterns with client subscriptions.                                                                                                                   |
| **gcp.memorystore.instance.node.stats.pubsubshard_channels**(gauge)                                           | Global number of pub/sub shard channels with client subscriptions.                                                                                                             |
| **gcp.memorystore.instance.node.stats.rejected_connections_count**(count)                                    | Number of connections rejected because of maxclients limit by the instance node.                                                                                               |
| **gcp.memorystore.instance.node.stats.total_fork_count**(count)                                              | Total number of forks since server start.                                                                                                                                      |
| **gcp.memorystore.instance.node.stats.tracking_total_items**(gauge)                                          | Number of items (Sum of clients per key) being tracked by the server.                                                                                                          |
| **gcp.memorystore.instance.node.stats.tracking_total_keys**(gauge)                                           | Number of keys being tracked by the server.                                                                                                                                    |
| **gcp.memorystore.instance.node.stats.tracking_total_prefixes**(gauge)                                       | Number of tracked prefixes in server prefix table.                                                                                                                             |
| **gcp.memorystore.instance.persistence.aof_fsync_lags.avg**(gauge)                                           | Distribution of AOF lag between memory and persistent store across the instance.*Shown as second*                                                                              |
| **gcp.memorystore.instance.persistence.aof_fsync_lags.samplecount**(gauge)                                   | Distribution of AOF lag between memory and persistent store across the instance.                                                                                               |
| **gcp.memorystore.instance.persistence.aof_fsync_lags.sumsqdev**(gauge)                                      | Distribution of AOF lag between memory and persistent store across the instance.                                                                                               |
| **gcp.memorystore.instance.persistence.aof_rewrite_count**(count)                                            | Count of AOF rewrites across the instance.                                                                                                                                     |
| **gcp.memorystore.instance.persistence.rdb_last_success_ages.avg**(gauge)                                   | Age of RDB snapshots across instance.*Shown as second*                                                                                                                         |
| **gcp.memorystore.instance.persistence.rdb_last_success_ages.samplecount**(gauge)                           | Age of RDB snapshots across instance.                                                                                                                                          |
| **gcp.memorystore.instance.persistence.rdb_last_success_ages.sumsqdev**(gauge)                              | Age of RDB snapshots across instance.                                                                                                                                          |
| **gcp.memorystore.instance.persistence.rdb_saves_count**(count)                                              | Count of RDB saves across the instance.                                                                                                                                        |
| **gcp.memorystore.instance.replication.average_ack_lag**(gauge)                                              | Mean replication acknowledge lag (in seconds) of replica across the instance.*Shown as second*                                                                                 |
| **gcp.memorystore.instance.replication.average_offset_diff**(gauge)                                          | Mean replication offset diff (in bytes) across the instance.*Shown as byte*                                                                                                    |
| **gcp.memorystore.instance.replication.maximum_ack_lag**(gauge)                                              | Maximum replication acknowledge lag (in seconds) of replica across the instance.*Shown as second*                                                                              |
| **gcp.memorystore.instance.replication.maximum_offset_diff**(gauge)                                          | Maximum replication offset diff (in bytes) across the instance.*Shown as byte*                                                                                                 |
| **gcp.memorystore.instance.search.attributes**(gauge)                                                          | The number of attributes across all indexes for vector search.                                                                                                                 |
| **gcp.memorystore.instance.search.average_used_memory_bytes**(gauge)                                        | The average per-node used memory for all search functionality, in bytes.                                                                                                       |
| **gcp.memorystore.instance.search.background_indexing_in_progress**(gauge)                                  | Indicates if the background indexing is in progress across any index. When the metric value is true, background indexing is in progress in at least one index.                 |
| **gcp.memorystore.instance.search.indexed_keys**(gauge)                                                       | The number of keys indexed across all indexes.                                                                                                                                 |
| **gcp.memorystore.instance.search.indexes**(gauge)                                                             | The number of indexes created for searching for vector search.                                                                                                                 |
| **gcp.memorystore.instance.search.maximum_used_memory_bytes**(gauge)                                        | The maximum per-node used memory for all search functionality, in bytes.                                                                                                       |
| **gcp.memorystore.instance.search.query_requests_count**(count)                                              | The number of query requests across all indexes.                                                                                                                               |
| **gcp.memorystore.instance.search.total_used_memory_bytes**(gauge)                                          | The total used memory in bytes for all search functionality in all nodes, in bytes.                                                                                            |
| **gcp.memorystore.instance.security.rotate_tls_cert_count**(count)                                          | Count of TLS certificate rotations on the instance.                                                                                                                            |
| **gcp.memorystore.instance.stats.average_evicted_keys**(gauge)                                               | Mean number of evicted keys due to memory capacity.                                                                                                                            |
| **gcp.memorystore.instance.stats.average_expired_keys**(gauge)                                               | Mean number of key expiration events.                                                                                                                                          |
| **gcp.memorystore.instance.stats.average_keyspace_hits**(gauge)                                              | Mean number of successful lookup of keys across the instance.                                                                                                                  |
| **gcp.memorystore.instance.stats.average_keyspace_misses**(gauge)                                            | Mean number of failed lookup of keys across the instance.                                                                                                                      |
| **gcp.memorystore.instance.stats.maximum_evicted_keys**(gauge)                                               | Maximum number of evicted keys due to memory capacity.                                                                                                                         |
| **gcp.memorystore.instance.stats.maximum_expired_keys**(gauge)                                               | Maximum number of key expiration events.                                                                                                                                       |
| **gcp.memorystore.instance.stats.maximum_keyspace_hits**(gauge)                                              | Maximum number of successful lookup of keys across the instance.                                                                                                               |
| **gcp.memorystore.instance.stats.maximum_keyspace_misses**(gauge)                                            | Maximum number of failed lookup of keys across the instance.                                                                                                                   |
| **gcp.memorystore.instance.stats.total_connections_received_count**(count)                                  | Count of client connections created in the last one minute.                                                                                                                    |
| **gcp.memorystore.instance.stats.total_evicted_keys_count**(count)                                          | Total number of evicted keys due to memory capacity.                                                                                                                           |
| **gcp.memorystore.instance.stats.total_expired_keys_count**(count)                                          | Total number of key expiration events.                                                                                                                                         |
| **gcp.memorystore.instance.stats.total_keyspace_hits_count**(count)                                         | Total number of successful lookup of keys across the instance.                                                                                                                 |
| **gcp.memorystore.instance.stats.total_keyspace_misses_count**(count)                                       | Total number of failed lookup of keys across the instance.                                                                                                                     |
| **gcp.memorystore.instance.stats.total_net_input_bytes_count**(count)                                      | Count of incoming network bytes received by the instance.*Shown as byte*                                                                                                       |
| **gcp.memorystore.instance.stats.total_net_output_bytes_count**(count)                                     | Count of outgoing network bytes sent from the instance.*Shown as byte*                                                                                                         |
| **gcp.memorystore.instance.stats.total_rejected_connections_count**(count)                                  | Count of client connections rejected because of maxclients limit.                                                                                                              |

### Events{% #events %}

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

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

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

## Troubleshooting{% #troubleshooting %}

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