---
title: Alibaba Cloud PolarDB
description: >-
  Monitor Alibaba Cloud PolarDB CPU, memory, storage, connections, and
  replication lag across all compatible engines.
breadcrumbs: Docs > Integrations > Alibaba Cloud PolarDB
---

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

# Alibaba Cloud PolarDB
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 PolarDB is a cloud-native relational database service compatible with MySQL, PostgreSQL, and Oracle, using a compute-storage separation architecture for elastic scaling and high availability.

Use this integration to monitor cluster CPU, memory, storage, and connection usage, as well as query throughput, IOPS, and replication lag across your PolarDB clusters.

## Setup{% #setup %}

### Installation{% #installation %}

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

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

### Metrics{% #metrics %}

|  |
|  |
| **alibabacloud.polardb.ms_cached_tokens.average**(gauge)                                                                       | Cumulative number of tokens that hit the cache across one or more calls.*Shown as unit*                                                                                                                                               |
| **alibabacloud.polardb.ms_cached_tokens_api_key.average**(gauge)                                                             | Cumulative number of tokens that hit the cache across one or more calls.*Shown as unit*                                                                                                                                               |
| **alibabacloud.polardb.ms_input_tokens.average**(gauge)                                                                        | Cumulative number of tokens the input text was split into across one or more calls.*Shown as unit*                                                                                                                                    |
| **alibabacloud.polardb.ms_input_tokens_api_key.average**(gauge)                                                              | Cumulative number of tokens the input text was split into across one or more calls.*Shown as unit*                                                                                                                                    |
| **alibabacloud.polardb.ms_latency_avg.average**(gauge)                                                                         | Model call latency, calculated as first-token time plus non-first-token time, excluding network latency (average).*Shown as second*                                                                                                   |
| **alibabacloud.polardb.ms_latency_p50.average**(gauge)                                                                         | Model call latency, calculated as first-token time plus non-first-token time, excluding network latency (P50).*Shown as second*                                                                                                       |
| **alibabacloud.polardb.ms_latency_p90.average**(gauge)                                                                         | Model call latency, calculated as first-token time plus non-first-token time, excluding network latency (P90).*Shown as second*                                                                                                       |
| **alibabacloud.polardb.ms_latency_p95.average**(gauge)                                                                         | Model call latency, calculated as first-token time plus non-first-token time, excluding network latency (P95).*Shown as second*                                                                                                       |
| **alibabacloud.polardb.ms_latency_p99.average**(gauge)                                                                         | Model call latency, calculated as first-token time plus non-first-token time, excluding network latency (P99).*Shown as second*                                                                                                       |
| **alibabacloud.polardb.ms_load_ratio.average**(gauge)                                                                          | Load level of the model, calculated as requests per minute divided by maximum QPM (queries per minute).*Shown as percent*                                                                                                             |
| **alibabacloud.polardb.ms_max_qpm.average**(gauge)                                                                             | Maximum QPM, representing the performance ceiling of a model.*Shown as query*                                                                                                                                                         |
| **alibabacloud.polardb.ms_output_tokens.average**(gauge)                                                                       | Cumulative number of tokens the output text was split into across one or more calls.*Shown as unit*                                                                                                                                   |
| **alibabacloud.polardb.ms_output_tokens_api_key.average**(gauge)                                                             | Cumulative number of tokens the output text was split into across one or more calls.*Shown as unit*                                                                                                                                   |
| **alibabacloud.polardb.ms_qps.average**(rate)                                                                                   | Number of requests received by the system per second.*Shown as query*                                                                                                                                                                 |
| **alibabacloud.polardb.ms_qps_api_key.average**(rate)                                                                         | Number of requests received by the system per second for a given API key.*Shown as query*                                                                                                                                             |
| **alibabacloud.polardb.ms_request_count.average**(gauge)                                                                       | Cumulative total number of requests a user or application sent to the model during the specified period.*Shown as request*                                                                                                            |
| **alibabacloud.polardb.ms_request_count_api_key.average**(gauge)                                                             | Cumulative total number of requests a user or application sent to the model using a given API key during the specified period.*Shown as request*                                                                                      |
| **alibabacloud.polardb.ms_success_ratio.average**(gauge)                                                                       | Ratio of successful calls to total calls for the instance.*Shown as percent*                                                                                                                                                          |
| **alibabacloud.polardb.ms_success_ratio_api_key.average**(gauge)                                                             | Ratio of successful calls to total calls for a given API key.*Shown as percent*                                                                                                                                                       |
| **alibabacloud.polardb.ms_success_request_count.average**(gauge)                                                              | Cumulative number of requests successfully completed by the instance during the specified period.*Shown as request*                                                                                                                   |
| **alibabacloud.polardb.ms_success_request_count_api_key.average**(gauge)                                                    | Cumulative number of requests successfully completed by a given API key during the specified period.*Shown as request*                                                                                                                |
| **alibabacloud.polardb.ms_tps.average**(rate)                                                                                   | Number of tokens consumed per second.*Shown as unit*                                                                                                                                                                                  |
| **alibabacloud.polardb.ms_tps_api_key.average**(rate)                                                                         | Number of tokens consumed per second.*Shown as unit*                                                                                                                                                                                  |
| **alibabacloud.polardb.ms_time_per_output_token_avg.average**(gauge)                                                        | Average time to generate each token, excluding the first token (average).*Shown as second*                                                                                                                                            |
| **alibabacloud.polardb.ms_time_per_output_token_p50.average**(gauge)                                                        | Average time to generate each token, excluding the first token (P50).*Shown as second*                                                                                                                                                |
| **alibabacloud.polardb.ms_time_per_output_token_p99.average**(gauge)                                                        | Average time to generate each token, excluding the first token (P99).*Shown as second*                                                                                                                                                |
| **alibabacloud.polardb.ms_time_to_first_token_avg.average**(gauge)                                                          | Time from receiving the request to generating and returning the first token (average).*Shown as second*                                                                                                                               |
| **alibabacloud.polardb.ms_time_to_first_token_p50.average**(gauge)                                                          | Time from receiving the request to generating and returning the first token (P50).*Shown as second*                                                                                                                                   |
| **alibabacloud.polardb.ms_time_to_first_token_p99.average**(gauge)                                                          | Time from receiving the request to generating and returning the first token (P99).*Shown as second*                                                                                                                                   |
| **alibabacloud.polardb.ms_total_tokens.average**(gauge)                                                                        | Cumulative number of tokens the input and output text were split into across one or more calls.*Shown as unit*                                                                                                                        |
| **alibabacloud.polardb.ms_total_tokens_api_key.average**(gauge)                                                              | Cumulative number of tokens the input and output text were split into across one or more calls.*Shown as unit*                                                                                                                        |
| **alibabacloud.polardb.opened_tables.average**(gauge)                                                                           | Number of table cache misses, which require initializing the table object from the data dictionary; this is a slow process, and a high rate indicates the table cache is too small and can lead to many slow queries.*Shown as table* |
| **alibabacloud.polardb.replica_lag_ms.average**(gauge)                                                                         | Replication delay of the instance.*Shown as millisecond*                                                                                                                                                                              |
| **alibabacloud.polardb.replica_lag_ms.maximum**(gauge)                                                                         | Replication delay of the instance.*Shown as millisecond*                                                                                                                                                                              |
| **alibabacloud.polardb.replica_lag_ms.minimum**(gauge)                                                                         | Replication delay of the instance.*Shown as millisecond*                                                                                                                                                                              |
| **alibabacloud.polardb.active_connections.average**(gauge)                                                                      | Number of active connections on the current instance.*Shown as connection*                                                                                                                                                            |
| **alibabacloud.polardb.add_memory_total_avg_ms.average**(gauge)                                                              | Average latency of memory creation.*Shown as millisecond*                                                                                                                                                                             |
| **alibabacloud.polardb.add_memory_total_count.average**(gauge)                                                                | Total number of times memory was created.*Shown as operation*                                                                                                                                                                         |
| **alibabacloud.polardb.add_memory_total_failure_rate.average**(gauge)                                                        | Failure rate of memory creation.*Shown as percent*                                                                                                                                                                                    |
| **alibabacloud.polardb.blks_read_delta.average**(rate)                                                                         | Number of data blocks read per second.*Shown as block*                                                                                                                                                                                |
| **alibabacloud.polardb.cluster_active_sessions.average**(gauge)                                                                | Number of active connections.*Shown as session*                                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_blktag_utilization.average**(gauge)                                                             | Block tag usage.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_com_delete.average**(rate)                                                                      | Number of DELETE statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_delete.maximum**(rate)                                                                      | Number of DELETE statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_delete.minimum**(rate)                                                                      | Number of DELETE statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_delete_multi.average**(rate)                                                               | Number of multi-table DELETE statement executions per second.*Shown as operation*                                                                                                                                                     |
| **alibabacloud.polardb.cluster_com_delete_multi.maximum**(rate)                                                               | Number of multi-table DELETE statement executions per second.*Shown as operation*                                                                                                                                                     |
| **alibabacloud.polardb.cluster_com_delete_multi.minimum**(rate)                                                               | Number of multi-table DELETE statement executions per second.*Shown as operation*                                                                                                                                                     |
| **alibabacloud.polardb.cluster_com_insert.average**(rate)                                                                      | Number of INSERT statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_insert.maximum**(rate)                                                                      | Number of INSERT statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_insert.minimum**(rate)                                                                      | Number of INSERT statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_insert_select.average**(rate)                                                              | Number of INSERT-SELECT statement executions per second.*Shown as operation*                                                                                                                                                          |
| **alibabacloud.polardb.cluster_com_insert_select.maximum**(rate)                                                              | Number of INSERT-SELECT statement executions per second.*Shown as operation*                                                                                                                                                          |
| **alibabacloud.polardb.cluster_com_insert_select.minimum**(rate)                                                              | Number of INSERT-SELECT statement executions per second.*Shown as operation*                                                                                                                                                          |
| **alibabacloud.polardb.cluster_com_replace.average**(rate)                                                                     | Number of REPLACE statement executions per second.*Shown as operation*                                                                                                                                                                |
| **alibabacloud.polardb.cluster_com_replace.maximum**(rate)                                                                     | Number of REPLACE statement executions per second.*Shown as operation*                                                                                                                                                                |
| **alibabacloud.polardb.cluster_com_replace.minimum**(rate)                                                                     | Number of REPLACE statement executions per second.*Shown as operation*                                                                                                                                                                |
| **alibabacloud.polardb.cluster_com_replace_select.average**(rate)                                                             | Number of REPLACE-SELECT statement executions per second.*Shown as operation*                                                                                                                                                         |
| **alibabacloud.polardb.cluster_com_replace_select.maximum**(rate)                                                             | Number of REPLACE-SELECT statement executions per second.*Shown as operation*                                                                                                                                                         |
| **alibabacloud.polardb.cluster_com_replace_select.minimum**(rate)                                                             | Number of REPLACE-SELECT statement executions per second.*Shown as operation*                                                                                                                                                         |
| **alibabacloud.polardb.cluster_com_select.average**(rate)                                                                      | Number of SELECT statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_select.maximum**(rate)                                                                      | Number of SELECT statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_select.minimum**(rate)                                                                      | Number of SELECT statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_update.average**(rate)                                                                      | Number of UPDATE statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_update.maximum**(rate)                                                                      | Number of UPDATE statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_update.minimum**(rate)                                                                      | Number of UPDATE statement executions per second.*Shown as operation*                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_com_update_multi.average**(rate)                                                               | Number of multi-table UPDATE statement executions per second.*Shown as operation*                                                                                                                                                     |
| **alibabacloud.polardb.cluster_com_update_multi.maximum**(rate)                                                               | Number of multi-table UPDATE statement executions per second.*Shown as operation*                                                                                                                                                     |
| **alibabacloud.polardb.cluster_com_update_multi.minimum**(rate)                                                               | Number of multi-table UPDATE statement executions per second.*Shown as operation*                                                                                                                                                     |
| **alibabacloud.polardb.cluster_connection_utilization.average**(gauge)                                                         | Connection usage.*Shown as percent*                                                                                                                                                                                                   |
| **alibabacloud.polardb.cluster_connection_utilization.maximum**(gauge)                                                         | Connection usage.*Shown as percent*                                                                                                                                                                                                   |
| **alibabacloud.polardb.cluster_connection_utilization.minimum**(gauge)                                                         | Connection usage.*Shown as percent*                                                                                                                                                                                                   |
| **alibabacloud.polardb.cluster_cpu_utilization.average**(gauge)                                                                | CPU usage.*Shown as percent*                                                                                                                                                                                                          |
| **alibabacloud.polardb.cluster_cpu_utilization.maximum**(gauge)                                                                | CPU usage.*Shown as percent*                                                                                                                                                                                                          |
| **alibabacloud.polardb.cluster_created_tmp_disk_tables.average**(gauge)                                                      | Number of on-disk temporary tables created.*Shown as table*                                                                                                                                                                           |
| **alibabacloud.polardb.cluster_created_tmp_files.average**(gauge)                                                             | Number of temporary files created.*Shown as file*                                                                                                                                                                                     |
| **alibabacloud.polardb.cluster_data_io.average**(rate)                                                                         | Storage engine IO throughput per second.*Shown as byte*                                                                                                                                                                               |
| **alibabacloud.polardb.cluster_data_iops.average**(rate)                                                                       | Number of storage engine IO operations per second.*Shown as operation*                                                                                                                                                                |
| **alibabacloud.polardb.cluster_direntry_utilization.average**(gauge)                                                           | Directory entry usage.*Shown as percent*                                                                                                                                                                                              |
| **alibabacloud.polardb.cluster_disk_utilization.average**(gauge)                                                               | Disk usage.*Shown as percent*                                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_imci_datasize.average**(gauge)                                                                  | Amount of columnar index storage used by the IMCI node.*Shown as mebibyte*                                                                                                                                                            |
| **alibabacloud.polardb.cluster_imci_exememusage.average**(gauge)                                                               | Amount of memory used by the IMCI executor.*Shown as mebibyte*                                                                                                                                                                        |
| **alibabacloud.polardb.cluster_imci_stmtsexepersec.average**(rate)                                                             | Number of SQL queries processed by IMCI per second.*Shown as query*                                                                                                                                                                   |
| **alibabacloud.polardb.cluster_imci_stmtsinqueue.average**(gauge)                                                              | Number of SQL statements in the IMCI scheduling queue.*Shown as query*                                                                                                                                                                |
| **alibabacloud.polardb.cluster_imci_tmpfileusedsize.average**(gauge)                                                           | Size of temporary tables used by the IMCI executor.*Shown as mebibyte*                                                                                                                                                                |
| **alibabacloud.polardb.cluster_innodb_buffer_dirty_ratio.average**(gauge)                                                    | Buffer pool dirty page ratio.*Shown as percent*                                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_innodb_buffer_dirty_ratio.maximum**(gauge)                                                    | Buffer pool dirty page ratio.*Shown as percent*                                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_innodb_buffer_dirty_ratio.minimum**(gauge)                                                    | Buffer pool dirty page ratio.*Shown as percent*                                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_innodb_buffer_read_hit_rate.average**(gauge)                                                 | Buffer pool read hit ratio.*Shown as percent*                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_innodb_buffer_read_hit_rate.maximum**(gauge)                                                 | Buffer pool read hit ratio.*Shown as percent*                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_innodb_buffer_read_hit_rate.minimum**(gauge)                                                 | Buffer pool read hit ratio.*Shown as percent*                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_innodb_data_read_ps.average**(rate)                                                           | Amount of data read by the InnoDB engine per second.*Shown as byte*                                                                                                                                                                   |
| **alibabacloud.polardb.cluster_innodb_data_reads_ps.average**(rate)                                                          | Number of InnoDB engine I/O read requests per second.*Shown as operation*                                                                                                                                                             |
| **alibabacloud.polardb.cluster_innodb_data_writes_ps.average**(rate)                                                         | Number of InnoDB engine I/O write requests per second.*Shown as operation*                                                                                                                                                            |
| **alibabacloud.polardb.cluster_innodb_data_written_ps.average**(rate)                                                        | Amount of data written by the InnoDB engine per second.*Shown as byte*                                                                                                                                                                |
| **alibabacloud.polardb.cluster_innodb_repl_trx_wait_timeout.average**(gauge)                                                | Number of semi-synchronous transaction timeouts.*Shown as transaction*                                                                                                                                                                |
| **alibabacloud.polardb.cluster_innodb_row_lock_current_waits.average**(gauge)                                               | Number of threads currently waiting on table or row locks.*Shown as thread*                                                                                                                                                           |
| **alibabacloud.polardb.cluster_innodb_rows_deleted.average**(count)                                                           | Total number of rows deleted so far.*Shown as row*                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_innodb_rows_deleted_ps.average**(rate)                                                        | Number of rows deleted per second.*Shown as row*                                                                                                                                                                                      |
| **alibabacloud.polardb.cluster_innodb_rows_deleted_ps.sum**(rate)                                                            | Number of rows deleted per second.*Shown as row*                                                                                                                                                                                      |
| **alibabacloud.polardb.cluster_innodb_rows_inserted.average**(count)                                                          | Total number of rows inserted so far.*Shown as row*                                                                                                                                                                                   |
| **alibabacloud.polardb.cluster_innodb_rows_inserted_ps.average**(rate)                                                       | Number of rows inserted per second.*Shown as row*                                                                                                                                                                                     |
| **alibabacloud.polardb.cluster_innodb_rows_inserted_ps.sum**(rate)                                                           | Number of rows inserted per second.*Shown as row*                                                                                                                                                                                     |
| **alibabacloud.polardb.cluster_innodb_rows_read.average**(count)                                                              | Total number of rows read so far.*Shown as row*                                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_innodb_rows_read_ps.average**(rate)                                                           | Number of rows read per second.*Shown as row*                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_innodb_rows_read_ps.sum**(rate)                                                               | Number of rows read per second.*Shown as row*                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_innodb_rows_updated.average**(count)                                                           | Total number of rows updated so far.*Shown as row*                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_innodb_rows_updated_ps.average**(rate)                                                        | Number of rows updated per second.*Shown as row*                                                                                                                                                                                      |
| **alibabacloud.polardb.cluster_innodb_rows_updated_ps.sum**(rate)                                                            | Number of rows updated per second.*Shown as row*                                                                                                                                                                                      |
| **alibabacloud.polardb.cluster_inode_utilization.average**(gauge)                                                              | Inode usage.*Shown as percent*                                                                                                                                                                                                        |
| **alibabacloud.polardb.cluster_input_traffic.average**(rate)                                                                   | Network inbound traffic per second.*Shown as bit*                                                                                                                                                                                     |
| **alibabacloud.polardb.cluster_input_traffic.maximum**(rate)                                                                   | Network inbound traffic per second.*Shown as bit*                                                                                                                                                                                     |
| **alibabacloud.polardb.cluster_input_traffic.minimum**(rate)                                                                   | Network inbound traffic per second.*Shown as bit*                                                                                                                                                                                     |
| **alibabacloud.polardb.cluster_iops.average**(rate)                                                                             | Number of IO operations per second.*Shown as operation*                                                                                                                                                                               |
| **alibabacloud.polardb.cluster_iops_usage.average**(gauge)                                                                     | IOPS usage.*Shown as percent*                                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_iops_usage.maximum**(gauge)                                                                     | IOPS usage.*Shown as percent*                                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_iops_usage.minimum**(gauge)                                                                     | IOPS usage.*Shown as percent*                                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_mdl_lock_session.average**(gauge)                                                              | Number of connections blocked by MDL locks.*Shown as session*                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_mdl_lock_session.maximum**(gauge)                                                              | Number of connections blocked by MDL locks.*Shown as session*                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_mdl_lock_session.minimum**(gauge)                                                              | Number of connections blocked by MDL locks.*Shown as session*                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_mem_hit_ratio.average**(gauge)                                                                 | Memory hit ratio.*Shown as percent*                                                                                                                                                                                                   |
| **alibabacloud.polardb.cluster_memory_utilization.average**(gauge)                                                             | Memory usage.*Shown as percent*                                                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_memory_utilization.maximum**(gauge)                                                             | Memory usage.*Shown as percent*                                                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_mps.average**(rate)                                                                              | Number of data operations per second.*Shown as operation*                                                                                                                                                                             |
| **alibabacloud.polardb.cluster_mps.maximum**(rate)                                                                              | Number of data operations per second.*Shown as operation*                                                                                                                                                                             |
| **alibabacloud.polardb.cluster_mps.minimum**(rate)                                                                              | Number of data operations per second.*Shown as operation*                                                                                                                                                                             |
| **alibabacloud.polardb.cluster_open_files.average**(gauge)                                                                     | Number of open files.*Shown as file*                                                                                                                                                                                                  |
| **alibabacloud.polardb.cluster_other_lock_session.average**(gauge)                                                            | Number of connections blocked by other locks.*Shown as session*                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_other_lock_session.maximum**(gauge)                                                            | Number of connections blocked by other locks.*Shown as session*                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_other_lock_session.minimum**(gauge)                                                            | Number of connections blocked by other locks.*Shown as session*                                                                                                                                                                       |
| **alibabacloud.polardb.cluster_output_traffic.average**(rate)                                                                  | Network outbound traffic per second.*Shown as bit*                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_output_traffic.maximum**(rate)                                                                  | Network outbound traffic per second.*Shown as bit*                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_output_traffic.minimum**(rate)                                                                  | Network outbound traffic per second.*Shown as bit*                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_pcu_by_cpu_cores.average**(gauge)                                                             | Management unit for elastic resource scaling in a PolarDB Serverless cluster; the minimum scaling increment is 0.5 PCU.*Shown as core*                                                                                                |
| **alibabacloud.polardb.cluster_pcu_by_cpu_cores.maximum**(gauge)                                                             | Management unit for elastic resource scaling in a PolarDB Serverless cluster; the minimum scaling increment is 0.5 PCU.*Shown as core*                                                                                                |
| **alibabacloud.polardb.cluster_pcu_by_cpu_cores.minimum**(gauge)                                                             | Management unit for elastic resource scaling in a PolarDB Serverless cluster; the minimum scaling increment is 0.5 PCU.*Shown as core*                                                                                                |
| **alibabacloud.polardb.cluster_prepared_stmt_count.average**(gauge)                                                           | Number of prepared statements.*Shown as command*                                                                                                                                                                                      |
| **alibabacloud.polardb.cluster_prepared_stmt_count.maximum**(gauge)                                                           | Number of prepared statements.*Shown as command*                                                                                                                                                                                      |
| **alibabacloud.polardb.cluster_prepared_stmt_count.minimum**(gauge)                                                           | Number of prepared statements.*Shown as command*                                                                                                                                                                                      |
| **alibabacloud.polardb.cluster_prepared_stmt_utilization.average**(gauge)                                                     | Prepared statement usage ratio.*Shown as percent*                                                                                                                                                                                     |
| **alibabacloud.polardb.cluster_prepared_stmt_utilization.maximum**(gauge)                                                     | Prepared statement usage ratio.*Shown as percent*                                                                                                                                                                                     |
| **alibabacloud.polardb.cluster_prepared_stmt_utilization.minimum**(gauge)                                                     | Prepared statement usage ratio.*Shown as percent*                                                                                                                                                                                     |
| **alibabacloud.polardb.cluster_proxy_cpu_utilization.average**(gauge)                                                         | Proxy CPU usage.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_proxy_cpu_utilization.maximum**(gauge)                                                         | Proxy CPU usage.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_proxy_cpu_utilization.minimum**(gauge)                                                         | Proxy CPU usage.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_qps.average**(rate)                                                                              | Number of queries per second.*Shown as query*                                                                                                                                                                                         |
| **alibabacloud.polardb.cluster_redo_write_rate.average**(rate)                                                                | Redo log write rate.*Shown as byte*                                                                                                                                                                                                   |
| **alibabacloud.polardb.cluster_replica_lag.average**(gauge)                                                                    | Replication delay of the read-only node.*Shown as second*                                                                                                                                                                             |
| **alibabacloud.polardb.cluster_replica_lag.maximum**(gauge)                                                                    | Replication delay of the read-only node.*Shown as second*                                                                                                                                                                             |
| **alibabacloud.polardb.cluster_replica_lag.minimum**(gauge)                                                                    | Replication delay of the read-only node.*Shown as second*                                                                                                                                                                             |
| **alibabacloud.polardb.cluster_select_scan.average**(rate)                                                                     | Number of scan queries per second.*Shown as operation*                                                                                                                                                                                |
| **alibabacloud.polardb.cluster_slow_queries_ps.average**(rate)                                                                | Number of slow queries per second.*Shown as query*                                                                                                                                                                                    |
| **alibabacloud.polardb.cluster_sort_scan.average**(rate)                                                                       | Number of sort queries per second.*Shown as operation*                                                                                                                                                                                |
| **alibabacloud.polardb.cluster_storage_soft_limit.average**(gauge)                                                            | Prepaid storage capacity of the PolarStore instance.*Shown as mebibyte*                                                                                                                                                               |
| **alibabacloud.polardb.cluster_table_open_cache_overflows.average**(gauge)                                                   | Number of table open cache overflows.*Shown as table*                                                                                                                                                                                 |
| **alibabacloud.polardb.cluster_total_session.average**(gauge)                                                                  | Current total number of connections.*Shown as session*                                                                                                                                                                                |
| **alibabacloud.polardb.cluster_total_session.maximum**(gauge)                                                                  | Current total number of connections.*Shown as session*                                                                                                                                                                                |
| **alibabacloud.polardb.cluster_total_session.minimum**(gauge)                                                                  | Current total number of connections.*Shown as session*                                                                                                                                                                                |
| **alibabacloud.polardb.cluster_tps.average**(rate)                                                                              | Number of transactions per second.*Shown as transaction*                                                                                                                                                                              |
| **alibabacloud.polardb.commits_delta.average**(rate)                                                                            | Number of transaction commits per second.*Shown as transaction*                                                                                                                                                                       |
| **alibabacloud.polardb.conn_usage.average**(gauge)                                                                              | Ratio of currently used connections to the maximum number of connections.*Shown as percent*                                                                                                                                           |
| **alibabacloud.polardb.connections.average**(gauge)                                                                              | Total number of connections.*Shown as connection*                                                                                                                                                                                     |
| **alibabacloud.polardb.cpu_total.average**(gauge)                                                                               | CPU usage.*Shown as percent*                                                                                                                                                                                                          |
| **alibabacloud.polardb.db_age.average**(gauge)                                                                                  | Transaction ID age of the database, used to monitor progress toward transaction ID wraparound.*Shown as transaction*                                                                                                                  |
| **alibabacloud.polardb.deadlocks_delta.average**(rate)                                                                          | Number of deadlocks that occur per second.*Shown as lock*                                                                                                                                                                             |
| **alibabacloud.polardb.disk_used.average**(gauge)                                                                               | Usage ratio of the PolarStore instance's prepaid storage capacity.*Shown as percent*                                                                                                                                                  |
| **alibabacloud.polardb.five_seconds_executing_sqls.average**(gauge)                                                           | Number of SQL statements that have run for 5 seconds.*Shown as query*                                                                                                                                                                 |
| **alibabacloud.polardb.five_seconds_long_transactions.average**(gauge)                                                        | Number of transactions that have run for 5 seconds.*Shown as transaction*                                                                                                                                                             |
| **alibabacloud.polardb.host_sys_cpu_usage.value**(gauge)                                                                      | CPU usage.*Shown as percent*                                                                                                                                                                                                          |
| **alibabacloud.polardb.host_sys_mem_usage.value**(gauge)                                                                      | Memory usage.*Shown as percent*                                                                                                                                                                                                       |
| **alibabacloud.polardb.host_sys_memory_usage.value**(gauge)                                                                   | GPU memory usage.*Shown as percent*                                                                                                                                                                                                   |
| **alibabacloud.polardb.idle_connections.average**(gauge)                                                                        | Number of idle connections.*Shown as connection*                                                                                                                                                                                      |
| **alibabacloud.polardb.innodb_row_lock_current_waits.average**(gauge)                                                        | Number of threads currently waiting on table or row locks.*Shown as thread*                                                                                                                                                           |
| **alibabacloud.polardb.innodb_rows_deleted.average**(count)                                                                    | Total number of rows deleted so far.*Shown as row*                                                                                                                                                                                    |
| **alibabacloud.polardb.innodb_rows_inserted.average**(count)                                                                   | Total number of rows inserted so far.*Shown as row*                                                                                                                                                                                   |
| **alibabacloud.polardb.innodb_rows_read.average**(count)                                                                       | Total number of rows read so far.*Shown as row*                                                                                                                                                                                       |
| **alibabacloud.polardb.innodb_rows_updated.average**(count)                                                                    | Total number of rows updated so far.*Shown as row*                                                                                                                                                                                    |
| **alibabacloud.polardb.max_executing_sql_last_time.average**(gauge)                                                          | Longest execution time among currently running SQL statements.*Shown as second*                                                                                                                                                       |
| **alibabacloud.polardb.mem_usage.average**(gauge)                                                                               | Memory usage.*Shown as percent*                                                                                                                                                                                                       |
| **alibabacloud.polardb.mysql_monitoring_active_session.average**(gauge)                                                       | Number of active connections.*Shown as session*                                                                                                                                                                                       |
| **alibabacloud.polardb.mysql_monitoring_com_delete_ps.average**(rate)                                                        | Number of DELETE statements per second.*Shown as operation*                                                                                                                                                                           |
| **alibabacloud.polardb.mysql_monitoring_cpu_usage.average**(gauge)                                                            | CPU usage.*Shown as percent*                                                                                                                                                                                                          |
| **alibabacloud.polardb.mysql_monitoring_created_tmp_disk_tables_ps.average**(rate)                                         | Number of temporary tables created per second.*Shown as table*                                                                                                                                                                        |
| **alibabacloud.polardb.mysql_monitoring_innodb_orca_cmd_avg_latency.average**(gauge)                                       | Average latency of executed commands.*Shown as microsecond*                                                                                                                                                                           |
| **alibabacloud.polardb.mysql_monitoring_innodb_orca_dbsize.average**(gauge)                                                  | Number of keys.*Shown as key*                                                                                                                                                                                                         |
| **alibabacloud.polardb.mysql_monitoring_innodb_rows_deleted_ps.average**(rate)                                              | Number of rows deleted per second.*Shown as row*                                                                                                                                                                                      |
| **alibabacloud.polardb.mysql_monitoring_innodb_rows_inserted_ps.average**(rate)                                             | Number of rows inserted per second.*Shown as row*                                                                                                                                                                                     |
| **alibabacloud.polardb.mysql_monitoring_innodb_rows_read_ps.average**(rate)                                                 | Number of rows read per second.*Shown as row*                                                                                                                                                                                         |
| **alibabacloud.polardb.mysql_monitoring_innodb_rows_updated_ps.average**(rate)                                              | Number of rows updated per second.*Shown as row*                                                                                                                                                                                      |
| **alibabacloud.polardb.mysql_monitoring_input_traffic_ps.average**(rate)                                                     | Inbound traffic per second.*Shown as bit*                                                                                                                                                                                             |
| **alibabacloud.polardb.mysql_monitoring_iops_r.average**(rate)                                                                | Read IOPS.*Shown as operation*                                                                                                                                                                                                        |
| **alibabacloud.polardb.mysql_monitoring_iops_throughout_r.average**(rate)                                                    | Read I/O throughput.*Shown as byte*                                                                                                                                                                                                   |
| **alibabacloud.polardb.mysql_monitoring_iops_throughout_w.average**(rate)                                                    | Write I/O throughput.*Shown as byte*                                                                                                                                                                                                  |
| **alibabacloud.polardb.mysql_monitoring_iops_w.average**(rate)                                                                | Write IOPS.*Shown as operation*                                                                                                                                                                                                       |
| **alibabacloud.polardb.mysql_monitoring_mem_usage.average**(gauge)                                                            | Memory usage.*Shown as percent*                                                                                                                                                                                                       |
| **alibabacloud.polardb.mysql_monitoring_mps.average**(rate)                                                                    | Number of operations per second.*Shown as operation*                                                                                                                                                                                  |
| **alibabacloud.polardb.mysql_monitoring_output_traffic_ps.average**(rate)                                                    | Outbound traffic per second.*Shown as bit*                                                                                                                                                                                            |
| **alibabacloud.polardb.mysql_monitoring_queries_ps.average**(rate)                                                            | Total number of SQL statements executed per second.*Shown as query*                                                                                                                                                                   |
| **alibabacloud.polardb.mysql_monitoring_replica_lag.average**(gauge)                                                          | Replication delay of the read-only node behind the read-write node.*Shown as second*                                                                                                                                                  |
| **alibabacloud.polardb.mysql_monitoring_replica_lag_ms.average**(gauge)                                                      | Replication delay of the read-only node behind the read-write node.*Shown as millisecond*                                                                                                                                             |
| **alibabacloud.polardb.mysql_monitoring_thread_pool_running_threads.average**(gauge)                                        | Number of threads currently running in the thread pool.*Shown as thread*                                                                                                                                                              |
| **alibabacloud.polardb.mysql_monitoring_total_session.average**(gauge)                                                        | Current total number of connections.*Shown as session*                                                                                                                                                                                |
| **alibabacloud.polardb.mysql_monitoring_tp_thread_count.average**(gauge)                                                     | Total number of threads in the thread pool.*Shown as thread*                                                                                                                                                                          |
| **alibabacloud.polardb.mysql_monitoring_tps.average**(rate)                                                                    | Number of transactions per second.*Shown as transaction*                                                                                                                                                                              |
| **alibabacloud.polardb.one_second_executing_sqls.average**(gauge)                                                             | Number of SQL statements that have run for 1 second.*Shown as query*                                                                                                                                                                  |
| **alibabacloud.polardb.one_second_transactions.average**(gauge)                                                                | Number of transactions that have run for 1 second.*Shown as transaction*                                                                                                                                                              |
| **alibabacloud.polardb.opensearch_cluster_status.value**(gauge)                                                                | Cluster status.*Shown as item*                                                                                                                                                                                                        |
| **alibabacloud.polardb.opensearch_flink_jobmanager_job_num_restarts.value**(gauge)                                          | Number of times the sync job restarted.*Shown as event*                                                                                                                                                                               |
| **alibabacloud.polardb.opensearch_flink_jobmanager_job_number_of_completed_checkpoints.value**(gauge)                     | Number of checkpoints completed by the job.*Shown as event*                                                                                                                                                                           |
| **alibabacloud.polardb.opensearch_flink_jobmanager_job_operator_coordinator_enumerator_is_binlog_reading.value**(gauge) | Whether the data source is in the incremental (binlog reading) phase. 0 indicates it is not in the incremental phase, otherwise it is.*Shown as item*                                                                                 |
| **alibabacloud.polardb.opensearch_flink_taskmanager_job_task_operator_current_emit_event_time_lag.value**(gauge)       | Business latency, calculated as the time the data left the source (EmitTime) minus the data's event time (EventTime).*Shown as millisecond*                                                                                           |
| **alibabacloud.polardb.opensearch_flink_taskmanager_job_task_operator_sink_num_records_out_per_second.value**(rate)   | Number of records output per second at the sink (total records output by each operator, excluding intermediate operators, divided by time in seconds; supported in Flink 1.13+).*Shown as record*                                     |
| **alibabacloud.polardb.opensearch_flink_taskmanager_job_task_operator_source_num_records_in_per_second.value**(rate)  | Number of records input per second at the source (total records input by each operator, excluding intermediate operators, divided by time in seconds).*Shown as record*                                                               |
| **alibabacloud.polardb.opensearch_http_open_server_number.average**(gauge)                                                   | Number of HTTP connections.*Shown as connection*                                                                                                                                                                                      |
| **alibabacloud.polardb.opensearch_http_open_server_number.maximum**(gauge)                                                   | Number of HTTP connections.*Shown as connection*                                                                                                                                                                                      |
| **alibabacloud.polardb.opensearch_http_open_server_number.minimum**(gauge)                                                   | Number of HTTP connections.*Shown as connection*                                                                                                                                                                                      |
| **alibabacloud.polardb.opensearch_indices_doc_deleted_number.average**(gauge)                                                | Number of documents deleted.*Shown as document*                                                                                                                                                                                       |
| **alibabacloud.polardb.opensearch_indices_doc_deleted_number_cluster.value**(gauge)                                         | Total number of documents deleted across the cluster.*Shown as document*                                                                                                                                                              |
| **alibabacloud.polardb.opensearch_indices_doc_number.average**(gauge)                                                         | Number of documents.*Shown as document*                                                                                                                                                                                               |
| **alibabacloud.polardb.opensearch_indices_doc_number_cluster.value**(gauge)                                                  | Total number of documents in the cluster.*Shown as document*                                                                                                                                                                          |
| **alibabacloud.polardb.opensearch_indices_fetch_latency_node.value**(gauge)                                                  | Node fetch latency.*Shown as microsecond*                                                                                                                                                                                             |
| **alibabacloud.polardb.opensearch_indices_flush_rate.value**(rate)                                                            | Flush rate.*Shown as operation*                                                                                                                                                                                                       |
| **alibabacloud.polardb.opensearch_indices_get_latency_node.value**(gauge)                                                    | Node get latency.*Shown as microsecond*                                                                                                                                                                                               |
| **alibabacloud.polardb.opensearch_indices_get_rate_cluster.value**(rate)                                                     | Cluster get rate.*Shown as request*                                                                                                                                                                                                   |
| **alibabacloud.polardb.opensearch_indices_get_rate_node.value**(rate)                                                        | Node get rate.*Shown as request*                                                                                                                                                                                                      |
| **alibabacloud.polardb.opensearch_indices_indexing_delete_latency_node.value**(gauge)                                       | Node delete latency.*Shown as microsecond*                                                                                                                                                                                            |
| **alibabacloud.polardb.opensearch_indices_indexing_delete_rate_cluster.value**(rate)                                        | Cluster delete rate.*Shown as operation*                                                                                                                                                                                              |
| **alibabacloud.polardb.opensearch_indices_indexing_delete_rate_node.value**(rate)                                           | Node delete rate.*Shown as operation*                                                                                                                                                                                                 |
| **alibabacloud.polardb.opensearch_indices_indexing_index_rate_cluster.value**(rate)                                         | Cluster indexing rate.*Shown as operation*                                                                                                                                                                                            |
| **alibabacloud.polardb.opensearch_indices_indexing_index_rate_node.value**(rate)                                            | Node indexing rate.*Shown as operation*                                                                                                                                                                                               |
| **alibabacloud.polardb.opensearch_indices_indexing_latency_node.value**(gauge)                                               | Node indexing latency.*Shown as microsecond*                                                                                                                                                                                          |
| **alibabacloud.polardb.opensearch_indices_merge_rate.value**(rate)                                                            | Merge rate.*Shown as operation*                                                                                                                                                                                                       |
| **alibabacloud.polardb.opensearch_indices_querycache_evictions_rate.value**(rate)                                            | Query cache eviction rate.*Shown as event*                                                                                                                                                                                            |
| **alibabacloud.polardb.opensearch_indices_querycache_hit_ratio.value**(gauge)                                                | Query cache hit ratio.*Shown as percent*                                                                                                                                                                                              |
| **alibabacloud.polardb.opensearch_indices_refresh_rate.value**(rate)                                                          | Refresh rate.*Shown as operation*                                                                                                                                                                                                     |
| **alibabacloud.polardb.opensearch_indices_requestcache_evictions_rate.value**(rate)                                          | Request cache eviction rate.*Shown as event*                                                                                                                                                                                          |
| **alibabacloud.polardb.opensearch_indices_requestcache_hit_ratio.value**(gauge)                                              | Request cache hit ratio.*Shown as percent*                                                                                                                                                                                            |
| **alibabacloud.polardb.opensearch_indices_search_fetch_rate_cluster.value**(rate)                                           | Cluster document fetch rate.*Shown as request*                                                                                                                                                                                        |
| **alibabacloud.polardb.opensearch_indices_search_fetch_rate_node.value**(rate)                                              | Node document fetch rate.*Shown as request*                                                                                                                                                                                           |
| **alibabacloud.polardb.opensearch_indices_search_latency_node.value**(gauge)                                                 | Node search latency.*Shown as microsecond*                                                                                                                                                                                            |
| **alibabacloud.polardb.opensearch_indices_search_query_rate_cluster.value**(rate)                                           | Cluster query rate.*Shown as query*                                                                                                                                                                                                   |
| **alibabacloud.polardb.opensearch_indices_search_query_rate_node.value**(rate)                                              | Node query rate.*Shown as query*                                                                                                                                                                                                      |
| **alibabacloud.polardb.opensearch_indices_store_size_bytes_cluster.value**(gauge)                                           | Total index storage space used by the cluster.*Shown as byte*                                                                                                                                                                         |
| **alibabacloud.polardb.opensearch_jvm_gc_collection_rate.value**(rate)                                                       | JVM garbage collection rate.*Shown as event*                                                                                                                                                                                          |
| **alibabacloud.polardb.opensearch_jvm_gc_collection_time_ps.value**(gauge)                                                  | JVM garbage collection time per second.*Shown as fraction*                                                                                                                                                                            |
| **alibabacloud.polardb.opensearch_jvm_mem_heap_used_percent.average**(gauge)                                                | JVM heap memory usage.*Shown as percent*                                                                                                                                                                                              |
| **alibabacloud.polardb.opensearch_jvm_mem_heap_used_percent.maximum**(gauge)                                                | JVM heap memory usage.*Shown as percent*                                                                                                                                                                                              |
| **alibabacloud.polardb.opensearch_jvm_mem_heap_used_percent.minimum**(gauge)                                                | JVM heap memory usage.*Shown as percent*                                                                                                                                                                                              |
| **alibabacloud.polardb.opensearch_os_mem_used_percent.value**(gauge)                                                         | Memory usage.*Shown as percent*                                                                                                                                                                                                       |
| **alibabacloud.polardb.opensearch_process_cpu_percent.average**(gauge)                                                        | CPU utilization.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.opensearch_process_cpu_percent.maximum**(gauge)                                                        | CPU utilization.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.opensearch_process_cpu_percent.minimum**(gauge)                                                        | CPU utilization.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.opensearch_store_iobw_r.value**(rate)                                                                  | Read bandwidth.*Shown as byte*                                                                                                                                                                                                        |
| **alibabacloud.polardb.opensearch_store_iobw_w.value**(rate)                                                                  | Write bandwidth.*Shown as byte*                                                                                                                                                                                                       |
| **alibabacloud.polardb.opensearch_store_iops_r.value**(rate)                                                                  | Read IOPS.*Shown as operation*                                                                                                                                                                                                        |
| **alibabacloud.polardb.opensearch_store_iops_w.value**(rate)                                                                  | Write IOPS.*Shown as operation*                                                                                                                                                                                                       |
| **alibabacloud.polardb.oracle_connections.average**(gauge)                                                                      | Total number of connections.*Shown as connection*                                                                                                                                                                                     |
| **alibabacloud.polardb.oracle_idle_connections.average**(gauge)                                                                | Number of idle connections.*Shown as connection*                                                                                                                                                                                      |
| **alibabacloud.polardb.oracle_inactive_slots.average**(gauge)                                                                  | Number of inactive Oracle replication slots.*Shown as item*                                                                                                                                                                           |
| **alibabacloud.polardb.oracle_max_slot_wal_delay_in_mb.average**(gauge)                                                    | Maximum WAL delay among all Oracle replication slots.*Shown as mebibyte*                                                                                                                                                              |
| **alibabacloud.polardb.oracle_pcu_cpu_cores_usage.average**(gauge)                                                           | Oracle PCU usage.*Shown as percent*                                                                                                                                                                                                   |
| **alibabacloud.polardb.oracle_pls_blk_usage.average**(gauge)                                                                  | PFS block usage.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.oracle_pls_data_size_usage.average**(gauge)                                                           | PFS data size usage.*Shown as percent*                                                                                                                                                                                                |
| **alibabacloud.polardb.oracle_pls_inode_usage.average**(gauge)                                                                | PFS inode usage.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.oracle_pls_iops_usage.average**(gauge)                                                                 | Oracle shared storage IOPS usage.*Shown as percent*                                                                                                                                                                                   |
| **alibabacloud.polardb.pfs2_acc_blockcache_bytes.average**(gauge)                                                             | Amount of space occupied by the cache.*Shown as byte*                                                                                                                                                                                 |
| **alibabacloud.polardb.pfs2_acc_cpu_usage.average**(gauge)                                                                    | Client CPU usage.*Shown as percent*                                                                                                                                                                                                   |
| **alibabacloud.polardb.pfs2_acc_memory.average**(gauge)                                                                        | Amount of memory used by the client.*Shown as byte*                                                                                                                                                                                   |
| **alibabacloud.polardb.pfs2_acc_objectfs_read_bytes_total.average**(rate)                                                   | Client read bandwidth.*Shown as byte*                                                                                                                                                                                                 |
| **alibabacloud.polardb.pfs2_acc_objectfs_read_bytes_total_all.value**(rate)                                                | Total client read bandwidth.*Shown as byte*                                                                                                                                                                                           |
| **alibabacloud.polardb.pfs2_acc_objectfs_read_latency_seconds.average**(gauge)                                              | Client read latency.*Shown as second*                                                                                                                                                                                                 |
| **alibabacloud.polardb.pfs2_acc_objectfs_read_ops_total.average**(rate)                                                     | Client read IOPS.*Shown as operation*                                                                                                                                                                                                 |
| **alibabacloud.polardb.pfs2_acc_objectfs_read_ops_total_all.value**(rate)                                                  | Total client read IOPS.*Shown as operation*                                                                                                                                                                                           |
| **alibabacloud.polardb.pfs2_acc_objectfs_write_bytes_total.average**(rate)                                                  | Client write bandwidth.*Shown as byte*                                                                                                                                                                                                |
| **alibabacloud.polardb.pfs2_acc_objectfs_write_bytes_total_all.value**(rate)                                               | Total client write bandwidth.*Shown as byte*                                                                                                                                                                                          |
| **alibabacloud.polardb.pfs2_acc_objectfs_write_latency_seconds.average**(gauge)                                             | Client write latency.*Shown as second*                                                                                                                                                                                                |
| **alibabacloud.polardb.pfs2_acc_objectfs_write_ops_total.average**(rate)                                                    | Client write IOPS.*Shown as operation*                                                                                                                                                                                                |
| **alibabacloud.polardb.pfs2_acc_objectfs_write_ops_total_all.value**(rate)                                                 | Total client write IOPS.*Shown as operation*                                                                                                                                                                                          |
| **alibabacloud.polardb.pfs2_acc_origin_oss_request_iobw.value**(rate)                                                       | OSS origin-fetch bandwidth.*Shown as byte*                                                                                                                                                                                            |
| **alibabacloud.polardb.pfs2_acc_osscache_block_hit_bytes_ratio.average**(gauge)                                            | Cache bandwidth hit ratio.*Shown as percent*                                                                                                                                                                                          |
| **alibabacloud.polardb.pfs2_acc_osscache_block_hits_ratio.average**(gauge)                                                  | Cache hit ratio by request count.*Shown as percent*                                                                                                                                                                                   |
| **alibabacloud.polardb.pfs2_acc_osscache_head_hit_latency.average**(gauge)                                                  | Average latency of cache HEAD hits.*Shown as millisecond*                                                                                                                                                                             |
| **alibabacloud.polardb.pfs2_acc_osscache_head_miss_latency.average**(gauge)                                                 | Average latency of cache HEAD misses.*Shown as millisecond*                                                                                                                                                                           |
| **alibabacloud.polardb.pfs2_acc_osscache_oss_request_latency_seconds.average**(gauge)                                      | Average latency of OSS GET requests.*Shown as second*                                                                                                                                                                                 |
| **alibabacloud.polardb.pfs2_acc_s3gateway_request_iobw.value**(rate)                                                         | S3 Gateway bandwidth.*Shown as byte*                                                                                                                                                                                                  |
| **alibabacloud.polardb.pfs2_acc_s3gateway_request_latency.value**(gauge)                                                     | S3 Gateway latency.*Shown as millisecond*                                                                                                                                                                                             |
| **alibabacloud.polardb.pfs2_acc_s3gateway_request_qps.value**(rate)                                                          | S3 Gateway queries per second.*Shown as query*                                                                                                                                                                                        |
| **alibabacloud.polardb.pfs2_acc_uptime.average**(gauge)                                                                        | Uptime.*Shown as second*                                                                                                                                                                                                              |
| **alibabacloud.polardb.pfs2_blockcache_bytes.value**(gauge)                                                                    | Amount of cached data.*Shown as byte*                                                                                                                                                                                                 |
| **alibabacloud.polardb.pfs2_blockcache_count.value**(gauge)                                                                    | Cache hit ratio (count).*Shown as percent*                                                                                                                                                                                            |
| **alibabacloud.polardb.pfs2_blockcache_rate.value**(gauge)                                                                     | Cache hit ratio (bandwidth).*Shown as percent*                                                                                                                                                                                        |
| **alibabacloud.polardb.pfs2_cpu_usage.value**(gauge)                                                                           | Client CPU usage.*Shown as percent*                                                                                                                                                                                                   |
| **alibabacloud.polardb.pfs2_distributed_cache_get_latency_seconds_count.value**(rate)                                      | Number of cache GET requests.*Shown as request*                                                                                                                                                                                       |
| **alibabacloud.polardb.pfs2_distributed_cache_put_latency_seconds_count.value**(rate)                                      | Number of cache PUT requests.*Shown as request*                                                                                                                                                                                       |
| **alibabacloud.polardb.pfs2_fuse_ops_flush_total.value**(rate)                                                               | Client flush IOPS.*Shown as operation*                                                                                                                                                                                                |
| **alibabacloud.polardb.pfs2_fuse_ops_read_total.value**(rate)                                                                | Client read IOPS.*Shown as operation*                                                                                                                                                                                                 |
| **alibabacloud.polardb.pfs2_fuse_ops_write_total.value**(rate)                                                               | Client write IOPS.*Shown as operation*                                                                                                                                                                                                |
| **alibabacloud.polardb.pfs2_fuse_read_size_bytes_sum.value**(rate)                                                          | Client read bandwidth.*Shown as byte*                                                                                                                                                                                                 |
| **alibabacloud.polardb.pfs2_fuse_written_size_bytes_sum.value**(rate)                                                       | Client write bandwidth.*Shown as byte*                                                                                                                                                                                                |
| **alibabacloud.polardb.pfs2_memory.value**(gauge)                                                                               | Client memory usage.*Shown as byte*                                                                                                                                                                                                   |
| **alibabacloud.polardb.pfs2_object_delete_request_durations_histogram_seconds_count.value**(rate)                         | Number of OSS DELETE IOPS.*Shown as request*                                                                                                                                                                                          |
| **alibabacloud.polardb.pfs2_object_get_request_durations_histogram_get_seconds_count.value**(rate)                       | Cache node OSS GET IOPS.*Shown as request*                                                                                                                                                                                            |
| **alibabacloud.polardb.pfs2_object_put_request_durations_histogram_seconds_count.value**(rate)                            | Number of OSS PUT IOPS.*Shown as request*                                                                                                                                                                                             |
| **alibabacloud.polardb.pfs2_object_request_client_get_data_bytes.value**(rate)                                             | Client GET bandwidth.*Shown as byte*                                                                                                                                                                                                  |
| **alibabacloud.polardb.pfs2_object_request_client_put_data_bytes.value**(rate)                                             | OSS PUT bandwidth.*Shown as byte*                                                                                                                                                                                                     |
| **alibabacloud.polardb.pfs2_object_request_node_get_data_bytes.value**(rate)                                               | Cache node OSS GET bandwidth.*Shown as byte*                                                                                                                                                                                          |
| **alibabacloud.polardb.pfs2_transaction_total.value**(rate)                                                                    | Number of metadata engine operations.*Shown as transaction*                                                                                                                                                                           |
| **alibabacloud.polardb.pfs2_uptime.value**(gauge)                                                                               | Uptime.*Shown as second*                                                                                                                                                                                                              |
| **alibabacloud.polardb.pfs2_used_inodes.value**(gauge)                                                                         | Number of files and directories.*Shown as file*                                                                                                                                                                                       |
| **alibabacloud.polardb.pfs2_used_space.value**(gauge)                                                                          | Amount of data.*Shown as byte*                                                                                                                                                                                                        |
| **alibabacloud.polardb.pg_active_connections.average**(gauge)                                                                  | Number of active connections on the current instance.*Shown as connection*                                                                                                                                                            |
| **alibabacloud.polardb.pg_blks_read_delta.average**(rate)                                                                     | Number of data blocks read per second.*Shown as block*                                                                                                                                                                                |
| **alibabacloud.polardb.pg_commits_delta.average**(rate)                                                                        | Number of transaction commits per second.*Shown as transaction*                                                                                                                                                                       |
| **alibabacloud.polardb.pg_conn_usage.average**(gauge)                                                                          | Ratio of currently used connections to the maximum number of connections.*Shown as percent*                                                                                                                                           |
| **alibabacloud.polardb.pg_cpu_total.average**(gauge)                                                                           | CPU usage.*Shown as percent*                                                                                                                                                                                                          |
| **alibabacloud.polardb.pg_db_age.average**(gauge)                                                                              | Transaction ID age of the database, used to monitor progress toward transaction ID wraparound.*Shown as transaction*                                                                                                                  |
| **alibabacloud.polardb.pg_deadlocks_delta.average**(rate)                                                                      | Number of deadlocks that occur per second.*Shown as lock*                                                                                                                                                                             |
| **alibabacloud.polardb.pg_five_seconds_executing_sqls.average**(gauge)                                                       | Number of PostgreSQL SQL statements that have run for 5 seconds.*Shown as query*                                                                                                                                                      |
| **alibabacloud.polardb.pg_five_seconds_long_transactions.average**(gauge)                                                    | Number of PostgreSQL transactions that have run for 5 seconds.*Shown as transaction*                                                                                                                                                  |
| **alibabacloud.polardb.pg_inactive_slots.average**(gauge)                                                                      | Number of inactive PostgreSQL replication slots.*Shown as item*                                                                                                                                                                       |
| **alibabacloud.polardb.pg_max_executing_sql_last_time.average**(gauge)                                                      | Longest execution time among currently running SQL statements.*Shown as second*                                                                                                                                                       |
| **alibabacloud.polardb.pg_max_slot_wal_delay_in_mb.average**(gauge)                                                        | Maximum WAL delay among all PostgreSQL replication slots.*Shown as mebibyte*                                                                                                                                                          |
| **alibabacloud.polardb.pg_mem_usage.average**(gauge)                                                                           | Memory usage.*Shown as percent*                                                                                                                                                                                                       |
| **alibabacloud.polardb.pg_one_second_executing_sqls.average**(gauge)                                                         | Number of PostgreSQL SQL statements that have run for 1 second.*Shown as query*                                                                                                                                                       |
| **alibabacloud.polardb.pg_one_second_transactions.average**(gauge)                                                            | Number of PostgreSQL transactions that have run for 1 second.*Shown as transaction*                                                                                                                                                   |
| **alibabacloud.polardb.pg_pcu_cpu_cores_usage.average**(gauge)                                                               | PostgreSQL PCU usage.*Shown as percent*                                                                                                                                                                                               |
| **alibabacloud.polardb.pg_pls_data_size.value**(gauge)                                                                        | Data disk size.*Shown as mebibyte*                                                                                                                                                                                                    |
| **alibabacloud.polardb.pg_pls_iops.average**(rate)                                                                             | Number of IO operations per second.*Shown as operation*                                                                                                                                                                               |
| **alibabacloud.polardb.pg_pls_iops_read.average**(rate)                                                                       | Number of read IO operations per second.*Shown as operation*                                                                                                                                                                          |
| **alibabacloud.polardb.pg_pls_iops_usage.average**(gauge)                                                                     | PostgreSQL shared storage IOPS usage.*Shown as percent*                                                                                                                                                                               |
| **alibabacloud.polardb.pg_pls_iops_write.average**(rate)                                                                      | Number of write IO operations per second.*Shown as operation*                                                                                                                                                                         |
| **alibabacloud.polardb.pg_pls_pg_wal_dir_size.value**(gauge)                                                                | Size of the WAL log.*Shown as mebibyte*                                                                                                                                                                                               |
| **alibabacloud.polardb.pg_pls_throughput.average**(rate)                                                                       | IO throughput.*Shown as byte*                                                                                                                                                                                                         |
| **alibabacloud.polardb.pg_pls_throughput_read.average**(rate)                                                                 | Read operation IO throughput.*Shown as byte*                                                                                                                                                                                          |
| **alibabacloud.polardb.pg_pls_throughput_write.average**(rate)                                                                | Write operation IO throughput.*Shown as byte*                                                                                                                                                                                         |
| **alibabacloud.polardb.pg_qps_delta.average**(rate)                                                                            | Number of queries executed per second.*Shown as query*                                                                                                                                                                                |
| **alibabacloud.polardb.pg_rollback_ratio.average**(gauge)                                                                      | Transaction rollback ratio.*Shown as percent*                                                                                                                                                                                         |
| **alibabacloud.polardb.pg_rollbacks_delta.average**(rate)                                                                      | Number of transaction rollbacks per second.*Shown as transaction*                                                                                                                                                                     |
| **alibabacloud.polardb.pg_swell_time.average**(gauge)                                                                          | Longest transaction duration.*Shown as second*                                                                                                                                                                                        |
| **alibabacloud.polardb.pg_three_seconds_executing_sqls.average**(gauge)                                                      | Number of PostgreSQL SQL statements that have run for 3 seconds.*Shown as query*                                                                                                                                                      |
| **alibabacloud.polardb.pg_three_seconds_transactions.average**(gauge)                                                         | Number of PostgreSQL transactions that have run for 3 seconds.*Shown as transaction*                                                                                                                                                  |
| **alibabacloud.polardb.pg_tps.average**(rate)                                                                                   | Number of transactions per second.*Shown as transaction*                                                                                                                                                                              |
| **alibabacloud.polardb.pls_blk_usage.average**(gauge)                                                                          | PFS block usage.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.pls_data_size.value**(gauge)                                                                            | Data disk size.*Shown as mebibyte*                                                                                                                                                                                                    |
| **alibabacloud.polardb.pls_data_size_usage.average**(gauge)                                                                   | Disk usage.*Shown as percent*                                                                                                                                                                                                         |
| **alibabacloud.polardb.pls_inode_usage.average**(gauge)                                                                        | PFS inode usage.*Shown as percent*                                                                                                                                                                                                    |
| **alibabacloud.polardb.pls_iops.average**(rate)                                                                                 | Number of IO operations per second.*Shown as operation*                                                                                                                                                                               |
| **alibabacloud.polardb.pls_iops_read.average**(rate)                                                                           | Number of read IO operations per second.*Shown as operation*                                                                                                                                                                          |
| **alibabacloud.polardb.pls_iops_write.average**(rate)                                                                          | Number of write IO operations per second.*Shown as operation*                                                                                                                                                                         |
| **alibabacloud.polardb.pls_pg_wal_dir_size.value**(gauge)                                                                    | Size of the WAL log.*Shown as mebibyte*                                                                                                                                                                                               |
| **alibabacloud.polardb.pls_throughput.average**(rate)                                                                           | IO throughput.*Shown as byte*                                                                                                                                                                                                         |
| **alibabacloud.polardb.pls_throughput_read.average**(rate)                                                                     | Read operation IO throughput.*Shown as byte*                                                                                                                                                                                          |
| **alibabacloud.polardb.pls_throughput_write.average**(rate)                                                                    | Write operation IO throughput.*Shown as byte*                                                                                                                                                                                         |
| **alibabacloud.polardb.prepaid_disk_usage.average**(gauge)                                                                     | Usage ratio of the PolarStore instance's prepaid storage capacity.*Shown as percent*                                                                                                                                                  |
| **alibabacloud.polardb.qps_delta.average**(rate)                                                                                | Number of queries executed per second.*Shown as query*                                                                                                                                                                                |
| **alibabacloud.polardb.rollback_ratio.average**(gauge)                                                                          | Transaction rollback ratio.*Shown as percent*                                                                                                                                                                                         |
| **alibabacloud.polardb.rollbacks_delta.average**(rate)                                                                          | Number of transaction rollbacks per second.*Shown as transaction*                                                                                                                                                                     |
| **alibabacloud.polardb.search_total_avg_ms.average**(gauge)                                                                   | Average latency of memory retrieval.*Shown as millisecond*                                                                                                                                                                            |
| **alibabacloud.polardb.search_total_count.average**(gauge)                                                                     | Total number of times memory was retrieved.*Shown as query*                                                                                                                                                                           |
| **alibabacloud.polardb.search_total_failure_rate.average**(gauge)                                                             | Failure rate of memory retrieval.*Shown as percent*                                                                                                                                                                                   |
| **alibabacloud.polardb.search_total_p99_ms.average**(gauge)                                                                   | P99 latency of memory retrieval.*Shown as millisecond*                                                                                                                                                                                |
| **alibabacloud.polardb.storage_soft_limit.average**(gauge)                                                                     | Prepaid storage capacity of the PolarStore instance.*Shown as mebibyte*                                                                                                                                                               |
| **alibabacloud.polardb.storage_disk_info_used.value**(gauge)                                                                  | Amount of disk space used.*Shown as mebibyte*                                                                                                                                                                                         |
| **alibabacloud.polardb.storage_read_bytes.sum**(rate)                                                                          | Amount of data read from storage.*Shown as byte*                                                                                                                                                                                      |
| **alibabacloud.polardb.storage_req_read_succ_latency_mean.average**(gauge)                                                  | Mean storage read latency.*Shown as millisecond*                                                                                                                                                                                      |
| **alibabacloud.polardb.storage_req_read_succ_latency_p50.average**(gauge)                                                   | P50 storage read latency.*Shown as millisecond*                                                                                                                                                                                       |
| **alibabacloud.polardb.storage_req_read_succ_latency_p90.average**(gauge)                                                   | P90 storage read latency.*Shown as millisecond*                                                                                                                                                                                       |
| **alibabacloud.polardb.storage_req_read_succ_latency_p95.average**(gauge)                                                   | P95 storage read latency.*Shown as millisecond*                                                                                                                                                                                       |
| **alibabacloud.polardb.storage_req_read_succ_latency_p99.average**(gauge)                                                   | P99 storage read latency.*Shown as millisecond*                                                                                                                                                                                       |
| **alibabacloud.polardb.storage_req_write_bytes.sum**(rate)                                                                    | Amount of data written to storage.*Shown as byte*                                                                                                                                                                                     |
| **alibabacloud.polardb.storage_req_write_succ_latency_mean.average**(gauge)                                                 | Mean storage write latency.*Shown as millisecond*                                                                                                                                                                                     |
| **alibabacloud.polardb.storage_req_write_succ_latency_p50.average**(gauge)                                                  | P50 storage write latency.*Shown as millisecond*                                                                                                                                                                                      |
| **alibabacloud.polardb.storage_req_write_succ_latency_p90.average**(gauge)                                                  | P90 storage write latency.*Shown as millisecond*                                                                                                                                                                                      |
| **alibabacloud.polardb.storage_req_write_succ_latency_p95.average**(gauge)                                                  | P95 storage write latency.*Shown as millisecond*                                                                                                                                                                                      |
| **alibabacloud.polardb.storage_req_write_succ_latency_p99.average**(gauge)                                                  | P99 storage write latency.*Shown as millisecond*                                                                                                                                                                                      |
| **alibabacloud.polardb.swell_time.average**(gauge)                                                                              | Longest transaction duration.*Shown as second*                                                                                                                                                                                        |
| **alibabacloud.polardb.three_seconds_executing_sqls.average**(gauge)                                                          | Number of SQL statements that have run for 3 seconds.*Shown as query*                                                                                                                                                                 |
| **alibabacloud.polardb.three_seconds_transactions.average**(gauge)                                                             | Number of transactions that have run for 3 seconds.*Shown as transaction*                                                                                                                                                             |
| **alibabacloud.polardb.tps.average**(rate)                                                                                       | Number of transactions per second.*Shown as transaction*                                                                                                                                                                              |
| **alibabacloud.polardb.cluster_innodb_trx_history_list_len.average**(gauge)                                                 | Length of the history transaction list, specifically transactions that have not yet been purged.*Shown as transaction*                                                                                                                |
| **alibabacloud.polardb.ms_cached_creation_input_tokens.average**(gauge)                                                      | Cumulative number of tokens used to create the explicit cache across one or more calls.*Shown as unit*                                                                                                                                |
| **alibabacloud.polardb.ms_cached_creation_input_tokens_api_key.average**(gauge)                                            | Cumulative number of tokens used to create the explicit cache across one or more calls.*Shown as unit*                                                                                                                                |
| **alibabacloud.polardb.ms_ephemeral_cached_tokens.average**(gauge)                                                            | Cumulative number of tokens that hit the explicit cache across one or more calls.*Shown as unit*                                                                                                                                      |
| **alibabacloud.polardb.ms_ephemeral_cached_tokens_api_key.average**(gauge)                                                  | Cumulative number of tokens that hit the explicit cache across one or more calls.*Shown as unit*                                                                                                                                      |
| **alibabacloud.polardb.ms_tpm_load_ratio.average**(gauge)                                                                     | Represents the model's tokens per minute (TPM) load ratio at the instance level (not broken down by API key).*Shown as percent*                                                                                                       |
| **alibabacloud.polardb.opensearch_os_mem_actual_free_percent.average**(gauge)                                               | Percentage of memory available on the node. Supported on version 3.0.1.1.6 or later for the 3.0 series, or version 1.0.1.1.3 or later for the 1.0 series.*Shown as percent*                                                           |
| **alibabacloud.polardb.pfs2_acc_top_error_ip.average**(gauge)                                                                | Top 10 client IPs by error count.*Shown as error*                                                                                                                                                                                     |
| **alibabacloud.polardb.pfs2_acc_top_qps_ip.average**(gauge)                                                                  | Top 10 client IPs by QPS.*Shown as query*                                                                                                                                                                                             |
| **alibabacloud.polardb.pfs2_fuse_ops_read_instance.average**(gauge)                                                          | Read IOPS per client.*Shown as operation*                                                                                                                                                                                             |
| **alibabacloud.polardb.pfs2_fuse_ops_read_latency_ms_instance.average**(gauge)                                             | Read latency per client.*Shown as millisecond*                                                                                                                                                                                        |
| **alibabacloud.polardb.pfs2_fuse_ops_write_instance.average**(gauge)                                                         | Write IOPS per client.*Shown as operation*                                                                                                                                                                                            |
| **alibabacloud.polardb.pfs2_fuse_ops_write_latency_ms_instance.average**(gauge)                                            | Write latency per client.*Shown as millisecond*                                                                                                                                                                                       |
| **alibabacloud.polardb.pfs2_fuse_read_size_bytes_instance.average**(gauge)                                                  | Read bandwidth per client.*Shown as byte*                                                                                                                                                                                             |
| **alibabacloud.polardb.pfs2_fuse_written_size_bytes_instance.average**(gauge)                                               | Write bandwidth per client.*Shown as byte*                                                                                                                                                                                            |
| **alibabacloud.polardb.pfs2_meta_ops_latency_ms.average**(gauge)                                                             | Overview of metadata operation latency.*Shown as millisecond*                                                                                                                                                                         |
| **alibabacloud.polardb.pfs2_meta_ops_total.average**(gauge)                                                                   | Breakdown of metadata operation counts.*Shown as operation*                                                                                                                                                                           |

### Events{% #events %}

Alibaba Cloud PolarDB does not include any events.

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

Alibaba Cloud PolarDB does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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