---
title: Alibaba Cloud Tair
description: >-
  Monitor Alibaba Cloud Tair cache hit rates, memory, CPU, and connection
  metrics.
breadcrumbs: Docs > Integrations > Alibaba Cloud Tair
---

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

# Alibaba Cloud Tair
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 %}

[Alibaba Cloud Tair](https://www.alibabacloud.com/help/en/tair/product-overview/what-is-tair) is an in-memory database service compatible with the Redis protocol, offering persistent memory-optimized instances and a KV cache for large language model applications.

Use this integration to monitor cache hit rates, memory and CPU usage, connection counts, and token throughput across your Tair instances.

## Setup{% #setup %}

### Installation{% #installation %}

After you set up the [Alibaba Cloud](https://docs.datadoghq.com/integrations/alibaba_cloud.md) integration, ensure that the Tair service is included in your Alibaba Cloud monitoring configuration.

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

### Metrics{% #metrics %}

|  |
|  |
| **alibabacloud.tair.tair_kv_cache_cached_tokens.sum**(gauge)                                  | Cumulative count of tokens from input text cached by the KV cache across one or more calls.*Shown as token*                              |
| **alibabacloud.tair.tair_kv_cache_fail_request_count.value**(gauge)                          | Cumulative count of failed requests to the model within the specified period.*Shown as request*                                          |
| **alibabacloud.tair.tair_kv_cache_input_token_tps.sum**(gauge)                               | Input tokens consumed by the user per second.*Shown as token*                                                                            |
| **alibabacloud.tair.tair_kv_cache_input_tokens.sum**(gauge)                                   | Cumulative count of tokens from input text not cached by the KV cache across one or more calls.*Shown as token*                          |
| **alibabacloud.tair.tair_kv_cache_latency_avg.average**(gauge)                                | Average time to generate each token, excluding the first token (average).*Shown as second*                                               |
| **alibabacloud.tair.tair_kv_cache_latency_p50.average**(gauge)                                | Average time to generate each token, excluding the first token (P50).*Shown as second*                                                   |
| **alibabacloud.tair.tair_kv_cache_latency_p99.average**(gauge)                                | Average time to generate each token, excluding the first token (P99).*Shown as second*                                                   |
| **alibabacloud.tair.tair_kv_cache_output_token_tps.sum**(gauge)                              | Output tokens consumed by the user per second.*Shown as token*                                                                           |
| **alibabacloud.tair.tair_kv_cache_output_tokens.sum**(gauge)                                  | Cumulative count of tokens from output text across one or more calls.*Shown as token*                                                    |
| **alibabacloud.tair.tair_kv_cache_qps.value**(gauge)                                           | Requests received by the model per second.*Shown as operation*                                                                           |
| **alibabacloud.tair.tair_kv_cache_request_count.value**(gauge)                                | Cumulative total requests sent to the model by users or applications within the specified period.*Shown as request*                      |
| **alibabacloud.tair.tair_kv_cache_success_request_count.value**(gauge)                       | Cumulative count of successfully completed requests to the model within the specified period.*Shown as request*                          |
| **alibabacloud.tair.tair_kv_cache_success_request_ratio.maximum**(gauge)                     | Ratio of successful model calls to total calls within the specified period.*Shown as percent*                                            |
| **alibabacloud.tair.tair_kv_cache_time_per_output_token_avg.average**(gauge)               | End-to-end latency of model calls, including first-token and non-first-token time, excluding network latency (average).*Shown as second* |
| **alibabacloud.tair.tair_kv_cache_time_per_output_token_p50.average**(gauge)               | End-to-end latency of model calls, including first-token and non-first-token time, excluding network latency (P50).*Shown as second*     |
| **alibabacloud.tair.tair_kv_cache_time_per_output_token_p99.average**(gauge)               | End-to-end latency of model calls, including first-token and non-first-token time, excluding network latency (P99).*Shown as second*     |
| **alibabacloud.tair.tair_kv_cache_time_to_first_token_avg.average**(gauge)                 | Time from receiving a request to generating and returning the first token (average).*Shown as second*                                    |
| **alibabacloud.tair.tair_kv_cache_time_to_first_token_p50.average**(gauge)                 | Time from receiving a request to generating and returning the first token (P50).*Shown as second*                                        |
| **alibabacloud.tair.tair_kv_cache_time_to_first_token_p99.average**(gauge)                 | Time from receiving a request to generating and returning the first token (P99).*Shown as second*                                        |
| **alibabacloud.tair.tair_kv_cache_token_tps.sum**(gauge)                                      | Tokens consumed by the user per second.*Shown as token*                                                                                  |
| **alibabacloud.tair.tair_kv_cache_total_tokens.sum**(gauge)                                   | Cumulative count of tokens from input and output text across one or more calls.*Shown as token*                                          |
| **alibabacloud.tair.tair_pdb_sharding_admin_clients_usage.average**(gauge)                   | Proxy to DB connection usage (disk cluster edition).*Shown as percent*                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_admin_clients_usage.maximum**(gauge)                   | Proxy to DB connection usage (disk cluster edition).*Shown as percent*                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_avg_rt.average**(gauge)                                 | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pdb_sharding_avg_rt.maximum**(gauge)                                 | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pdb_sharding_avg_ttl.average**(gauge)                                | TTL key average lifetime (disk cluster edition).*Shown as millisecond*                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_avg_ttl.maximum**(gauge)                                | TTL key average lifetime (disk cluster edition).*Shown as millisecond*                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_clients_in_timeout_table.average**(gauge)             | Client connections in the timeout table (disk cluster edition).*Shown as connection*                                                     |
| **alibabacloud.tair.tair_pdb_sharding_clients_in_timeout_table.maximum**(gauge)             | Client connections in the timeout table (disk cluster edition).*Shown as connection*                                                     |
| **alibabacloud.tair.tair_pdb_sharding_connection_usage.average**(gauge)                       | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_connection_usage.maximum**(gauge)                       | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_cpu_usage.average**(gauge)                              | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pdb_sharding_cpu_usage.maximum**(gauge)                              | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pdb_sharding_disk_usage.average**(gauge)                             | Disk usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pdb_sharding_disk_usage.maximum**(gauge)                             | Disk usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pdb_sharding_evicted_keys.average**(gauge)                           | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_evicted_keys.maximum**(gauge)                           | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_evicted_keys_per_second.average**(rate)               | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_evicted_keys_per_second.maximum**(rate)               | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_expired_keys.average**(gauge)                           | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_expired_keys.maximum**(gauge)                           | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_expired_keys_per_second.average**(rate)               | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_expired_keys_per_second.maximum**(rate)               | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_expires.average**(gauge)                                 | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pdb_sharding_expires.maximum**(gauge)                                 | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pdb_sharding_hit_rate.average**(gauge)                               | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pdb_sharding_hit_rate.maximum**(gauge)                               | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pdb_sharding_io_await.average**(gauge)                               | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pdb_sharding_io_await.maximum**(gauge)                               | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pdb_sharding_io_bandwidth.average**(rate)                            | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_io_bandwidth.maximum**(rate)                            | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_i_ops_usage.average**(gauge)                           | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pdb_sharding_i_ops_usage.maximum**(gauge)                           | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pdb_sharding_intranet_in.average**(rate)                             | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pdb_sharding_intranet_in.maximum**(rate)                             | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pdb_sharding_intranet_in_ratio.average**(gauge)                     | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pdb_sharding_intranet_in_ratio.maximum**(gauge)                     | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pdb_sharding_intranet_out.average**(rate)                            | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pdb_sharding_intranet_out.maximum**(rate)                            | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pdb_sharding_intranet_out_ratio.average**(gauge)                    | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pdb_sharding_intranet_out_ratio.maximum**(gauge)                    | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pdb_sharding_keys.average**(gauge)                                    | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pdb_sharding_keys.maximum**(gauge)                                    | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pdb_sharding_lb_active_conn_ps.average**(rate)                     | LB used connections (disk cluster edition).*Shown as connection*                                                                         |
| **alibabacloud.tair.tair_pdb_sharding_lb_active_conn_ps.maximum**(rate)                     | LB used connections (disk cluster edition).*Shown as connection*                                                                         |
| **alibabacloud.tair.tair_pdb_sharding_lb_in_bps.average**(rate)                              | LB inbound traffic (disk cluster edition).*Shown as bit*                                                                                 |
| **alibabacloud.tair.tair_pdb_sharding_lb_in_bps.maximum**(rate)                              | LB inbound traffic (disk cluster edition).*Shown as bit*                                                                                 |
| **alibabacloud.tair.tair_pdb_sharding_lb_in_drop_pps.average**(rate)                        | LB inbound dropped packets (disk cluster edition).*Shown as packet*                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_lb_in_drop_pps.maximum**(rate)                        | LB inbound dropped packets (disk cluster edition).*Shown as packet*                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_lb_inflow_usage.average**(gauge)                       | LB inbound traffic usage (disk cluster edition).*Shown as percent*                                                                       |
| **alibabacloud.tair.tair_pdb_sharding_lb_inflow_usage.maximum**(gauge)                       | LB inbound traffic usage (disk cluster edition).*Shown as percent*                                                                       |
| **alibabacloud.tair.tair_pdb_sharding_lb_out_bps.average**(rate)                             | LB outbound traffic (disk cluster edition).*Shown as bit*                                                                                |
| **alibabacloud.tair.tair_pdb_sharding_lb_out_bps.maximum**(rate)                             | LB outbound traffic (disk cluster edition).*Shown as bit*                                                                                |
| **alibabacloud.tair.tair_pdb_sharding_lb_out_drop_pps.average**(rate)                       | LB outbound dropped packets (disk cluster edition).*Shown as packet*                                                                     |
| **alibabacloud.tair.tair_pdb_sharding_lb_out_drop_pps.maximum**(rate)                       | LB outbound dropped packets (disk cluster edition).*Shown as packet*                                                                     |
| **alibabacloud.tair.tair_pdb_sharding_lb_outflow_usage.average**(gauge)                      | LB outbound traffic usage (disk cluster edition).*Shown as percent*                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_lb_outflow_usage.maximum**(gauge)                      | LB outbound traffic usage (disk cluster edition).*Shown as percent*                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_memory_usage.average**(gauge)                           | Memory usage.*Shown as percent*                                                                                                          |
| **alibabacloud.tair.tair_pdb_sharding_memory_usage.maximum**(gauge)                           | Memory usage.*Shown as percent*                                                                                                          |
| **alibabacloud.tair.tair_pdb_sharding_normal_clients_mem.average**(gauge)                    | Total client memory usage (disk cluster edition).*Shown as byte*                                                                         |
| **alibabacloud.tair.tair_pdb_sharding_normal_clients_mem.maximum**(gauge)                    | Total client memory usage (disk cluster edition).*Shown as byte*                                                                         |
| **alibabacloud.tair.tair_pdb_sharding_quota_connection.average**(gauge)                       | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pdb_sharding_quota_connection.maximum**(gauge)                       | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pdb_sharding_read_io_await.average**(gauge)                         | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pdb_sharding_read_io_await.maximum**(gauge)                         | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pdb_sharding_read_io_bandwidth.average**(rate)                      | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pdb_sharding_read_io_bandwidth.maximum**(rate)                      | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pdb_sharding_read_i_ops.average**(rate)                             | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pdb_sharding_read_i_ops.maximum**(rate)                             | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pdb_sharding_repl_delay.average**(gauge)                             | Primary-replica sync delay (disk cluster edition).*Shown as second*                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_repl_delay.maximum**(gauge)                             | Primary-replica sync delay (disk cluster edition).*Shown as second*                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_slowlog_count.average**(gauge)                          | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pdb_sharding_slowlog_count.maximum**(gauge)                          | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pdb_sharding_total_commands_processed.average**(gauge)              | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pdb_sharding_total_commands_processed.maximum**(gauge)              | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pdb_sharding_uptime_in_days.average**(gauge)                        | Instance uptime in days (disk cluster edition).*Shown as day*                                                                            |
| **alibabacloud.tair.tair_pdb_sharding_uptime_in_days.maximum**(gauge)                        | Instance uptime in days (disk cluster edition).*Shown as day*                                                                            |
| **alibabacloud.tair.tair_pdb_sharding_uptime_in_seconds.average**(gauge)                     | Instance uptime in seconds (disk cluster edition).*Shown as second*                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_uptime_in_seconds.maximum**(gauge)                     | Instance uptime in seconds (disk cluster edition).*Shown as second*                                                                      |
| **alibabacloud.tair.tair_pdb_sharding_used_connection.average**(gauge)                        | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_used_connection.maximum**(gauge)                        | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pdb_sharding_used_memory.average**(gauge)                            | Memory usage.*Shown as byte*                                                                                                             |
| **alibabacloud.tair.tair_pdb_sharding_used_memory.maximum**(gauge)                            | Memory usage.*Shown as byte*                                                                                                             |
| **alibabacloud.tair.tair_pdb_sharding_used_qps.average**(gauge)                               | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pdb_sharding_used_qps.maximum**(gauge)                               | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pdb_sharding_write_io_await.average**(gauge)                        | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pdb_sharding_write_io_await.maximum**(gauge)                        | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pdb_sharding_write_io_bandwidth.average**(rate)                     | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pdb_sharding_write_io_bandwidth.maximum**(rate)                     | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pdb_sharding_write_i_ops.average**(rate)                            | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_pdb_sharding_write_i_ops.maximum**(rate)                            | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_pdb_standard_avg_rt.average**(gauge)                                 | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pdb_standard_avg_rt.maximum**(gauge)                                 | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pdb_standard_avg_ttl.average**(gauge)                                | TTL key average lifetime (disk standard edition).*Shown as millisecond*                                                                  |
| **alibabacloud.tair.tair_pdb_standard_avg_ttl.maximum**(gauge)                                | TTL key average lifetime (disk standard edition).*Shown as millisecond*                                                                  |
| **alibabacloud.tair.tair_pdb_standard_clients_in_timeout_table.average**(gauge)             | Client connections in the timeout table (disk standard edition).*Shown as connection*                                                    |
| **alibabacloud.tair.tair_pdb_standard_clients_in_timeout_table.maximum**(gauge)             | Client connections in the timeout table (disk standard edition).*Shown as connection*                                                    |
| **alibabacloud.tair.tair_pdb_standard_connection_usage.average**(gauge)                       | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pdb_standard_connection_usage.maximum**(gauge)                       | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pdb_standard_cpu_usage.average**(gauge)                              | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pdb_standard_cpu_usage.maximum**(gauge)                              | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pdb_standard_disk_usage.average**(gauge)                             | Disk usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pdb_standard_disk_usage.maximum**(gauge)                             | Disk usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pdb_standard_evicted_keys.average**(gauge)                           | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_evicted_keys.maximum**(gauge)                           | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_evicted_keys_per_second.average**(rate)               | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_evicted_keys_per_second.maximum**(rate)               | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_expired_keys.average**(gauge)                           | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_expired_keys.maximum**(gauge)                           | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_expired_keys_per_second.average**(rate)               | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_expired_keys_per_second.maximum**(rate)               | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_expires.average**(gauge)                                 | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pdb_standard_expires.maximum**(gauge)                                 | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pdb_standard_io_await.average**(gauge)                               | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pdb_standard_io_await.maximum**(gauge)                               | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pdb_standard_io_bandwidth.average**(rate)                            | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pdb_standard_io_bandwidth.maximum**(rate)                            | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pdb_standard_i_ops_usage.average**(gauge)                           | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pdb_standard_i_ops_usage.maximum**(gauge)                           | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pdb_standard_intranet_in.average**(rate)                             | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pdb_standard_intranet_in.maximum**(rate)                             | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pdb_standard_intranet_in_ratio.average**(gauge)                     | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pdb_standard_intranet_in_ratio.maximum**(gauge)                     | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pdb_standard_intranet_out.average**(rate)                            | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pdb_standard_intranet_out.maximum**(rate)                            | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pdb_standard_intranet_out_ratio.average**(gauge)                    | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pdb_standard_intranet_out_ratio.maximum**(gauge)                    | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pdb_standard_keys.average**(gauge)                                    | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pdb_standard_keys.maximum**(gauge)                                    | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pdb_standard_memory_usage.average**(gauge)                           | Memory usage.*Shown as percent*                                                                                                          |
| **alibabacloud.tair.tair_pdb_standard_memory_usage.maximum**(gauge)                           | Memory usage.*Shown as percent*                                                                                                          |
| **alibabacloud.tair.tair_pdb_standard_normal_clients_mem.average**(gauge)                    | Total client memory usage (disk standard edition).*Shown as byte*                                                                        |
| **alibabacloud.tair.tair_pdb_standard_normal_clients_mem.maximum**(gauge)                    | Total client memory usage (disk standard edition).*Shown as byte*                                                                        |
| **alibabacloud.tair.tair_pdb_standard_quota_connection.average**(gauge)                       | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pdb_standard_quota_connection.maximum**(gauge)                       | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pdb_standard_read_io_await.average**(gauge)                         | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pdb_standard_read_io_await.maximum**(gauge)                         | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pdb_standard_read_io_bandwidth.average**(rate)                      | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pdb_standard_read_io_bandwidth.maximum**(rate)                      | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pdb_standard_read_i_ops.average**(rate)                             | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pdb_standard_read_i_ops.maximum**(rate)                             | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pdb_standard_repl_delay.average**(gauge)                             | Primary-replica sync delay (disk standard edition).*Shown as second*                                                                     |
| **alibabacloud.tair.tair_pdb_standard_repl_delay.maximum**(gauge)                             | Primary-replica sync delay (disk standard edition).*Shown as second*                                                                     |
| **alibabacloud.tair.tair_pdb_standard_slowlog_count.average**(gauge)                          | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pdb_standard_slowlog_count.maximum**(gauge)                          | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pdb_standard_standard_hit_rate.average**(gauge)                     | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pdb_standard_standard_hit_rate.maximum**(gauge)                     | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pdb_standard_total_commands_processed.average**(gauge)              | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pdb_standard_total_commands_processed.maximum**(gauge)              | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pdb_standard_uptime_in_days.average**(gauge)                        | Instance uptime in days (disk standard edition).*Shown as day*                                                                           |
| **alibabacloud.tair.tair_pdb_standard_uptime_in_days.maximum**(gauge)                        | Instance uptime in days (disk standard edition).*Shown as day*                                                                           |
| **alibabacloud.tair.tair_pdb_standard_uptime_in_seconds.average**(gauge)                     | Instance uptime in seconds (disk standard edition).*Shown as second*                                                                     |
| **alibabacloud.tair.tair_pdb_standard_uptime_in_seconds.maximum**(gauge)                     | Instance uptime in seconds (disk standard edition).*Shown as second*                                                                     |
| **alibabacloud.tair.tair_pdb_standard_used_connection.average**(gauge)                        | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_used_connection.maximum**(gauge)                        | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pdb_standard_used_memory.average**(gauge)                            | Memory usage.*Shown as byte*                                                                                                             |
| **alibabacloud.tair.tair_pdb_standard_used_memory.maximum**(gauge)                            | Memory usage.*Shown as byte*                                                                                                             |
| **alibabacloud.tair.tair_pdb_standard_used_qps.average**(gauge)                               | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pdb_standard_used_qps.maximum**(gauge)                               | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pdb_standard_write_io_await.average**(gauge)                        | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pdb_standard_write_io_await.maximum**(gauge)                        | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pdb_standard_write_io_bandwidth.average**(rate)                     | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pdb_standard_write_io_bandwidth.maximum**(rate)                     | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pdb_standard_write_i_ops.average**(rate)                            | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_pdb_standard_write_i_ops.maximum**(rate)                            | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_pena_sharding_admin_clients_usage.average**(gauge)                  | Proxy to DB connection usage (persistent memory cluster edition).*Shown as percent*                                                      |
| **alibabacloud.tair.tair_pena_sharding_admin_clients_usage.maximum**(gauge)                  | Proxy to DB connection usage (persistent memory cluster edition).*Shown as percent*                                                      |
| **alibabacloud.tair.tair_pena_sharding_avg_rt.average**(gauge)                                | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pena_sharding_avg_rt.maximum**(gauge)                                | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pena_sharding_avg_ttl.average**(gauge)                               | TTL key average lifetime (persistent memory cluster edition).*Shown as millisecond*                                                      |
| **alibabacloud.tair.tair_pena_sharding_avg_ttl.maximum**(gauge)                               | TTL key average lifetime (persistent memory cluster edition).*Shown as millisecond*                                                      |
| **alibabacloud.tair.tair_pena_sharding_clients_in_timeout_table.average**(gauge)            | Client connections in the timeout table (persistent memory cluster edition).*Shown as connection*                                        |
| **alibabacloud.tair.tair_pena_sharding_clients_in_timeout_table.maximum**(gauge)            | Client connections in the timeout table (persistent memory cluster edition).*Shown as connection*                                        |
| **alibabacloud.tair.tair_pena_sharding_connection_usage.average**(gauge)                      | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pena_sharding_connection_usage.maximum**(gauge)                      | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pena_sharding_cpu_usage.average**(gauge)                             | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pena_sharding_cpu_usage.maximum**(gauge)                             | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pena_sharding_evicted_keys.average**(gauge)                          | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_evicted_keys.maximum**(gauge)                          | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_evicted_keys_per_second.average**(rate)              | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_evicted_keys_per_second.maximum**(rate)              | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_expired_keys.average**(gauge)                          | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_expired_keys.maximum**(gauge)                          | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_expired_keys_per_second.average**(rate)              | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_expired_keys_per_second.maximum**(rate)              | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_expires.average**(gauge)                                | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pena_sharding_expires.maximum**(gauge)                                | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pena_sharding_hit_rate.average**(gauge)                              | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pena_sharding_hit_rate.maximum**(gauge)                              | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pena_sharding_io_await.average**(gauge)                              | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pena_sharding_io_await.maximum**(gauge)                              | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pena_sharding_io_bandwidth.average**(rate)                           | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pena_sharding_io_bandwidth.maximum**(rate)                           | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pena_sharding_i_ops_usage.average**(gauge)                          | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pena_sharding_i_ops_usage.maximum**(gauge)                          | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pena_sharding_intranet_in.average**(rate)                            | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pena_sharding_intranet_in.maximum**(rate)                            | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pena_sharding_intranet_in_ratio.average**(gauge)                    | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_sharding_intranet_in_ratio.maximum**(gauge)                    | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_sharding_intranet_out.average**(rate)                           | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pena_sharding_intranet_out.maximum**(rate)                           | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pena_sharding_intranet_out_ratio.average**(gauge)                   | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pena_sharding_intranet_out_ratio.maximum**(gauge)                   | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pena_sharding_keys.average**(gauge)                                   | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pena_sharding_keys.maximum**(gauge)                                   | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pena_sharding_lb_active_conn_ps.average**(rate)                    | LB used connections (persistent memory cluster edition).*Shown as connection*                                                            |
| **alibabacloud.tair.tair_pena_sharding_lb_active_conn_ps.maximum**(rate)                    | LB used connections (persistent memory cluster edition).*Shown as connection*                                                            |
| **alibabacloud.tair.tair_pena_sharding_lb_in_bps.average**(rate)                             | LB inbound traffic (persistent memory cluster edition).*Shown as bit*                                                                    |
| **alibabacloud.tair.tair_pena_sharding_lb_in_bps.maximum**(rate)                             | LB inbound traffic (persistent memory cluster edition).*Shown as bit*                                                                    |
| **alibabacloud.tair.tair_pena_sharding_lb_in_drop_pps.average**(rate)                       | LB inbound dropped packets (persistent memory cluster edition).*Shown as packet*                                                         |
| **alibabacloud.tair.tair_pena_sharding_lb_in_drop_pps.maximum**(rate)                       | LB inbound dropped packets (persistent memory cluster edition).*Shown as packet*                                                         |
| **alibabacloud.tair.tair_pena_sharding_lb_inflow_usage.average**(gauge)                      | LB inbound traffic usage (persistent memory cluster edition).*Shown as percent*                                                          |
| **alibabacloud.tair.tair_pena_sharding_lb_inflow_usage.maximum**(gauge)                      | LB inbound traffic usage (persistent memory cluster edition).*Shown as percent*                                                          |
| **alibabacloud.tair.tair_pena_sharding_lb_out_bps.average**(rate)                            | LB outbound traffic (persistent memory cluster edition).*Shown as bit*                                                                   |
| **alibabacloud.tair.tair_pena_sharding_lb_out_bps.maximum**(rate)                            | LB outbound traffic (persistent memory cluster edition).*Shown as bit*                                                                   |
| **alibabacloud.tair.tair_pena_sharding_lb_out_drop_pps.average**(rate)                      | LB outbound dropped packets (persistent memory cluster edition).*Shown as packet*                                                        |
| **alibabacloud.tair.tair_pena_sharding_lb_out_drop_pps.maximum**(rate)                      | LB outbound dropped packets (persistent memory cluster edition).*Shown as packet*                                                        |
| **alibabacloud.tair.tair_pena_sharding_lb_outflow_usage.average**(gauge)                     | LB outbound traffic usage (persistent memory cluster edition).*Shown as percent*                                                         |
| **alibabacloud.tair.tair_pena_sharding_lb_outflow_usage.maximum**(gauge)                     | LB outbound traffic usage (persistent memory cluster edition).*Shown as percent*                                                         |
| **alibabacloud.tair.tair_pena_sharding_normal_clients_mem.average**(gauge)                   | Total client memory usage (persistent memory cluster edition).*Shown as byte*                                                            |
| **alibabacloud.tair.tair_pena_sharding_normal_clients_mem.maximum**(gauge)                   | Total client memory usage (persistent memory cluster edition).*Shown as byte*                                                            |
| **alibabacloud.tair.tair_pena_sharding_pmem_usage.average**(gauge)                            | Persistent memory usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_sharding_pmem_usage.maximum**(gauge)                            | Persistent memory usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_sharding_quota_connection.average**(gauge)                      | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pena_sharding_quota_connection.maximum**(gauge)                      | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pena_sharding_read_io_await.average**(gauge)                        | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pena_sharding_read_io_await.maximum**(gauge)                        | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pena_sharding_read_io_bandwidth.average**(rate)                     | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pena_sharding_read_io_bandwidth.maximum**(rate)                     | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pena_sharding_read_i_ops.average**(rate)                            | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pena_sharding_read_i_ops.maximum**(rate)                            | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pena_sharding_repl_delay.average**(gauge)                            | Primary-replica sync delay (persistent memory cluster edition).*Shown as second*                                                         |
| **alibabacloud.tair.tair_pena_sharding_repl_delay.maximum**(gauge)                            | Primary-replica sync delay (persistent memory cluster edition).*Shown as second*                                                         |
| **alibabacloud.tair.tair_pena_sharding_slowlog_count.average**(gauge)                         | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pena_sharding_slowlog_count.maximum**(gauge)                         | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pena_sharding_total_commands_processed.average**(gauge)             | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pena_sharding_total_commands_processed.maximum**(gauge)             | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pena_sharding_uptime_in_days.average**(gauge)                       | Instance uptime in days (persistent memory cluster edition).*Shown as day*                                                               |
| **alibabacloud.tair.tair_pena_sharding_uptime_in_days.maximum**(gauge)                       | Instance uptime in days (persistent memory cluster edition).*Shown as day*                                                               |
| **alibabacloud.tair.tair_pena_sharding_uptime_in_seconds.average**(gauge)                    | Instance uptime in seconds (persistent memory cluster edition).*Shown as second*                                                         |
| **alibabacloud.tair.tair_pena_sharding_uptime_in_seconds.maximum**(gauge)                    | Instance uptime in seconds (persistent memory cluster edition).*Shown as second*                                                         |
| **alibabacloud.tair.tair_pena_sharding_used_connection.average**(gauge)                       | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_used_connection.maximum**(gauge)                       | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pena_sharding_used_p_memory.average**(gauge)                        | Persistent memory usage.*Shown as byte*                                                                                                  |
| **alibabacloud.tair.tair_pena_sharding_used_p_memory.maximum**(gauge)                        | Persistent memory usage.*Shown as byte*                                                                                                  |
| **alibabacloud.tair.tair_pena_sharding_used_qps.average**(gauge)                              | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pena_sharding_used_qps.maximum**(gauge)                              | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pena_sharding_write_io_await.average**(gauge)                       | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pena_sharding_write_io_await.maximum**(gauge)                       | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pena_sharding_write_io_bandwidth.average**(rate)                    | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pena_sharding_write_io_bandwidth.maximum**(rate)                    | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pena_sharding_write_i_ops.average**(rate)                           | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_pena_sharding_write_i_ops.maximum**(rate)                           | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_pena_splitrw_admin_clients_usage.average**(gauge)                   | Proxy to DB connection usage (read-write splitting edition).*Shown as percent*                                                           |
| **alibabacloud.tair.tair_pena_splitrw_admin_clients_usage.maximum**(gauge)                   | Proxy to DB connection usage (read-write splitting edition).*Shown as percent*                                                           |
| **alibabacloud.tair.tair_pena_splitrw_avg_rt.average**(gauge)                                 | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pena_splitrw_avg_rt.maximum**(gauge)                                 | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pena_splitrw_avg_ttl.average**(gauge)                                | TTL key average lifetime (persistent memory read-write splitting edition).*Shown as millisecond*                                         |
| **alibabacloud.tair.tair_pena_splitrw_avg_ttl.maximum**(gauge)                                | TTL key average lifetime (persistent memory read-write splitting edition).*Shown as millisecond*                                         |
| **alibabacloud.tair.tair_pena_splitrw_clients_in_timeout_table.average**(gauge)             | Client connections in the timeout table (persistent memory read-write splitting edition).*Shown as connection*                           |
| **alibabacloud.tair.tair_pena_splitrw_clients_in_timeout_table.maximum**(gauge)             | Client connections in the timeout table (persistent memory read-write splitting edition).*Shown as connection*                           |
| **alibabacloud.tair.tair_pena_splitrw_connection_usage.average**(gauge)                       | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pena_splitrw_connection_usage.maximum**(gauge)                       | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pena_splitrw_cpu_usage.average**(gauge)                              | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pena_splitrw_cpu_usage.maximum**(gauge)                              | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pena_splitrw_evicted_keys.average**(gauge)                           | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_evicted_keys.maximum**(gauge)                           | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_evicted_keys_per_second.average**(rate)               | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_evicted_keys_per_second.maximum**(rate)               | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_expired_keys.average**(gauge)                           | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_expired_keys.maximum**(gauge)                           | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_expired_keys_per_second.average**(rate)               | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_expired_keys_per_second.maximum**(rate)               | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_expires.average**(gauge)                                 | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pena_splitrw_expires.maximum**(gauge)                                 | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pena_splitrw_hit_rate.average**(gauge)                               | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pena_splitrw_hit_rate.maximum**(gauge)                               | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pena_splitrw_io_await.average**(gauge)                               | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pena_splitrw_io_await.maximum**(gauge)                               | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pena_splitrw_io_bandwidth.average**(rate)                            | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pena_splitrw_io_bandwidth.maximum**(rate)                            | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pena_splitrw_i_ops_usage.average**(gauge)                           | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pena_splitrw_i_ops_usage.maximum**(gauge)                           | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pena_splitrw_intranet_in.average**(rate)                             | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pena_splitrw_intranet_in.maximum**(rate)                             | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pena_splitrw_intranet_in_ratio.average**(gauge)                     | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_splitrw_intranet_in_ratio.maximum**(gauge)                     | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_splitrw_intranet_out.average**(rate)                            | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pena_splitrw_intranet_out.maximum**(rate)                            | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pena_splitrw_intranet_out_ratio.average**(gauge)                    | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pena_splitrw_intranet_out_ratio.maximum**(gauge)                    | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pena_splitrw_keys.average**(gauge)                                    | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pena_splitrw_keys.maximum**(gauge)                                    | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pena_splitrw_lb_active_conn_ps.average**(rate)                     | LB used connections (persistent memory read-write splitting edition).*Shown as connection*                                               |
| **alibabacloud.tair.tair_pena_splitrw_lb_active_conn_ps.maximum**(rate)                     | LB used connections (persistent memory read-write splitting edition).*Shown as connection*                                               |
| **alibabacloud.tair.tair_pena_splitrw_lb_in_bps.average**(rate)                              | LB inbound traffic (persistent memory read-write splitting edition).*Shown as bit*                                                       |
| **alibabacloud.tair.tair_pena_splitrw_lb_in_bps.maximum**(rate)                              | LB inbound traffic (persistent memory read-write splitting edition).*Shown as bit*                                                       |
| **alibabacloud.tair.tair_pena_splitrw_lb_in_drop_pps.average**(rate)                        | LB inbound dropped packets (persistent memory read-write splitting edition).*Shown as packet*                                            |
| **alibabacloud.tair.tair_pena_splitrw_lb_in_drop_pps.maximum**(rate)                        | LB inbound dropped packets (persistent memory read-write splitting edition).*Shown as packet*                                            |
| **alibabacloud.tair.tair_pena_splitrw_lb_inflow_usage.average**(gauge)                       | LB inbound traffic usage (persistent memory read-write splitting edition).*Shown as percent*                                             |
| **alibabacloud.tair.tair_pena_splitrw_lb_inflow_usage.maximum**(gauge)                       | LB inbound traffic usage (persistent memory read-write splitting edition).*Shown as percent*                                             |
| **alibabacloud.tair.tair_pena_splitrw_lb_out_bps.average**(rate)                             | LB outbound traffic (persistent memory read-write splitting edition).*Shown as bit*                                                      |
| **alibabacloud.tair.tair_pena_splitrw_lb_out_bps.maximum**(rate)                             | LB outbound traffic (persistent memory read-write splitting edition).*Shown as bit*                                                      |
| **alibabacloud.tair.tair_pena_splitrw_lb_out_drop_pps.average**(rate)                       | LB outbound dropped packets (persistent memory read-write splitting edition).*Shown as packet*                                           |
| **alibabacloud.tair.tair_pena_splitrw_lb_out_drop_pps.maximum**(rate)                       | LB outbound dropped packets (persistent memory read-write splitting edition).*Shown as packet*                                           |
| **alibabacloud.tair.tair_pena_splitrw_lb_outflow_usage.average**(gauge)                      | LB outbound traffic usage (persistent memory read-write splitting edition).*Shown as percent*                                            |
| **alibabacloud.tair.tair_pena_splitrw_lb_outflow_usage.maximum**(gauge)                      | LB outbound traffic usage (persistent memory read-write splitting edition).*Shown as percent*                                            |
| **alibabacloud.tair.tair_pena_splitrw_normal_clients_mem.average**(gauge)                    | Total client memory usage (persistent memory read-write splitting edition).*Shown as byte*                                               |
| **alibabacloud.tair.tair_pena_splitrw_normal_clients_mem.maximum**(gauge)                    | Total client memory usage (persistent memory read-write splitting edition).*Shown as byte*                                               |
| **alibabacloud.tair.tair_pena_splitrw_pmem_usage.average**(gauge)                             | Persistent memory usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_splitrw_pmem_usage.maximum**(gauge)                             | Persistent memory usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_splitrw_quota_connection.average**(gauge)                       | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pena_splitrw_quota_connection.maximum**(gauge)                       | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pena_splitrw_read_io_await.average**(gauge)                         | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pena_splitrw_read_io_await.maximum**(gauge)                         | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pena_splitrw_read_io_bandwidth.average**(rate)                      | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pena_splitrw_read_io_bandwidth.maximum**(rate)                      | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pena_splitrw_read_i_ops.average**(rate)                             | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pena_splitrw_read_i_ops.maximum**(rate)                             | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pena_splitrw_repl_delay.average**(gauge)                             | Primary-replica sync delay (read-write splitting edition).*Shown as second*                                                              |
| **alibabacloud.tair.tair_pena_splitrw_repl_delay.maximum**(gauge)                             | Primary-replica sync delay (read-write splitting edition).*Shown as second*                                                              |
| **alibabacloud.tair.tair_pena_splitrw_slowlog_count.average**(gauge)                          | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pena_splitrw_slowlog_count.maximum**(gauge)                          | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pena_splitrw_total_commands_processed.average**(gauge)              | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pena_splitrw_total_commands_processed.maximum**(gauge)              | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pena_splitrw_uptime_in_days.average**(gauge)                        | Instance uptime in days (persistent memory read-write splitting edition).*Shown as day*                                                  |
| **alibabacloud.tair.tair_pena_splitrw_uptime_in_days.maximum**(gauge)                        | Instance uptime in days (persistent memory read-write splitting edition).*Shown as day*                                                  |
| **alibabacloud.tair.tair_pena_splitrw_uptime_in_seconds.average**(gauge)                     | Instance uptime in seconds (persistent memory read-write splitting edition).*Shown as second*                                            |
| **alibabacloud.tair.tair_pena_splitrw_uptime_in_seconds.maximum**(gauge)                     | Instance uptime in seconds (persistent memory read-write splitting edition).*Shown as second*                                            |
| **alibabacloud.tair.tair_pena_splitrw_used_connection.average**(gauge)                        | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_used_connection.maximum**(gauge)                        | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pena_splitrw_used_p_memory.average**(gauge)                         | Persistent memory usage.*Shown as byte*                                                                                                  |
| **alibabacloud.tair.tair_pena_splitrw_used_p_memory.maximum**(gauge)                         | Persistent memory usage.*Shown as byte*                                                                                                  |
| **alibabacloud.tair.tair_pena_splitrw_used_qps.average**(gauge)                               | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pena_splitrw_used_qps.maximum**(gauge)                               | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pena_splitrw_write_io_await.average**(gauge)                        | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pena_splitrw_write_io_await.maximum**(gauge)                        | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pena_splitrw_write_io_bandwidth.average**(rate)                     | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pena_splitrw_write_io_bandwidth.maximum**(rate)                     | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pena_splitrw_write_i_ops.average**(rate)                            | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_pena_splitrw_write_i_ops.maximum**(rate)                            | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_pena_standard_avg_rt.average**(gauge)                                | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pena_standard_avg_rt.maximum**(gauge)                                | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_pena_standard_avg_ttl.average**(gauge)                               | TTL key average lifetime (persistent memory standard edition).*Shown as millisecond*                                                     |
| **alibabacloud.tair.tair_pena_standard_avg_ttl.maximum**(gauge)                               | TTL key average lifetime (persistent memory standard edition).*Shown as millisecond*                                                     |
| **alibabacloud.tair.tair_pena_standard_clients_in_timeout_table.average**(gauge)            | Client connections in the timeout table (persistent memory standard edition).*Shown as connection*                                       |
| **alibabacloud.tair.tair_pena_standard_clients_in_timeout_table.maximum**(gauge)            | Client connections in the timeout table (persistent memory standard edition).*Shown as connection*                                       |
| **alibabacloud.tair.tair_pena_standard_connection_usage.average**(gauge)                      | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pena_standard_connection_usage.maximum**(gauge)                      | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_pena_standard_cpu_usage.average**(gauge)                             | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pena_standard_cpu_usage.maximum**(gauge)                             | CPU usage.*Shown as percent*                                                                                                             |
| **alibabacloud.tair.tair_pena_standard_evicted_keys.average**(gauge)                          | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_evicted_keys.maximum**(gauge)                          | Cumulative evicted keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_evicted_keys_per_second.average**(rate)              | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_evicted_keys_per_second.maximum**(rate)              | Evicted keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_expired_keys.average**(gauge)                          | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_expired_keys.maximum**(gauge)                          | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_expired_keys_per_second.average**(rate)              | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_expired_keys_per_second.maximum**(rate)              | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_expires.average**(gauge)                                | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pena_standard_expires.maximum**(gauge)                                | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_pena_standard_hit_rate.average**(gauge)                              | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pena_standard_hit_rate.maximum**(gauge)                              | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_pena_standard_io_await.average**(gauge)                              | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pena_standard_io_await.maximum**(gauge)                              | IO average latency.*Shown as millisecond*                                                                                                |
| **alibabacloud.tair.tair_pena_standard_io_bandwidth.average**(rate)                           | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pena_standard_io_bandwidth.maximum**(rate)                           | Disk throughput.*Shown as kibibyte*                                                                                                      |
| **alibabacloud.tair.tair_pena_standard_i_ops_usage.average**(gauge)                          | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pena_standard_i_ops_usage.maximum**(gauge)                          | IOPS usage.*Shown as percent*                                                                                                            |
| **alibabacloud.tair.tair_pena_standard_intranet_in.average**(rate)                            | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pena_standard_intranet_in.maximum**(rate)                            | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_pena_standard_intranet_in_ratio.average**(gauge)                    | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_standard_intranet_in_ratio.maximum**(gauge)                    | Inbound bandwidth usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_standard_intranet_out.average**(rate)                           | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pena_standard_intranet_out.maximum**(rate)                           | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_pena_standard_intranet_out_ratio.average**(gauge)                   | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pena_standard_intranet_out_ratio.maximum**(gauge)                   | Outbound bandwidth usage.*Shown as percent*                                                                                              |
| **alibabacloud.tair.tair_pena_standard_keys.average**(gauge)                                   | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pena_standard_keys.maximum**(gauge)                                   | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_pena_standard_normal_clients_mem.average**(gauge)                   | Total client memory usage (persistent memory standard edition).*Shown as byte*                                                           |
| **alibabacloud.tair.tair_pena_standard_normal_clients_mem.maximum**(gauge)                   | Total client memory usage (persistent memory standard edition).*Shown as byte*                                                           |
| **alibabacloud.tair.tair_pena_standard_pmem_usage.average**(gauge)                            | Persistent memory usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_standard_pmem_usage.maximum**(gauge)                            | Persistent memory usage.*Shown as percent*                                                                                               |
| **alibabacloud.tair.tair_pena_standard_pmem_used.average**(gauge)                             | Persistent memory usage.*Shown as byte*                                                                                                  |
| **alibabacloud.tair.tair_pena_standard_pmem_used.maximum**(gauge)                             | Persistent memory usage.*Shown as byte*                                                                                                  |
| **alibabacloud.tair.tair_pena_standard_pmem_used.sum**(gauge)                                 | Persistent memory usage.*Shown as byte*                                                                                                  |
| **alibabacloud.tair.tair_pena_standard_quota_connection.average**(gauge)                      | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pena_standard_quota_connection.maximum**(gauge)                      | Maximum instance connections.*Shown as connection*                                                                                       |
| **alibabacloud.tair.tair_pena_standard_read_io_await.average**(gauge)                        | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pena_standard_read_io_await.maximum**(gauge)                        | Read IO average latency.*Shown as millisecond*                                                                                           |
| **alibabacloud.tair.tair_pena_standard_read_io_bandwidth.average**(rate)                     | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pena_standard_read_io_bandwidth.maximum**(rate)                     | Disk read throughput.*Shown as kibibyte*                                                                                                 |
| **alibabacloud.tair.tair_pena_standard_read_i_ops.average**(rate)                            | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pena_standard_read_i_ops.maximum**(rate)                            | Read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.tair.tair_pena_standard_repl_delay.average**(gauge)                            | Primary-replica sync delay (persistent memory standard edition).*Shown as second*                                                        |
| **alibabacloud.tair.tair_pena_standard_repl_delay.maximum**(gauge)                            | Primary-replica sync delay (persistent memory standard edition).*Shown as second*                                                        |
| **alibabacloud.tair.tair_pena_standard_slowlog_count.average**(gauge)                         | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pena_standard_slowlog_count.maximum**(gauge)                         | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_pena_standard_total_commands_processed.average**(gauge)             | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pena_standard_total_commands_processed.maximum**(gauge)             | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_pena_standard_uptime_in_days.average**(gauge)                       | Instance uptime in days (persistent memory standard edition).*Shown as day*                                                              |
| **alibabacloud.tair.tair_pena_standard_uptime_in_days.maximum**(gauge)                       | Instance uptime in days (persistent memory standard edition).*Shown as day*                                                              |
| **alibabacloud.tair.tair_pena_standard_uptime_in_seconds.average**(gauge)                    | Instance uptime in seconds (persistent memory standard edition).*Shown as second*                                                        |
| **alibabacloud.tair.tair_pena_standard_uptime_in_seconds.maximum**(gauge)                    | Instance uptime in seconds (persistent memory standard edition).*Shown as second*                                                        |
| **alibabacloud.tair.tair_pena_standard_used_connection.average**(gauge)                       | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_used_connection.maximum**(gauge)                       | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_pena_standard_used_p_memory.average**(gauge)                        | Persistent memory usage.*Shown as byte*                                                                                                  |
| **alibabacloud.tair.tair_pena_standard_used_p_memory.maximum**(gauge)                        | Persistent memory usage.*Shown as byte*                                                                                                  |
| **alibabacloud.tair.tair_pena_standard_used_qps.average**(gauge)                              | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pena_standard_used_qps.maximum**(gauge)                              | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_pena_standard_write_io_await.average**(gauge)                       | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pena_standard_write_io_await.maximum**(gauge)                       | Write IO average latency.*Shown as millisecond*                                                                                          |
| **alibabacloud.tair.tair_pena_standard_write_io_bandwidth.average**(rate)                    | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pena_standard_write_io_bandwidth.maximum**(rate)                    | Disk write throughput.*Shown as kibibyte*                                                                                                |
| **alibabacloud.tair.tair_pena_standard_write_i_ops.average**(rate)                           | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_pena_standard_write_i_ops.maximum**(rate)                           | Write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.tair.tair_serverless_redis_avg_rt.average**(gauge)                             | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_serverless_redis_avg_rt.sum**(gauge)                                 | Average response time.*Shown as microsecond*                                                                                             |
| **alibabacloud.tair.tair_serverless_redis_billing_logical_storage_byte.average**(gauge)     | Logical storage used for billing of the serverless Redis instance.*Shown as byte*                                                        |
| **alibabacloud.tair.tair_serverless_redis_billing_logical_storage_byte.sum**(gauge)         | Logical storage used for billing of the serverless Redis instance.*Shown as byte*                                                        |
| **alibabacloud.tair.tair_serverless_redis_billing_read_cu_per_sec.average**(rate)          | Read capacity units consumed per second for billing of the serverless Redis instance.*Shown as operation*                                |
| **alibabacloud.tair.tair_serverless_redis_billing_read_cu_per_sec.sum**(rate)              | Read capacity units consumed per second for billing of the serverless Redis instance.*Shown as operation*                                |
| **alibabacloud.tair.tair_serverless_redis_billing_write_cu_per_sec.average**(rate)         | Write capacity units consumed per second for billing of the serverless Redis instance.*Shown as operation*                               |
| **alibabacloud.tair.tair_serverless_redis_billing_write_cu_per_sec.sum**(rate)             | Write capacity units consumed per second for billing of the serverless Redis instance.*Shown as operation*                               |
| **alibabacloud.tair.tair_serverless_redis_connection_usage.average**(gauge)                   | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_serverless_redis_connection_usage.sum**(gauge)                       | Connection usage.*Shown as percent*                                                                                                      |
| **alibabacloud.tair.tair_serverless_redis_expired_keys.average**(gauge)                       | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_serverless_redis_expired_keys.sum**(gauge)                           | Cumulative expired keys.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_serverless_redis_expired_keys_per_second.average**(rate)           | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_serverless_redis_expired_keys_per_second.sum**(rate)               | Expired keys per second.*Shown as key*                                                                                                   |
| **alibabacloud.tair.tair_serverless_redis_expires.average**(gauge)                             | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_serverless_redis_expires.sum**(gauge)                                 | Keys with expiration time set.*Shown as key*                                                                                             |
| **alibabacloud.tair.tair_serverless_redis_hit_rate.average**(gauge)                           | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_serverless_redis_hit_rate.sum**(gauge)                               | Hit rate.*Shown as percent*                                                                                                              |
| **alibabacloud.tair.tair_serverless_redis_intranet_in.average**(rate)                         | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_serverless_redis_intranet_in.sum**(rate)                             | Inbound bandwidth.*Shown as bit*                                                                                                         |
| **alibabacloud.tair.tair_serverless_redis_intranet_out.average**(rate)                        | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_serverless_redis_intranet_out.sum**(rate)                            | Outbound bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.tair.tair_serverless_redis_keys.average**(gauge)                                | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_serverless_redis_keys.sum**(gauge)                                    | Total keys.*Shown as key*                                                                                                                |
| **alibabacloud.tair.tair_serverless_redis_slowlog_count.average**(gauge)                      | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_serverless_redis_slowlog_count.sum**(gauge)                          | Slow query count.*Shown as query*                                                                                                        |
| **alibabacloud.tair.tair_serverless_redis_total_commands_processed.average**(gauge)          | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_serverless_redis_total_commands_processed.sum**(gauge)              | Total processed commands.*Shown as command*                                                                                              |
| **alibabacloud.tair.tair_serverless_redis_total_throttled_requests_per_sec.average**(rate) | Throttled requests per second for the serverless Redis instance.*Shown as request*                                                       |
| **alibabacloud.tair.tair_serverless_redis_total_throttled_requests_per_sec.sum**(rate)     | Throttled requests per second for the serverless Redis instance.*Shown as request*                                                       |
| **alibabacloud.tair.tair_serverless_redis_used_connection.average**(gauge)                    | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_serverless_redis_used_connection.sum**(gauge)                        | Used connections.*Shown as connection*                                                                                                   |
| **alibabacloud.tair.tair_serverless_redis_used_qps.average**(gauge)                           | Average accesses per second.*Shown as operation*                                                                                         |
| **alibabacloud.tair.tair_serverless_redis_used_qps.sum**(gauge)                               | Average accesses per second.*Shown as operation*                                                                                         |

### Events{% #events %}

Alibaba Cloud Tair does not include any events.

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

Alibaba Cloud Tair does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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