---
title: Alibaba Cloud
description: >-
  Alibaba Cloud, a subsidiary of Alibaba Group, provides cloud computing
  services.
breadcrumbs: Docs > Integrations > Alibaba Cloud
---

# Alibaba Cloud

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



{% alert level="warning" %}
The Datadog Alibaba Cloud integration does not support the Datadog for Government site.
{% /alert %}


{% /callout %}

## Overview{% #overview %}

Connect to Alibaba Cloud to get metrics from your:

- Alibaba Cloud Servers Load Balancer (SLB)
- Alibaba Elastic Compute Service instances
- Alibaba Cloud ApsaraDB for RDS instances
- Alibaba Cloud ApsaraDB for Redis instances
- Alibaba Cloud Content Delivery Network (CDN) instances
- Alibaba Cloud Container Service clusters
- Alibaba Cloud Express Connect instances

**Note:** Due to Alibaba Cloud's deprecation of Cloud Monitor support for Container Service metrics, you will not be able to collect metrics for clusters created after September 30, 2025. For more information, refer to the [Alibaba Cloud deprecation notice](https://www.alibabacloud.com/help/cms/cloudmonitor-1-0/product-overview/announcement-on-the-discontinuation-of-kubernetes-container-monitoring-feature-of-cloudmonitor).

*All use of Datadog Services in (or in connection with environments within) mainland China is subject to the disclaimer published in the [Restricted Service Locations](https://www.datadoghq.com/legal/restricted-service-locations/) section on our website.*

## Setup{% #setup %}

### Installation{% #installation %}

Navigate to the [Datadog-Alibaba Cloud integration configuration tile](https://app.datadoghq.com/integrations/alibaba_cloud) and press *add account*.

### Configuration{% #configuration %}

Fill out the following parameters to integrate Datadog with the Alibaba Cloud API:

- **`Account Id`**

Find this by hovering over the avatar on the top right of the Alibaba Cloud console and selecting *Security Settings*. The account ID is displayed on the top of that page.

{% image
   source="https://docs.dd-static.net/images/integrations/alibaba_cloud/account_id_ac.eb578e45e50e5b42250c037ebd6a9ccb.png?auto=format&fit=max&w=850 1x, https://docs.dd-static.net/images/integrations/alibaba_cloud/account_id_ac.eb578e45e50e5b42250c037ebd6a9ccb.png?auto=format&fit=max&w=850&dpr=2 2x"
   alt="Account ID AC" /%}

- **`Access Key Id`** & **`Access Key Secret`**

In your Alibaba Cloud Account:

1. Create a new user in the *RAM* tab with the following parameters:

   - `Logon Name`: Datadog
   - `display name`: Datadog
   - `description`: Datadog User for the Datadog-Alibaba Cloud integration

1. Select *Programmatic Access*:

   {% image
      source="https://docs.dd-static.net/images/integrations/alibaba_cloud/ac_programmatic_access.43cec1d2bcd8619fb73dc7c1783e0590.png?auto=format&fit=max&w=850 1x, https://docs.dd-static.net/images/integrations/alibaba_cloud/ac_programmatic_access.43cec1d2bcd8619fb73dc7c1783e0590.png?auto=format&fit=max&w=850&dpr=2 2x"
      alt="Programmatic access" /%}

1. After hitting *OK*, copy and paste the `AccessKeyID` and `AccessKeySecret` in the [Datadog-Alibaba Cloud integration tile](https://app.datadoghq.com/integrations/alibaba_cloud) and click *install integration*.

   {% image
      source="https://docs.dd-static.net/images/integrations/alibaba_cloud/ac_access_keys.3e465550d15171454b4944fdd9f418e1.png?auto=format&fit=max&w=850 1x, https://docs.dd-static.net/images/integrations/alibaba_cloud/ac_access_keys.3e465550d15171454b4944fdd9f418e1.png?auto=format&fit=max&w=850&dpr=2 2x"
      alt="AC access keys" /%}

1. In your Alibaba Cloud Account, select `Add Permissions` for the user you just created, then add all of the following permissions:

   ```text
   ReadOnlyAccess
   ```

1. Press *Update*, and after around ~15 minutes, the metrics seen in the *Metrics* tab of the Datadog-Alibaba Cloud integration tile starts appearing in your [metric explorer page](https://app.datadoghq.com/metric/explorer) tagged with any custom tags you add to your resources and tags found here:

   - [kvstore/redis DescribeInstances](https://www.alibabacloud.com/help/doc-detail/60933.htm)
   - [ECS DescribeInstances](https://www.alibabacloud.com/help/doc-detail/25506.htm)
   - [DescribeDBInstances](https://www.alibabacloud.com/help/doc-detail/26232.htm)
   - [DescribeLoadBalancers](https://www.alibabacloud.com/help/doc-detail/27582.htm)

1. Optional - Set `Optionally Limit Metrics Collection` in your [Datadog-Alibaba Cloud integration tile](https://app.datadoghq.com/integrations/alibaba_cloud). This comma separated list of Alibaba Cloud tags (in the form `<KEY:VALUE>`) defines a filter to use when collecting metrics from Alibaba Cloud. Wildcards such as `?` (for single characters) and `*` (for multiple characters) can be used. Only hosts that match one of the defined labels are imported into Datadog—the rest are ignored. Hosts matching a given label can also be excluded by adding `!` before the label.

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

**Note**: Metrics from the following namespaces are only available if you set up the Alibaba Cloud integration after December 1, 2025: `alibabacloud.kafka`, `alibabacloud.memcache`, `alibabacloud.mongodb`, `alibabacloud.oceanbase`.

### Metrics{% #metrics %}

|  |
|  |
| **alibabacloud.cdn.qps.average**(gauge)                                                              | Total access requests.*Shown as request*                                                                                                                   |
| **alibabacloud.cdn.qps.minimum**(gauge)                                                              | Total access requests.*Shown as request*                                                                                                                   |
| **alibabacloud.cdn.qps.maximum**(gauge)                                                              | Total access requests.*Shown as request*                                                                                                                   |
| **alibabacloud.cdn.bps.average**(rate)                                                               | Peak bandwidth.*Shown as bit*                                                                                                                              |
| **alibabacloud.cdn.bps.minimum**(rate)                                                               | Peak bandwidth.*Shown as bit*                                                                                                                              |
| **alibabacloud.cdn.bps.maximum**(rate)                                                               | Peak bandwidth.*Shown as bit*                                                                                                                              |
| **alibabacloud.cdn.hit\_rate.average**(gauge)                                                        | Bytes hit rate.*Shown as percent*                                                                                                                          |
| **alibabacloud.cdn.hit\_rate.minimum**(gauge)                                                        | Bytes hit rate.*Shown as percent*                                                                                                                          |
| **alibabacloud.cdn.hit\_rate.maximum**(gauge)                                                        | Bytes hit rate.*Shown as percent*                                                                                                                          |
| **alibabacloud.cdn.code4xx.average**(gauge)                                                          | Percent of 4xx status codes.*Shown as percent*                                                                                                             |
| **alibabacloud.cdn.code4xx.minimum**(gauge)                                                          | Percent of 4xx status codes.*Shown as percent*                                                                                                             |
| **alibabacloud.cdn.code4xx.maximum**(gauge)                                                          | Percent of 4xx status codes.*Shown as percent*                                                                                                             |
| **alibabacloud.cdn.code5xx.average**(gauge)                                                          | Percent of 5xx status codes.*Shown as percent*                                                                                                             |
| **alibabacloud.cdn.code5xx.minimum**(gauge)                                                          | Percent of 5xx status codes.*Shown as percent*                                                                                                             |
| **alibabacloud.cdn.code5xx.maximum**(gauge)                                                          | Percent of 5xx status codes.*Shown as percent*                                                                                                             |
| **alibabacloud.cdn.internet\_out.average**(gauge)                                                    | Outbound traffic.*Shown as byte*                                                                                                                           |
| **alibabacloud.cdn.internet\_out.minimum**(gauge)                                                    | Outbound traffic.*Shown as byte*                                                                                                                           |
| **alibabacloud.cdn.internet\_out.maximum**(gauge)                                                    | Outbound traffic.*Shown as byte*                                                                                                                           |
| **alibabacloud.dcdn.code\_count\_1.maximum**(gauge)                                                  | Number of instance edge nodes 1xx.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_2.maximum**(gauge)                                                  | Number of instance edge nodes 2xx.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_3.maximum**(gauge)                                                  | Number of instance edge nodes 3xx.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_4.maximum**(gauge)                                                  | Number of instance edge nodes 4xx.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_400.maximum**(gauge)                                                | Number of instance edge nodes 400.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_403.maximum**(gauge)                                                | Number of instance edge nodes 403.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_404.maximum**(gauge)                                                | Number of instance edge nodes 404.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_416.maximum**(gauge)                                                | Number of instance edge nodes 416.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_499.maximum**(gauge)                                                | Number of instance edge nodes 499.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_5.maximum**(gauge)                                                  | Number of instance edge nodes 5xx.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_500.maximum**(gauge)                                                | Number of instance edge nodes 500.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_502.maximum**(gauge)                                                | Number of instance edge nodes 502.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_503.maximum**(gauge)                                                | Number of instance edge nodes 503.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_count\_504.maximum**(gauge)                                                | Number of instance edge nodes 504.*Shown as instance*                                                                                                      |
| **alibabacloud.dcdn.code\_ratio\_400.maximum**(gauge)                                                | Ratio of instance edge nodes to 400.*Shown as percent*                                                                                                     |
| **alibabacloud.dcdn.code\_ratio\_403.maximum**(gauge)                                                | Ratio of instance edge nodes to 403.*Shown as percent*                                                                                                     |
| **alibabacloud.dcdn.code\_ratio\_404.maximum**(gauge)                                                | Ratio of instance edge nodes to 404.*Shown as percent*                                                                                                     |
| **alibabacloud.dcdn.code\_ratio\_416.maximum**(gauge)                                                | Ratio of instance edge nodes to 416.*Shown as percent*                                                                                                     |
| **alibabacloud.dcdn.code\_ratio\_499.maximum**(gauge)                                                | Ratio of instance edge nodes to 499.*Shown as percent*                                                                                                     |
| **alibabacloud.dcdn.code\_ratio\_500.maximum**(gauge)                                                | Ratio of instance edge nodes to 500.*Shown as percent*                                                                                                     |
| **alibabacloud.dcdn.code\_ratio\_502.maximum**(gauge)                                                | Ratio of instance edge nodes to 502.*Shown as percent*                                                                                                     |
| **alibabacloud.dcdn.code\_ratio\_503.maximum**(gauge)                                                | Ratio of instance edge nodes to 503.*Shown as percent*                                                                                                     |
| **alibabacloud.dcdn.code\_ratio\_504.maximum**(gauge)                                                | Ratio of instance edge nodes to 504.*Shown as percent*                                                                                                     |
| **alibabacloud.dcdn.ori\_acc.maximum**(gauge)                                                        | Number of requests back to the origin server.*Shown as instance*                                                                                           |
| **alibabacloud.dcdn.ori\_bandwidth.maximum**(rate)                                                   | Bandwidth to the origin.*Shown as bit*                                                                                                                     |
| **alibabacloud.dcdn.ori\_code\_count\_1.maximum**(gauge)                                             | Back-to-origin 1xx responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_2.maximum**(gauge)                                             | Back-to-origin 2xx responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_3.maximum**(gauge)                                             | Back-to-origin 3xx responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_4.maximum**(gauge)                                             | Back-to-origin 4xx responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_400.maximum**(gauge)                                           | Back-to-origin 400 responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_403.maximum**(gauge)                                           | Back-to-origin 403 responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_404.maximum**(gauge)                                           | Back-to-origin 404 responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_416.maximum**(gauge)                                           | Back-to-origin 416 responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_499.maximum**(gauge)                                           | Back-to-origin 499 responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_5.maximum**(gauge)                                             | Back-to-origin 5* responses.*Shown as instance*                                                                                                            |
| **alibabacloud.dcdn.ori\_code\_count\_500.maximum**(gauge)                                           | Back-to-origin 500 responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_502.maximum**(gauge)                                           | Back-to-origin 502 responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_503.maximum**(gauge)                                           | Back-to-origin 503 responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_count\_504.maximum**(gauge)                                           | Back-to-origin 504 responses.*Shown as instance*                                                                                                           |
| **alibabacloud.dcdn.ori\_code\_ratio\_1.maximum**(gauge)                                             | Ratio of back-to-origin 1xx responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_2.maximum**(gauge)                                             | Ratio of back-to-origin 2xx responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_3.maximum**(gauge)                                             | Ratio of back-to-origin 3xx responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_4.maximum**(gauge)                                             | Ratio of back-to-origin 4xx responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_400.maximum**(gauge)                                           | Ratio of back-to-origin 400 responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_403.maximum**(gauge)                                           | Ratio of back-to-origin 403 responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_404.maximum**(gauge)                                           | Ratio of back-to-origin 404 responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_416.maximum**(gauge)                                           | Ratio of back-to-origin 416 responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_499.maximum**(gauge)                                           | Ratio of back-to-origin 499 responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_5.maximum**(gauge)                                             | Ratio of back-to-origin 5* responses.*Shown as percent*                                                                                                    |
| **alibabacloud.dcdn.ori\_code\_ratio\_500.maximum**(gauge)                                           | Ratio of back-to-origin 500 responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_502.maximum**(gauge)                                           | Ratio of back-to-origin 502 responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_503.maximum**(gauge)                                           | Ratio of back-to-origin 503 responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.ori\_code\_ratio\_504.maximum**(gauge)                                           | Ratio of back-to-origin 504 responses.*Shown as percent*                                                                                                   |
| **alibabacloud.dcdn.bps\_in.maximum**(rate)                                                          | Inbound bandwidth.*Shown as bit*                                                                                                                           |
| **alibabacloud.dcdn.bps\_in\_http.maximum**(rate)                                                    | HTTP inbound bandwidth.*Shown as bit*                                                                                                                      |
| **alibabacloud.dcdn.bps\_in\_ws.maximum**(rate)                                                      | WebSocket inbound bandwidth.*Shown as bit*                                                                                                                 |
| **alibabacloud.dcdn.bps\_out.maximum**(rate)                                                         | Outbound bandwidth.*Shown as bit*                                                                                                                          |
| **alibabacloud.dcdn.bps\_out\_http.maximum**(rate)                                                   | HTTP outbound bandwidth.*Shown as bit*                                                                                                                     |
| **alibabacloud.dcdn.bps\_out\_ws.maximum**(rate)                                                     | WebSocket outbound bandwidth.*Shown as bit*                                                                                                                |
| **alibabacloud.dcdn.code\_count\_499\_http.average**(gauge)                                          | Number of HTTP 499 status codes.*Shown as instance*                                                                                                        |
| **alibabacloud.dcdn.code\_count\_499\_http.minimum**(gauge)                                          | Number of HTTP 499 status codes.*Shown as instance*                                                                                                        |
| **alibabacloud.dcdn.code\_count\_499\_http.maximum**(gauge)                                          | Number of HTTP 499 status codes.*Shown as instance*                                                                                                        |
| **alibabacloud.dcdn.code\_count\_499\_ws.average**(gauge)                                            | Number of WebSocket 499 status codes.*Shown as instance*                                                                                                   |
| **alibabacloud.dcdn.code\_count\_499\_ws.minimum**(gauge)                                            | Number of WebSocket 499 status codes.*Shown as instance*                                                                                                   |
| **alibabacloud.dcdn.code\_count\_499\_ws.maximum**(gauge)                                            | Number of WebSocket 499 status codes.*Shown as instance*                                                                                                   |
| **alibabacloud.dcdn.code\_ratio\_1.maximum**(gauge)                                                  | 1xx status code ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.dcdn.code\_ratio\_1\_http.maximum**(gauge)                                            | HTTP 1xx status code ratio.*Shown as percent*                                                                                                              |
| **alibabacloud.dcdn.code\_ratio\_1\_ws.maximum**(gauge)                                              | WebSocket 1xx status code ratio.*Shown as percent*                                                                                                         |
| **alibabacloud.dcdn.code\_ratio\_2.maximum**(gauge)                                                  | 2xx status code ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.dcdn.code\_ratio\_2\_http.maximum**(gauge)                                            | HTTP 2xx status code ratio.*Shown as percent*                                                                                                              |
| **alibabacloud.dcdn.code\_ratio\_2\_ws.maximum**(gauge)                                              | WebSocket 2xx status code ratio.*Shown as percent*                                                                                                         |
| **alibabacloud.dcdn.code\_ratio\_3.maximum**(gauge)                                                  | 3xx status code ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.dcdn.code\_ratio\_3\_http.maximum**(gauge)                                            | HTTP 3xx status code ratio.*Shown as percent*                                                                                                              |
| **alibabacloud.dcdn.code\_ratio\_3\_ws.maximum**(gauge)                                              | WebSocket 3xx status code ratio.*Shown as percent*                                                                                                         |
| **alibabacloud.dcdn.code\_ratio\_4.maximum**(gauge)                                                  | 4xx status code ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.dcdn.code\_ratio\_499\_http.maximum**(gauge)                                          | HTTP 499 status code ratio.*Shown as percent*                                                                                                              |
| **alibabacloud.dcdn.code\_ratio\_499\_ws.maximum**(gauge)                                            | WebSocket 499 status code ratio.*Shown as percent*                                                                                                         |
| **alibabacloud.dcdn.code\_ratio\_4\_http.maximum**(gauge)                                            | HTTP 4xx status code ratio.*Shown as percent*                                                                                                              |
| **alibabacloud.dcdn.code\_ratio\_4\_ws.maximum**(gauge)                                              | WebSocket 4xx status code ratio.*Shown as percent*                                                                                                         |
| **alibabacloud.dcdn.code\_ratio\_5.maximum**(gauge)                                                  | 5xx status code ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.dcdn.code\_ratio\_5\_http.maximum**(gauge)                                            | HTTP 5xx status code ratio.*Shown as percent*                                                                                                              |
| **alibabacloud.dcdn.code\_ratio\_5\_ws.maximum**(gauge)                                              | WebSocket 5xx status code ratio.*Shown as percent*                                                                                                         |
| **alibabacloud.dcdn.dcdn\_qps.maximum**(rate)                                                        | Requests per second.*Shown as request*                                                                                                                     |
| **alibabacloud.dcdn.dcdn\_qps\_http.maximum**(rate)                                                  | HTTP requests per second.*Shown as request*                                                                                                                |
| **alibabacloud.dcdn.dcdn\_qps\_ws.maximum**(rate)                                                    | WebSocket requests per second.*Shown as request*                                                                                                           |
| **alibabacloud.dcdn.hit\_rate.maximum**(gauge)                                                       | Byte hit rate.*Shown as percent*                                                                                                                           |
| **alibabacloud.dcdn.hit\_rate\_http.maximum**(gauge)                                                 | HTTP hit rate.*Shown as percent*                                                                                                                           |
| **alibabacloud.dcdn.hit\_rate\_ws.maximum**(gauge)                                                   | WebSocket hit rate.*Shown as percent*                                                                                                                      |
| **alibabacloud.dcdn.rt.maximum**(gauge)                                                              | Request time.*Shown as millisecond*                                                                                                                        |
| **alibabacloud.dcdn.rt\_http.maximum**(gauge)                                                        | HTTP request time.*Shown as millisecond*                                                                                                                   |
| **alibabacloud.dcdn.rt\_ws.maximum**(gauge)                                                          | WebSocket request time.*Shown as millisecond*                                                                                                              |
| **alibabacloud.dcdn.waf\_acl\_block\_qps.value**(rate)                                               | DCDN WAF custom rule interception rate per second.*Shown as instance*                                                                                      |
| **alibabacloud.dcdn.waf\_web\_block\_qps.value**(rate)                                               | DCDN WAF basic protection interception rate per second.*Shown as instance*                                                                                 |
| **alibabacloud.ecs.cpu\_utilization.average**(gauge)                                                 | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.ecs.cpu\_utilization.minimum**(gauge)                                                 | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.ecs.cpu\_utilization.maximum**(gauge)                                                 | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.ecs.cpu\_idle.average**(gauge)                                                        | Host.cpu.idle, percentage of CPU in the idle state*Shown as percent*                                                                                       |
| **alibabacloud.ecs.cpu\_idle.minimum**(gauge)                                                        | Host.cpu.idle, percentage of CPU in the idle state*Shown as percent*                                                                                       |
| **alibabacloud.ecs.cpu\_idle.maximum**(gauge)                                                        | Host.cpu.idle, percentage of CPU in the idle state*Shown as percent*                                                                                       |
| **alibabacloud.ecs.cpu\_other.average**(gauge)                                                       | Host.cpu.other, CPU usage of other items. Other types of CPU consumption are calculated using the formula Nice + SoftIrq + Irq + Stolen.*Shown as percent* |
| **alibabacloud.ecs.cpu\_other.minimum**(gauge)                                                       | Host.cpu.other, CPU usage of other items. Other types of CPU consumption are calculated using the formula Nice + SoftIrq + Irq + Stolen.*Shown as percent* |
| **alibabacloud.ecs.cpu\_other.maximum**(gauge)                                                       | Host.cpu.other, CPU usage of other items. Other types of CPU consumption are calculated using the formula Nice + SoftIrq + Irq + Stolen.*Shown as percent* |
| **alibabacloud.ecs.cpu\_system.average**(gauge)                                                      | Host.cpu.system, CPU usage of the current kernel space*Shown as percent*                                                                                   |
| **alibabacloud.ecs.cpu\_system.minimum**(gauge)                                                      | Host.cpu.system, CPU usage of the current kernel space*Shown as percent*                                                                                   |
| **alibabacloud.ecs.cpu\_system.maximum**(gauge)                                                      | Host.cpu.system, CPU usage of the current kernel space*Shown as percent*                                                                                   |
| **alibabacloud.ecs.cpu\_total.average**(gauge)                                                       | Host.cpu.total, current total CPU usage*Shown as percent*                                                                                                  |
| **alibabacloud.ecs.cpu\_total.minimum**(gauge)                                                       | Host.cpu.total, current total CPU usage*Shown as percent*                                                                                                  |
| **alibabacloud.ecs.cpu\_total.maximum**(gauge)                                                       | Host.cpu.total, current total CPU usage*Shown as percent*                                                                                                  |
| **alibabacloud.ecs.cpu\_user.average**(gauge)                                                        | Host.cpu.user, CPU usage of the current user space*Shown as percent*                                                                                       |
| **alibabacloud.ecs.cpu\_user.minimum**(gauge)                                                        | Host.cpu.user, CPU usage of the current user space*Shown as percent*                                                                                       |
| **alibabacloud.ecs.cpu\_user.maximum**(gauge)                                                        | Host.cpu.user, CPU usage of the current user space*Shown as percent*                                                                                       |
| **alibabacloud.ecs.cpu\_wait.average**(gauge)                                                        | Host.cpu.iowait, percentage of CPU waiting for I/O operation*Shown as percent*                                                                             |
| **alibabacloud.ecs.cpu\_wait.minimum**(gauge)                                                        | Host.cpu.iowait, percentage of CPU waiting for I/O operation*Shown as percent*                                                                             |
| **alibabacloud.ecs.memory\_actualusedspace.maximum**(gauge)                                          | Size of Memory Consumed by User.*Shown as byte*                                                                                                            |
| **alibabacloud.ecs.memory\_actualusedspace.minimum**(gauge)                                          | Size of Memory Consumed by User.*Shown as byte*                                                                                                            |
| **alibabacloud.ecs.memory\_actualusedspace.average**(gauge)                                          | Size of Memory Consumed by User.*Shown as byte*                                                                                                            |
| **alibabacloud.ecs.memory\_freespace.maximum**(gauge)                                                | Available Memory.*Shown as byte*                                                                                                                           |
| **alibabacloud.ecs.memory\_freespace.minimum**(gauge)                                                | Available Memory.*Shown as byte*                                                                                                                           |
| **alibabacloud.ecs.memory\_freespace.average**(gauge)                                                | Available Memory.*Shown as byte*                                                                                                                           |
| **alibabacloud.ecs.memory\_freeutilization.maximum**(gauge)                                          | Available Memory Usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.ecs.memory\_freeutilization.minimum**(gauge)                                          | Available Memory Usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.ecs.memory\_freeutilization.average**(gauge)                                          | Available Memory Usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.ecs.memory\_totalspace.maximum**(gauge)                                               | Total Memory.*Shown as byte*                                                                                                                               |
| **alibabacloud.ecs.memory\_totalspace.minimum**(gauge)                                               | Total Memory.*Shown as byte*                                                                                                                               |
| **alibabacloud.ecs.memory\_totalspace.average**(gauge)                                               | Total Memory.*Shown as byte*                                                                                                                               |
| **alibabacloud.ecs.memory\_usedspace.maximum**(gauge)                                                | Used Memory.*Shown as byte*                                                                                                                                |
| **alibabacloud.ecs.memory\_usedspace.minimum**(gauge)                                                | Used Memory.*Shown as byte*                                                                                                                                |
| **alibabacloud.ecs.memory\_usedspace.average**(gauge)                                                | Used Memory.*Shown as byte*                                                                                                                                |
| **alibabacloud.ecs.memory\_usedutilization.maximum**(gauge)                                          | Memory Usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.ecs.memory\_usedutilization.minimum**(gauge)                                          | Memory Usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.ecs.memory\_usedutilization.average**(gauge)                                          | Memory Usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.ecs.cpu\_wait.maximum**(gauge)                                                        | Host.cpu.iowait, percentage of CPU waiting for I/O operation*Shown as percent*                                                                             |
| **alibabacloud.ecs.internet\_in\_rate.average**(rate)                                                | Inbound public network bandwidth.*Shown as bit*                                                                                                            |
| **alibabacloud.ecs.internet\_in\_rate.minimum**(rate)                                                | Inbound public network bandwidth.*Shown as bit*                                                                                                            |
| **alibabacloud.ecs.internet\_in\_rate.maximum**(rate)                                                | Inbound public network bandwidth.*Shown as bit*                                                                                                            |
| **alibabacloud.ecs.intranet\_in\_rate.average**(rate)                                                | Inbound private network bandwidth.*Shown as bit*                                                                                                           |
| **alibabacloud.ecs.intranet\_in\_rate.minimum**(rate)                                                | Inbound private network bandwidth.*Shown as bit*                                                                                                           |
| **alibabacloud.ecs.intranet\_in\_rate.maximum**(rate)                                                | Inbound private network bandwidth.*Shown as bit*                                                                                                           |
| **alibabacloud.ecs.internet\_out\_rate.average**(rate)                                               | Outbound public network bandwidth.*Shown as bit*                                                                                                           |
| **alibabacloud.ecs.internet\_out\_rate.minimum**(rate)                                               | Outbound public network bandwidth.*Shown as bit*                                                                                                           |
| **alibabacloud.ecs.internet\_out\_rate.maximum**(rate)                                               | Outbound public network bandwidth.*Shown as bit*                                                                                                           |
| **alibabacloud.ecs.intranet\_out\_rate.average**(rate)                                               | Outbound private network bandwidth.*Shown as bit*                                                                                                          |
| **alibabacloud.ecs.intranet\_out\_rate.maximum**(rate)                                               | Outbound private network bandwidth.*Shown as bit*                                                                                                          |
| **alibabacloud.ecs.intranet\_out\_rate.minimum**(rate)                                               | Outbound private network bandwidth.*Shown as bit*                                                                                                          |
| **alibabacloud.ecs.internet\_out\_rate\_percent.average**(gauge)                                     | Outbound public network bandwidth usage.*Shown as percent*                                                                                                 |
| **alibabacloud.ecs.disk\_read\_bps.average**(rate)                                                   | Total system disk read BPS.*Shown as bit*                                                                                                                  |
| **alibabacloud.ecs.disk\_read\_bps.minimum**(rate)                                                   | Total system disk read BPS.*Shown as bit*                                                                                                                  |
| **alibabacloud.ecs.disk\_read\_bps.maximum**(rate)                                                   | Total system disk read BPS.*Shown as bit*                                                                                                                  |
| **alibabacloud.ecs.disk\_write\_bps.average**(rate)                                                  | Total system disk write BPS.*Shown as bit*                                                                                                                 |
| **alibabacloud.ecs.disk\_write\_bps.minimum**(rate)                                                  | Total system disk write BPS.*Shown as bit*                                                                                                                 |
| **alibabacloud.ecs.disk\_write\_bps.maximum**(rate)                                                  | Total system disk write BPS.*Shown as bit*                                                                                                                 |
| **alibabacloud.ecs.disk\_read\_iops.average**(rate)                                                  | System disk read IOPS.*Shown as operation*                                                                                                                 |
| **alibabacloud.ecs.disk\_read\_iops.minimum**(rate)                                                  | System disk read IOPS.*Shown as operation*                                                                                                                 |
| **alibabacloud.ecs.disk\_read\_iops.maximum**(rate)                                                  | System disk read IOPS.*Shown as operation*                                                                                                                 |
| **alibabacloud.ecs.disk\_write\_iops.average**(rate)                                                 | System disk write IOPS.*Shown as operation*                                                                                                                |
| **alibabacloud.ecs.disk\_write\_iops.minimum**(rate)                                                 | System disk write IOPS.*Shown as operation*                                                                                                                |
| **alibabacloud.ecs.disk\_write\_iops.maximum**(rate)                                                 | System disk write IOPS.*Shown as operation*                                                                                                                |
| **alibabacloud.ecs.vpc\_public\_ip\_internet\_in\_rate.average**(rate)                               | VPC inbound public network bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.ecs.vpc\_public\_ip\_internet\_in\_rate.minimum**(rate)                               | VPC inbound public network bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.ecs.vpc\_public\_ip\_internet\_in\_rate.maximum**(rate)                               | VPC inbound public network bandwidth.*Shown as bit*                                                                                                        |
| **alibabacloud.ecs.vpc\_public\_ip\_internet\_out\_rate.average**(rate)                              | VPC outbound public network bandwidth.*Shown as bit*                                                                                                       |
| **alibabacloud.ecs.vpc\_public\_ip\_internet\_out\_rate.minimum**(rate)                              | VPC outbound public network bandwidth.*Shown as bit*                                                                                                       |
| **alibabacloud.ecs.vpc\_public\_ip\_internet\_out\_rate.maximum**(rate)                              | VPC outbound public network bandwidth.*Shown as bit*                                                                                                       |
| **alibabacloud.ecs.vpc\_public\_ip\_internet\_out\_rate\_percent.average**(gauge)                    | VPC outbound public network bandwidth usage.*Shown as percent*                                                                                             |
| **alibabacloud.ecs.disk\_readbytes.average**(rate)                                                   | System agent disk read bytes.*Shown as byte*                                                                                                               |
| **alibabacloud.ecs.disk\_readbytes.minimum**(rate)                                                   | System agent disk read bytes.*Shown as byte*                                                                                                               |
| **alibabacloud.ecs.disk\_readbytes.maximum**(rate)                                                   | System agent disk read bytes.*Shown as byte*                                                                                                               |
| **alibabacloud.ecs.disk\_readiops.average**(rate)                                                    | System agent disk read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.ecs.disk\_readiops.minimum**(rate)                                                    | System agent disk read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.ecs.disk\_readiops.maximum**(rate)                                                    | System agent disk read IOPS.*Shown as operation*                                                                                                           |
| **alibabacloud.ecs.disk\_writebytes.average**(rate)                                                  | System agent disk write bytes.*Shown as byte*                                                                                                              |
| **alibabacloud.ecs.disk\_writebytes.minimum**(rate)                                                  | System agent disk write bytes.*Shown as byte*                                                                                                              |
| **alibabacloud.ecs.disk\_writebytes.maximum**(rate)                                                  | System agent disk write bytes.*Shown as byte*                                                                                                              |
| **alibabacloud.ecs.disk\_writeiops.average**(rate)                                                   | System agent disk write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.ecs.disk\_writeiops.minimum**(rate)                                                   | System agent disk write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.ecs.disk\_writeiops.maximum**(rate)                                                   | System agent disk write IOPS.*Shown as operation*                                                                                                          |
| **alibabacloud.ecs.diskusage\_avail.average**(gauge)                                                 | System agent disk usage available.*Shown as byte*                                                                                                          |
| **alibabacloud.ecs.diskusage\_avail.minimum**(gauge)                                                 | System agent disk usage available.*Shown as byte*                                                                                                          |
| **alibabacloud.ecs.diskusage\_avail.maximum**(gauge)                                                 | System agent disk usage available.*Shown as byte*                                                                                                          |
| **alibabacloud.ecs.diskusage\_free.average**(gauge)                                                  | Host disk usage free.*Shown as byte*                                                                                                                       |
| **alibabacloud.ecs.diskusage\_free.minimum**(gauge)                                                  | Host disk usage free.*Shown as byte*                                                                                                                       |
| **alibabacloud.ecs.diskusage\_free.maximum**(gauge)                                                  | Host disk usage free.*Shown as byte*                                                                                                                       |
| **alibabacloud.ecs.diskusage\_total.average**(gauge)                                                 | Host disk usage total.*Shown as byte*                                                                                                                      |
| **alibabacloud.ecs.diskusage\_total.minimum**(gauge)                                                 | Host disk usage total.*Shown as byte*                                                                                                                      |
| **alibabacloud.ecs.diskusage\_total.maximum**(gauge)                                                 | Host disk usage total.*Shown as byte*                                                                                                                      |
| **alibabacloud.ecs.diskusage\_used.average**(gauge)                                                  | Host disk usage used.*Shown as byte*                                                                                                                       |
| **alibabacloud.ecs.diskusage\_used.minimum**(gauge)                                                  | Host disk usage used.*Shown as byte*                                                                                                                       |
| **alibabacloud.ecs.diskusage\_used.maximum**(gauge)                                                  | Host disk usage used.*Shown as byte*                                                                                                                       |
| **alibabacloud.ecs.diskusage\_utilization.average**(gauge)                                           | Host disk usage utilization.*Shown as byte*                                                                                                                |
| **alibabacloud.ecs.diskusage\_utilization.minimum**(gauge)                                           | Host disk usage utilization.*Shown as byte*                                                                                                                |
| **alibabacloud.ecs.diskusage\_utilization.maximum**(gauge)                                           | Host disk usage utilization.*Shown as byte*                                                                                                                |
| **alibabacloud.ecs.gpu\_decoder\_utilization.average**(gauge)                                        | GPU decoder utilization.*Shown as percent*                                                                                                                 |
| **alibabacloud.ecs.gpu\_decoder\_utilization.minimum**(gauge)                                        | GPU decoder utilization.*Shown as percent*                                                                                                                 |
| **alibabacloud.ecs.gpu\_decoder\_utilization.maximum**(gauge)                                        | GPU decoder utilization.*Shown as percent*                                                                                                                 |
| **alibabacloud.ecs.gpu\_encoder\_utilization.average**(gauge)                                        | GPU encoder utilization.*Shown as percent*                                                                                                                 |
| **alibabacloud.ecs.gpu\_encoder\_utilization.minimum**(gauge)                                        | GPU encoder utilization.*Shown as percent*                                                                                                                 |
| **alibabacloud.ecs.gpu\_encoder\_utilization.maximum**(gauge)                                        | GPU encoder utilization.*Shown as percent*                                                                                                                 |
| **alibabacloud.ecs.gpu\_gpu\_temperature.average**(gauge)                                            | GPU temperature.*Shown as degree celsius*                                                                                                                  |
| **alibabacloud.ecs.gpu\_gpu\_temperature.minimum**(gauge)                                            | GPU temperature.*Shown as degree celsius*                                                                                                                  |
| **alibabacloud.ecs.gpu\_gpu\_temperature.maximum**(gauge)                                            | GPU temperature.*Shown as degree celsius*                                                                                                                  |
| **alibabacloud.ecs.gpu\_gpu\_usedutilization.average**(gauge)                                        | GPU used utilization.*Shown as percent*                                                                                                                    |
| **alibabacloud.ecs.gpu\_gpu\_usedutilization.minimum**(gauge)                                        | GPU used utilization.*Shown as percent*                                                                                                                    |
| **alibabacloud.ecs.gpu\_gpu\_usedutilization.maximum**(gauge)                                        | GPU used utilization.*Shown as percent*                                                                                                                    |
| **alibabacloud.ecs.gpu\_memory\_freespace.average**(gauge)                                           | GPU memory free space.*Shown as byte*                                                                                                                      |
| **alibabacloud.ecs.gpu\_memory\_freespace.minimum**(gauge)                                           | GPU memory free space.*Shown as byte*                                                                                                                      |
| **alibabacloud.ecs.gpu\_memory\_freespace.maximum**(gauge)                                           | GPU memory free space.*Shown as byte*                                                                                                                      |
| **alibabacloud.ecs.gpu\_memory\_freeutilization.average**(gauge)                                     | GPU memory free utilization.*Shown as percent*                                                                                                             |
| **alibabacloud.ecs.gpu\_memory\_freeutilization.minimum**(gauge)                                     | GPU memory free utilization.*Shown as percent*                                                                                                             |
| **alibabacloud.ecs.gpu\_memory\_freeutilization.maximum**(gauge)                                     | GPU memory free utilization.*Shown as percent*                                                                                                             |
| **alibabacloud.ecs.gpu\_memory\_usedspace.average**(gauge)                                           | GPU memory used space.*Shown as byte*                                                                                                                      |
| **alibabacloud.ecs.gpu\_memory\_usedspace.minimum**(gauge)                                           | GPU memory used space.*Shown as byte*                                                                                                                      |
| **alibabacloud.ecs.gpu\_memory\_usedspace.maximum**(gauge)                                           | GPU memory used space.*Shown as byte*                                                                                                                      |
| **alibabacloud.ecs.gpu\_memory\_usedutilization.average**(gauge)                                     | GPU memory used utilization.*Shown as percent*                                                                                                             |
| **alibabacloud.ecs.gpu\_memory\_usedutilization.minimum**(gauge)                                     | GPU memory used utilization.*Shown as percent*                                                                                                             |
| **alibabacloud.ecs.gpu\_memory\_usedutilization.maximum**(gauge)                                     | GPU memory used utilization.*Shown as percent*                                                                                                             |
| **alibabacloud.ecs.gpu\_power\_readings\_power\_draw.average**(gauge)                                | GPU power readings power draw.*Shown as watt*                                                                                                              |
| **alibabacloud.ecs.gpu\_power\_readings\_power\_draw.minimum**(gauge)                                | GPU power readings power draw.*Shown as watt*                                                                                                              |
| **alibabacloud.ecs.gpu\_power\_readings\_power\_draw.maximum**(gauge)                                | GPU power readings power draw.*Shown as watt*                                                                                                              |
| **alibabacloud.ecs.fs\_inodeutilization.average**(gauge)                                             | Host.fs.inode, inode usage*Shown as percent*                                                                                                               |
| **alibabacloud.ecs.fs\_inodeutilization.minimum**(gauge)                                             | Host.fs.inode, inode usage*Shown as percent*                                                                                                               |
| **alibabacloud.ecs.fs\_inodeutilization.maximum**(gauge)                                             | Host.fs.inode, inode usage*Shown as percent*                                                                                                               |
| **alibabacloud.ecs.load\_15m.average**(gauge)                                                        | Host.load15, average system load during the past 15 minutes. This metric is not available in Windows.*Shown as process*                                    |
| **alibabacloud.ecs.load\_15m.minimum**(gauge)                                                        | Host.load15, average system load during the past 15 minutes. This metric is not available in Windows.*Shown as process*                                    |
| **alibabacloud.ecs.load\_15m.maximum**(gauge)                                                        | Host.load15, average system load during the past 15 minutes. This metric is not available in Windows.*Shown as process*                                    |
| **alibabacloud.ecs.load\_5m.average**(gauge)                                                         | Host.load5, average system load during the past 5 minutes. This metric is not available in Windows.*Shown as process*                                      |
| **alibabacloud.ecs.load\_5m.minimum**(gauge)                                                         | Host.load5, average system load during the past 5 minutes. This metric is not available in Windows.*Shown as process*                                      |
| **alibabacloud.ecs.load\_5m.maximum**(gauge)                                                         | Host.load5, average system load during the past 5 minutes. This metric is not available in Windows.*Shown as process*                                      |
| **alibabacloud.ecs.load\_1m.average**(gauge)                                                         | Host.load1, average system load during the past minute. This metric is not available in Windows.*Shown as process*                                         |
| **alibabacloud.ecs.load\_1m.minimum**(gauge)                                                         | Host.load1, average system load during the past minute. This metric is not available in Windows.*Shown as process*                                         |
| **alibabacloud.ecs.load\_1m.maximum**(gauge)                                                         | Host.load1, average system load during the past minute. This metric is not available in Windows.*Shown as process*                                         |
| **alibabacloud.ecs.networkin\_errorpackages.average**(gauge)                                         | Host.netin.errorpackage, number of incoming error packets detected by the drive*Shown as packet*                                                           |
| **alibabacloud.ecs.networkin\_errorpackages.minimum**(gauge)                                         | Host.netin.errorpackage, number of incoming error packets detected by the drive*Shown as packet*                                                           |
| **alibabacloud.ecs.networkin\_errorpackages.maximum**(gauge)                                         | Host.netin.package, number of incoming error packets detected by the drive*Shown as packet*                                                                |
| **alibabacloud.ecs.networkin\_packages.average**(gauge)                                              | Host.netin.packages, number of packets received by the network adapter per second*Shown as packet*                                                         |
| **alibabacloud.ecs.networkin\_packages.minimum**(gauge)                                              | Host.netin.packages, number of packets received by the network adapter per second*Shown as packet*                                                         |
| **alibabacloud.ecs.networkin\_packages.maximum**(gauge)                                              | Host.netin.packages, number of packets received by the network adapter per second*Shown as packet*                                                         |
| **alibabacloud.ecs.networkin\_rate.average**(rate)                                                   | Host.netin.rate, number of bits received by the network adapter per second, that is, the uplink bandwidth of the network adapter*Shown as bit*             |
| **alibabacloud.ecs.networkin\_rate.minimum**(rate)                                                   | Host.netin.rate, number of bits received by the network adapter per second, that is, the uplink bandwidth of the network adapter*Shown as bit*             |
| **alibabacloud.ecs.networkin\_rate.maximum**(rate)                                                   | Host.netin.rate, number of bits received by the network adapter per second, that is, the uplink bandwidth of the network adapter*Shown as bit*             |
| **alibabacloud.ecs.networkout\_errorpackages.average**(gauge)                                        | Host.netout.errorpackages, number of outgoing error packets detected by the drive*Shown as packet*                                                         |
| **alibabacloud.ecs.networkout\_errorpackages.minimum**(gauge)                                        | Host.netout.errorpackages, number of outgoing error packets detected by the drive*Shown as packet*                                                         |
| **alibabacloud.ecs.networkout\_errorpackages.maximum**(gauge)                                        | Host.netout.errorpackages, number of outgoing error packets detected by the drive*Shown as packet*                                                         |
| **alibabacloud.ecs.networkout\_packages.average**(gauge)                                             | Host.netout.packages, number of packets sent by the network adapter per second*Shown as packet*                                                            |
| **alibabacloud.ecs.networkout\_packages.minimum**(gauge)                                             | Host.netout.packages, number of packets sent by the network adapter per second*Shown as packet*                                                            |
| **alibabacloud.ecs.networkout\_packages.maximum**(gauge)                                             | Host.netout.packages, number of packets sent by the network adapter per second*Shown as packet*                                                            |
| **alibabacloud.ecs.networkout\_rate.average**(rate)                                                  | Host.netout.rate, number of bits received by the network adapter per second, that is, the downlink bandwidth of the network adapter*Shown as bit*          |
| **alibabacloud.ecs.networkout\_rate.minimum**(rate)                                                  | Host.netout.rate, number of bits received by the network adapter per second, that is, the downlink bandwidth of the network adapter*Shown as bit*          |
| **alibabacloud.ecs.networkout\_rate.maximum**(rate)                                                  | Host.netout.rate, number of bits received by the network adapter per second, that is, the downlink bandwidth of the network adapter*Shown as bit*          |
| **alibabacloud.express\_connect.intranet\_rx**(gauge)                                                | Inbound network traffic.*Shown as byte*                                                                                                                    |
| **alibabacloud.express\_connect.intranet\_tx**(gauge)                                                | Outbound network traffic.*Shown as byte*                                                                                                                   |
| **alibabacloud.express\_connect.rate\_limit\_drop\_pps**(rate)                                       | Rate limit drop packets.*Shown as packet*                                                                                                                  |
| **alibabacloud.express\_connect.receive\_bandwidth**(rate)                                           | Inbound network bandwidth.*Shown as bit*                                                                                                                   |
| **alibabacloud.express\_connect.transported\_bandwidth**(rate)                                       | Outbound network bandwidth.*Shown as bit*                                                                                                                  |
| **alibabacloud.express\_connect.router\_interface\_response\_time.maximum**(gauge)                   | Latency.*Shown as millisecond*                                                                                                                             |
| **alibabacloud.express\_connect.router\_interface\_loss\_rate.maximum**(gauge)                       | The percentage of the packet loss rate.*Shown as percent*                                                                                                  |
| **alibabacloud.container\_service.cluster.cpu.limit**(gauge)                                         | Cluster CPU limit.*Shown as core*                                                                                                                          |
| **alibabacloud.container\_service.cluster.cpu.request**(gauge)                                       | Cluster CPU request.*Shown as core*                                                                                                                        |
| **alibabacloud.container\_service.cluster.cpu.usage\_rate**(gauge)                                   | Cluster CPU usage rate.*Shown as core*                                                                                                                     |
| **alibabacloud.container\_service.cluster.cpu.utilization**(gauge)                                   | Cluster CPU utilization.*Shown as percent*                                                                                                                 |
| **alibabacloud.container\_service.cluster.memory.limit**(gauge)                                      | Cluster memory limit.*Shown as byte*                                                                                                                       |
| **alibabacloud.container\_service.cluster.memory.request**(gauge)                                    | Cluster memory request.*Shown as byte*                                                                                                                     |
| **alibabacloud.container\_service.cluster.memory.utilization**(gauge)                                | Cluster memory utilization.*Shown as percent*                                                                                                              |
| **alibabacloud.container\_service.node.cpu.allocatable**(gauge)                                      | Node CPU allocatable.*Shown as core*                                                                                                                       |
| **alibabacloud.container\_service.node.cpu.capacity**(gauge)                                         | Node CPU capacity.*Shown as core*                                                                                                                          |
| **alibabacloud.container\_service.node.cpu.limit**(gauge)                                            | Node CPU limit.*Shown as core*                                                                                                                             |
| **alibabacloud.container\_service.node.cpu.oversale\_rate**(rate)                                    | Node CPU oversale rate.*Shown as core*                                                                                                                     |
| **alibabacloud.container\_service.node.cpu.request**(gauge)                                          | Node CPU request.*Shown as core*                                                                                                                           |
| **alibabacloud.container\_service.node.cpu.usage\_rate**(rate)                                       | Node CPU usage rate.*Shown as core*                                                                                                                        |
| **alibabacloud.container\_service.node.cpu.utilization**(gauge)                                      | Node CPU utilization.*Shown as percent*                                                                                                                    |
| **alibabacloud.container\_service.node.filesystem.available**(gauge)                                 | Node filesystem available.*Shown as node*                                                                                                                  |
| **alibabacloud.container\_service.node.filesystem.inodes**(gauge)                                    | Node filesystem inodes.*Shown as inode*                                                                                                                    |
| **alibabacloud.container\_service.node.filesystem.limit**(gauge)                                     | Node filesystem limit.*Shown as node*                                                                                                                      |
| **alibabacloud.container\_service.node.filesystem.usage**(gauge)                                     | Node filesystem usage.*Shown as node*                                                                                                                      |
| **alibabacloud.container\_service.node.memory.allocatable**(gauge)                                   | Node memory allocatable.*Shown as byte*                                                                                                                    |
| **alibabacloud.container\_service.node.memory.cache**(gauge)                                         | Node memory cache.*Shown as byte*                                                                                                                          |
| **alibabacloud.container\_service.node.memory.limit**(gauge)                                         | Node memory limit.*Shown as byte*                                                                                                                          |
| **alibabacloud.container\_service.node.memory.oversale\_rate**(gauge)                                | Node memory oversale rate.*Shown as percent*                                                                                                               |
| **alibabacloud.container\_service.node.memory.request**(gauge)                                       | Node memory request.*Shown as byte*                                                                                                                        |
| **alibabacloud.container\_service.node.memory.usage**(gauge)                                         | Node memory usage.*Shown as byte*                                                                                                                          |
| **alibabacloud.container\_service.node.memory.utilization**(gauge)                                   | Node memory utilization.*Shown as percent*                                                                                                                 |
| **alibabacloud.container\_service.node.memory.working\_set**(gauge)                                  | Node memory working set.*Shown as byte*                                                                                                                    |
| **alibabacloud.container\_service.node.network.rx\_errors**(gauge)                                   | Node network rx errors.*Shown as error*                                                                                                                    |
| **alibabacloud.container\_service.node.network.rx\_errors\_rate**(rate)                              | Node network rx errors rate.*Shown as byte*                                                                                                                |
| **alibabacloud.container\_service.node.network.rx\_rate**(rate)                                      | Node network rx rate.*Shown as byte*                                                                                                                       |
| **alibabacloud.container\_service.node.network.tx\_errors\_rate**(rate)                              | Node network tx errors rate.*Shown as byte*                                                                                                                |
| **alibabacloud.container\_service.node.network.tx\_rate**(rate)                                      | Node network tx rate.*Shown as byte*                                                                                                                       |
| **alibabacloud.container\_service.ns.cpu.limit**(gauge)                                              | Namespace CPU limit.*Shown as core*                                                                                                                        |
| **alibabacloud.container\_service.pod.cpu.limit**(gauge)                                             | Pod CPU limit.*Shown as core*                                                                                                                              |
| **alibabacloud.container\_service.pod.cpu.oversale\_rate**(gauge)                                    | Pod CPU oversale rate.*Shown as percent*                                                                                                                   |
| **alibabacloud.container\_service.pod.cpu.request**(gauge)                                           | Pod CPU request.*Shown as core*                                                                                                                            |
| **alibabacloud.container\_service.pod.cpu.usage\_rate**(rate)                                        | Pod CPU usage rate.*Shown as core*                                                                                                                         |
| **alibabacloud.container\_service.pod.cpu.utilization**(gauge)                                       | Pod CPU utilization.*Shown as percent*                                                                                                                     |
| **alibabacloud.container\_service.pod.memory.cache**(gauge)                                          | Pod memory cache.*Shown as byte*                                                                                                                           |
| **alibabacloud.container\_service.pod.memory.limit**(gauge)                                          | Pod memory limit.*Shown as byte*                                                                                                                           |
| **alibabacloud.container\_service.pod.memory.oversale\_rate**(gauge)                                 | Pod memory oversale rate.*Shown as percent*                                                                                                                |
| **alibabacloud.container\_service.pod.memory.request**(gauge)                                        | Pod memory request.*Shown as byte*                                                                                                                         |
| **alibabacloud.container\_service.pod.memory.rss**(gauge)                                            | Pod memory rss.*Shown as byte*                                                                                                                             |
| **alibabacloud.container\_service.pod.memory.utilization**(gauge)                                    | Pod memory utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.container\_service.pod.memory.working\_set**(gauge)                                   | Pod memory working set.*Shown as byte*                                                                                                                     |
| **alibabacloud.container\_service.pod.network.rx\_errors\_rate**(rate)                               | Pod network rx errors rate.*Shown as byte*                                                                                                                 |
| **alibabacloud.container\_service.pod.network.rx\_rate**(rate)                                       | Pod network rx rate.*Shown as byte*                                                                                                                        |
| **alibabacloud.container\_service.pod.network.tx\_errors\_rate**(rate)                               | Pod network tx errors rate.*Shown as byte*                                                                                                                 |
| **alibabacloud.container\_service.pod.network.tx\_rate**(rate)                                       | Pod network tx rate.*Shown as byte*                                                                                                                        |
| **alibabacloud.container\_service.deployment.filesystem.available**(gauge)                           | Deployment filesystem available.*Shown as byte*                                                                                                            |
| **alibabacloud.container\_service.deployment.filesystem.limit**(gauge)                               | Deployment filesystem limit.*Shown as byte*                                                                                                                |
| **alibabacloud.container\_service.pod.filesystem.available**(gauge)                                  | Pod filesystem available.*Shown as byte*                                                                                                                   |
| **alibabacloud.container\_service.pod.filesystem.limit**(gauge)                                      | Pod filesystem limit.*Shown as byte*                                                                                                                       |
| **alibabacloud.container\_service.cluster.filesystem.available**(gauge)                              | Cluster filesystem available.*Shown as byte*                                                                                                               |
| **alibabacloud.container\_service.cluster.filesystem.limit**(gauge)                                  | Cluster filesystem limit.*Shown as byte*                                                                                                                   |
| **alibabacloud.kafka.cluster\_message\_input\_v3**(rate)                                             | Input byte for V3 clusters.*Shown as byte*                                                                                                                 |
| **alibabacloud.kafka.disk\_instance\_ratio\_v3**(gauge)                                              | Disk Usage by Instance.*Shown as percent*                                                                                                                  |
| **alibabacloud.kafka.group\_message\_num\_output\_onetopic\_onepartition\_v3**(rate)                 | Number of messages per topic per partition.*Shown as message*                                                                                              |
| **alibabacloud.kafka.group\_message\_num\_output\_onetopic\_v3**(rate)                               | Number of messages per topic.*Shown as message*                                                                                                            |
| **alibabacloud.kafka.group\_message\_num\_output\_v3**(rate)                                         | Number of messages.*Shown as message*                                                                                                                      |
| **alibabacloud.kafka.instance\_batch\_size\_tp50v2**(gauge)                                          | Instance Batch Size TP50.*Shown as byte*                                                                                                                   |
| **alibabacloud.kafka.instance\_batch\_size\_tp999v2**(gauge)                                         | Instance Batch Size TP999.*Shown as byte*                                                                                                                  |
| **alibabacloud.kafka.instance\_cpu\_usage\_v2**(gauge)                                               | Instance CPU Utilization.*Shown as percent*                                                                                                                |
| **alibabacloud.kafka.instance\_disk\_log\_size\_v3**(gauge)                                          | Instance Disk log size.*Shown as byte*                                                                                                                     |
| **alibabacloud.kafka.instance\_internet\_rx\_rate\_v3**(rate)                                        | Instance inbound internet traffic.*Shown as byte*                                                                                                          |
| **alibabacloud.kafka.instance\_internet\_tx\_rate\_v3**(gauge)                                       | Instance outbound internet traffic.*Shown as byte*                                                                                                         |
| **alibabacloud.kafka.instance\_max\_connection\_ratio\_v3**(gauge)                                   | Usage of Maximum Connections per Node (Internet + Internal Network).*Shown as percent*                                                                     |
| **alibabacloud.kafka.instance\_max\_connection\_v3**(gauge)                                          | Instance max connections.*Shown as instance*                                                                                                               |
| **alibabacloud.kafka.instance\_max\_internet\_connection\_ratio\_v3**(gauge)                         | Usage of Maximum Connections per Node (Internet).*Shown as percent*                                                                                        |
| **alibabacloud.kafka.instance\_max\_internet\_connection\_v3**(gauge)                                | Instance max internet connections.*Shown as instance*                                                                                                      |
| **alibabacloud.kafka.instance\_max\_node\_input\_ratio\_v3**(gauge)                                  | Instance Max Node Input Ratio.*Shown as percent*                                                                                                           |
| **alibabacloud.kafka.instance\_max\_node\_output\_ratio\_v3**(gauge)                                 | Instance Max Node Output Ratio.*Shown as percent*                                                                                                          |
| **alibabacloud.kafka.instance\_message\_input\_ratio\_v3**(gauge)                                    | Instance message input ratio.*Shown as percent*                                                                                                            |
| **alibabacloud.kafka.instance\_message\_input\_v3**(rate)                                            | Instance message input.*Shown as byte*                                                                                                                     |
| **alibabacloud.kafka.instance\_message\_num\_input\_v3**(rate)                                       | Instance message number input.*Shown as message*                                                                                                           |
| **alibabacloud.kafka.instance\_message\_num\_output\_v3**(rate)                                      | Instance message number output.*Shown as message*                                                                                                          |
| **alibabacloud.kafka.instance\_message\_output\_ratio\_v3**(gauge)                                   | Instance message output ratio.*Shown as percent*                                                                                                           |
| **alibabacloud.kafka.instance\_message\_output\_v3**(rate)                                           | Instance message output.*Shown as byte*                                                                                                                    |
| **alibabacloud.kafka.instance\_reqs\_input\_v3**(rate)                                               | Instance CPU Utilization.*Shown as instance*                                                                                                               |
| **alibabacloud.kafka.instance\_reqs\_output\_v3**(rate)                                              | Instance CPU Utilization.*Shown as instance*                                                                                                               |
| **alibabacloud.kafka.instance\_throttle\_time\_p99\_input\_v3**(gauge)                               | Instance throttle p99 input.*Shown as millisecond*                                                                                                         |
| **alibabacloud.kafka.instance\_throttle\_time\_p99\_output\_v3**(gauge)                              | Instance throttle p99 output.*Shown as millisecond*                                                                                                        |
| **alibabacloud.kafka.instance\_total\_connection\_v3**(gauge)                                        | Instance total connections.*Shown as connection*                                                                                                           |
| **alibabacloud.kafka.instance\_total\_internet\_connection\_V3**(gauge)                              | Instance total internet connections.*Shown as percent*                                                                                                     |
| **alibabacloud.kafka.message\_accumulation\_onetopic\_v3**(gauge)                                    | Message accumulation per topic.*Shown as message*                                                                                                          |
| **alibabacloud.kafka.message\_accumulation\_v3**(gauge)                                              | Message accumulation.*Shown as message*                                                                                                                    |
| **alibabacloud.kafka.partition\_instance\_ratio\_v3**(gauge)                                         | Partition Usage by Instance*Shown as percent*                                                                                                              |
| **alibabacloud.kafka.topic\_abnormal\_ha\_partition\_v3**(gauge)                                     | Topic abnormal ha partition number.*Shown as instance*                                                                                                     |
| **alibabacloud.kafka.topic\_message\_input\_v3**(rate)                                               | Topic message input.*Shown as byte*                                                                                                                        |
| **alibabacloud.kafka.topic\_message\_num\_input\_v3**(rate)                                          | Topic message input number.*Shown as message*                                                                                                              |
| **alibabacloud.kafka.topic\_message\_num\_output\_v3**(rate)                                         | Topic message output number.*Shown as message*                                                                                                             |
| **alibabacloud.kafka.topic\_message\_output\_input\_ratio\_v3**(gauge)                               | Topic message input/output ratio.*Shown as percent*                                                                                                        |
| **alibabacloud.kafka.topic\_message\_output\_v3**(rate)                                              | Topic message output.*Shown as byte*                                                                                                                       |
| **alibabacloud.kafka.topic\_normal\_ha\_partition\_num\_v3**(gauge)                                  | Topic normal ha partition number.*Shown as instance*                                                                                                       |
| **alibabacloud.kafka.topic\_reqs\_input\_v3**(rate)                                                  | Topic requests input.*Shown as instance*                                                                                                                   |
| **alibabacloud.kafka.topic\_reqs\_output\_v3**(rate)                                                 | Topic requests output.*Shown as instance*                                                                                                                  |
| **alibabacloud.kafka.instance\_fetch\_throttle\_queue\_size\_v2**(gauge)                             | Throttled Consumption Requests of Instance.*Shown as instance*                                                                                             |
| **alibabacloud.kafka.instance\_ha\_event\_v2**(gauge)                                                | Instance HA Event.*Shown as instance*                                                                                                                      |
| **alibabacloud.kafka.instance\_internet\_rx\_rate\_by\_node**(rate)                                  | Instance inbound traffic per node.*Shown as byte*                                                                                                          |
| **alibabacloud.kafka.instance\_internet\_rx\_utilization\_by\_node**(gauge)                          | Instance inbound traffic utilization per node.*Shown as percent*                                                                                           |
| **alibabacloud.kafka.instance\_internet\_tx\_rate\_by\_node**(rate)                                  | Instance outbound traffic per node.*Shown as byte*                                                                                                         |
| **alibabacloud.kafka.instance\_internet\_tx\_utilization\_by\_node**(gauge)                          | Instance outbound traffic utilization per node.*Shown as percent*                                                                                          |
| **alibabacloud.kafka.instance\_max\_connection**(gauge)                                              | Instance max connections.*Shown as connection*                                                                                                             |
| **alibabacloud.kafka.instance\_max\_internet\_connection**(gauge)                                    | Instance max internet connections.*Shown as connection*                                                                                                    |
| **alibabacloud.kafka.instance\_max\_read\_iops\_v2**(gauge)                                          | Maximum Read IOPS per Node*Shown as operation*                                                                                                             |
| **alibabacloud.kafka.instance\_max\_write\_iops\_v2**(gauge)                                         | Maximum Write IOPS per Node.*Shown as operation*                                                                                                           |
| **alibabacloud.kafka.intance\_message\_input\_ratio\_v2**(gauge)                                     | Instance message input ratio.*Shown as percent*                                                                                                            |
| **alibabacloud.kafka.intance\_message\_output\_ratio\_v2**(gauge)                                    | Instance message output ratio.*Shown as percent*                                                                                                           |
| **alibabacloud.kafka.instance\_produce\_throttle\_queue\_size\_v2**(gauge)                           | Throttled Sending Requests of Instance.*Shown as instance*                                                                                                 |
| **alibabacloud.kafka.instance\_rebalance\_time\_v2**(gauge)                                          | Maximum Rebalance Time of Instance.*Shown as millisecond*                                                                                                  |
| **alibabacloud.kafka.instance\_total\_connection**(gauge)                                            | Instance total connections.*Shown as connection*                                                                                                           |
| **alibabacloud.kafka.instance\_total\_internet\_connection**(gauge)                                  | Instance total internet connections.*Shown as connection*                                                                                                  |
| **alibabacloud.kafka.partition\_instance\_ratio\_v2**(gauge)                                         | Partition instance ratio.*Shown as percent*                                                                                                                |
| **alibabacloud.kafka.cluster\_message\_input**(rate)                                                 | (Deprecated) cluster_message_input.*Shown as byte*                                                                                                         |
| **alibabacloud.kafka.group\_message\_num\_output**(rate)                                             | Message number output.*Shown as message*                                                                                                                   |
| **alibabacloud.kafka.group\_message\_num\_output\_onetopic**(rate)                                   | Message number output per topic.*Shown as message*                                                                                                         |
| **alibabacloud.kafka.group\_message\_num\_output\_onetopic\_onepartition**(rate)                     | (Deprecated) Message number output per topic per partition.*Shown as message*                                                                              |
| **alibabacloud.kafka.group\_topic\_accumulation\_consume\_cost\_time**(gauge)                        | Estimated Time to Clear Topic Backlog for Consumer Group.*Shown as second*                                                                                 |
| **alibabacloud.kafka.instance\_disk\_capacity.maximum**(gauge)                                       | Instance disk capacity.*Shown as percent*                                                                                                                  |
| **alibabacloud.kafka.instance\_disk\_log\_size.maximum**(gauge)                                      | Instance disk log size.*Shown as byte*                                                                                                                     |
| **alibabacloud.kafka.instance\_internet\_rx.rate**(rate)                                             | Instance internet inbound traffic.*Shown as bit*                                                                                                           |
| **alibabacloud.kafka.instance\_internet\_rxrate**(rate)                                              | (Deprecated) KafkaInternetRxV3.*Shown as bit*                                                                                                              |
| **alibabacloud.kafka.instance\_internet\_tx.rate**(rate)                                             | Instance internet outbound traffic.*Shown as bit*                                                                                                          |
| **alibabacloud.kafka.instance\_internet\_txrate**(rate)                                              | (Deprecated) KafkaInternetTxV3.*Shown as bit*                                                                                                              |
| **alibabacloud.kafka.instance\_message\_input**(rate)                                                | Instance message input.*Shown as byte*                                                                                                                     |
| **alibabacloud.kafka.instance\_message\_num\_input**(rate)                                           | Instance message number input.*Shown as message*                                                                                                           |
| **alibabacloud.kafka.instance\_message\_num\_output**(rate)                                          | Instance message number output.*Shown as message*                                                                                                          |
| **alibabacloud.kafka.instance\_message\_output**(rate)                                               | Instance message output.*Shown as byte*                                                                                                                    |
| **alibabacloud.kafka.instance\_reqs\_input**(rate)                                                   | Instance requests input.*Shown as instance*                                                                                                                |
| **alibabacloud.kafka.instance\_reqs\_output**(rate)                                                  | Instance requests output.*Shown as instance*                                                                                                               |
| **alibabacloud.kafka.message\_accumulation**(gauge)                                                  | Message accumulation.*Shown as message*                                                                                                                    |
| **alibabacloud.kafka.message\_accumulation\_onetopic**(gauge)                                        | Message accumulation per topic.*Shown as percent*                                                                                                          |
| **alibabacloud.kafka.topic\_message\_input**(rate)                                                   | Topic message input.*Shown as byte*                                                                                                                        |
| **alibabacloud.kafka.topic\_message\_num\_input**(rate)                                              | Topic message number input.*Shown as message*                                                                                                              |
| **alibabacloud.kafka.topic\_message\_num\_output**(rate)                                             | Topic message number output.*Shown as message*                                                                                                             |
| **alibabacloud.kafka.topic\_message\_output**(rate)                                                  | Topic message output.*Shown as byte*                                                                                                                       |
| **alibabacloud.kafka.topic\_message\_output\_input\_ratio**(gauge)                                   | Topic message output/input ratio.*Shown as percent*                                                                                                        |
| **alibabacloud.kafka.topic\_reqs\_input**(rate)                                                      | Topic requests input.*Shown as instance*                                                                                                                   |
| **alibabacloud.kafka.topic\_reqs\_output**(rate)                                                     | Topic requests output.*Shown as instance*                                                                                                                  |
| **alibabacloud.redis.memory\_usage.average**(gauge)                                                  | Percentage of memory in use.*Shown as percent*                                                                                                             |
| **alibabacloud.redis.memory\_usage.minimum**(gauge)                                                  | Percentage of memory in use.*Shown as percent*                                                                                                             |
| **alibabacloud.redis.memory\_usage.maximum**(gauge)                                                  | Percentage of memory in use.*Shown as percent*                                                                                                             |
| **alibabacloud.redis.connection\_usage.average**(gauge)                                              | Percentage of connections in use.*Shown as percent*                                                                                                        |
| **alibabacloud.redis.connection\_usage.minimum**(gauge)                                              | Percentage of connections in use.*Shown as percent*                                                                                                        |
| **alibabacloud.redis.connection\_usage.maximum**(gauge)                                              | Percentage of connections in use.*Shown as percent*                                                                                                        |
| **alibabacloud.redis.intranet\_in\_ratio.average**(gauge)                                            | Percentage of bandwidth consumed during write operations.*Shown as percent*                                                                                |
| **alibabacloud.redis.intranet\_in\_ratio.minimum**(gauge)                                            | Percentage of bandwidth consumed during write operations.*Shown as percent*                                                                                |
| **alibabacloud.redis.intranet\_in\_ratio.maximum**(gauge)                                            | Percentage of bandwidth consumed during write operations.*Shown as percent*                                                                                |
| **alibabacloud.redis.intranet\_in.average**(rate)                                                    | Write speed.*Shown as bit*                                                                                                                                 |
| **alibabacloud.redis.intranet\_in.minimum**(rate)                                                    | Write speed.*Shown as bit*                                                                                                                                 |
| **alibabacloud.redis.intranet\_in.maximum**(rate)                                                    | Write speed.*Shown as bit*                                                                                                                                 |
| **alibabacloud.redis.failed\_count.average**(rate)                                                   | Number of failed operations on KVSTORE.*Shown as operation*                                                                                                |
| **alibabacloud.redis.failed\_count.minimum**(rate)                                                   | Number of failed operations on KVSTORE.*Shown as operation*                                                                                                |
| **alibabacloud.redis.failed\_count.maximum**(rate)                                                   | Number of failed operations on KVSTORE.*Shown as operation*                                                                                                |
| **alibabacloud.redis.cpu\_usage.average**(gauge)                                                     | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.redis.cpu\_usage.minimum**(gauge)                                                     | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.redis.cpu\_usage.maximum**(gauge)                                                     | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.redis.used\_memory.average**(gauge)                                                   | Memory in use.*Shown as byte*                                                                                                                              |
| **alibabacloud.redis.used\_memory.minimum**(gauge)                                                   | Memory in use.*Shown as byte*                                                                                                                              |
| **alibabacloud.redis.used\_memory.maximum**(gauge)                                                   | Memory in use.*Shown as byte*                                                                                                                              |
| **alibabacloud.redis.used\_connection.average**(gauge)                                               | Number of used connections.*Shown as connection*                                                                                                           |
| **alibabacloud.redis.used\_connection.minimum**(gauge)                                               | Number of used connections.*Shown as connection*                                                                                                           |
| **alibabacloud.redis.used\_connection.maximum**(gauge)                                               | Number of used connections.*Shown as connection*                                                                                                           |
| **alibabacloud.redis.intranet\_out.maximum**(rate)                                                   | Network out rate.*Shown as byte*                                                                                                                           |
| **alibabacloud.redis.intranet\_out.minimum**(rate)                                                   | Network out rate.*Shown as byte*                                                                                                                           |
| **alibabacloud.redis.intranet\_out.average**(rate)                                                   | Network out rate.*Shown as byte*                                                                                                                           |
| **alibabacloud.redis.intranet\_out\_ratio.minimum**(rate)                                            | Outbound Bandwidth Usage.*Shown as byte*                                                                                                                   |
| **alibabacloud.redis.intranet\_out\_ratio.average**(rate)                                            | Outbound Bandwidth Usage.*Shown as byte*                                                                                                                   |
| **alibabacloud.redis.intranet\_out\_ratio.maximum**(rate)                                            | Outbound Bandwidth Usage.*Shown as byte*                                                                                                                   |
| **alibabacloud.redis.sharding\_avg\_rt.maximum**(gauge)                                              | Sharding rate.*Shown as microsecond*                                                                                                                       |
| **alibabacloud.redis.sharding\_avg\_rt.average**(gauge)                                              | Sharding rate.*Shown as microsecond*                                                                                                                       |
| **alibabacloud.redis.sharding\_connection\_usage.average**(gauge)                                    | Sharding connection usage.*Shown as percent*                                                                                                               |
| **alibabacloud.redis.sharding\_connection\_usage.maximum**(gauge)                                    | Sharding connection usage.*Shown as percent*                                                                                                               |
| **alibabacloud.redis.sharding\_cpu\_usage.maximum**(gauge)                                           | Sharding CPU usage.*Shown as percent*                                                                                                                      |
| **alibabacloud.redis.sharding\_cpu\_usage.average**(gauge)                                           | Sharding CPU usage.*Shown as percent*                                                                                                                      |
| **alibabacloud.redis.sharding\_hit\_rate.maximum**(gauge)                                            | Sharding hit rate.*Shown as percent*                                                                                                                       |
| **alibabacloud.redis.sharding\_hit\_rate.average**(gauge)                                            | Sharding hit rate.*Shown as percent*                                                                                                                       |
| **alibabacloud.redis.sharding\_intranet\_in.average**(rate)                                          | Sharding intranet input.*Shown as kibibyte*                                                                                                                |
| **alibabacloud.redis.sharding\_intranet\_in.maximum**(rate)                                          | Sharding intranet input.*Shown as kibibyte*                                                                                                                |
| **alibabacloud.redis.sharding\_intranet\_in\_ratio.average**(gauge)                                  | Sharding intranet input ratio.*Shown as percent*                                                                                                           |
| **alibabacloud.redis.sharding\_intranet\_in\_ratio.maximum**(gauge)                                  | Sharding intranet input ratio.*Shown as percent*                                                                                                           |
| **alibabacloud.redis.sharding\_intranet\_out.average**(rate)                                         | Sharding intranet output.*Shown as kibibyte*                                                                                                               |
| **alibabacloud.redis.sharding\_intranet\_out.maximum**(rate)                                         | Sharding intranet output.*Shown as kibibyte*                                                                                                               |
| **alibabacloud.redis.sharding\_intranet\_out\_ratio.average**(gauge)                                 | Sharding intranet output ratio.*Shown as percent*                                                                                                          |
| **alibabacloud.redis.sharding\_intranet\_out\_ratio.maximum**(gauge)                                 | Sharding intranet output ratio.*Shown as percent*                                                                                                          |
| **alibabacloud.redis.sharding\_keys.average**(gauge)                                                 | Sharding keys.*Shown as key*                                                                                                                               |
| **alibabacloud.redis.sharding\_keys.maximum**(gauge)                                                 | Sharding keys.*Shown as key*                                                                                                                               |
| **alibabacloud.redis.sharding\_memory\_usage.average**(gauge)                                        | Sharding memory usage*Shown as percent*                                                                                                                    |
| **alibabacloud.redis.sharding\_memory\_usage.maximum**(gauge)                                        | Sharding memory usage*Shown as percent*                                                                                                                    |
| **alibabacloud.redis.sharding\_proxy\_avg\_request\_size.average**(gauge)                            | Average request size.*Shown as byte*                                                                                                                       |
| **alibabacloud.redis.sharding\_proxy\_avg\_request\_size.maximum**(gauge)                            | Average request size.*Shown as byte*                                                                                                                       |
| **alibabacloud.redis.sharding\_proxy\_avg\_response\_size.average**(gauge)                           | Average response size.*Shown as byte*                                                                                                                      |
| **alibabacloud.redis.sharding\_proxy\_avg\_response\_size.maximum**(gauge)                           | Average response size.*Shown as byte*                                                                                                                      |
| **alibabacloud.redis.sharding\_proxy\_avg\_rt.average**(gauge)                                       | Sharding proxy average response time.*Shown as microsecond*                                                                                                |
| **alibabacloud.redis.sharding\_proxy\_avg\_rt.maximum**(gauge)                                       | Sharding proxy average response time.*Shown as microsecond*                                                                                                |
| **alibabacloud.redis.sharding\_proxy\_connection\_usage.average**(gauge)                             | Sharding proxy connection usage.*Shown as percent*                                                                                                         |
| **alibabacloud.redis.sharding\_proxy\_connection\_usage.maximum**(gauge)                             | Sharding proxy connection usage.*Shown as percent*                                                                                                         |
| **alibabacloud.redis.sharding\_proxy\_cpu\_usage.average**(gauge)                                    | Sharding proxy CPU utilization.*Shown as percent*                                                                                                          |
| **alibabacloud.redis.sharding\_proxy\_cpu\_usage.maximum**(gauge)                                    | Sharding proxy CPU utilization.*Shown as percent*                                                                                                          |
| **alibabacloud.redis.sharding\_proxy\_intranet\_in.average**(rate)                                   | Sharding proxy intranet input.*Shown as kibibyte*                                                                                                          |
| **alibabacloud.redis.sharding\_proxy\_intranet\_in.maximum**(rate)                                   | Sharding proxy intranet input.*Shown as kibibyte*                                                                                                          |
| **alibabacloud.redis.sharding\_proxy\_intranet\_out.average**(rate)                                  | Sharding proxy intranet output.*Shown as kibibyte*                                                                                                         |
| **alibabacloud.redis.sharding\_proxy\_intranet\_out.maximum**(rate)                                  | Sharding proxy intranet output.*Shown as kibibyte*                                                                                                         |
| **alibabacloud.redis.sharding\_proxy\_max\_request\_size.average**(gauge)                            | Sharding proxy max request size.*Shown as byte*                                                                                                            |
| **alibabacloud.redis.sharding\_proxy\_max\_request\_size.maximum**(gauge)                            | Sharding proxy max request size.*Shown as byte*                                                                                                            |
| **alibabacloud.redis.sharding\_proxy\_max\_response\_size.average**(gauge)                           | Sharding proxy max response size.*Shown as byte*                                                                                                           |
| **alibabacloud.redis.sharding\_proxy\_max\_response\_size.maximum**(gauge)                           | Sharding proxy max response size.*Shown as byte*                                                                                                           |
| **alibabacloud.redis.sharding\_proxy\_total\_qps.average**(rate)                                     | Sharding proxy query per second*Shown as query*                                                                                                            |
| **alibabacloud.redis.sharding\_proxy\_total\_qps.maximum**(rate)                                     | Sharding proxy query per second*Shown as query*                                                                                                            |
| **alibabacloud.redis.sharding\_proxy\_used\_connection.average**(gauge)                              | Sharding proxy used connections.*Shown as connection*                                                                                                      |
| **alibabacloud.redis.sharding\_proxy\_used\_connection.maximum**(gauge)                              | Sharding proxy used connections.*Shown as connection*                                                                                                      |
| **alibabacloud.redis.sharding\_sync\_delay\_time.average**(gauge)                                    | Multi active sync delay time.*Shown as second*                                                                                                             |
| **alibabacloud.redis.sharding\_sync\_delay\_time.maximum**(gauge)                                    | Multi active sync delay time.*Shown as second*                                                                                                             |
| **alibabacloud.redis.sharding\_used\_connection.average**(gauge)                                     | Sharding used connections.*Shown as connection*                                                                                                            |
| **alibabacloud.redis.sharding\_used\_connection.maximum**(gauge)                                     | Sharding used connections.*Shown as connection*                                                                                                            |
| **alibabacloud.redis.sharding\_used\_memory.average**(gauge)                                         | Sharding used memory.*Shown as byte*                                                                                                                       |
| **alibabacloud.redis.sharding\_used\_memory.maximum**(gauge)                                         | Sharding used memory.*Shown as byte*                                                                                                                       |
| **alibabacloud.redis.sharding\_used\_qps.average**(gauge)                                            | Sharding used queries.*Shown as query*                                                                                                                     |
| **alibabacloud.redis.sharding\_used\_qps.maximum**(gauge)                                            | Sharding used queries.*Shown as query*                                                                                                                     |
| **alibabacloud.redis.splitrw\_avg\_rt.average**(gauge)                                               | Average response time.*Shown as microsecond*                                                                                                               |
| **alibabacloud.redis.splitrw\_avg\_rt.maximum**(gauge)                                               | Average response time.*Shown as microsecond*                                                                                                               |
| **alibabacloud.redis.splitrw\_connection\_usage.average**(gauge)                                     | Connection utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.redis.splitrw\_connection\_usage.maximum**(gauge)                                     | Connection utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.redis.splitrw\_cpu\_usage.average**(gauge)                                            | CPU utilization.*Shown as percent*                                                                                                                         |
| **alibabacloud.redis.splitrw\_cpu\_usage.maximum**(gauge)                                            | CPU utilization.*Shown as percent*                                                                                                                         |
| **alibabacloud.redis.splitrw\_hit\_rate.average**(gauge)                                             | Hit rate.*Shown as percent*                                                                                                                                |
| **alibabacloud.redis.splitrw\_hit\_rate.maximum**(gauge)                                             | Hit rate.*Shown as percent*                                                                                                                                |
| **alibabacloud.redis.splitrw\_intranet\_in.average**(rate)                                           | Intranet input.*Shown as kibibyte*                                                                                                                         |
| **alibabacloud.redis.splitrw\_intranet\_in.maximum**(rate)                                           | Intranet input.*Shown as kibibyte*                                                                                                                         |
| **alibabacloud.redis.splitrw\_intranet\_in\_ratio.average**(gauge)                                   | Intranet input ratio.*Shown as percent*                                                                                                                    |
| **alibabacloud.redis.splitrw\_intranet\_in\_ratio.maximum**(gauge)                                   | Intranet input ratio.*Shown as percent*                                                                                                                    |
| **alibabacloud.redis.splitrw\_intranet\_out.average**(rate)                                          | Intranet output.*Shown as kibibyte*                                                                                                                        |
| **alibabacloud.redis.splitrw\_intranet\_out.maximum**(rate)                                          | Intranet output.*Shown as kibibyte*                                                                                                                        |
| **alibabacloud.redis.splitrw\_intranet\_out\_ratio.average**(gauge)                                  | Intranet output ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.redis.splitrw\_intranet\_out\_ratio.maximum**(gauge)                                  | Intranet output ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.redis.splitrw\_keys.average**(gauge)                                                  | Number of keys.*Shown as key*                                                                                                                              |
| **alibabacloud.redis.splitrw\_keys.maximum**(gauge)                                                  | Number of keys.*Shown as key*                                                                                                                              |
| **alibabacloud.redis.splitrw\_memory\_usage.average**(gauge)                                         | Memory utilization.*Shown as percent*                                                                                                                      |
| **alibabacloud.redis.splitrw\_memory\_usage.maximum**(gauge)                                         | Memory utilization.*Shown as percent*                                                                                                                      |
| **alibabacloud.redis.splitrw\_proxy\_avg\_request\_size.average**(gauge)                             | Average request size.*Shown as byte*                                                                                                                       |
| **alibabacloud.redis.splitrw\_proxy\_avg\_request\_size.maximum**(gauge)                             | Average request size.*Shown as byte*                                                                                                                       |
| **alibabacloud.redis.splitrw\_proxy\_avg\_response\_size.average**(gauge)                            | Average response size.*Shown as byte*                                                                                                                      |
| **alibabacloud.redis.splitrw\_proxy\_avg\_response\_size.maximum**(gauge)                            | Average response size.*Shown as byte*                                                                                                                      |
| **alibabacloud.redis.splitrw\_proxy\_avg\_rt.average**(gauge)                                        | Average response time.*Shown as microsecond*                                                                                                               |
| **alibabacloud.redis.splitrw\_proxy\_avg\_rt.maximum**(gauge)                                        | Average response time.*Shown as microsecond*                                                                                                               |
| **alibabacloud.redis.splitrw\_proxy\_connection\_usage.average**(gauge)                              | Connection utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.redis.splitrw\_proxy\_connection\_usage.maximum**(gauge)                              | Connection utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.redis.splitrw\_proxy\_cpu\_usage.average**(gauge)                                     | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.redis.splitrw\_proxy\_cpu\_usage.maximum**(gauge)                                     | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.redis.splitrw\_proxy\_intranet\_in.average**(rate)                                    | Intranet input.*Shown as kibibyte*                                                                                                                         |
| **alibabacloud.redis.splitrw\_proxy\_intranet\_in.maximum**(rate)                                    | Intranet input.*Shown as kibibyte*                                                                                                                         |
| **alibabacloud.redis.splitrw\_proxy\_intranet\_out.average**(rate)                                   | Intranet output.*Shown as kibibyte*                                                                                                                        |
| **alibabacloud.redis.splitrw\_proxy\_intranet\_out.maximum**(rate)                                   | Intranet output.*Shown as kibibyte*                                                                                                                        |
| **alibabacloud.redis.splitrw\_proxy\_max\_request\_size.average**(gauge)                             | Max request size.*Shown as byte*                                                                                                                           |
| **alibabacloud.redis.splitrw\_proxy\_max\_request\_size.maximum**(gauge)                             | Max request size.*Shown as byte*                                                                                                                           |
| **alibabacloud.redis.splitrw\_proxy\_max\_response\_size.average**(gauge)                            | Max response size.*Shown as byte*                                                                                                                          |
| **alibabacloud.redis.splitrw\_proxy\_max\_response\_size.maximum**(gauge)                            | Max response size.*Shown as byte*                                                                                                                          |
| **alibabacloud.redis.splitrw\_proxy\_total\_qps.average**(rate)                                      | Query per second.*Shown as query*                                                                                                                          |
| **alibabacloud.redis.splitrw\_proxy\_total\_qps.maximum**(rate)                                      | Query per second.*Shown as query*                                                                                                                          |
| **alibabacloud.redis.splitrw\_proxy\_used\_connection.average**(gauge)                               | Used connection.*Shown as connection*                                                                                                                      |
| **alibabacloud.redis.splitrw\_proxy\_used\_connection.maximum**(gauge)                               | Used connection.*Shown as connection*                                                                                                                      |
| **alibabacloud.redis.splitrw\_used\_connection.average**(gauge)                                      | Used connection.*Shown as connection*                                                                                                                      |
| **alibabacloud.redis.splitrw\_used\_connection.maximum**(gauge)                                      | Used connection.*Shown as connection*                                                                                                                      |
| **alibabacloud.redis.splitrw\_used\_memory.average**(gauge)                                          | Memory utilization.*Shown as byte*                                                                                                                         |
| **alibabacloud.redis.splitrw\_used\_memory.maximum**(gauge)                                          | Memory utilization.*Shown as byte*                                                                                                                         |
| **alibabacloud.redis.splitrw\_used\_qps.average**(gauge)                                             | Query utilization.*Shown as query*                                                                                                                         |
| **alibabacloud.redis.splitrw\_used\_qps.maximum**(gauge)                                             | Query utilization.*Shown as query*                                                                                                                         |
| **alibabacloud.redis.standard\_avg\_rt.average**(gauge)                                              | Response time.*Shown as microsecond*                                                                                                                       |
| **alibabacloud.redis.standard\_avg\_rt.maximum**(gauge)                                              | Response time.*Shown as microsecond*                                                                                                                       |
| **alibabacloud.redis.standard\_connection\_usage.average**(gauge)                                    | Connection utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.redis.standard\_connection\_usage.maximum**(gauge)                                    | Connection utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.redis.standard\_cpu\_usage.average**(gauge)                                           | CPU utilization.*Shown as percent*                                                                                                                         |
| **alibabacloud.redis.standard\_cpu\_usage.maximum**(gauge)                                           | CPU utilization.*Shown as percent*                                                                                                                         |
| **alibabacloud.redis.standard\_hit\_rate.average**(gauge)                                            | Hit rate.*Shown as percent*                                                                                                                                |
| **alibabacloud.redis.standard\_hit\_rate.maximum**(gauge)                                            | Hit rate.*Shown as percent*                                                                                                                                |
| **alibabacloud.redis.standard\_intranet\_in.average**(rate)                                          | Intranet input.*Shown as kibibyte*                                                                                                                         |
| **alibabacloud.redis.standard\_intranet\_in.maximum**(rate)                                          | Intranet input.*Shown as kibibyte*                                                                                                                         |
| **alibabacloud.redis.standard\_intranet\_out.average**(rate)                                         | Intranet output.*Shown as kibibyte*                                                                                                                        |
| **alibabacloud.redis.standard\_intranet\_out.maximum**(rate)                                         | Intranet output.*Shown as kibibyte*                                                                                                                        |
| **alibabacloud.redis.standard\_intranet\_in\_ratio.average**(gauge)                                  | Intranet input ratio.*Shown as percent*                                                                                                                    |
| **alibabacloud.redis.standard\_intranet\_in\_ratio.maximum**(gauge)                                  | Intranet input ratio.*Shown as percent*                                                                                                                    |
| **alibabacloud.redis.standard\_intranet\_out\_ratio.average**(gauge)                                 | Intranet output ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.redis.standard\_intranet\_out\_ratio.maximum**(gauge)                                 | Intranet output ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.redis.standard\_keys.average**(gauge)                                                 | Standard keys.*Shown as key*                                                                                                                               |
| **alibabacloud.redis.standard\_keys.maximum**(gauge)                                                 | Standard keys.*Shown as key*                                                                                                                               |
| **alibabacloud.redis.standard\_memory\_usage.average**(gauge)                                        | Memory utilization.*Shown as percent*                                                                                                                      |
| **alibabacloud.redis.standard\_memory\_usage.maximum**(gauge)                                        | Memory utilization.*Shown as percent*                                                                                                                      |
| **alibabacloud.redis.standard\_used\_connection.average**(gauge)                                     | Connection utilization.*Shown as connection*                                                                                                               |
| **alibabacloud.redis.standard\_used\_connection.maximum**(gauge)                                     | Connection utilization.*Shown as connection*                                                                                                               |
| **alibabacloud.redis.standard\_used\_memory.average**(gauge)                                         | Memory utilization.*Shown as byte*                                                                                                                         |
| **alibabacloud.redis.standard\_used\_memory.maximum**(gauge)                                         | Memory utilization.*Shown as byte*                                                                                                                         |
| **alibabacloud.redis.standard\_used\_qps.average**(gauge)                                            | Query utilization.*Shown as query*                                                                                                                         |
| **alibabacloud.redis.standard\_used\_qps.maximum**(gauge)                                            | Query utilization.*Shown as query*                                                                                                                         |
| **alibabacloud.memcache.connection\_usage.average**(gauge)                                           | Connection usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.memcache.connection\_usage.minimum**(gauge)                                           | Connection usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.memcache.connection\_usage.maximum**(gauge)                                           | Connection usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.memcache.cpu\_usage.average**(gauge)                                                  | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.memcache.cpu\_usage.minimum**(gauge)                                                  | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.memcache.cpu\_usage.maximum**(gauge)                                                  | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.memcache.failed\_count.average**(gauge)                                               | Failed count.                                                                                                                                              |
| **alibabacloud.memcache.failed\_count.minimum**(gauge)                                               | Failed count.                                                                                                                                              |
| **alibabacloud.memcache.failed\_count.maximum**(gauge)                                               | Failed count.                                                                                                                                              |
| **alibabacloud.memcache.hit\_rate.average**(gauge)                                                   | Hit rate.*Shown as percent*                                                                                                                                |
| **alibabacloud.memcache.hit\_rate.maximum**(gauge)                                                   | Hit rate.*Shown as percent*                                                                                                                                |
| **alibabacloud.memcache.hit\_rate.minimum**(gauge)                                                   | Hit rate.*Shown as percent*                                                                                                                                |
| **alibabacloud.memcache.intranet\_in.average**(rate)                                                 | Inbound traffic.*Shown as byte*                                                                                                                            |
| **alibabacloud.memcache.intranet\_in.minimum**(rate)                                                 | Inbound traffic.*Shown as byte*                                                                                                                            |
| **alibabacloud.memcache.intranet\_in.maximum**(rate)                                                 | Inbound traffic.*Shown as byte*                                                                                                                            |
| **alibabacloud.memcache.intranet\_in\_ratio.average**(gauge)                                         | Inbound traffic ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.memcache.intranet\_in\_ratio.minimum**(gauge)                                         | Inbound traffic ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.memcache.intranet\_in\_ratio.maximum**(gauge)                                         | Inbound traffic ratio.*Shown as percent*                                                                                                                   |
| **alibabacloud.memcache.intranet\_out.average**(rate)                                                | Outbound traffic.*Shown as byte*                                                                                                                           |
| **alibabacloud.memcache.intranet\_out.minimum**(rate)                                                | Outbound traffic.*Shown as byte*                                                                                                                           |
| **alibabacloud.memcache.intranet\_out.maximum**(rate)                                                | Outbound traffic.*Shown as byte*                                                                                                                           |
| **alibabacloud.memcache.intranet\_out\_ratio.average**(gauge)                                        | Outbound traffic ratio.*Shown as percent*                                                                                                                  |
| **alibabacloud.memcache.intranet\_out\_ratio.minimum**(gauge)                                        | Outbound traffic ratio.*Shown as percent*                                                                                                                  |
| **alibabacloud.memcache.intranet\_out\_ratio.maximum**(gauge)                                        | Outbound traffic ratio.*Shown as percent*                                                                                                                  |
| **alibabacloud.memcache.memory\_usage.average**(gauge)                                               | Memory usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.memcache.memory\_usage.minimum**(gauge)                                               | Memory usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.memcache.memory\_usage.maximum**(gauge)                                               | Memory usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.memcache.used\_connection.average**(gauge)                                            | Used connections.*Shown as connection*                                                                                                                     |
| **alibabacloud.memcache.used\_connection.minimum**(gauge)                                            | Used connections.*Shown as connection*                                                                                                                     |
| **alibabacloud.memcache.used\_connection.maximum**(gauge)                                            | Used connections.*Shown as connection*                                                                                                                     |
| **alibabacloud.memcache.used\_memory.average**(gauge)                                                | Used memory.*Shown as byte*                                                                                                                                |
| **alibabacloud.memcache.used\_memory.minimum**(gauge)                                                | Used memory.*Shown as byte*                                                                                                                                |
| **alibabacloud.memcache.used\_memory.maximum**(gauge)                                                | Used memory.*Shown as byte*                                                                                                                                |
| **alibabacloud.mongodb.active\_conns.average**(gauge)                                                | Active connections.*Shown as connection*                                                                                                                   |
| **alibabacloud.mongodb.active\_conns.maximum**(gauge)                                                | Active connections.*Shown as connection*                                                                                                                   |
| **alibabacloud.mongodb.active\_conns.minimum**(gauge)                                                | Active connections.*Shown as connection*                                                                                                                   |
| **alibabacloud.mongodb.active\_conns\_node.average**(gauge)                                          | Active connections on node.*Shown as connection*                                                                                                           |
| **alibabacloud.mongodb.active\_conns\_node.maximum**(gauge)                                          | Active connections on node.*Shown as connection*                                                                                                           |
| **alibabacloud.mongodb.active\_conns\_node.minimum**(gauge)                                          | Active connections on node.*Shown as connection*                                                                                                           |
| **alibabacloud.mongodb.active\_read\_locks.average**(gauge)                                          | Active read locks.*Shown as lock*                                                                                                                          |
| **alibabacloud.mongodb.active\_read\_locks.maximum**(gauge)                                          | Active read locks.*Shown as lock*                                                                                                                          |
| **alibabacloud.mongodb.active\_read\_locks.minimum**(gauge)                                          | Active read locks.*Shown as lock*                                                                                                                          |
| **alibabacloud.mongodb.active\_read\_locks\_node.average**(gauge)                                    | Active read locks on node.*Shown as lock*                                                                                                                  |
| **alibabacloud.mongodb.active\_read\_locks\_node.maximum**(gauge)                                    | Active read locks on node.*Shown as lock*                                                                                                                  |
| **alibabacloud.mongodb.active\_read\_locks\_node.minimum**(gauge)                                    | Active read locks on node.*Shown as lock*                                                                                                                  |
| **alibabacloud.mongodb.active\_write\_locks.average**(gauge)                                         | Active write locks.*Shown as lock*                                                                                                                         |
| **alibabacloud.mongodb.active\_write\_locks.maximum**(gauge)                                         | Active write locks.*Shown as lock*                                                                                                                         |
| **alibabacloud.mongodb.active\_write\_locks.minimum**(gauge)                                         | Active write locks.*Shown as lock*                                                                                                                         |
| **alibabacloud.mongodb.active\_write\_locks\_node.average**(gauge)                                   | Active write locks on node.*Shown as lock*                                                                                                                 |
| **alibabacloud.mongodb.active\_write\_locks\_node.maximum**(gauge)                                   | Active write locks on node.*Shown as lock*                                                                                                                 |
| **alibabacloud.mongodb.active\_write\_locks\_node.minimum**(gauge)                                   | Active write locks on node.*Shown as lock*                                                                                                                 |
| **alibabacloud.mongodb.avail\_conns.average**(gauge)                                                 | Available connections.*Shown as connection*                                                                                                                |
| **alibabacloud.mongodb.avail\_conns.maximum**(gauge)                                                 | Available connections.*Shown as connection*                                                                                                                |
| **alibabacloud.mongodb.avail\_conns.minimum**(gauge)                                                 | Available connections.*Shown as connection*                                                                                                                |
| **alibabacloud.mongodb.avail\_conns\_node.average**(gauge)                                           | Available connections on node.*Shown as connection*                                                                                                        |
| **alibabacloud.mongodb.avail\_conns\_node.maximum**(gauge)                                           | Available connections on node.*Shown as connection*                                                                                                        |
| **alibabacloud.mongodb.avail\_conns\_node.minimum**(gauge)                                           | Available connections on node.*Shown as connection*                                                                                                        |
| **alibabacloud.mongodb.avg\_rt.average**(gauge)                                                      | Average response time.*Shown as microsecond*                                                                                                               |
| **alibabacloud.mongodb.avg\_rt.maximum**(gauge)                                                      | Average response time.*Shown as microsecond*                                                                                                               |
| **alibabacloud.mongodb.avg\_rt.minimum**(gauge)                                                      | Average response time.*Shown as microsecond*                                                                                                               |
| **alibabacloud.mongodb.avg\_rt\_node.average**(gauge)                                                | Average response time on node.*Shown as microsecond*                                                                                                       |
| **alibabacloud.mongodb.avg\_rt\_node.maximum**(gauge)                                                | Average response time on node.*Shown as microsecond*                                                                                                       |
| **alibabacloud.mongodb.avg\_rt\_node.minimum**(gauge)                                                | Average response time on node.*Shown as microsecond*                                                                                                       |
| **alibabacloud.mongodb.bytes\_read\_cache.average**(gauge)                                           | Bytes read from cache.*Shown as byte*                                                                                                                      |
| **alibabacloud.mongodb.bytes\_read\_cache.maximum**(gauge)                                           | Bytes read from cache.*Shown as byte*                                                                                                                      |
| **alibabacloud.mongodb.bytes\_read\_cache.minimum**(gauge)                                           | Bytes read from cache.*Shown as byte*                                                                                                                      |
| **alibabacloud.mongodb.bytes\_read\_cache\_node.average**(gauge)                                     | Bytes read from cache on node.*Shown as byte*                                                                                                              |
| **alibabacloud.mongodb.bytes\_read\_cache\_node.maximum**(gauge)                                     | Bytes read from cache on node.*Shown as byte*                                                                                                              |
| **alibabacloud.mongodb.bytes\_read\_cache\_node.minimum**(gauge)                                     | Bytes read from cache on node.*Shown as byte*                                                                                                              |
| **alibabacloud.mongodb.bytes\_written\_cache.average**(gauge)                                        | Bytes written to cache.*Shown as byte*                                                                                                                     |
| **alibabacloud.mongodb.bytes\_written\_cache.maximum**(gauge)                                        | Bytes written to cache.*Shown as byte*                                                                                                                     |
| **alibabacloud.mongodb.bytes\_written\_cache.minimum**(gauge)                                        | Bytes written to cache.*Shown as byte*                                                                                                                     |
| **alibabacloud.mongodb.bytes\_written\_cache\_node.average**(gauge)                                  | Bytes written to cache on node.*Shown as byte*                                                                                                             |
| **alibabacloud.mongodb.bytes\_written\_cache\_node.maximum**(gauge)                                  | Bytes written to cache on node.*Shown as byte*                                                                                                             |
| **alibabacloud.mongodb.bytes\_written\_cache\_node.minimum**(gauge)                                  | Bytes written to cache on node.*Shown as byte*                                                                                                             |
| **alibabacloud.mongodb.cpu\_utilization.average**(gauge)                                             | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.mongodb.cpu\_utilization.minimum**(gauge)                                             | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.mongodb.cpu\_utilization.maximum**(gauge)                                             | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.mongodb.cpu\_utilization\_node.average**(gauge)                                       | CPU usage on node.*Shown as percent*                                                                                                                       |
| **alibabacloud.mongodb.cpu\_utilization\_node.minimum**(gauge)                                       | CPU usage on node.*Shown as percent*                                                                                                                       |
| **alibabacloud.mongodb.cpu\_utilization\_node.maximum**(gauge)                                       | CPU usage on node.*Shown as percent*                                                                                                                       |
| **alibabacloud.mongodb.cache\_bytes.average**(gauge)                                                 | Cache size.*Shown as byte*                                                                                                                                 |
| **alibabacloud.mongodb.cache\_bytes.maximum**(gauge)                                                 | Cache size.*Shown as byte*                                                                                                                                 |
| **alibabacloud.mongodb.cache\_bytes.minimum**(gauge)                                                 | Cache size.*Shown as byte*                                                                                                                                 |
| **alibabacloud.mongodb.cache\_bytes\_node.average**(gauge)                                           | Cache size on node.*Shown as byte*                                                                                                                         |
| **alibabacloud.mongodb.cache\_bytes\_node.maximum**(gauge)                                           | Cache size on node.*Shown as byte*                                                                                                                         |
| **alibabacloud.mongodb.cache\_bytes\_node.minimum**(gauge)                                           | Cache size on node.*Shown as byte*                                                                                                                         |
| **alibabacloud.mongodb.closed\_fd\_num.average**(gauge)                                              | Closed file descriptors.*Shown as file*                                                                                                                    |
| **alibabacloud.mongodb.closed\_fd\_num.maximum**(gauge)                                              | Closed file descriptors.*Shown as file*                                                                                                                    |
| **alibabacloud.mongodb.closed\_fd\_num.minimum**(gauge)                                              | Closed file descriptors.*Shown as file*                                                                                                                    |
| **alibabacloud.mongodb.closed\_fd\_num\_node.average**(gauge)                                        | Closed file descriptors on node.*Shown as file*                                                                                                            |
| **alibabacloud.mongodb.closed\_fd\_num\_node.maximum**(gauge)                                        | Closed file descriptors on node.*Shown as file*                                                                                                            |
| **alibabacloud.mongodb.closed\_fd\_num\_node.minimum**(gauge)                                        | Closed file descriptors on node.*Shown as file*                                                                                                            |
| **alibabacloud.mongodb.cmd\_avg\_rt.average**(gauge)                                                 | Command average response time.*Shown as microsecond*                                                                                                       |
| **alibabacloud.mongodb.cmd\_avg\_rt.maximum**(gauge)                                                 | Command average response time.*Shown as microsecond*                                                                                                       |
| **alibabacloud.mongodb.cmd\_avg\_rt.minimum**(gauge)                                                 | Command average response time.*Shown as microsecond*                                                                                                       |
| **alibabacloud.mongodb.cmd\_avg\_rt\_node.average**(gauge)                                           | Command average response time on node.*Shown as microsecond*                                                                                               |
| **alibabacloud.mongodb.cmd\_avg\_rt\_node.maximum**(gauge)                                           | Command average response time on node.*Shown as microsecond*                                                                                               |
| **alibabacloud.mongodb.cmd\_avg\_rt\_node.minimum**(gauge)                                           | Command average response time on node.*Shown as microsecond*                                                                                               |
| **alibabacloud.mongodb.commands\_latency\_ps.average**(rate)                                         | Commands latency per second.*Shown as microsecond*                                                                                                         |
| **alibabacloud.mongodb.commands\_latency\_ps.maximum**(rate)                                         | Commands latency per second.*Shown as microsecond*                                                                                                         |
| **alibabacloud.mongodb.commands\_latency\_ps.minimum**(rate)                                         | Commands latency per second.*Shown as microsecond*                                                                                                         |
| **alibabacloud.mongodb.commands\_latency\_ps\_node.average**(rate)                                   | Commands latency per second on node.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.commands\_latency\_ps\_node.maximum**(rate)                                   | Commands latency per second on node.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.commands\_latency\_ps\_node.minimum**(rate)                                   | Commands latency per second on node.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.concurrent\_reads.average**(gauge)                                            | Concurrent reads.*Shown as operation*                                                                                                                      |
| **alibabacloud.mongodb.concurrent\_reads.maximum**(gauge)                                            | Concurrent reads.*Shown as operation*                                                                                                                      |
| **alibabacloud.mongodb.concurrent\_reads.minimum**(gauge)                                            | Concurrent reads.*Shown as operation*                                                                                                                      |
| **alibabacloud.mongodb.concurrent\_reads\_node.average**(gauge)                                      | Concurrent reads on node.*Shown as operation*                                                                                                              |
| **alibabacloud.mongodb.concurrent\_reads\_node.maximum**(gauge)                                      | Concurrent reads on node.*Shown as operation*                                                                                                              |
| **alibabacloud.mongodb.concurrent\_reads\_node.minimum**(gauge)                                      | Concurrent reads on node.*Shown as operation*                                                                                                              |
| **alibabacloud.mongodb.concurrent\_total.average**(gauge)                                            | Total concurrent operations.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.concurrent\_total.maximum**(gauge)                                            | Total concurrent operations.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.concurrent\_total.minimum**(gauge)                                            | Total concurrent operations.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.concurrent\_total\_node.average**(gauge)                                      | Total concurrent operations on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.concurrent\_total\_node.maximum**(gauge)                                      | Total concurrent operations on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.concurrent\_total\_node.minimum**(gauge)                                      | Total concurrent operations on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.concurrent\_writes.average**(gauge)                                           | Concurrent writes.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.concurrent\_writes.maximum**(gauge)                                           | Concurrent writes.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.concurrent\_writes.minimum**(gauge)                                           | Concurrent writes.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.concurrent\_writes\_node.average**(gauge)                                     | Concurrent writes on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.concurrent\_writes\_node.maximum**(gauge)                                     | Concurrent writes on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.concurrent\_writes\_node.minimum**(gauge)                                     | Concurrent writes on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.connection\_amount.average**(gauge)                                           | Used connections.*Shown as connection*                                                                                                                     |
| **alibabacloud.mongodb.connection\_amount.minimum**(gauge)                                           | Used connections.*Shown as connection*                                                                                                                     |
| **alibabacloud.mongodb.connection\_amount.maximum**(gauge)                                           | Used connections.*Shown as connection*                                                                                                                     |
| **alibabacloud.mongodb.connection\_amount\_node.average**(gauge)                                     | Used connections on node.*Shown as connection*                                                                                                             |
| **alibabacloud.mongodb.connection\_amount\_node.minimum**(gauge)                                     | Used connections on node.*Shown as connection*                                                                                                             |
| **alibabacloud.mongodb.connection\_amount\_node.maximum**(gauge)                                     | Used connections on node.*Shown as connection*                                                                                                             |
| **alibabacloud.mongodb.connection\_utilization.average**(gauge)                                      | Connection usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.connection\_utilization.minimum**(gauge)                                      | Connection usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.connection\_utilization.maximum**(gauge)                                      | Connection usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.connection\_utilization\_node.average**(gauge)                                | Connection usage on node.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.connection\_utilization\_node.minimum**(gauge)                                | Connection usage on node.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.connection\_utilization\_node.maximum**(gauge)                                | Connection usage on node.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.conns\_created\_ps.average**(rate)                                            | Connections created per second.*Shown as connection*                                                                                                       |
| **alibabacloud.mongodb.conns\_created\_ps.maximum**(rate)                                            | Connections created per second.*Shown as connection*                                                                                                       |
| **alibabacloud.mongodb.conns\_created\_ps.minimum**(rate)                                            | Connections created per second.*Shown as connection*                                                                                                       |
| **alibabacloud.mongodb.conns\_created\_ps\_node.average**(rate)                                      | Connections created per second on node.*Shown as connection*                                                                                               |
| **alibabacloud.mongodb.conns\_created\_ps\_node.maximum**(rate)                                      | Connections created per second on node.*Shown as connection*                                                                                               |
| **alibabacloud.mongodb.conns\_created\_ps\_node.minimum**(rate)                                      | Connections created per second on node.*Shown as connection*                                                                                               |
| **alibabacloud.mongodb.cpu\_sys.average**(gauge)                                                     | System CPU usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.cpu\_sys.maximum**(gauge)                                                     | System CPU usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.cpu\_sys.minimum**(gauge)                                                     | System CPU usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.cpu\_sys\_node.average**(gauge)                                               | System CPU usage on node.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.cpu\_sys\_node.maximum**(gauge)                                               | System CPU usage on node.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.cpu\_sys\_node.minimum**(gauge)                                               | System CPU usage on node.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.cpu\_user.average**(gauge)                                                    | User CPU usage.*Shown as percent*                                                                                                                          |
| **alibabacloud.mongodb.cpu\_user.maximum**(gauge)                                                    | User CPU usage.*Shown as percent*                                                                                                                          |
| **alibabacloud.mongodb.cpu\_user.minimum**(gauge)                                                    | User CPU usage.*Shown as percent*                                                                                                                          |
| **alibabacloud.mongodb.cpu\_user\_node.average**(gauge)                                              | User CPU usage on node.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.cpu\_user\_node.maximum**(gauge)                                              | User CPU usage on node.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.cpu\_user\_node.minimum**(gauge)                                              | User CPU usage on node.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.cursors\_timed\_out.average**(gauge)                                          | Cursors timed out.*Shown as cursor*                                                                                                                        |
| **alibabacloud.mongodb.cursors\_timed\_out.maximum**(gauge)                                          | Cursors timed out.*Shown as cursor*                                                                                                                        |
| **alibabacloud.mongodb.cursors\_timed\_out.minimum**(gauge)                                          | Cursors timed out.*Shown as cursor*                                                                                                                        |
| **alibabacloud.mongodb.cursors\_timed\_out\_node.average**(gauge)                                    | Cursors timed out on node.*Shown as cursor*                                                                                                                |
| **alibabacloud.mongodb.cursors\_timed\_out\_node.maximum**(gauge)                                    | Cursors timed out on node.*Shown as cursor*                                                                                                                |
| **alibabacloud.mongodb.cursors\_timed\_out\_node.minimum**(gauge)                                    | Cursors timed out on node.*Shown as cursor*                                                                                                                |
| **alibabacloud.mongodb.data\_disk\_amount.average**(gauge)                                           | Log disk space used.*Shown as byte*                                                                                                                        |
| **alibabacloud.mongodb.data\_disk\_amount.minimum**(gauge)                                           | Log disk space used.*Shown as byte*                                                                                                                        |
| **alibabacloud.mongodb.data\_disk\_amount.maximum**(gauge)                                           | Log disk space used.*Shown as byte*                                                                                                                        |
| **alibabacloud.mongodb.data\_disk\_amount\_node.average**(gauge)                                     | Log disk space used on node.*Shown as byte*                                                                                                                |
| **alibabacloud.mongodb.data\_disk\_amount\_node.minimum**(gauge)                                     | Log disk space used on node.*Shown as byte*                                                                                                                |
| **alibabacloud.mongodb.data\_disk\_amount\_node.maximum**(gauge)                                     | Log disk space used on node.*Shown as byte*                                                                                                                |
| **alibabacloud.mongodb.data\_iops.average**(rate)                                                    | Data IOPS.*Shown as operation*                                                                                                                             |
| **alibabacloud.mongodb.data\_iops.maximum**(rate)                                                    | Data IOPS.*Shown as operation*                                                                                                                             |
| **alibabacloud.mongodb.data\_iops.minimum**(rate)                                                    | Data IOPS.*Shown as operation*                                                                                                                             |
| **alibabacloud.mongodb.data\_iops\_node.average**(rate)                                              | Data IOPS on node.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.data\_iops\_node.maximum**(rate)                                              | Data IOPS on node.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.data\_iops\_node.minimum**(rate)                                              | Data IOPS on node.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.dirty\_cache\_bytes.average**(gauge)                                          | Dirty cache bytes.*Shown as byte*                                                                                                                          |
| **alibabacloud.mongodb.dirty\_cache\_bytes.maximum**(gauge)                                          | Dirty cache bytes.*Shown as byte*                                                                                                                          |
| **alibabacloud.mongodb.dirty\_cache\_bytes.minimum**(gauge)                                          | Dirty cache bytes.*Shown as byte*                                                                                                                          |
| **alibabacloud.mongodb.dirty\_cache\_bytes\_node.average**(gauge)                                    | Dirty cache bytes on node.*Shown as byte*                                                                                                                  |
| **alibabacloud.mongodb.dirty\_cache\_bytes\_node.maximum**(gauge)                                    | Dirty cache bytes on node.*Shown as byte*                                                                                                                  |
| **alibabacloud.mongodb.dirty\_cache\_bytes\_node.minimum**(gauge)                                    | Dirty cache bytes on node.*Shown as byte*                                                                                                                  |
| **alibabacloud.mongodb.disk\_utilization.average**(gauge)                                            | Disk usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.mongodb.disk\_utilization.minimum**(gauge)                                            | Disk usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.mongodb.disk\_utilization.maximum**(gauge)                                            | Disk usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.mongodb.disk\_utilization\_node.average**(gauge)                                      | Disk usage on node.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.disk\_utilization\_node.minimum**(gauge)                                      | Disk usage on node.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.disk\_utilization\_node.maximum**(gauge)                                      | Disk usage on node.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.docs\_deleted\_ps.average**(rate)                                             | Documents deleted per second.*Shown as document*                                                                                                           |
| **alibabacloud.mongodb.docs\_deleted\_ps.maximum**(rate)                                             | Documents deleted per second.*Shown as document*                                                                                                           |
| **alibabacloud.mongodb.docs\_deleted\_ps.minimum**(rate)                                             | Documents deleted per second.*Shown as document*                                                                                                           |
| **alibabacloud.mongodb.docs\_deleted\_ps\_node.average**(rate)                                       | Documents deleted per second on node.*Shown as document*                                                                                                   |
| **alibabacloud.mongodb.docs\_deleted\_ps\_node.maximum**(rate)                                       | Documents deleted per second on node.*Shown as document*                                                                                                   |
| **alibabacloud.mongodb.docs\_deleted\_ps\_node.minimum**(rate)                                       | Documents deleted per second on node.*Shown as document*                                                                                                   |
| **alibabacloud.mongodb.docs\_inserted\_ps.average**(rate)                                            | Documents inserted per second.*Shown as document*                                                                                                          |
| **alibabacloud.mongodb.docs\_inserted\_ps.maximum**(rate)                                            | Documents inserted per second.*Shown as document*                                                                                                          |
| **alibabacloud.mongodb.docs\_inserted\_ps.minimum**(rate)                                            | Documents inserted per second.*Shown as document*                                                                                                          |
| **alibabacloud.mongodb.docs\_inserted\_ps\_node.average**(rate)                                      | Documents inserted per second on node.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.docs\_inserted\_ps\_node.maximum**(rate)                                      | Documents inserted per second on node.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.docs\_inserted\_ps\_node.minimum**(rate)                                      | Documents inserted per second on node.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.docs\_returned\_ps.average**(rate)                                            | Documents returned per second.*Shown as document*                                                                                                          |
| **alibabacloud.mongodb.docs\_returned\_ps.maximum**(rate)                                            | Documents returned per second.*Shown as document*                                                                                                          |
| **alibabacloud.mongodb.docs\_returned\_ps.minimum**(rate)                                            | Documents returned per second.*Shown as document*                                                                                                          |
| **alibabacloud.mongodb.docs\_returned\_ps\_node.average**(rate)                                      | Documents returned per second on node.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.docs\_returned\_ps\_node.maximum**(rate)                                      | Documents returned per second on node.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.docs\_returned\_ps\_node.minimum**(rate)                                      | Documents returned per second on node.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.docs\_updated\_ps.average**(rate)                                             | Documents updated per second.*Shown as document*                                                                                                           |
| **alibabacloud.mongodb.docs\_updated\_ps.maximum**(rate)                                             | Documents updated per second.*Shown as document*                                                                                                           |
| **alibabacloud.mongodb.docs\_updated\_ps.minimum**(rate)                                             | Documents updated per second.*Shown as document*                                                                                                           |
| **alibabacloud.mongodb.docs\_updated\_ps\_node.average**(rate)                                       | Documents updated per second on node.*Shown as document*                                                                                                   |
| **alibabacloud.mongodb.docs\_updated\_ps\_node.maximum**(rate)                                       | Documents updated per second on node.*Shown as document*                                                                                                   |
| **alibabacloud.mongodb.docs\_updated\_ps\_node.minimum**(rate)                                       | Documents updated per second on node.*Shown as document*                                                                                                   |
| **alibabacloud.mongodb.eviction\_check\_entries.average**(gauge)                                     | Eviction check entries.*Shown as entry*                                                                                                                    |
| **alibabacloud.mongodb.eviction\_check\_entries.maximum**(gauge)                                     | Eviction check entries.*Shown as entry*                                                                                                                    |
| **alibabacloud.mongodb.eviction\_check\_entries.minimum**(gauge)                                     | Eviction check entries.*Shown as entry*                                                                                                                    |
| **alibabacloud.mongodb.eviction\_check\_entries\_node.average**(gauge)                               | Eviction check entries on node.*Shown as entry*                                                                                                            |
| **alibabacloud.mongodb.eviction\_check\_entries\_node.maximum**(gauge)                               | Eviction check entries on node.*Shown as entry*                                                                                                            |
| **alibabacloud.mongodb.eviction\_check\_entries\_node.minimum**(gauge)                               | Eviction check entries on node.*Shown as entry*                                                                                                            |
| **alibabacloud.mongodb.exact\_id\_count.average**(gauge)                                             | Exact ID count.*Shown as document*                                                                                                                         |
| **alibabacloud.mongodb.exact\_id\_count.maximum**(gauge)                                             | Exact ID count.*Shown as document*                                                                                                                         |
| **alibabacloud.mongodb.exact\_id\_count.minimum**(gauge)                                             | Exact ID count.*Shown as document*                                                                                                                         |
| **alibabacloud.mongodb.exact\_id\_count\_node.average**(gauge)                                       | Exact ID count on node.*Shown as document*                                                                                                                 |
| **alibabacloud.mongodb.exact\_idcount\_node.maximum**(gauge)                                         | Exact ID count on node.*Shown as document*                                                                                                                 |
| **alibabacloud.mongodb.exact\_idcount\_node.minimum**(gauge)                                         | Exact ID count on node.*Shown as document*                                                                                                                 |
| **alibabacloud.mongodb.group\_cpu\_utilization.average**(gauge)                                      | Group CPU usage.*Shown as percent*                                                                                                                         |
| **alibabacloud.mongodb.group\_cpu\_utilization.minimum**(gauge)                                      | Group CPU usage.*Shown as percent*                                                                                                                         |
| **alibabacloud.mongodb.group\_cpu\_utilization.maximum**(gauge)                                      | Group CPU usage.*Shown as percent*                                                                                                                         |
| **alibabacloud.mongodb.group\_connection\_utilization.average**(gauge)                               | Group connection usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.group\_connection\_utilization.minimum**(gauge)                               | Group connection usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.group\_connection\_utilization.maximum**(gauge)                               | Group connection usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.group\_disk\_utilization.average**(gauge)                                     | Group disk usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.group\_disk\_utilization.minimum**(gauge)                                     | Group disk usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.group\_disk\_utilization.maximum**(gauge)                                     | Group disk usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.group\_iops\_utilization.average**(gauge)                                     | Group IOPS usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.group\_iops\_utilization.minimum**(gauge)                                     | Group IOPS usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.group\_iops\_utilization.maximum**(gauge)                                     | Group IOPS usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.mongodb.group\_memory\_utilization.average**(gauge)                                   | Group memory usage.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.group\_memory\_utilization.minimum**(gauge)                                   | Group memory usage.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.group\_memory\_utilization.maximum**(gauge)                                   | Group memory usage.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.hazard\_pointer\_blocked\_page\_eviction.average**(gauge)                     | Hazard pointer blocked page eviction.*Shown as event*                                                                                                      |
| **alibabacloud.mongodb.hazard\_pointer\_blocked\_page\_eviction.maximum**(gauge)                     | Hazard pointer blocked page eviction.*Shown as event*                                                                                                      |
| **alibabacloud.mongodb.hazard\_pointer\_blocked\_page\_eviction.minimum**(gauge)                     | Hazard pointer blocked page eviction.*Shown as event*                                                                                                      |
| **alibabacloud.mongodb.hazard\_pointer\_blocked\_page\_eviction\_node.average**(gauge)               | Hazard pointer blocked page eviction on node.*Shown as event*                                                                                              |
| **alibabacloud.mongodb.hazard\_pointer\_blocked\_page\_eviction\_node.maximum**(gauge)               | Hazard pointer blocked page eviction on node.*Shown as event*                                                                                              |
| **alibabacloud.mongodb.hazard\_pointer\_blocked\_page\_eviction\_node.minimum**(gauge)               | Hazard pointer blocked page eviction on node.*Shown as event*                                                                                              |
| **alibabacloud.mongodb.iops\_utilization.average**(gauge)                                            | IOPS usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.mongodb.iops\_utilization.minimum**(gauge)                                            | IOPS usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.mongodb.iops\_utilization.maximum**(gauge)                                            | IOPS usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.mongodb.iops\_utilization\_node.average**(gauge)                                      | IOPS usage on node.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.iops\_utilization\_node.minimum**(gauge)                                      | IOPS usage on node.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.iops\_utilization\_node.maximum**(gauge)                                      | IOPS usage on node.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.instance\_disk\_amount.average**(gauge)                                       | Instance disk space used.*Shown as byte*                                                                                                                   |
| **alibabacloud.mongodb.instance\_disk\_amount.minimum**(gauge)                                       | Instance disk space used.*Shown as byte*                                                                                                                   |
| **alibabacloud.mongodb.instance\_disk\_amount.maximum**(gauge)                                       | Instance disk space used.*Shown as byte*                                                                                                                   |
| **alibabacloud.mongodb.instance\_disk\_amount\_node.average**(gauge)                                 | Instance disk space used on node.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.instance\_disk\_amount\_node.minimum**(gauge)                                 | Instance disk space used on node.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.instance\_disk\_amount\_node.maximum**(gauge)                                 | Instance disk space used on node.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.intranet\_in.average**(gauge)                                                 | Inbound network traffic.*Shown as byte*                                                                                                                    |
| **alibabacloud.mongodb.intranet\_in.minimum**(gauge)                                                 | Inbound network traffic.*Shown as byte*                                                                                                                    |
| **alibabacloud.mongodb.intranet\_in.maximum**(gauge)                                                 | Inbound network traffic.*Shown as byte*                                                                                                                    |
| **alibabacloud.mongodb.intranet\_in\_node.average**(gauge)                                           | Inbound network traffic on node.*Shown as byte*                                                                                                            |
| **alibabacloud.mongodb.intranet\_in\_node.minimum**(gauge)                                           | Inbound network traffic on node.*Shown as byte*                                                                                                            |
| **alibabacloud.mongodb.intranet\_in\_node.maximum**(gauge)                                           | Inbound network traffic on node.*Shown as byte*                                                                                                            |
| **alibabacloud.mongodb.intranet\_out.average**(gauge)                                                | Outbound network traffic.*Shown as byte*                                                                                                                   |
| **alibabacloud.mongodb.intranet\_out.minimum**(gauge)                                                | Outbound network traffic.*Shown as byte*                                                                                                                   |
| **alibabacloud.mongodb.intranet\_out.maximum**(gauge)                                                | Outbound network traffic.*Shown as byte*                                                                                                                   |
| **alibabacloud.mongodb.intranet\_out\_node.average**(gauge)                                          | Outbound network traffic on node.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.intranet\_out\_node.minimum**(gauge)                                          | Outbound network traffic on node.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.intranet\_out\_node.maximum**(gauge)                                          | Outbound network traffic on node.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.io\_bandwidth.average**(rate)                                                 | I/O bandwidth.*Shown as mebibyte*                                                                                                                          |
| **alibabacloud.mongodb.io\_bandwidth.maximum**(rate)                                                 | I/O bandwidth.*Shown as mebibyte*                                                                                                                          |
| **alibabacloud.mongodb.io\_bandwidth.minimum**(rate)                                                 | I/O bandwidth.*Shown as mebibyte*                                                                                                                          |
| **alibabacloud.mongodb.io\_bandwidth\_node.average**(rate)                                           | I/O bandwidth on node.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.mongodb.io\_bandwidth\_node.maximum**(rate)                                           | I/O bandwidth on node.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.mongodb.io\_bandwidth\_node.minimum**(rate)                                           | I/O bandwidth on node.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.mongodb.log\_disk\_amount.average**(gauge)                                            | Data disk space used.*Shown as byte*                                                                                                                       |
| **alibabacloud.mongodb.log\_disk\_amount.minimum**(gauge)                                            | Data disk space used.*Shown as byte*                                                                                                                       |
| **alibabacloud.mongodb.log\_disk\_amount.maximum**(gauge)                                            | Data disk space used.*Shown as byte*                                                                                                                       |
| **alibabacloud.mongodb.log\_disk\_amount\_node.average**(gauge)                                      | Data disk space used on node.*Shown as byte*                                                                                                               |
| **alibabacloud.mongodb.log\_disk\_amount\_node.minimum**(gauge)                                      | Data disk space used on node.*Shown as byte*                                                                                                               |
| **alibabacloud.mongodb.log\_disk\_amount\_node.maximum**(gauge)                                      | Data disk space used on node.*Shown as byte*                                                                                                               |
| **alibabacloud.mongodb.log\_iops.average**(rate)                                                     | Log IOPS.*Shown as operation*                                                                                                                              |
| **alibabacloud.mongodb.log\_iops.maximum**(rate)                                                     | Log IOPS.*Shown as operation*                                                                                                                              |
| **alibabacloud.mongodb.log\_iops.minimum**(rate)                                                     | Log IOPS.*Shown as operation*                                                                                                                              |
| **alibabacloud.mongodb.log\_iops\_node.average**(rate)                                               | Log IOPS on node.*Shown as operation*                                                                                                                      |
| **alibabacloud.mongodb.log\_iops\_node.maximum**(rate)                                               | Log IOPS on node.*Shown as operation*                                                                                                                      |
| **alibabacloud.mongodb.log\_iops\_node.minimum**(rate)                                               | Log IOPS on node.*Shown as operation*                                                                                                                      |
| **alibabacloud.mongodb.max\_config\_bytes.average**(gauge)                                           | Maximum config bytes.*Shown as byte*                                                                                                                       |
| **alibabacloud.mongodb.max\_config\_bytes.maximum**(gauge)                                           | Maximum config bytes.*Shown as byte*                                                                                                                       |
| **alibabacloud.mongodb.max\_config\_bytes.minimum**(gauge)                                           | Maximum config bytes.*Shown as byte*                                                                                                                       |
| **alibabacloud.mongodb.max\_config\_bytes\_node.average**(gauge)                                     | Maximum config bytes on node.*Shown as byte*                                                                                                               |
| **alibabacloud.mongodb.max\_config\_bytes\_node.maximum**(gauge)                                     | Maximum config bytes on node.*Shown as byte*                                                                                                               |
| **alibabacloud.mongodb.max\_config\_bytes\_node.minimum**(gauge)                                     | Maximum config bytes on node.*Shown as byte*                                                                                                               |
| **alibabacloud.mongodb.max\_page\_size.average**(gauge)                                              | Maximum page size.*Shown as mebibyte*                                                                                                                      |
| **alibabacloud.mongodb.max\_page\_size.maximum**(gauge)                                              | Maximum page size.*Shown as mebibyte*                                                                                                                      |
| **alibabacloud.mongodb.max\_page\_size.minimum**(gauge)                                              | Maximum page size.*Shown as mebibyte*                                                                                                                      |
| **alibabacloud.mongodb.max\_page\_size\_node.average**(gauge)                                        | Maximum page size on node.*Shown as mebibyte*                                                                                                              |
| **alibabacloud.mongodb.max\_page\_size\_node.maximum**(gauge)                                        | Maximum page size on node.*Shown as mebibyte*                                                                                                              |
| **alibabacloud.mongodb.max\_page\_size\_node.minimum**(gauge)                                        | Maximum page size on node.*Shown as mebibyte*                                                                                                              |
| **alibabacloud.mongodb.memory\_utilization.average**(gauge)                                          | Memory usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.mongodb.memory\_utilization.minimum**(gauge)                                          | Memory usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.mongodb.memory\_utilization.maximum**(gauge)                                          | Memory usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.mongodb.memory\_utilization\_node.average**(gauge)                                    | Memory usage on node.*Shown as percent*                                                                                                                    |
| **alibabacloud.mongodb.memory\_utilization\_node.minimum**(gauge)                                    | Memory usage on node.*Shown as percent*                                                                                                                    |
| **alibabacloud.mongodb.memory\_utilization\_node.maximum**(gauge)                                    | Memory usage on node.*Shown as percent*                                                                                                                    |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_avg\_wtime.average**(gauge)                        | Get last error average wait time.*Shown as millisecond*                                                                                                    |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_avg\_wtime.maximum**(gauge)                        | Get last error average wait time.*Shown as millisecond*                                                                                                    |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_avg\_wtime.minimum**(gauge)                        | Get last error average wait time.*Shown as millisecond*                                                                                                    |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_avg\_wtime\_node.average**(gauge)                  | Get last error average wait time on node.*Shown as millisecond*                                                                                            |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_avg\_wtime\_node.maximum**(gauge)                  | Get last error average wait time on node.*Shown as millisecond*                                                                                            |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_avg\_wtime\_node.minimum**(gauge)                  | Get last error average wait time on node.*Shown as millisecond*                                                                                            |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_wtimeouts.average**(gauge)                         | Get last error wait timeouts.*Shown as timeout*                                                                                                            |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_wtimeouts.maximum**(gauge)                         | Get last error wait timeouts.*Shown as timeout*                                                                                                            |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_wtimeouts.minimum**(gauge)                         | Get last error wait timeouts.*Shown as timeout*                                                                                                            |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_wtimeouts\_node.average**(gauge)                   | Get last error wait timeouts on node.*Shown as timeout*                                                                                                    |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_wtimeouts\_node.maximum**(gauge)                   | Get last error wait timeouts on node.*Shown as timeout*                                                                                                    |
| **alibabacloud.mongodb.metrics\_get\_last\_error\_wtimeouts\_node.minimum**(gauge)                   | Get last error wait timeouts on node.*Shown as timeout*                                                                                                    |
| **alibabacloud.mongodb.metrics\_query\_multiplanner\_classic\_works.average**(gauge)                 | Query multiplanner classic works.*Shown as operation*                                                                                                      |
| **alibabacloud.mongodb.metrics\_query\_multiplanner\_classic\_works.maximum**(gauge)                 | Query multiplanner classic works.*Shown as operation*                                                                                                      |
| **alibabacloud.mongodb.metrics\_query\_multiplanner\_classic\_works.minimum**(gauge)                 | Query multiplanner classic works.*Shown as operation*                                                                                                      |
| **alibabacloud.mongodb.metrics\_query\_multiplanner\_classic\_works\_node.average**(gauge)           | Query multiplanner classic works on node.*Shown as operation*                                                                                              |
| **alibabacloud.mongodb.metrics\_query\_multiplanner\_classic\_works\_node.maximum**(gauge)           | Query multiplanner classic works on node.*Shown as operation*                                                                                              |
| **alibabacloud.mongodb.metrics\_query\_multiplanner\_classic\_works\_node.minimum**(gauge)           | Query multiplanner classic works on node.*Shown as operation*                                                                                              |
| **alibabacloud.mongodb.move\_chunk\_deleter\_task.average**(gauge)                                   | Move chunk deleter tasks.*Shown as task*                                                                                                                   |
| **alibabacloud.mongodb.move\_chunk\_deleter\_task.maximum**(gauge)                                   | Move chunk deleter tasks.*Shown as task*                                                                                                                   |
| **alibabacloud.mongodb.move\_chunk\_deleter\_task.minimum**(gauge)                                   | Move chunk deleter tasks.*Shown as task*                                                                                                                   |
| **alibabacloud.mongodb.move\_chunk\_deleter\_task\_node.average**(gauge)                             | Move chunk deleter tasks on node.*Shown as task*                                                                                                           |
| **alibabacloud.mongodb.move\_chunk\_deleter\_task\_node.maximum**(gauge)                             | Move chunk deleter tasks on node.*Shown as task*                                                                                                           |
| **alibabacloud.mongodb.move\_chunk\_deleter\_task\_node.minimum**(gauge)                             | Move chunk deleter tasks on node.*Shown as task*                                                                                                           |
| **alibabacloud.mongodb.msg.average**(gauge)                                                          | Messages.*Shown as message*                                                                                                                                |
| **alibabacloud.mongodb.msg.maximum**(gauge)                                                          | Messages.*Shown as message*                                                                                                                                |
| **alibabacloud.mongodb.msg.minimum**(gauge)                                                          | Messages.*Shown as message*                                                                                                                                |
| **alibabacloud.mongodb.msg\_node.average**(gauge)                                                    | Messages on node.*Shown as message*                                                                                                                        |
| **alibabacloud.mongodb.msg\_node.maximum**(gauge)                                                    | Messages on node.*Shown as message*                                                                                                                        |
| **alibabacloud.mongodb.msg\_node.minimum**(gauge)                                                    | Messages on node.*Shown as message*                                                                                                                        |
| **alibabacloud.mongodb.no\_timeout\_cursors.average**(gauge)                                         | No timeout cursors.*Shown as cursor*                                                                                                                       |
| **alibabacloud.mongodb.no\_timeout\_cursors.maximum**(gauge)                                         | No timeout cursors.*Shown as cursor*                                                                                                                       |
| **alibabacloud.mongodb.no\_timeout\_cursors.minimum**(gauge)                                         | No timeout cursors.*Shown as cursor*                                                                                                                       |
| **alibabacloud.mongodb.no\_timeout\_cursors\_node.average**(gauge)                                   | No timeout cursors on node.*Shown as cursor*                                                                                                               |
| **alibabacloud.mongodb.no\_timeout\_cursors\_node.maximum**(gauge)                                   | No timeout cursors on node.*Shown as cursor*                                                                                                               |
| **alibabacloud.mongodb.no\_timeout\_cursors\_node.minimum**(gauge)                                   | No timeout cursors on node.*Shown as cursor*                                                                                                               |
| **alibabacloud.mongodb.number\_requests.average**(gauge)                                             | Request count.*Shown as request*                                                                                                                           |
| **alibabacloud.mongodb.number\_requests.minimum**(gauge)                                             | Request count.*Shown as request*                                                                                                                           |
| **alibabacloud.mongodb.number\_requests.maximum**(gauge)                                             | Request count.*Shown as request*                                                                                                                           |
| **alibabacloud.mongodb.number\_requests\_node.average**(gauge)                                       | Request count on node.*Shown as request*                                                                                                                   |
| **alibabacloud.mongodb.number\_requests\_node.minimum**(gauge)                                       | Request count on node.*Shown as request*                                                                                                                   |
| **alibabacloud.mongodb.number\_requests\_node.maximum**(gauge)                                       | Request count on node.*Shown as request*                                                                                                                   |
| **alibabacloud.mongodb.op\_command.average**(gauge)                                                  | Command operations.*Shown as operation*                                                                                                                    |
| **alibabacloud.mongodb.op\_command.minimum**(gauge)                                                  | Command operations.*Shown as operation*                                                                                                                    |
| **alibabacloud.mongodb.op\_command.maximum**(gauge)                                                  | Command operations.*Shown as operation*                                                                                                                    |
| **alibabacloud.mongodb.op\_command\_node.average**(gauge)                                            | Command operations on node.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.op\_command\_node.minimum**(gauge)                                            | Command operations on node.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.op\_command\_node.maximum**(gauge)                                            | Command operations on node.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.op\_delete.average**(gauge)                                                   | Delete operations.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.op\_delete.minimum**(gauge)                                                   | Delete operations.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.op\_delete.maximum**(gauge)                                                   | Delete operations.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.op\_delete\_node.average**(gauge)                                             | Delete operations on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.op\_delete\_node.minimum**(gauge)                                             | Delete operations on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.op\_delete\_node.maximum**(gauge)                                             | Delete operations on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.op\_getmore.average**(gauge)                                                  | getMore operations.*Shown as operation*                                                                                                                    |
| **alibabacloud.mongodb.op\_getmore.minimum**(gauge)                                                  | getMore operations.*Shown as operation*                                                                                                                    |
| **alibabacloud.mongodb.op\_getmore.maximum**(gauge)                                                  | getMore operations.*Shown as operation*                                                                                                                    |
| **alibabacloud.mongodb.op\_getmore\_node.average**(gauge)                                            | getMore operations on node.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.op\_getmore\_node.minimum**(gauge)                                            | getMore operations on node.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.op\_getmore\_node.maximum**(gauge)                                            | getMore operations on node.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.op\_insert.average**(gauge)                                                   | Insert operations.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.op\_insert.minimum**(gauge)                                                   | Insert operations.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.op\_insert.maximum**(gauge)                                                   | Insert operations.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.op\_insert\_node.average**(gauge)                                             | Insert operations on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.op\_insert\_node.minimum**(gauge)                                             | Insert operations on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.op\_insert\_node.maximum**(gauge)                                             | Insert operations on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.op\_query.average**(gauge)                                                    | Query operations.*Shown as operation*                                                                                                                      |
| **alibabacloud.mongodb.op\_query.minimum**(gauge)                                                    | Query operations.*Shown as operation*                                                                                                                      |
| **alibabacloud.mongodb.op\_query.maximum**(gauge)                                                    | Query operations.*Shown as operation*                                                                                                                      |
| **alibabacloud.mongodb.op\_query\_node.average**(gauge)                                              | Query operations on node.*Shown as operation*                                                                                                              |
| **alibabacloud.mongodb.op\_query\_node.minimum**(gauge)                                              | Query operations on node.*Shown as operation*                                                                                                              |
| **alibabacloud.mongodb.op\_query\_node.maximum**(gauge)                                              | Query operations on node.*Shown as operation*                                                                                                              |
| **alibabacloud.mongodb.op\_update.average**(gauge)                                                   | Update operations.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.op\_update.minimum**(gauge)                                                   | Update operations.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.op\_update.maximum**(gauge)                                                   | Update operations.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.op\_update\_node.average**(gauge)                                             | Update operations on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.op\_update\_node.minimum**(gauge)                                             | Update operations on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.op\_update\_node.maximum**(gauge)                                             | Update operations on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.opened\_fd\_mem.average**(gauge)                                              | Opened file descriptor memory.*Shown as mebibyte*                                                                                                          |
| **alibabacloud.mongodb.opened\_fd\_mem.maximum**(gauge)                                              | Opened file descriptor memory.*Shown as mebibyte*                                                                                                          |
| **alibabacloud.mongodb.opened\_fd\_mem.minimum**(gauge)                                              | Opened file descriptor memory.*Shown as mebibyte*                                                                                                          |
| **alibabacloud.mongodb.opened\_fd\_mem\_node.average**(gauge)                                        | Opened file descriptor memory on node.*Shown as mebibyte*                                                                                                  |
| **alibabacloud.mongodb.opened\_fd\_mem\_node.maximum**(gauge)                                        | Opened file descriptor memory on node.*Shown as mebibyte*                                                                                                  |
| **alibabacloud.mongodb.opened\_fd\_mem\_node.minimum**(gauge)                                        | Opened file descriptor memory on node.*Shown as mebibyte*                                                                                                  |
| **alibabacloud.mongodb.opened\_fd\_num.average**(gauge)                                              | Opened file descriptors.*Shown as file*                                                                                                                    |
| **alibabacloud.mongodb.opened\_fd\_num.maximum**(gauge)                                              | Opened file descriptors.*Shown as file*                                                                                                                    |
| **alibabacloud.mongodb.opened\_fd\_num.minimum**(gauge)                                              | Opened file descriptors.*Shown as file*                                                                                                                    |
| **alibabacloud.mongodb.opened\_fd\_num\_node.average**(gauge)                                        | Opened file descriptors on node.*Shown as file*                                                                                                            |
| **alibabacloud.mongodb.opened\_fd\_num\_node.maximum**(gauge)                                        | Opened file descriptors on node.*Shown as file*                                                                                                            |
| **alibabacloud.mongodb.opened\_fd\_num\_node.minimum**(gauge)                                        | Opened file descriptors on node.*Shown as file*                                                                                                            |
| **alibabacloud.mongodb.oplog\_time\_interval.average**(gauge)                                        | Oplog time interval.*Shown as hour*                                                                                                                        |
| **alibabacloud.mongodb.oplog\_time\_interval.maximum**(gauge)                                        | Oplog time interval.*Shown as hour*                                                                                                                        |
| **alibabacloud.mongodb.oplog\_time\_interval.minimum**(gauge)                                        | Oplog time interval.*Shown as hour*                                                                                                                        |
| **alibabacloud.mongodb.oplog\_time\_interval\_node.average**(gauge)                                  | Oplog time interval on node.*Shown as hour*                                                                                                                |
| **alibabacloud.mongodb.oplog\_time\_interval\_node.maximum**(gauge)                                  | Oplog time interval on node.*Shown as hour*                                                                                                                |
| **alibabacloud.mongodb.oplog\_time\_interval\_node.minimum**(gauge)                                  | Oplog time interval on node.*Shown as hour*                                                                                                                |
| **alibabacloud.mongodb.page\_acquire\_eviction\_blocked.average**(gauge)                             | Page acquire eviction blocked.*Shown as event*                                                                                                             |
| **alibabacloud.mongodb.page\_acquire\_eviction\_blocked.maximum**(gauge)                             | Page acquire eviction blocked.*Shown as event*                                                                                                             |
| **alibabacloud.mongodb.page\_acquire\_eviction\_blocked.minimum**(gauge)                             | Page acquire eviction blocked.*Shown as event*                                                                                                             |
| **alibabacloud.mongodb.page\_acquire\_eviction\_blocked\_node.average**(gauge)                       | Page acquire eviction blocked on node.*Shown as event*                                                                                                     |
| **alibabacloud.mongodb.page\_acquire\_eviction\_blocked\_node.maximum**(gauge)                       | Page acquire eviction blocked on node.*Shown as event*                                                                                                     |
| **alibabacloud.mongodb.page\_acquire\_eviction\_blocked\_node.minimum**(gauge)                       | Page acquire eviction blocked on node.*Shown as event*                                                                                                     |
| **alibabacloud.mongodb.page\_acquire\_locked\_blocked.average**(gauge)                               | Page acquire locked blocked.*Shown as event*                                                                                                               |
| **alibabacloud.mongodb.page\_acquire\_locked\_blocked.maximum**(gauge)                               | Page acquire locked blocked.*Shown as event*                                                                                                               |
| **alibabacloud.mongodb.page\_acquire\_locked\_blocked.minimum**(gauge)                               | Page acquire locked blocked.*Shown as event*                                                                                                               |
| **alibabacloud.mongodb.page\_acquire\_locked\_blocked\_node.average**(gauge)                         | Page acquire locked blocked on node.*Shown as event*                                                                                                       |
| **alibabacloud.mongodb.page\_acquire\_locked\_blocked\_node.maximum**(gauge)                         | Page acquire locked blocked on node.*Shown as event*                                                                                                       |
| **alibabacloud.mongodb.page\_acquire\_locked\_blocked\_node.minimum**(gauge)                         | Page acquire locked blocked on node.*Shown as event*                                                                                                       |
| **alibabacloud.mongodb.page\_acquire\_time\_sleeping.average**(gauge)                                | Page acquire time sleeping.*Shown as microsecond*                                                                                                          |
| **alibabacloud.mongodb.page\_acquire\_time\_sleeping.maximum**(gauge)                                | Page acquire time sleeping.*Shown as microsecond*                                                                                                          |
| **alibabacloud.mongodb.page\_acquire\_time\_sleeping.minimum**(gauge)                                | Page acquire time sleeping.*Shown as microsecond*                                                                                                          |
| **alibabacloud.mongodb.page\_acquire\_time\_sleeping\_node.average**(gauge)                          | Page acquire time sleeping on node.*Shown as microsecond*                                                                                                  |
| **alibabacloud.mongodb.page\_acquire\_time\_sleeping\_node.maximum**(gauge)                          | Page acquire time sleeping on node.*Shown as microsecond*                                                                                                  |
| **alibabacloud.mongodb.page\_acquire\_time\_sleeping\_node.minimum**(gauge)                          | Page acquire time sleeping on node.*Shown as microsecond*                                                                                                  |
| **alibabacloud.mongodb.pages\_evicted\_by\_application\_threads.average**(gauge)                     | Pages evicted by application threads.*Shown as page*                                                                                                       |
| **alibabacloud.mongodb.pages\_evicted\_by\_application\_threads.maximum**(gauge)                     | Pages evicted by application threads.*Shown as page*                                                                                                       |
| **alibabacloud.mongodb.pages\_evicted\_by\_application\_threads.minimum**(gauge)                     | Pages evicted by application threads.*Shown as page*                                                                                                       |
| **alibabacloud.mongodb.pages\_evicted\_by\_application\_threads\_node.average**(gauge)               | Pages evicted by application threads on node.*Shown as page*                                                                                               |
| **alibabacloud.mongodb.pages\_evicted\_by\_application\_threads\_node.maximum**(gauge)               | Pages evicted by application threads on node.*Shown as page*                                                                                               |
| **alibabacloud.mongodb.pages\_evicted\_by\_application\_threads\_node.minimum**(gauge)               | Pages evicted by application threads on node.*Shown as page*                                                                                               |
| **alibabacloud.mongodb.pages\_selected\_count.average**(gauge)                                       | Pages selected count.*Shown as page*                                                                                                                       |
| **alibabacloud.mongodb.pages\_selected\_count.maximum**(gauge)                                       | Pages selected count.*Shown as page*                                                                                                                       |
| **alibabacloud.mongodb.pages\_selected\_count.minimum**(gauge)                                       | Pages selected count.*Shown as page*                                                                                                                       |
| **alibabacloud.mongodb.pages\_selected\_count\_node.average**(gauge)                                 | Pages selected count on node.*Shown as page*                                                                                                               |
| **alibabacloud.mongodb.pages\_selected\_count\_node.maximum**(gauge)                                 | Pages selected count on node.*Shown as page*                                                                                                               |
| **alibabacloud.mongodb.pages\_selected\_count\_node.minimum**(gauge)                                 | Pages selected count on node.*Shown as page*                                                                                                               |
| **alibabacloud.mongodb.pages\_selected\_unable\_to\_evict\_count.average**(gauge)                    | Pages selected unable to evict.*Shown as page*                                                                                                             |
| **alibabacloud.mongodb.pages\_selected\_unable\_to\_evict\_count.maximum**(gauge)                    | Pages selected unable to evict.*Shown as page*                                                                                                             |
| **alibabacloud.mongodb.pages\_selected\_unable\_to\_evict\_count.minimum**(gauge)                    | Pages selected unable to evict.*Shown as page*                                                                                                             |
| **alibabacloud.mongodb.pages\_selected\_unable\_to\_evict\_count\_node.average**(gauge)              | Pages selected unable to evict on node.*Shown as page*                                                                                                     |
| **alibabacloud.mongodb.pages\_selected\_unable\_to\_evict\_count\_node.maximum**(gauge)              | Pages selected unable to evict on node.*Shown as page*                                                                                                     |
| **alibabacloud.mongodb.pages\_selected\_unable\_to\_evict\_count\_node.minimum**(gauge)              | Pages selected unable to evict on node.*Shown as page*                                                                                                     |
| **alibabacloud.mongodb.pinned\_cursors.average**(gauge)                                              | Pinned cursors.*Shown as cursor*                                                                                                                           |
| **alibabacloud.mongodb.pinned\_cursors.maximum**(gauge)                                              | Pinned cursors.*Shown as cursor*                                                                                                                           |
| **alibabacloud.mongodb.pinned\_cursors.minimum**(gauge)                                              | Pinned cursors.*Shown as cursor*                                                                                                                           |
| **alibabacloud.mongodb.pinned\_cursors\_node.average**(gauge)                                        | Pinned cursors on node.*Shown as cursor*                                                                                                                   |
| **alibabacloud.mongodb.pinned\_cursors\_node.maximum**(gauge)                                        | Pinned cursors on node.*Shown as cursor*                                                                                                                   |
| **alibabacloud.mongodb.pinned\_cursors\_node.minimum**(gauge)                                        | Pinned cursors on node.*Shown as cursor*                                                                                                                   |
| **alibabacloud.mongodb.qps.average**(rate)                                                           | Queries per second.*Shown as query*                                                                                                                        |
| **alibabacloud.mongodb.qps.minimum**(rate)                                                           | Queries per second.*Shown as query*                                                                                                                        |
| **alibabacloud.mongodb.qps.maximum**(rate)                                                           | Queries per second.*Shown as query*                                                                                                                        |
| **alibabacloud.mongodb.qps\_node.average**(rate)                                                     | Queries per second on node.*Shown as query*                                                                                                                |
| **alibabacloud.mongodb.qps\_node.minimum**(rate)                                                     | Queries per second on node.*Shown as query*                                                                                                                |
| **alibabacloud.mongodb.qps\_node.maximum**(rate)                                                     | Queries per second on node.*Shown as query*                                                                                                                |
| **alibabacloud.mongodb.read\_avg\_rt.average**(gauge)                                                | Read average response time.*Shown as microsecond*                                                                                                          |
| **alibabacloud.mongodb.read\_avg\_rt.maximum**(gauge)                                                | Read average response time.*Shown as microsecond*                                                                                                          |
| **alibabacloud.mongodb.read\_avg\_rt.minimum**(gauge)                                                | Read average response time.*Shown as microsecond*                                                                                                          |
| **alibabacloud.mongodb.read\_avg\_rt\_node.average**(gauge)                                          | Read average response time on node.*Shown as microsecond*                                                                                                  |
| **alibabacloud.mongodb.read\_avg\_rt\_node.maximum**(gauge)                                          | Read average response time on node.*Shown as microsecond*                                                                                                  |
| **alibabacloud.mongodb.read\_avg\_rt\_node.minimum**(gauge)                                          | Read average response time on node.*Shown as microsecond*                                                                                                  |
| **alibabacloud.mongodb.read\_bandwidth.average**(rate)                                               | Read bandwidth.*Shown as mebibyte*                                                                                                                         |
| **alibabacloud.mongodb.read\_bandwidth.maximum**(rate)                                               | Read bandwidth.*Shown as mebibyte*                                                                                                                         |
| **alibabacloud.mongodb.read\_bandwidth.minimum**(rate)                                               | Read bandwidth.*Shown as mebibyte*                                                                                                                         |
| **alibabacloud.mongodb.read\_bandwidth\_node.average**(rate)                                         | Read bandwidth on node.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.mongodb.read\_bandwidth\_node.maximum**(rate)                                         | Read bandwidth on node.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.mongodb.read\_bandwidth\_node.minimum**(rate)                                         | Read bandwidth on node.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.mongodb.read\_trans\_concurrent\_avail.average**(gauge)                               | Read transactions concurrent available.*Shown as transaction*                                                                                              |
| **alibabacloud.mongodb.read\_trans\_concurrent\_avail.maximum**(gauge)                               | Read transactions concurrent available.*Shown as transaction*                                                                                              |
| **alibabacloud.mongodb.read\_trans\_concurrent\_avail.minimum**(gauge)                               | Read transactions concurrent available.*Shown as transaction*                                                                                              |
| **alibabacloud.mongodb.read\_trans\_concurrent\_avail\_node.average**(gauge)                         | Read transactions concurrent available on node.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.read\_trans\_concurrent\_avail\_node.maximum**(gauge)                         | Read transactions concurrent available on node.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.read\_trans\_concurrent\_avail\_node.minimum**(gauge)                         | Read transactions concurrent available on node.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.read\_trans\_concurrent\_out.average**(gauge)                                 | Read transactions concurrent out.*Shown as transaction*                                                                                                    |
| **alibabacloud.mongodb.read\_trans\_concurrent\_out.maximum**(gauge)                                 | Read transactions concurrent out.*Shown as transaction*                                                                                                    |
| **alibabacloud.mongodb.read\_trans\_concurrent\_out.minimum**(gauge)                                 | Read transactions concurrent out.*Shown as transaction*                                                                                                    |
| **alibabacloud.mongodb.read\_trans\_concurrent\_out\_node.average**(gauge)                           | Read transactions concurrent out on node.*Shown as transaction*                                                                                            |
| **alibabacloud.mongodb.read\_trans\_concurrent\_out\_node.maximum**(gauge)                           | Read transactions concurrent out on node.*Shown as transaction*                                                                                            |
| **alibabacloud.mongodb.read\_trans\_concurrent\_out\_node.minimum**(gauge)                           | Read transactions concurrent out on node.*Shown as transaction*                                                                                            |
| **alibabacloud.mongodb.reads\_latency\_ps.average**(rate)                                            | Reads latency per second.*Shown as microsecond*                                                                                                            |
| **alibabacloud.mongodb.reads\_latency\_ps.maximum**(rate)                                            | Reads latency per second.*Shown as microsecond*                                                                                                            |
| **alibabacloud.mongodb.reads\_latency\_ps.minimum**(rate)                                            | Reads latency per second.*Shown as microsecond*                                                                                                            |
| **alibabacloud.mongodb.reads\_latency\_ps\_node.average**(rate)                                      | Reads latency per second on node.*Shown as microsecond*                                                                                                    |
| **alibabacloud.mongodb.reads\_latency\_ps\_node.maximum**(rate)                                      | Reads latency per second on node.*Shown as microsecond*                                                                                                    |
| **alibabacloud.mongodb.reads\_latency\_ps\_node.minimum**(rate)                                      | Reads latency per second on node.*Shown as microsecond*                                                                                                    |
| **alibabacloud.mongodb.regular.average**(gauge)                                                      | Regular cursors.*Shown as cursor*                                                                                                                          |
| **alibabacloud.mongodb.regular.maximum**(gauge)                                                      | Regular cursors.*Shown as cursor*                                                                                                                          |
| **alibabacloud.mongodb.regular.minimum**(gauge)                                                      | Regular cursors.*Shown as cursor*                                                                                                                          |
| **alibabacloud.mongodb.regular\_node.average**(gauge)                                                | Regular cursors on node.*Shown as cursor*                                                                                                                  |
| **alibabacloud.mongodb.regular\_node.maximum**(gauge)                                                | Regular cursors on node.*Shown as cursor*                                                                                                                  |
| **alibabacloud.mongodb.regular\_node.minimum**(gauge)                                                | Regular cursors on node.*Shown as cursor*                                                                                                                  |
| **alibabacloud.mongodb.repl\_buffer\_max\_size.average**(gauge)                                      | Replication buffer max size.*Shown as mebibyte*                                                                                                            |
| **alibabacloud.mongodb.repl\_buffer\_max\_size.maximum**(gauge)                                      | Replication buffer max size.*Shown as mebibyte*                                                                                                            |
| **alibabacloud.mongodb.repl\_buffer\_max\_size.minimum**(gauge)                                      | Replication buffer max size.*Shown as mebibyte*                                                                                                            |
| **alibabacloud.mongodb.repl\_buffer\_max\_size\_node.average**(gauge)                                | Replication buffer max size on node.*Shown as mebibyte*                                                                                                    |
| **alibabacloud.mongodb.repl\_buffer\_max\_size\_node.maximum**(gauge)                                | Replication buffer max size on node.*Shown as mebibyte*                                                                                                    |
| **alibabacloud.mongodb.repl\_buffer\_max\_size\_node.minimum**(gauge)                                | Replication buffer max size on node.*Shown as mebibyte*                                                                                                    |
| **alibabacloud.mongodb.repl\_buffer\_size.average**(gauge)                                           | Replication buffer size.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.mongodb.repl\_buffer\_size.maximum**(gauge)                                           | Replication buffer size.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.mongodb.repl\_buffer\_size.minimum**(gauge)                                           | Replication buffer size.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.mongodb.repl\_buffer\_size\_node.average**(gauge)                                     | Replication buffer size on node.*Shown as mebibyte*                                                                                                        |
| **alibabacloud.mongodb.repl\_buffer\_size\_node.maximum**(gauge)                                     | Replication buffer size on node.*Shown as mebibyte*                                                                                                        |
| **alibabacloud.mongodb.repl\_buffer\_size\_node.minimum**(gauge)                                     | Replication buffer size on node.*Shown as mebibyte*                                                                                                        |
| **alibabacloud.mongodb.repl\_cmds.average**(gauge)                                                   | Replication commands.*Shown as command*                                                                                                                    |
| **alibabacloud.mongodb.repl\_cmds.maximum**(gauge)                                                   | Replication commands.*Shown as command*                                                                                                                    |
| **alibabacloud.mongodb.repl\_cmds.minimum**(gauge)                                                   | Replication commands.*Shown as command*                                                                                                                    |
| **alibabacloud.mongodb.repl\_cmds\_node.average**(gauge)                                             | Replication commands on node.*Shown as command*                                                                                                            |
| **alibabacloud.mongodb.repl\_cmds\_node.maximum**(gauge)                                             | Replication commands on node.*Shown as command*                                                                                                            |
| **alibabacloud.mongodb.repl\_cmds\_node.minimum**(gauge)                                             | Replication commands on node.*Shown as command*                                                                                                            |
| **alibabacloud.mongodb.repl\_deletes.average**(gauge)                                                | Replication deletes.*Shown as operation*                                                                                                                   |
| **alibabacloud.mongodb.repl\_deletes.maximum**(gauge)                                                | Replication deletes.*Shown as operation*                                                                                                                   |
| **alibabacloud.mongodb.repl\_deletes.minimum**(gauge)                                                | Replication deletes.*Shown as operation*                                                                                                                   |
| **alibabacloud.mongodb.repl\_deletes\_node.average**(gauge)                                          | Replication deletes on node.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.repl\_deletes\_node.maximum**(gauge)                                          | Replication deletes on node.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.repl\_deletes\_node.minimum**(gauge)                                          | Replication deletes on node.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.repl\_getmores.average**(gauge)                                               | Replication getMore operations.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.repl\_getmores.maximum**(gauge)                                               | Replication getMore operations.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.repl\_getmores.minimum**(gauge)                                               | Replication getMore operations.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.repl\_getmores\_node.average**(gauge)                                         | Replication getMore operations on node.*Shown as operation*                                                                                                |
| **alibabacloud.mongodb.repl\_getmores\_node.maximum**(gauge)                                         | Replication getMore operations on node.*Shown as operation*                                                                                                |
| **alibabacloud.mongodb.repl\_getmores\_node.minimum**(gauge)                                         | Replication getMore operations on node.*Shown as operation*                                                                                                |
| **alibabacloud.mongodb.repl\_inserts.average**(gauge)                                                | Replication inserts.*Shown as operation*                                                                                                                   |
| **alibabacloud.mongodb.repl\_inserts.maximum**(gauge)                                                | Replication inserts.*Shown as operation*                                                                                                                   |
| **alibabacloud.mongodb.repl\_inserts.minimum**(gauge)                                                | Replication inserts.*Shown as operation*                                                                                                                   |
| **alibabacloud.mongodb.repl\_inserts\_node.average**(gauge)                                          | Replication inserts on node.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.repl\_inserts\_node.maximum**(gauge)                                          | Replication inserts on node.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.repl\_inserts\_node.minimum**(gauge)                                          | Replication inserts on node.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.repl\_queries.average**(gauge)                                                | Replication queries.*Shown as query*                                                                                                                       |
| **alibabacloud.mongodb.repl\_queries.maximum**(gauge)                                                | Replication queries.*Shown as query*                                                                                                                       |
| **alibabacloud.mongodb.repl\_queries.minimum**(gauge)                                                | Replication queries.*Shown as query*                                                                                                                       |
| **alibabacloud.mongodb.repl\_queries\_node.average**(gauge)                                          | Replication queries on node.*Shown as query*                                                                                                               |
| **alibabacloud.mongodb.repl\_queries\_node.maximum**(gauge)                                          | Replication queries on node.*Shown as query*                                                                                                               |
| **alibabacloud.mongodb.repl\_queries\_node.minimum**(gauge)                                          | Replication queries on node.*Shown as query*                                                                                                               |
| **alibabacloud.mongodb.repl\_updates.average**(gauge)                                                | Replication updates.*Shown as operation*                                                                                                                   |
| **alibabacloud.mongodb.repl\_updates.maximum**(gauge)                                                | Replication updates.*Shown as operation*                                                                                                                   |
| **alibabacloud.mongodb.repl\_updates.minimum**(gauge)                                                | Replication updates.*Shown as operation*                                                                                                                   |
| **alibabacloud.mongodb.repl\_updates\_node.average**(gauge)                                          | Replication updates on node.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.repl\_updates\_node.maximum**(gauge)                                          | Replication updates on node.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.repl\_updates\_node.minimum**(gauge)                                          | Replication updates on node.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.replication\_lag.average**(gauge)                                             | Replication lag.*Shown as second*                                                                                                                          |
| **alibabacloud.mongodb.replication\_lag.maximum**(gauge)                                             | Replication lag.*Shown as second*                                                                                                                          |
| **alibabacloud.mongodb.replication\_lag.minimum**(gauge)                                             | Replication lag.*Shown as second*                                                                                                                          |
| **alibabacloud.mongodb.replication\_lag\_node.average**(gauge)                                       | Replication lag on node.*Shown as second*                                                                                                                  |
| **alibabacloud.mongodb.replication\_lag\_node.maximum**(gauge)                                       | Replication lag on node.*Shown as second*                                                                                                                  |
| **alibabacloud.mongodb.replication\_lag\_node.minimum**(gauge)                                       | Replication lag on node.*Shown as second*                                                                                                                  |
| **alibabacloud.mongodb.scan\_order\_ops\_ps.average**(rate)                                          | Scan order operations per second.*Shown as operation*                                                                                                      |
| **alibabacloud.mongodb.scan\_order\_ops\_ps.maximum**(rate)                                          | Scan order operations per second.*Shown as operation*                                                                                                      |
| **alibabacloud.mongodb.scan\_order\_ops\_ps.minimum**(rate)                                          | Scan order operations per second.*Shown as operation*                                                                                                      |
| **alibabacloud.mongodb.scan\_order\_ops\_ps\_node.average**(rate)                                    | Scan order operations per second on node.*Shown as operation*                                                                                              |
| **alibabacloud.mongodb.scan\_order\_ops\_ps\_node.maximum**(rate)                                    | Scan order operations per second on node.*Shown as operation*                                                                                              |
| **alibabacloud.mongodb.scan\_order\_ops\_ps\_node.minimum**(rate)                                    | Scan order operations per second on node.*Shown as operation*                                                                                              |
| **alibabacloud.mongodb.scanned\_docs.average**(gauge)                                                | Scanned documents.*Shown as document*                                                                                                                      |
| **alibabacloud.mongodb.scanned\_docs.maximum**(gauge)                                                | Scanned documents.*Shown as document*                                                                                                                      |
| **alibabacloud.mongodb.scanned\_docs.minimum**(gauge)                                                | Scanned documents.*Shown as document*                                                                                                                      |
| **alibabacloud.mongodb.scanned\_docs\_node.average**(gauge)                                          | Scanned documents on node.*Shown as document*                                                                                                              |
| **alibabacloud.mongodb.scanned\_docs\_node.maximum**(gauge)                                          | Scanned documents on node.*Shown as document*                                                                                                              |
| **alibabacloud.mongodb.scanned\_docs\_node.minimum**(gauge)                                          | Scanned documents on node.*Shown as document*                                                                                                              |
| **alibabacloud.mongodb.scanned\_keys.average**(gauge)                                                | Scanned keys.*Shown as key*                                                                                                                                |
| **alibabacloud.mongodb.scanned\_keys.maximum**(gauge)                                                | Scanned keys.*Shown as key*                                                                                                                                |
| **alibabacloud.mongodb.scanned\_keys.minimum**(gauge)                                                | Scanned keys.*Shown as key*                                                                                                                                |
| **alibabacloud.mongodb.scanned\_keys\_node.average**(gauge)                                          | Scanned keys on node.*Shown as key*                                                                                                                        |
| **alibabacloud.mongodb.scanned\_keys\_node.maximum**(gauge)                                          | Scanned keys on node.*Shown as key*                                                                                                                        |
| **alibabacloud.mongodb.scanned\_keys\_node.minimum**(gauge)                                          | Scanned keys on node.*Shown as key*                                                                                                                        |
| **alibabacloud.mongodb.session\_closed\_cursors.average**(gauge)                                     | Session closed cursors.*Shown as cursor*                                                                                                                   |
| **alibabacloud.mongodb.session\_closed\_cursors.maximum**(gauge)                                     | Session closed cursors.*Shown as cursor*                                                                                                                   |
| **alibabacloud.mongodb.session\_closed\_cursors.minimum**(gauge)                                     | Session closed cursors.*Shown as cursor*                                                                                                                   |
| **alibabacloud.mongodb.session\_closed\_cursors\_node.average**(gauge)                               | Session closed cursors on node.*Shown as cursor*                                                                                                           |
| **alibabacloud.mongodb.session\_closed\_cursors\_node.maximum**(gauge)                               | Session closed cursors on node.*Shown as cursor*                                                                                                           |
| **alibabacloud.mongodb.session\_closed\_cursors\_node.minimum**(gauge)                               | Session closed cursors on node.*Shown as cursor*                                                                                                           |
| **alibabacloud.mongodb.slow\_log\_count.sum**(gauge)                                                 | Slow query count.*Shown as query*                                                                                                                          |
| **alibabacloud.mongodb.tcmalloc\_cache\_mem\_ratio.average**(gauge)                                  | Tcmalloc cache memory ratio.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.tcmalloc\_cache\_mem\_ratio.maximum**(gauge)                                  | Tcmalloc cache memory ratio.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.tcmalloc\_cache\_mem\_ratio.minimum**(gauge)                                  | Tcmalloc cache memory ratio.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.tcmalloc\_cache\_mem\_ratio\_node.average**(gauge)                            | Tcmalloc cache memory ratio on node.*Shown as percent*                                                                                                     |
| **alibabacloud.mongodb.tcmalloc\_cache\_mem\_ratio\_node.maximum**(gauge)                            | Tcmalloc cache memory ratio on node.*Shown as percent*                                                                                                     |
| **alibabacloud.mongodb.tcmalloc\_cache\_mem\_ratio\_node.minimum**(gauge)                            | Tcmalloc cache memory ratio on node.*Shown as percent*                                                                                                     |
| **alibabacloud.mongodb.total\_cursors.average**(gauge)                                               | Total cursors.*Shown as cursor*                                                                                                                            |
| **alibabacloud.mongodb.total\_cursors.maximum**(gauge)                                               | Total cursors.*Shown as cursor*                                                                                                                            |
| **alibabacloud.mongodb.total\_cursors.minimum**(gauge)                                               | Total cursors.*Shown as cursor*                                                                                                                            |
| **alibabacloud.mongodb.total\_cursors\_node.average**(gauge)                                         | Total cursors on node.*Shown as cursor*                                                                                                                    |
| **alibabacloud.mongodb.total\_cursors\_node.maximum**(gauge)                                         | Total cursors on node.*Shown as cursor*                                                                                                                    |
| **alibabacloud.mongodb.total\_cursors\_node.minimum**(gauge)                                         | Total cursors on node.*Shown as cursor*                                                                                                                    |
| **alibabacloud.mongodb.total\_mbps\_usage.average**(gauge)                                           | Total network bandwidth usage.*Shown as percent*                                                                                                           |
| **alibabacloud.mongodb.total\_mbps\_usage.maximum**(gauge)                                           | Total network bandwidth usage.*Shown as percent*                                                                                                           |
| **alibabacloud.mongodb.total\_mbps\_usage.minimum**(gauge)                                           | Total network bandwidth usage.*Shown as percent*                                                                                                           |
| **alibabacloud.mongodb.total\_mbps\_usage\_node.average**(gauge)                                     | Total network bandwidth usage on node.*Shown as percent*                                                                                                   |
| **alibabacloud.mongodb.total\_mbps\_usage\_node.maximum**(gauge)                                     | Total network bandwidth usage on node.*Shown as percent*                                                                                                   |
| **alibabacloud.mongodb.total\_mbps\_usage\_node.minimum**(gauge)                                     | Total network bandwidth usage on node.*Shown as percent*                                                                                                   |
| **alibabacloud.mongodb.trans\_latency\_ps.average**(rate)                                            | Transaction latency per second.*Shown as microsecond*                                                                                                      |
| **alibabacloud.mongodb.trans\_latency\_ps.maximum**(rate)                                            | Transaction latency per second.*Shown as microsecond*                                                                                                      |
| **alibabacloud.mongodb.trans\_latency\_ps.minimum**(rate)                                            | Transaction latency per second.*Shown as microsecond*                                                                                                      |
| **alibabacloud.mongodb.trans\_latency\_ps\_node.average**(rate)                                      | Transaction latency per second on node.*Shown as microsecond*                                                                                              |
| **alibabacloud.mongodb.trans\_latency\_ps\_node.maximum**(rate)                                      | Transaction latency per second on node.*Shown as microsecond*                                                                                              |
| **alibabacloud.mongodb.trans\_latency\_ps\_node.minimum**(rate)                                      | Transaction latency per second on node.*Shown as microsecond*                                                                                              |
| **alibabacloud.mongodb.trans\_total\_aborted\_ps.average**(rate)                                     | Total aborted transactions per second.*Shown as transaction*                                                                                               |
| **alibabacloud.mongodb.trans\_total\_aborted\_ps.maximum**(rate)                                     | Total aborted transactions per second.*Shown as transaction*                                                                                               |
| **alibabacloud.mongodb.trans\_total\_aborted\_ps.minimum**(rate)                                     | Total aborted transactions per second.*Shown as transaction*                                                                                               |
| **alibabacloud.mongodb.trans\_total\_aborted\_ps\_node.average**(rate)                               | Total aborted transactions per second on node.*Shown as transaction*                                                                                       |
| **alibabacloud.mongodb.trans\_total\_aborted\_ps\_node.maximum**(rate)                               | Total aborted transactions per second on node.*Shown as transaction*                                                                                       |
| **alibabacloud.mongodb.trans\_total\_aborted\_ps\_node.minimum**(rate)                               | Total aborted transactions per second on node.*Shown as transaction*                                                                                       |
| **alibabacloud.mongodb.trans\_total\_commited\_ps.average**(rate)                                    | Total committed transactions per second.*Shown as transaction*                                                                                             |
| **alibabacloud.mongodb.trans\_total\_commited\_ps.maximum**(rate)                                    | Total committed transactions per second.*Shown as transaction*                                                                                             |
| **alibabacloud.mongodb.trans\_total\_commited\_ps.minimum**(rate)                                    | Total committed transactions per second.*Shown as transaction*                                                                                             |
| **alibabacloud.mongodb.trans\_total\_commited\_ps\_node.average**(rate)                              | Total committed transactions per second on node.*Shown as transaction*                                                                                     |
| **alibabacloud.mongodb.trans\_total\_commited\_ps\_node.maximum**(rate)                              | Total committed transactions per second on node.*Shown as transaction*                                                                                     |
| **alibabacloud.mongodb.trans\_total\_commited\_ps\_node.minimum**(rate)                              | Total committed transactions per second on node.*Shown as transaction*                                                                                     |
| **alibabacloud.mongodb.trans\_total\_prepared\_ps.average**(rate)                                    | Total prepared transactions per second.*Shown as transaction*                                                                                              |
| **alibabacloud.mongodb.trans\_total\_prepared\_ps.maximum**(rate)                                    | Total prepared transactions per second.*Shown as transaction*                                                                                              |
| **alibabacloud.mongodb.trans\_total\_prepared\_ps.minimum**(rate)                                    | Total prepared transactions per second.*Shown as transaction*                                                                                              |
| **alibabacloud.mongodb.trans\_total\_prepared\_ps\_node.average**(rate)                              | Total prepared transactions per second on node.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.trans\_total\_prepared\_ps\_node.maximum**(rate)                              | Total prepared transactions per second on node.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.trans\_total\_prepared\_ps\_node.minimum**(rate)                              | Total prepared transactions per second on node.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_aborted\_ps.average**(rate)                     | Total prepared then aborted transactions per second.*Shown as transaction*                                                                                 |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_aborted\_ps.maximum**(rate)                     | Total prepared then aborted transactions per second.*Shown as transaction*                                                                                 |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_aborted\_ps.minimum**(rate)                     | Total prepared then aborted transactions per second.*Shown as transaction*                                                                                 |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_aborted\_ps\_node.average**(rate)               | Total prepared then aborted transactions per second on node.*Shown as transaction*                                                                         |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_aborted\_ps\_node.maximum**(rate)               | Total prepared then aborted transactions per second on node.*Shown as transaction*                                                                         |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_aborted\_ps\_node.minimum**(rate)               | Total prepared then aborted transactions per second on node.*Shown as transaction*                                                                         |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_commited\_ps.average**(rate)                    | Total prepared then committed transactions per second.*Shown as transaction*                                                                               |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_commited\_ps.maximum**(rate)                    | Total prepared then committed transactions per second.*Shown as transaction*                                                                               |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_commited\_ps.minimum**(rate)                    | Total prepared then committed transactions per second.*Shown as transaction*                                                                               |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_commited\_ps\_node.average**(rate)              | Total prepared then committed transactions per second on node.*Shown as transaction*                                                                       |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_commited\_ps\_node.maximum**(rate)              | Total prepared then committed transactions per second on node.*Shown as transaction*                                                                       |
| **alibabacloud.mongodb.trans\_total\_prepared\_then\_commited\_ps\_node.minimum**(rate)              | Total prepared then committed transactions per second on node.*Shown as transaction*                                                                       |
| **alibabacloud.mongodb.trans\_total\_started\_ps.average**(rate)                                     | Total started transactions per second.*Shown as transaction*                                                                                               |
| **alibabacloud.mongodb.trans\_total\_started\_ps.maximum**(rate)                                     | Total started transactions per second.*Shown as transaction*                                                                                               |
| **alibabacloud.mongodb.trans\_total\_started\_ps.minimum**(rate)                                     | Total started transactions per second.*Shown as transaction*                                                                                               |
| **alibabacloud.mongodb.trans\_total\_started\_ps\_node.average**(rate)                               | Total started transactions per second on node.*Shown as transaction*                                                                                       |
| **alibabacloud.mongodb.trans\_total\_started\_ps\_node.maximum**(rate)                               | Total started transactions per second on node.*Shown as transaction*                                                                                       |
| **alibabacloud.mongodb.trans\_total\_started\_ps\_node.minimum**(rate)                               | Total started transactions per second on node.*Shown as transaction*                                                                                       |
| **alibabacloud.mongodb.ttl\_deleted\_ps.average**(rate)                                              | TTL deleted per second.*Shown as operation*                                                                                                                |
| **alibabacloud.mongodb.ttl\_deleted\_ps.maximum**(rate)                                              | TTL deleted per second.*Shown as operation*                                                                                                                |
| **alibabacloud.mongodb.ttl\_deleted\_ps.minimum**(rate)                                              | TTL deleted per second.*Shown as operation*                                                                                                                |
| **alibabacloud.mongodb.ttl\_deleted\_ps\_node.average**(rate)                                        | TTL deleted per second on node.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.ttl\_deleted\_ps\_node.maximum**(rate)                                        | TTL deleted per second on node.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.ttl\_deleted\_ps\_node.minimum**(rate)                                        | TTL deleted per second on node.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.ttl\_passes\_ps.average**(rate)                                               | TTL passes per second.*Shown as scan*                                                                                                                      |
| **alibabacloud.mongodb.ttl\_passes\_ps.maximum**(rate)                                               | TTL passes per second.*Shown as scan*                                                                                                                      |
| **alibabacloud.mongodb.ttl\_passes\_ps.minimum**(rate)                                               | TTL passes per second.*Shown as scan*                                                                                                                      |
| **alibabacloud.mongodb.ttl\_passes\_ps\_node.average**(rate)                                         | TTL passes per second on node.*Shown as scan*                                                                                                              |
| **alibabacloud.mongodb.ttl\_passes\_ps\_node.maximum**(rate)                                         | TTL passes per second on node.*Shown as scan*                                                                                                              |
| **alibabacloud.mongodb.ttl\_passes\_ps\_node.minimum**(rate)                                         | TTL passes per second on node.*Shown as scan*                                                                                                              |
| **alibabacloud.mongodb.txn\_avg\_rt.average**(gauge)                                                 | Transaction average response time.*Shown as microsecond*                                                                                                   |
| **alibabacloud.mongodb.txn\_avg\_rt.maximum**(gauge)                                                 | Transaction average response time.*Shown as microsecond*                                                                                                   |
| **alibabacloud.mongodb.txn\_avg\_rt.minimum**(gauge)                                                 | Transaction average response time.*Shown as microsecond*                                                                                                   |
| **alibabacloud.mongodb.txn\_avg\_rt\_node.average**(gauge)                                           | Transaction average response time on node.*Shown as microsecond*                                                                                           |
| **alibabacloud.mongodb.txn\_avg\_rt\_node.maximum**(gauge)                                           | Transaction average response time on node.*Shown as microsecond*                                                                                           |
| **alibabacloud.mongodb.txn\_avg\_rt\_node.minimum**(gauge)                                           | Transaction average response time on node.*Shown as microsecond*                                                                                           |
| **alibabacloud.mongodb.user.average**(gauge)                                                         | User cursors.*Shown as cursor*                                                                                                                             |
| **alibabacloud.mongodb.user.maximum**(gauge)                                                         | User cursors.*Shown as cursor*                                                                                                                             |
| **alibabacloud.mongodb.user.minimum**(gauge)                                                         | User cursors.*Shown as cursor*                                                                                                                             |
| **alibabacloud.mongodb.user\_node.average**(gauge)                                                   | User cursors on node.*Shown as cursor*                                                                                                                     |
| **alibabacloud.mongodb.user\_node.maximum**(gauge)                                                   | User cursors on node.*Shown as cursor*                                                                                                                     |
| **alibabacloud.mongodb.user\_node.minimum**(gauge)                                                   | User cursors on node.*Shown as cursor*                                                                                                                     |
| **alibabacloud.mongodb.warning.average**(gauge)                                                      | Warnings.                                                                                                                                                  |
| **alibabacloud.mongodb.warning.maximum**(gauge)                                                      | Warnings.                                                                                                                                                  |
| **alibabacloud.mongodb.warning.minimum**(gauge)                                                      | Warnings.                                                                                                                                                  |
| **alibabacloud.mongodb.warning\_node.average**(gauge)                                                | Warnings on node.                                                                                                                                          |
| **alibabacloud.mongodb.warning\_node.maximum**(gauge)                                                | Warnings on node.                                                                                                                                          |
| **alibabacloud.mongodb.warning\_node.minimum**(gauge)                                                | Warnings on node.                                                                                                                                          |
| **alibabacloud.mongodb.wired\_tiger\_check\_point\_lock.average**(gauge)                             | WiredTiger checkpoint lock acquisitions.*Shown as lock*                                                                                                    |
| **alibabacloud.mongodb.wired\_tiger\_check\_point\_lock.maximum**(gauge)                             | WiredTiger checkpoint lock acquisitions.*Shown as lock*                                                                                                    |
| **alibabacloud.mongodb.wired\_tiger\_check\_point\_lock.minimum**(gauge)                             | WiredTiger checkpoint lock acquisitions.*Shown as lock*                                                                                                    |
| **alibabacloud.mongodb.wired\_tiger\_check\_point\_lock\_node.average**(gauge)                       | WiredTiger checkpoint lock acquisitions on node.*Shown as lock*                                                                                            |
| **alibabacloud.mongodb.wired\_tiger\_check\_point\_lock\_node.maximum**(gauge)                       | WiredTiger checkpoint lock acquisitions on node.*Shown as lock*                                                                                            |
| **alibabacloud.mongodb.wired\_tiger\_check\_point\_lock\_node.minimum**(gauge)                       | WiredTiger checkpoint lock acquisitions on node.*Shown as lock*                                                                                            |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_read\_lock.average**(gauge)                            | WiredTiger dhandle read lock acquisitions.*Shown as lock*                                                                                                  |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_read\_lock.maximum**(gauge)                            | WiredTiger dhandle read lock acquisitions.*Shown as lock*                                                                                                  |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_read\_lock.minimum**(gauge)                            | WiredTiger dhandle read lock acquisitions.*Shown as lock*                                                                                                  |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_read\_lock\_node.average**(gauge)                      | WiredTiger dhandle read lock acquisitions on node.*Shown as lock*                                                                                          |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_read\_lock\_node.maximum**(gauge)                      | WiredTiger dhandle read lock acquisitions on node.*Shown as lock*                                                                                          |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_read\_lock\_node.minimum**(gauge)                      | WiredTiger dhandle read lock acquisitions on node.*Shown as lock*                                                                                          |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_write\_lock.average**(gauge)                           | WiredTiger dhandle write lock acquisitions.*Shown as lock*                                                                                                 |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_write\_lock.maximum**(gauge)                           | WiredTiger dhandle write lock acquisitions.*Shown as lock*                                                                                                 |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_write\_lock.minimum**(gauge)                           | WiredTiger dhandle write lock acquisitions.*Shown as lock*                                                                                                 |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_write\_lock\_node.average**(gauge)                     | WiredTiger dhandle write lock acquisitions on node.*Shown as lock*                                                                                         |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_write\_lock\_node.maximum**(gauge)                     | WiredTiger dhandle write lock acquisitions on node.*Shown as lock*                                                                                         |
| **alibabacloud.mongodb.wired\_tiger\_dhandle\_write\_lock\_node.minimum**(gauge)                     | WiredTiger dhandle write lock acquisitions on node.*Shown as lock*                                                                                         |
| **alibabacloud.mongodb.wired\_tiger\_metadata\_lock.average**(gauge)                                 | WiredTiger metadata lock acquisitions.*Shown as lock*                                                                                                      |
| **alibabacloud.mongodb.wired\_tiger\_metadata\_lock.maximum**(gauge)                                 | WiredTiger metadata lock acquisitions.*Shown as lock*                                                                                                      |
| **alibabacloud.mongodb.wired\_tiger\_metadata\_lock.minimum**(gauge)                                 | WiredTiger metadata lock acquisitions.*Shown as lock*                                                                                                      |
| **alibabacloud.mongodb.wired\_tiger\_metadata\_lock\_node.average**(gauge)                           | WiredTiger metadata lock acquisitions on node.*Shown as lock*                                                                                              |
| **alibabacloud.mongodb.wired\_tiger\_metadata\_lock\_node.maximum**(gauge)                           | WiredTiger metadata lock acquisitions on node.*Shown as lock*                                                                                              |
| **alibabacloud.mongodb.wired\_tiger\_metadata\_lock\_node.minimum**(gauge)                           | WiredTiger metadata lock acquisitions on node.*Shown as lock*                                                                                              |
| **alibabacloud.mongodb.wired\_tiger\_schema\_lock.average**(gauge)                                   | WiredTiger schema lock acquisitions.*Shown as lock*                                                                                                        |
| **alibabacloud.mongodb.wired\_tiger\_schema\_lock.maximum**(gauge)                                   | WiredTiger schema lock acquisitions.*Shown as lock*                                                                                                        |
| **alibabacloud.mongodb.wired\_tiger\_schema\_lock.minimum**(gauge)                                   | WiredTiger schema lock acquisitions.*Shown as lock*                                                                                                        |
| **alibabacloud.mongodb.wired\_tiger\_schema\_lock\_node.average**(gauge)                             | WiredTiger schema lock acquisitions on node.*Shown as lock*                                                                                                |
| **alibabacloud.mongodb.wired\_tiger\_schema\_lock\_node.maximum**(gauge)                             | WiredTiger schema lock acquisitions on node.*Shown as lock*                                                                                                |
| **alibabacloud.mongodb.wired\_tiger\_schema\_lock\_node.minimum**(gauge)                             | WiredTiger schema lock acquisitions on node.*Shown as lock*                                                                                                |
| **alibabacloud.mongodb.wired\_tiger\_table\_read\_lock.average**(gauge)                              | WiredTiger table read lock acquisitions.*Shown as lock*                                                                                                    |
| **alibabacloud.mongodb.wired\_tiger\_table\_read\_lock.maximum**(gauge)                              | WiredTiger table read lock acquisitions.*Shown as lock*                                                                                                    |
| **alibabacloud.mongodb.wired\_tiger\_table\_read\_lock.minimum**(gauge)                              | WiredTiger table read lock acquisitions.*Shown as lock*                                                                                                    |
| **alibabacloud.mongodb.wired\_tiger\_table\_read\_lock\_node.average**(gauge)                        | WiredTiger table read lock acquisitions on node.*Shown as lock*                                                                                            |
| **alibabacloud.mongodb.wired\_tiger\_table\_read\_lock\_node.maximum**(gauge)                        | WiredTiger table read lock acquisitions on node.*Shown as lock*                                                                                            |
| **alibabacloud.mongodb.wired\_tiger\_table\_read\_lock\_node.minimum**(gauge)                        | WiredTiger table read lock acquisitions on node.*Shown as lock*                                                                                            |
| **alibabacloud.mongodb.wired\_tiger\_table\_write\_lock.average**(gauge)                             | WiredTiger table write lock acquisitions.*Shown as lock*                                                                                                   |
| **alibabacloud.mongodb.wired\_tiger\_table\_write\_lock.maximum**(gauge)                             | WiredTiger table write lock acquisitions.*Shown as lock*                                                                                                   |
| **alibabacloud.mongodb.wired\_tiger\_table\_write\_lock.minimum**(gauge)                             | WiredTiger table write lock acquisitions.*Shown as lock*                                                                                                   |
| **alibabacloud.mongodb.wired\_tiger\_table\_write\_lock\_node.average**(gauge)                       | WiredTiger table write lock acquisitions on node.*Shown as lock*                                                                                           |
| **alibabacloud.mongodb.wired\_tiger\_table\_write\_lock\_node.maximum**(gauge)                       | WiredTiger table write lock acquisitions on node.*Shown as lock*                                                                                           |
| **alibabacloud.mongodb.wired\_tiger\_table\_write\_lock\_node.minimum**(gauge)                       | WiredTiger table write lock acquisitions on node.*Shown as lock*                                                                                           |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_read\_lock.average**(gauge)                        | WiredTiger transaction global read lock acquisitions.*Shown as lock*                                                                                       |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_read\_lock.maximum**(gauge)                        | WiredTiger transaction global read lock acquisitions.*Shown as lock*                                                                                       |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_read\_lock.minimum**(gauge)                        | WiredTiger transaction global read lock acquisitions.*Shown as lock*                                                                                       |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_read\_lock\_node.average**(gauge)                  | WiredTiger transaction global read lock acquisitions on node.*Shown as lock*                                                                               |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_read\_lock\_node.maximum**(gauge)                  | WiredTiger transaction global read lock acquisitions on node.*Shown as lock*                                                                               |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_read\_lock\_node.minimum**(gauge)                  | WiredTiger transaction global read lock acquisitions on node.*Shown as lock*                                                                               |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_write\_lock.average**(gauge)                       | WiredTiger transaction global write lock acquisitions.*Shown as lock*                                                                                      |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_write\_lock.maximum**(gauge)                       | WiredTiger transaction global write lock acquisitions.*Shown as lock*                                                                                      |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_write\_lock.minimum**(gauge)                       | WiredTiger transaction global write lock acquisitions.*Shown as lock*                                                                                      |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_write\_lock\_node.average**(gauge)                 | WiredTiger transaction global write lock acquisitions on node.*Shown as lock*                                                                              |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_write\_lock\_node.maximum**(gauge)                 | WiredTiger transaction global write lock acquisitions on node.*Shown as lock*                                                                              |
| **alibabacloud.mongodb.wired\_tiger\_txn\_global\_write\_lock\_node.minimum**(gauge)                 | WiredTiger transaction global write lock acquisitions on node.*Shown as lock*                                                                              |
| **alibabacloud.mongodb.write\_avg\_rt.average**(gauge)                                               | Write average response time.*Shown as microsecond*                                                                                                         |
| **alibabacloud.mongodb.write\_avg\_rt.maximum**(gauge)                                               | Write average response time.*Shown as microsecond*                                                                                                         |
| **alibabacloud.mongodb.write\_avg\_rt.minimum**(gauge)                                               | Write average response time.*Shown as microsecond*                                                                                                         |
| **alibabacloud.mongodb.write\_avg\_rt\_node.average**(gauge)                                         | Write average response time on node.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.write\_avg\_rt\_node.maximum**(gauge)                                         | Write average response time on node.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.write\_avg\_rt\_node.minimum**(gauge)                                         | Write average response time on node.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.write\_bandwidth.average**(rate)                                              | Write bandwidth.*Shown as mebibyte*                                                                                                                        |
| **alibabacloud.mongodb.write\_bandwidth.maximum**(rate)                                              | Write bandwidth.*Shown as mebibyte*                                                                                                                        |
| **alibabacloud.mongodb.write\_bandwidth.minimum**(rate)                                              | Write bandwidth.*Shown as mebibyte*                                                                                                                        |
| **alibabacloud.mongodb.write\_bandwidth\_node.average**(rate)                                        | Write bandwidth on node.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.mongodb.write\_bandwidth\_node.maximum**(rate)                                        | Write bandwidth on node.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.mongodb.write\_bandwidth\_node.minimum**(rate)                                        | Write bandwidth on node.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.mongodb.write\_conflicts.average**(gauge)                                             | Write conflicts.                                                                                                                                           |
| **alibabacloud.mongodb.write\_conflicts.maximum**(gauge)                                             | Write conflicts.                                                                                                                                           |
| **alibabacloud.mongodb.write\_conflicts.minimum**(gauge)                                             | Write conflicts.                                                                                                                                           |
| **alibabacloud.mongodb.write\_conflicts\_node.average**(gauge)                                       | Write conflicts on node.                                                                                                                                   |
| **alibabacloud.mongodb.write\_conflicts\_node.maximum**(gauge)                                       | Write conflicts on node.                                                                                                                                   |
| **alibabacloud.mongodb.write\_conflicts\_node.minimum**(gauge)                                       | Write conflicts on node.                                                                                                                                   |
| **alibabacloud.mongodb.write\_trans\_concurrent\_avail.average**(gauge)                              | Write transactions concurrent available.*Shown as transaction*                                                                                             |
| **alibabacloud.mongodb.write\_trans\_concurrent\_avail.maximum**(gauge)                              | Write transactions concurrent available.*Shown as transaction*                                                                                             |
| **alibabacloud.mongodb.write\_trans\_concurrent\_avail.minimum**(gauge)                              | Write transactions concurrent available.*Shown as transaction*                                                                                             |
| **alibabacloud.mongodb.write\_trans\_concurrent\_avail\_node.average**(gauge)                        | Write transactions concurrent available on node.*Shown as transaction*                                                                                     |
| **alibabacloud.mongodb.write\_trans\_concurrent\_avail\_node.maximum**(gauge)                        | Write transactions concurrent available on node.*Shown as transaction*                                                                                     |
| **alibabacloud.mongodb.write\_trans\_concurrent\_avail\_node.minimum**(gauge)                        | Write transactions concurrent available on node.*Shown as transaction*                                                                                     |
| **alibabacloud.mongodb.write\_trans\_concurrent\_out.average**(gauge)                                | Write transactions concurrent out.*Shown as transaction*                                                                                                   |
| **alibabacloud.mongodb.write\_trans\_concurrent\_out.maximum**(gauge)                                | Write transactions concurrent out.*Shown as transaction*                                                                                                   |
| **alibabacloud.mongodb.write\_trans\_concurrent\_out.minimum**(gauge)                                | Write transactions concurrent out.*Shown as transaction*                                                                                                   |
| **alibabacloud.mongodb.write\_trans\_concurrent\_out\_node.average**(gauge)                          | Write transactions concurrent out on node.*Shown as transaction*                                                                                           |
| **alibabacloud.mongodb.write\_trans\_concurrent\_out\_node.maximum**(gauge)                          | Write transactions concurrent out on node.*Shown as transaction*                                                                                           |
| **alibabacloud.mongodb.write\_trans\_concurrent\_out\_node.minimum**(gauge)                          | Write transactions concurrent out on node.*Shown as transaction*                                                                                           |
| **alibabacloud.mongodb.writes\_latency\_ps.average**(rate)                                           | Writes latency per second.*Shown as microsecond*                                                                                                           |
| **alibabacloud.mongodb.writes\_latency\_ps.maximum**(rate)                                           | Writes latency per second.*Shown as microsecond*                                                                                                           |
| **alibabacloud.mongodb.writes\_latency\_ps.minimum**(rate)                                           | Writes latency per second.*Shown as microsecond*                                                                                                           |
| **alibabacloud.mongodb.writes\_latency\_ps\_node.average**(rate)                                     | Writes latency per second on node.*Shown as microsecond*                                                                                                   |
| **alibabacloud.mongodb.writes\_latency\_ps\_node.maximum**(rate)                                     | Writes latency per second on node.*Shown as microsecond*                                                                                                   |
| **alibabacloud.mongodb.writes\_latency\_ps\_node.minimum**(rate)                                     | Writes latency per second on node.*Shown as microsecond*                                                                                                   |
| **alibabacloud.mongodb.wt\_cache\_dirty\_usage.average**(gauge)                                      | WiredTiger cache dirty usage.*Shown as percent*                                                                                                            |
| **alibabacloud.mongodb.wt\_cache\_dirty\_usage.maximum**(gauge)                                      | WiredTiger cache dirty usage.*Shown as percent*                                                                                                            |
| **alibabacloud.mongodb.wt\_cache\_dirty\_usage.minimum**(gauge)                                      | WiredTiger cache dirty usage.*Shown as percent*                                                                                                            |
| **alibabacloud.mongodb.wt\_cache\_dirty\_usage\_node.average**(gauge)                                | WiredTiger cache dirty usage on node.*Shown as percent*                                                                                                    |
| **alibabacloud.mongodb.wt\_cache\_dirty\_usage\_node.maximum**(gauge)                                | WiredTiger cache dirty usage on node.*Shown as percent*                                                                                                    |
| **alibabacloud.mongodb.wt\_cache\_dirty\_usage\_node.minimum**(gauge)                                | WiredTiger cache dirty usage on node.*Shown as percent*                                                                                                    |
| **alibabacloud.mongodb.wt\_cache\_updates\_usage.average**(gauge)                                    | WiredTiger cache updates usage.*Shown as percent*                                                                                                          |
| **alibabacloud.mongodb.wt\_cache\_updates\_usage.maximum**(gauge)                                    | WiredTiger cache updates usage.*Shown as percent*                                                                                                          |
| **alibabacloud.mongodb.wt\_cache\_updates\_usage.minimum**(gauge)                                    | WiredTiger cache updates usage.*Shown as percent*                                                                                                          |
| **alibabacloud.mongodb.wt\_cache\_updates\_usage\_node.average**(gauge)                              | WiredTiger cache updates usage on node.*Shown as percent*                                                                                                  |
| **alibabacloud.mongodb.wt\_cache\_updates\_usage\_node.maximum**(gauge)                              | WiredTiger cache updates usage on node.*Shown as percent*                                                                                                  |
| **alibabacloud.mongodb.wt\_cache\_updates\_usage\_node.minimum**(gauge)                              | WiredTiger cache updates usage on node.*Shown as percent*                                                                                                  |
| **alibabacloud.mongodb.wt\_cache\_usage.average**(gauge)                                             | WiredTiger cache usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.wt\_cache\_usage.maximum**(gauge)                                             | WiredTiger cache usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.wt\_cache\_usage.minimum**(gauge)                                             | WiredTiger cache usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.wt\_cache\_usage\_node.average**(gauge)                                       | WiredTiger cache usage on node.*Shown as percent*                                                                                                          |
| **alibabacloud.mongodb.wt\_cache\_usage\_node.maximum**(gauge)                                       | WiredTiger cache usage on node.*Shown as percent*                                                                                                          |
| **alibabacloud.mongodb.wt\_cache\_usage\_node.minimum**(gauge)                                       | WiredTiger cache usage on node.*Shown as percent*                                                                                                          |
| **alibabacloud.mongodb.wt\_file\_num.average**(gauge)                                                | WiredTiger file count.*Shown as file*                                                                                                                      |
| **alibabacloud.mongodb.wt\_file\_num.maximum**(gauge)                                                | WiredTiger file count.*Shown as file*                                                                                                                      |
| **alibabacloud.mongodb.wt\_file\_num.minimum**(gauge)                                                | WiredTiger file count.*Shown as file*                                                                                                                      |
| **alibabacloud.mongodb.wt\_file\_num\_node.average**(gauge)                                          | WiredTiger file count on node.*Shown as file*                                                                                                              |
| **alibabacloud.mongodb.wt\_file\_num\_node.maximum**(gauge)                                          | WiredTiger file count on node.*Shown as file*                                                                                                              |
| **alibabacloud.mongodb.wt\_file\_num\_node.minimum**(gauge)                                          | WiredTiger file count on node.*Shown as file*                                                                                                              |
| **alibabacloud.mongodb.group\_sharding\_cpu\_utilization.average**(gauge)                            | Group sharding CPU usage.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.group\_sharding\_cpu\_utilization.minimum**(gauge)                            | Group sharding CPU usage.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.group\_sharding\_cpu\_utilization.maximum**(gauge)                            | Group sharding CPU usage.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.group\_sharding\_connection\_utilization.average**(gauge)                     | Group sharding connection usage.*Shown as percent*                                                                                                         |
| **alibabacloud.mongodb.group\_sharding\_connection\_utilization.minimum**(gauge)                     | Group sharding connection usage.*Shown as percent*                                                                                                         |
| **alibabacloud.mongodb.group\_sharding\_connection\_utilization.maximum**(gauge)                     | Group sharding connection usage.*Shown as percent*                                                                                                         |
| **alibabacloud.mongodb.group\_sharding\_disk\_utilization.average**(gauge)                           | Group sharding disk usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.group\_sharding\_disk\_utilization.minimum**(gauge)                           | Group sharding disk usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.group\_sharding\_disk\_utilization.maximum**(gauge)                           | Group sharding disk usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.group\_sharding\_iops\_utilization.average**(gauge)                           | Group sharding IOPS usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.group\_sharding\_iops\_utilization.minimum**(gauge)                           | Group sharding IOPS usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.group\_sharding\_iops\_utilization.maximum**(gauge)                           | Group sharding IOPS usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.group\_sharding\_memory\_utilization.average**(gauge)                         | Group sharding memory usage.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.group\_sharding\_memory\_utilization.minimum**(gauge)                         | Group sharding memory usage.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.group\_sharding\_memory\_utilization.maximum**(gauge)                         | Group sharding memory usage.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.sharding\_active\_conns.average**(gauge)                                      | Sharding active connections.*Shown as connection*                                                                                                          |
| **alibabacloud.mongodb.sharding\_active\_conns.maximum**(gauge)                                      | Sharding active connections.*Shown as connection*                                                                                                          |
| **alibabacloud.mongodb.sharding\_active\_conns.minimum**(gauge)                                      | Sharding active connections.*Shown as connection*                                                                                                          |
| **alibabacloud.mongodb.sharding\_active\_conns\_node.average**(gauge)                                | Sharding active connections on node.*Shown as connection*                                                                                                  |
| **alibabacloud.mongodb.sharding\_active\_conns\_node.maximum**(gauge)                                | Sharding active connections on node.*Shown as connection*                                                                                                  |
| **alibabacloud.mongodb.sharding\_active\_conns\_node.minimum**(gauge)                                | Sharding active connections on node.*Shown as connection*                                                                                                  |
| **alibabacloud.mongodb.sharding\_active\_read\_locks.average**(gauge)                                | Sharding active read locks.*Shown as lock*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_active\_read\_locks.maximum**(gauge)                                | Sharding active read locks.*Shown as lock*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_active\_read\_locks.minimum**(gauge)                                | Sharding active read locks.*Shown as lock*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_active\_read\_locks\_node.average**(gauge)                          | Sharding active read locks on node.*Shown as lock*                                                                                                         |
| **alibabacloud.mongodb.sharding\_active\_read\_locks\_node.maximum**(gauge)                          | Sharding active read locks on node.*Shown as lock*                                                                                                         |
| **alibabacloud.mongodb.sharding\_active\_read\_locks\_node.minimum**(gauge)                          | Sharding active read locks on node.*Shown as lock*                                                                                                         |
| **alibabacloud.mongodb.sharding\_active\_write\_locks.average**(gauge)                               | Sharding active write locks.*Shown as lock*                                                                                                                |
| **alibabacloud.mongodb.sharding\_active\_write\_locks.maximum**(gauge)                               | Sharding active write locks.*Shown as lock*                                                                                                                |
| **alibabacloud.mongodb.sharding\_active\_write\_locks.minimum**(gauge)                               | Sharding active write locks.*Shown as lock*                                                                                                                |
| **alibabacloud.mongodb.sharding\_active\_write\_locks\_node.average**(gauge)                         | Sharding active write locks on node.*Shown as lock*                                                                                                        |
| **alibabacloud.mongodb.sharding\_active\_write\_locks\_node.maximum**(gauge)                         | Sharding active write locks on node.*Shown as lock*                                                                                                        |
| **alibabacloud.mongodb.sharding\_active\_write\_locks\_node.minimum**(gauge)                         | Sharding active write locks on node.*Shown as lock*                                                                                                        |
| **alibabacloud.mongodb.sharding\_avail\_conns.average**(gauge)                                       | Sharding available connections.*Shown as connection*                                                                                                       |
| **alibabacloud.mongodb.sharding\_avail\_conns.maximum**(gauge)                                       | Sharding available connections.*Shown as connection*                                                                                                       |
| **alibabacloud.mongodb.sharding\_avail\_conns.minimum**(gauge)                                       | Sharding available connections.*Shown as connection*                                                                                                       |
| **alibabacloud.mongodb.sharding\_avail\_conns\_node.average**(gauge)                                 | Sharding available connections on node.*Shown as connection*                                                                                               |
| **alibabacloud.mongodb.sharding\_avail\_conns\_node.maximum**(gauge)                                 | Sharding available connections on node.*Shown as connection*                                                                                               |
| **alibabacloud.mongodb.sharding\_avail\_conns\_node.minimum**(gauge)                                 | Sharding available connections on node.*Shown as connection*                                                                                               |
| **alibabacloud.mongodb.sharding\_avg\_rt.average**(gauge)                                            | Sharding average response time.*Shown as microsecond*                                                                                                      |
| **alibabacloud.mongodb.sharding\_avg\_rt.maximum**(gauge)                                            | Sharding average response time.*Shown as microsecond*                                                                                                      |
| **alibabacloud.mongodb.sharding\_avg\_rt.minimum**(gauge)                                            | Sharding average response time.*Shown as microsecond*                                                                                                      |
| **alibabacloud.mongodb.sharding\_avg\_rt\_node.average**(gauge)                                      | Sharding average response time on node.*Shown as microsecond*                                                                                              |
| **alibabacloud.mongodb.sharding\_avg\_rt\_node.maximum**(gauge)                                      | Sharding average response time on node.*Shown as microsecond*                                                                                              |
| **alibabacloud.mongodb.sharding\_avg\_rt\_node.minimum**(gauge)                                      | Sharding average response time on node.*Shown as microsecond*                                                                                              |
| **alibabacloud.mongodb.sharding\_bytes\_read\_cache.average**(gauge)                                 | Sharding bytes read from cache.*Shown as byte*                                                                                                             |
| **alibabacloud.mongodb.sharding\_bytes\_read\_cache.maximum**(gauge)                                 | Sharding bytes read from cache.*Shown as byte*                                                                                                             |
| **alibabacloud.mongodb.sharding\_bytes\_read\_cache.minimum**(gauge)                                 | Sharding bytes read from cache.*Shown as byte*                                                                                                             |
| **alibabacloud.mongodb.sharding\_bytes\_read\_cache\_node.average**(gauge)                           | Sharding bytes read from cache on node.*Shown as byte*                                                                                                     |
| **alibabacloud.mongodb.sharding\_bytes\_read\_cache\_node.maximum**(gauge)                           | Sharding bytes read from cache on node.*Shown as byte*                                                                                                     |
| **alibabacloud.mongodb.sharding\_bytes\_read\_cache\_node.minimum**(gauge)                           | Sharding bytes read from cache on node.*Shown as byte*                                                                                                     |
| **alibabacloud.mongodb.sharding\_bytes\_written\_cache.average**(gauge)                              | Sharding bytes written to cache.*Shown as byte*                                                                                                            |
| **alibabacloud.mongodb.sharding\_bytes\_written\_cache.maximum**(gauge)                              | Sharding bytes written to cache.*Shown as byte*                                                                                                            |
| **alibabacloud.mongodb.sharding\_bytes\_written\_cache.minimum**(gauge)                              | Sharding bytes written to cache.*Shown as byte*                                                                                                            |
| **alibabacloud.mongodb.sharding\_bytes\_written\_cache\_node.average**(gauge)                        | Sharding bytes written to cache on node.*Shown as byte*                                                                                                    |
| **alibabacloud.mongodb.sharding\_bytes\_written\_cache\_node.maximum**(gauge)                        | Sharding bytes written to cache on node.*Shown as byte*                                                                                                    |
| **alibabacloud.mongodb.sharding\_bytes\_written\_cache\_node.minimum**(gauge)                        | Sharding bytes written to cache on node.*Shown as byte*                                                                                                    |
| **alibabacloud.mongodb.sharding\_cpu\_utilization.average**(gauge)                                   | Sharding CPU usage.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.sharding\_cpu\_utilization.maximum**(gauge)                                   | Sharding CPU usage.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.sharding\_cpu\_utilization.minimum**(gauge)                                   | Sharding CPU usage.*Shown as percent*                                                                                                                      |
| **alibabacloud.mongodb.sharding\_cpu\_utilization\_node.average**(gauge)                             | Sharding CPU usage on node.*Shown as percent*                                                                                                              |
| **alibabacloud.mongodb.sharding\_cpu\_utilization\_node.maximum**(gauge)                             | Sharding CPU usage on node.*Shown as percent*                                                                                                              |
| **alibabacloud.mongodb.sharding\_cpu\_utilization\_node.minimum**(gauge)                             | Sharding CPU usage on node.*Shown as percent*                                                                                                              |
| **alibabacloud.mongodb.sharding\_cache\_bytes.average**(gauge)                                       | Sharding cache size.*Shown as byte*                                                                                                                        |
| **alibabacloud.mongodb.sharding\_cache\_bytes.maximum**(gauge)                                       | Sharding cache size.*Shown as byte*                                                                                                                        |
| **alibabacloud.mongodb.sharding\_cache\_bytes.minimum**(gauge)                                       | Sharding cache size.*Shown as byte*                                                                                                                        |
| **alibabacloud.mongodb.sharding\_cache\_bytes\_node.average**(gauge)                                 | Sharding cache size on node.*Shown as byte*                                                                                                                |
| **alibabacloud.mongodb.sharding\_cache\_bytes\_node.maximum**(gauge)                                 | Sharding cache size on node.*Shown as byte*                                                                                                                |
| **alibabacloud.mongodb.sharding\_cache\_bytes\_node.minimum**(gauge)                                 | Sharding cache size on node.*Shown as byte*                                                                                                                |
| **alibabacloud.mongodb.sharding\_closed\_fd\_num.average**(gauge)                                    | Sharding closed file descriptors.*Shown as file*                                                                                                           |
| **alibabacloud.mongodb.sharding\_closed\_fd\_num.maximum**(gauge)                                    | Sharding closed file descriptors.*Shown as file*                                                                                                           |
| **alibabacloud.mongodb.sharding\_closed\_fd\_num.minimum**(gauge)                                    | Sharding closed file descriptors.*Shown as file*                                                                                                           |
| **alibabacloud.mongodb.sharding\_closed\_fd\_num\_node.average**(gauge)                              | Sharding closed file descriptors on node.*Shown as file*                                                                                                   |
| **alibabacloud.mongodb.sharding\_closed\_fd\_num\_node.maximum**(gauge)                              | Sharding closed file descriptors on node.*Shown as file*                                                                                                   |
| **alibabacloud.mongodb.sharding\_closed\_fd\_num\_node.minimum**(gauge)                              | Sharding closed file descriptors on node.*Shown as file*                                                                                                   |
| **alibabacloud.mongodb.sharding\_cmd\_avg\_rt.average**(gauge)                                       | Sharding command average response time.*Shown as microsecond*                                                                                              |
| **alibabacloud.mongodb.sharding\_cmd\_avg\_rt.maximum**(gauge)                                       | Sharding command average response time.*Shown as microsecond*                                                                                              |
| **alibabacloud.mongodb.sharding\_cmd\_avg\_rt.minimum**(gauge)                                       | Sharding command average response time.*Shown as microsecond*                                                                                              |
| **alibabacloud.mongodb.sharding\_cmd\_avg\_rt\_node.average**(gauge)                                 | Sharding command average response time on node.*Shown as microsecond*                                                                                      |
| **alibabacloud.mongodb.sharding\_cmd\_avg\_rt\_node.maximum**(gauge)                                 | Sharding command average response time on node.*Shown as microsecond*                                                                                      |
| **alibabacloud.mongodb.sharding\_cmd\_avg\_rt\_node.minimum**(gauge)                                 | Sharding command average response time on node.*Shown as microsecond*                                                                                      |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps.average**(rate)                               | Sharding commands latency per second.*Shown as microsecond*                                                                                                |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps.maximum**(rate)                               | Sharding commands latency per second.*Shown as microsecond*                                                                                                |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps.minimum**(rate)                               | Sharding commands latency per second.*Shown as microsecond*                                                                                                |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps\_node.average**(rate)                         | Sharding commands latency per second on node.*Shown as microsecond*                                                                                        |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps\_node.maximum**(rate)                         | Sharding commands latency per second on node.*Shown as microsecond*                                                                                        |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps\_node.minimum**(rate)                         | Sharding commands latency per second on node.*Shown as microsecond*                                                                                        |
| **alibabacloud.mongodb.sharding\_concurrent\_reads.average**(gauge)                                  | Sharding concurrent reads.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.sharding\_concurrent\_reads.maximum**(gauge)                                  | Sharding concurrent reads.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.sharding\_concurrent\_reads.minimum**(gauge)                                  | Sharding concurrent reads.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.sharding\_concurrent\_reads\_node.average**(gauge)                            | Sharding concurrent reads on node.*Shown as operation*                                                                                                     |
| **alibabacloud.mongodb.sharding\_concurrent\_reads\_node.maximum**(gauge)                            | Sharding concurrent reads on node.*Shown as operation*                                                                                                     |
| **alibabacloud.mongodb.sharding\_concurrent\_reads\_node.minimum**(gauge)                            | Sharding concurrent reads on node.*Shown as operation*                                                                                                     |
| **alibabacloud.mongodb.sharding\_concurrent\_total.average**(gauge)                                  | Sharding total concurrent operations.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_concurrent\_total.maximum**(gauge)                                  | Sharding total concurrent operations.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_concurrent\_total.minimum**(gauge)                                  | Sharding total concurrent operations.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_concurrent\_total\_node.average**(gauge)                            | Sharding total concurrent operations on node.*Shown as operation*                                                                                          |
| **alibabacloud.mongodb.sharding\_concurrent\_total\_node.maximum**(gauge)                            | Sharding total concurrent operations on node.*Shown as operation*                                                                                          |
| **alibabacloud.mongodb.sharding\_concurrent\_total\_node.minimum**(gauge)                            | Sharding total concurrent operations on node.*Shown as operation*                                                                                          |
| **alibabacloud.mongodb.sharding\_concurrent\_writes.average**(gauge)                                 | Sharding concurrent writes.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_concurrent\_writes.maximum**(gauge)                                 | Sharding concurrent writes.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_concurrent\_writes.minimum**(gauge)                                 | Sharding concurrent writes.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_concurrent\_writes\_node.average**(gauge)                           | Sharding concurrent writes on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_concurrent\_writes\_node.maximum**(gauge)                           | Sharding concurrent writes on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_concurrent\_writes\_node.minimum**(gauge)                           | Sharding concurrent writes on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_connection\_amount.average**(gauge)                                 | Sharding used connections.*Shown as connection*                                                                                                            |
| **alibabacloud.mongodb.sharding\_connection\_amount.maximum**(gauge)                                 | Sharding used connections.*Shown as connection*                                                                                                            |
| **alibabacloud.mongodb.sharding\_connection\_amount.minimum**(gauge)                                 | Sharding used connections.*Shown as connection*                                                                                                            |
| **alibabacloud.mongodb.sharding\_connection\_amount\_node.average**(gauge)                           | Sharding used connections on node.*Shown as connection*                                                                                                    |
| **alibabacloud.mongodb.sharding\_connection\_amount\_node.maximum**(gauge)                           | Sharding used connections on node.*Shown as connection*                                                                                                    |
| **alibabacloud.mongodb.sharding\_connection\_amount\_node.minimum**(gauge)                           | Sharding used connections on node.*Shown as connection*                                                                                                    |
| **alibabacloud.mongodb.sharding\_connection\_utilization.average**(gauge)                            | Sharding connection usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.sharding\_connection\_utilization.maximum**(gauge)                            | Sharding connection usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.sharding\_connection\_utilization.minimum**(gauge)                            | Sharding connection usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.sharding\_connection\_utilization\_node.average**(gauge)                      | Sharding connection usage on node.*Shown as percent*                                                                                                       |
| **alibabacloud.mongodb.sharding\_connection\_utilization\_node.maximum**(gauge)                      | Sharding connection usage on node.*Shown as percent*                                                                                                       |
| **alibabacloud.mongodb.sharding\_connection\_utilization\_node.minimum**(gauge)                      | Sharding connection usage on node.*Shown as percent*                                                                                                       |
| **alibabacloud.mongodb.sharding\_conns\_created\_ps.average**(rate)                                  | Sharding connections created per second.*Shown as connection*                                                                                              |
| **alibabacloud.mongodb.sharding\_conns\_created\_ps.maximum**(rate)                                  | Sharding connections created per second.*Shown as connection*                                                                                              |
| **alibabacloud.mongodb.sharding\_conns\_created\_ps.minimum**(rate)                                  | Sharding connections created per second.*Shown as connection*                                                                                              |
| **alibabacloud.mongodb.sharding\_conns\_created\_ps\_node.average**(rate)                            | Sharding connections created per second on node.*Shown as connection*                                                                                      |
| **alibabacloud.mongodb.sharding\_conns\_created\_ps\_node.maximum**(rate)                            | Sharding connections created per second on node.*Shown as connection*                                                                                      |
| **alibabacloud.mongodb.sharding\_conns\_created\_ps\_node.minimum**(rate)                            | Sharding connections created per second on node.*Shown as connection*                                                                                      |
| **alibabacloud.mongodb.sharding\_cpu\_sys.average**(gauge)                                           | Sharding system CPU usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.sharding\_cpu\_sys.maximum**(gauge)                                           | Sharding system CPU usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.sharding\_cpu\_sys.minimum**(gauge)                                           | Sharding system CPU usage.*Shown as percent*                                                                                                               |
| **alibabacloud.mongodb.sharding\_cpu\_sys\_node.average**(gauge)                                     | Sharding system CPU usage on node.*Shown as percent*                                                                                                       |
| **alibabacloud.mongodb.sharding\_cpu\_sys\_node.maximum**(gauge)                                     | Sharding system CPU usage on node.*Shown as percent*                                                                                                       |
| **alibabacloud.mongodb.sharding\_cpu\_sys\_node.minimum**(gauge)                                     | Sharding system CPU usage on node.*Shown as percent*                                                                                                       |
| **alibabacloud.mongodb.sharding\_cpu\_user.average**(gauge)                                          | Sharding user CPU usage.*Shown as percent*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_cpu\_user.maximum**(gauge)                                          | Sharding user CPU usage.*Shown as percent*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_cpu\_user.minimum**(gauge)                                          | Sharding user CPU usage.*Shown as percent*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_cpu\_user\_node.average**(gauge)                                    | Sharding user CPU usage on node.*Shown as percent*                                                                                                         |
| **alibabacloud.mongodb.sharding\_cpu\_user\_node.maximum**(gauge)                                    | Sharding user CPU usage on node.*Shown as percent*                                                                                                         |
| **alibabacloud.mongodb.sharding\_cpu\_user\_node.minimum**(gauge)                                    | Sharding user CPU usage on node.*Shown as percent*                                                                                                         |
| **alibabacloud.mongodb.sharding\_cursors\_timed\_out.average**(gauge)                                | Sharding cursors timed out.*Shown as cursor*                                                                                                               |
| **alibabacloud.mongodb.sharding\_cursors\_timed\_out.maximum**(gauge)                                | Sharding cursors timed out.*Shown as cursor*                                                                                                               |
| **alibabacloud.mongodb.sharding\_cursors\_timed\_out.minimum**(gauge)                                | Sharding cursors timed out.*Shown as cursor*                                                                                                               |
| **alibabacloud.mongodb.sharding\_cursors\_timed\_out\_node.average**(gauge)                          | Sharding cursors timed out on node.*Shown as cursor*                                                                                                       |
| **alibabacloud.mongodb.sharding\_cursors\_timed\_out\_node.maximum**(gauge)                          | Sharding cursors timed out on node.*Shown as cursor*                                                                                                       |
| **alibabacloud.mongodb.sharding\_cursors\_timed\_out\_node.minimum**(gauge)                          | Sharding cursors timed out on node.*Shown as cursor*                                                                                                       |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount.average**(gauge)                                 | Sharding data disk space used.*Shown as byte*                                                                                                              |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount.maximum**(gauge)                                 | Sharding data disk space used.*Shown as byte*                                                                                                              |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount.minimum**(gauge)                                 | Sharding data disk space used.*Shown as byte*                                                                                                              |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount\_node.average**(gauge)                           | Sharding data disk space used on node.*Shown as byte*                                                                                                      |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount\_node.maximum**(gauge)                           | Sharding data disk space used on node.*Shown as byte*                                                                                                      |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount\_node.minimum**(gauge)                           | Sharding data disk space used on node.*Shown as byte*                                                                                                      |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount\_original.average**(gauge)                       | Sharding data disk space used (original).*Shown as byte*                                                                                                   |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount\_original.maximum**(gauge)                       | Sharding data disk space used (original).*Shown as byte*                                                                                                   |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount\_original.minimum**(gauge)                       | Sharding data disk space used (original).*Shown as byte*                                                                                                   |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount\_original\_node.average**(gauge)                 | Sharding data disk space used on node (original).*Shown as byte*                                                                                           |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount\_original\_node.maximum**(gauge)                 | Sharding data disk space used on node (original).*Shown as byte*                                                                                           |
| **alibabacloud.mongodb.sharding\_data\_disk\_amount\_original\_node.minimum**(gauge)                 | Sharding data disk space used on node (original).*Shown as byte*                                                                                           |
| **alibabacloud.mongodb.sharding\_data\_iops.average**(rate)                                          | Sharding data IOPS.*Shown as operation*                                                                                                                    |
| **alibabacloud.mongodb.sharding\_data\_iops.maximum**(rate)                                          | Sharding data IOPS.*Shown as operation*                                                                                                                    |
| **alibabacloud.mongodb.sharding\_data\_iops.minimum**(rate)                                          | Sharding data IOPS.*Shown as operation*                                                                                                                    |
| **alibabacloud.mongodb.sharding\_data\_iops\_node.average**(rate)                                    | Sharding data IOPS on node.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_data\_iops\_node.maximum**(rate)                                    | Sharding data IOPS on node.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_data\_iops\_node.minimum**(rate)                                    | Sharding data IOPS on node.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_dirty\_cache\_bytes.average**(gauge)                                | Sharding dirty cache bytes.*Shown as byte*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_dirty\_cache\_bytes.maximum**(gauge)                                | Sharding dirty cache bytes.*Shown as byte*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_dirty\_cache\_bytes.minimum**(gauge)                                | Sharding dirty cache bytes.*Shown as byte*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_dirty\_cache\_bytes\_node.average**(gauge)                          | Sharding dirty cache bytes on node.*Shown as byte*                                                                                                         |
| **alibabacloud.mongodb.sharding\_dirty\_cache\_bytes\_node.maximum**(gauge)                          | Sharding dirty cache bytes on node.*Shown as byte*                                                                                                         |
| **alibabacloud.mongodb.sharding\_dirty\_cache\_bytes\_node.minimum**(gauge)                          | Sharding dirty cache bytes on node.*Shown as byte*                                                                                                         |
| **alibabacloud.mongodb.sharding\_disk\_utilization.average**(gauge)                                  | Sharding disk usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.mongodb.sharding\_disk\_utilization.maximum**(gauge)                                  | Sharding disk usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.mongodb.sharding\_disk\_utilization.minimum**(gauge)                                  | Sharding disk usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.mongodb.sharding\_disk\_utilization\_node.average**(gauge)                            | Sharding disk usage on node.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.sharding\_disk\_utilization\_node.maximum**(gauge)                            | Sharding disk usage on node.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.sharding\_disk\_utilization\_node.minimum**(gauge)                            | Sharding disk usage on node.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.sharding\_docs\_deleted\_ps.average**(rate)                                   | Sharding documents deleted per second.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.sharding\_docs\_deleted\_ps.maximum**(rate)                                   | Sharding documents deleted per second.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.sharding\_docs\_deleted\_ps.minimum**(rate)                                   | Sharding documents deleted per second.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.sharding\_docs\_deleted\_ps\_node.average**(rate)                             | Sharding documents deleted per second on node.*Shown as document*                                                                                          |
| **alibabacloud.mongodb.sharding\_docs\_deleted\_ps\_node.maximum**(rate)                             | Sharding documents deleted per second on node.*Shown as document*                                                                                          |
| **alibabacloud.mongodb.sharding\_docs\_deleted\_ps\_node.minimum**(rate)                             | Sharding documents deleted per second on node.*Shown as document*                                                                                          |
| **alibabacloud.mongodb.sharding\_docs\_inserted\_ps.average**(rate)                                  | Sharding documents inserted per second.*Shown as document*                                                                                                 |
| **alibabacloud.mongodb.sharding\_docs\_inserted\_ps.maximum**(rate)                                  | Sharding documents inserted per second.*Shown as document*                                                                                                 |
| **alibabacloud.mongodb.sharding\_docs\_inserted\_ps.minimum**(rate)                                  | Sharding documents inserted per second.*Shown as document*                                                                                                 |
| **alibabacloud.mongodb.sharding\_docs\_inserted\_ps\_node.average**(rate)                            | Sharding documents inserted per second on node.*Shown as document*                                                                                         |
| **alibabacloud.mongodb.sharding\_docs\_inserted\_ps\_node.maximum**(rate)                            | Sharding documents inserted per second on node.*Shown as document*                                                                                         |
| **alibabacloud.mongodb.sharding\_docs\_inserted\_ps\_node.minimum**(rate)                            | Sharding documents inserted per second on node.*Shown as document*                                                                                         |
| **alibabacloud.mongodb.sharding\_docs\_returned\_ps.average**(rate)                                  | Sharding documents returned per second.*Shown as document*                                                                                                 |
| **alibabacloud.mongodb.sharding\_docs\_returned\_ps.maximum**(rate)                                  | Sharding documents returned per second.*Shown as document*                                                                                                 |
| **alibabacloud.mongodb.sharding\_docs\_returned\_ps.minimum**(rate)                                  | Sharding documents returned per second.*Shown as document*                                                                                                 |
| **alibabacloud.mongodb.sharding\_docs\_returned\_ps\_node.average**(rate)                            | Sharding documents returned per second on node.*Shown as document*                                                                                         |
| **alibabacloud.mongodb.sharding\_docs\_returned\_ps\_node.maximum**(rate)                            | Sharding documents returned per second on node.*Shown as document*                                                                                         |
| **alibabacloud.mongodb.sharding\_docs\_returned\_ps\_node.minimum**(rate)                            | Sharding documents returned per second on node.*Shown as document*                                                                                         |
| **alibabacloud.mongodb.sharding\_docs\_updated\_ps.average**(rate)                                   | Sharding documents updated per second.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.sharding\_docs\_updated\_ps.maximum**(rate)                                   | Sharding documents updated per second.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.sharding\_docs\_updated\_ps.minimum**(rate)                                   | Sharding documents updated per second.*Shown as document*                                                                                                  |
| **alibabacloud.mongodb.sharding\_docs\_updated\_ps\_node.average**(rate)                             | Sharding documents updated per second on node.*Shown as document*                                                                                          |
| **alibabacloud.mongodb.sharding\_docs\_updated\_ps\_node.maximum**(rate)                             | Sharding documents updated per second on node.*Shown as document*                                                                                          |
| **alibabacloud.mongodb.sharding\_docs\_updated\_ps\_node.minimum**(rate)                             | Sharding documents updated per second on node.*Shown as document*                                                                                          |
| **alibabacloud.mongodb.sharding\_donor\_chunk\_starts.average**(gauge)                               | Sharding donor chunk starts.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.sharding\_donor\_chunk\_starts.maximum**(gauge)                               | Sharding donor chunk starts.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.sharding\_donor\_chunk\_starts.minimum**(gauge)                               | Sharding donor chunk starts.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.sharding\_donor\_chunk\_starts\_node.average**(gauge)                         | Sharding donor chunk starts on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.sharding\_donor\_chunk\_starts\_node.maximum**(gauge)                         | Sharding donor chunk starts on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.sharding\_donor\_chunk\_starts\_node.minimum**(gauge)                         | Sharding donor chunk starts on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.sharding\_eviction\_check\_entries.average**(gauge)                           | Sharding eviction check entries.*Shown as entry*                                                                                                           |
| **alibabacloud.mongodb.sharding\_eviction\_check\_entries.maximum**(gauge)                           | Sharding eviction check entries.*Shown as entry*                                                                                                           |
| **alibabacloud.mongodb.sharding\_eviction\_check\_entries.minimum**(gauge)                           | Sharding eviction check entries.*Shown as entry*                                                                                                           |
| **alibabacloud.mongodb.sharding\_eviction\_check\_entries\_node.average**(gauge)                     | Sharding eviction check entries on node.*Shown as entry*                                                                                                   |
| **alibabacloud.mongodb.sharding\_eviction\_check\_entries\_node.maximum**(gauge)                     | Sharding eviction check entries on node.*Shown as entry*                                                                                                   |
| **alibabacloud.mongodb.sharding\_eviction\_check\_entries\_node.minimum**(gauge)                     | Sharding eviction check entries on node.*Shown as entry*                                                                                                   |
| **alibabacloud.mongodb.sharding\_exact\_idcount.average**(gauge)                                     | Sharding exact ID count.*Shown as document*                                                                                                                |
| **alibabacloud.mongodb.sharding\_exact\_id\_count.maximum**(gauge)                                   | Sharding exact ID count.*Shown as document*                                                                                                                |
| **alibabacloud.mongodb.sharding\_exact\_id\_count.minimum**(gauge)                                   | Sharding exact ID count.*Shown as document*                                                                                                                |
| **alibabacloud.mongodb.sharding\_exact\_id\_count\_node.average**(gauge)                             | Sharding exact ID count on node.*Shown as document*                                                                                                        |
| **alibabacloud.mongodb.sharding\_exact\_id\_count\_node.maximum**(gauge)                             | Sharding exact ID count on node.*Shown as document*                                                                                                        |
| **alibabacloud.mongodb.sharding\_exact\_id\_count\_node.minimum**(gauge)                             | Sharding exact ID count on node.*Shown as document*                                                                                                        |
| **alibabacloud.mongodb.sharding\_hazard\_pointer\_blocked\_page\_eviction.average**(gauge)           | Sharding hazard pointer blocked page eviction.*Shown as event*                                                                                             |
| **alibabacloud.mongodb.sharding\_hazard\_pointer\_blocked\_page\_eviction.maximum**(gauge)           | Sharding hazard pointer blocked page eviction.*Shown as event*                                                                                             |
| **alibabacloud.mongodb.sharding\_hazard\_pointer\_blocked\_page\_eviction.minimum**(gauge)           | Sharding hazard pointer blocked page eviction.*Shown as event*                                                                                             |
| **alibabacloud.mongodb.sharding\_hazard\_pointer\_blocked\_page\_eviction\_node.average**(gauge)     | Sharding hazard pointer blocked page eviction on node.*Shown as event*                                                                                     |
| **alibabacloud.mongodb.sharding\_hazard\_pointer\_blocked\_page\_eviction\_node.maximum**(gauge)     | Sharding hazard pointer blocked page eviction on node.*Shown as event*                                                                                     |
| **alibabacloud.mongodb.sharding\_hazard\_pointer\_blocked\_page\_eviction\_node.minimum**(gauge)     | Sharding hazard pointer blocked page eviction on node.*Shown as event*                                                                                     |
| **alibabacloud.mongodb.sharding\_iops\_utilization.average**(gauge)                                  | Sharding IOPS usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.mongodb.sharding\_iops\_utilization.maximum**(gauge)                                  | Sharding IOPS usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.mongodb.sharding\_iops\_utilization.minimum**(gauge)                                  | Sharding IOPS usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.mongodb.sharding\_iops\_utilization\_node.average**(gauge)                            | Sharding IOPS usage on node.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.sharding\_iops\_utilization\_node.maximum**(gauge)                            | Sharding IOPS usage on node.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.sharding\_iops\_utilization\_node.minimum**(gauge)                            | Sharding IOPS usage on node.*Shown as percent*                                                                                                             |
| **alibabacloud.mongodb.sharding\_instance\_disk\_amount.average**(gauge)                             | Sharding instance disk space used.*Shown as byte*                                                                                                          |
| **alibabacloud.mongodb.sharding\_instance\_disk\_amount.maximum**(gauge)                             | Sharding instance disk space used.*Shown as byte*                                                                                                          |
| **alibabacloud.mongodb.sharding\_instance\_disk\_amount.minimum**(gauge)                             | Sharding instance disk space used.*Shown as byte*                                                                                                          |
| **alibabacloud.mongodb.sharding\_instance\_disk\_amount\_node.average**(gauge)                       | Sharding instance disk space used on node.*Shown as byte*                                                                                                  |
| **alibabacloud.mongodb.sharding\_instance\_disk\_amount\_node.maximum**(gauge)                       | Sharding instance disk space used on node.*Shown as byte*                                                                                                  |
| **alibabacloud.mongodb.sharding\_instance\_disk\_amount\_node.minimum**(gauge)                       | Sharding instance disk space used on node.*Shown as byte*                                                                                                  |
| **alibabacloud.mongodb.sharding\_intranet\_in.average**(gauge)                                       | Sharding inbound network traffic.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.sharding\_intranet\_in\_node.average**(gauge)                                 | Sharding inbound network traffic on node.*Shown as byte*                                                                                                   |
| **alibabacloud.mongodb.sharding\_intranet\_out.average**(gauge)                                      | Sharding outbound network traffic.*Shown as byte*                                                                                                          |
| **alibabacloud.mongodb.sharding\_intranet\_out\_node.average**(gauge)                                | Sharding outbound network traffic on node.*Shown as byte*                                                                                                  |
| **alibabacloud.mongodb.sharding\_io\_bandwidth.average**(rate)                                       | Sharding I/O bandwidth.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_io\_bandwidth.maximum**(rate)                                       | Sharding I/O bandwidth.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_io\_bandwidth.minimum**(rate)                                       | Sharding I/O bandwidth.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_io\_bandwidth\_node.average**(rate)                                 | Sharding I/O bandwidth on node.*Shown as mebibyte*                                                                                                         |
| **alibabacloud.mongodb.sharding\_io\_bandwidth\_node.maximum**(rate)                                 | Sharding I/O bandwidth on node.*Shown as mebibyte*                                                                                                         |
| **alibabacloud.mongodb.sharding\_io\_bandwidth\_node.minimum**(rate)                                 | Sharding I/O bandwidth on node.*Shown as mebibyte*                                                                                                         |
| **alibabacloud.mongodb.sharding\_log\_disk\_amount.average**(gauge)                                  | Sharding log disk space used.*Shown as byte*                                                                                                               |
| **alibabacloud.mongodb.sharding\_log\_disk\_amount.maximum**(gauge)                                  | Sharding log disk space used.*Shown as byte*                                                                                                               |
| **alibabacloud.mongodb.sharding\_log\_disk\_amount.minimum**(gauge)                                  | Sharding log disk space used.*Shown as byte*                                                                                                               |
| **alibabacloud.mongodb.sharding\_log\_disk\_amount\_node.average**(gauge)                            | Sharding log disk space used on node.*Shown as byte*                                                                                                       |
| **alibabacloud.mongodb.sharding\_log\_disk\_amount\_node.maximum**(gauge)                            | Sharding log disk space used on node.*Shown as byte*                                                                                                       |
| **alibabacloud.mongodb.sharding\_log\_disk\_amount\_node.minimum**(gauge)                            | Sharding log disk space used on node.*Shown as byte*                                                                                                       |
| **alibabacloud.mongodb.sharding\_log\_iops.average**(rate)                                           | Sharding log IOPS.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.sharding\_log\_iops.maximum**(rate)                                           | Sharding log IOPS.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.sharding\_log\_iops.minimum**(rate)                                           | Sharding log IOPS.*Shown as operation*                                                                                                                     |
| **alibabacloud.mongodb.sharding\_log\_iops\_node.average**(rate)                                     | Sharding log IOPS on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.sharding\_log\_iops\_node.maximum**(rate)                                     | Sharding log IOPS on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.sharding\_log\_iops\_node.minimum**(rate)                                     | Sharding log IOPS on node.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.sharding\_max\_config\_bytes.average**(gauge)                                 | Sharding maximum config bytes.*Shown as byte*                                                                                                              |
| **alibabacloud.mongodb.sharding\_max\_config\_bytes.maximum**(gauge)                                 | Sharding maximum config bytes.*Shown as byte*                                                                                                              |
| **alibabacloud.mongodb.sharding\_max\_config\_bytes.minimum**(gauge)                                 | Sharding maximum config bytes.*Shown as byte*                                                                                                              |
| **alibabacloud.mongodb.sharding\_max\_config\_bytes\_node.average**(gauge)                           | Sharding maximum config bytes on node.*Shown as byte*                                                                                                      |
| **alibabacloud.mongodb.sharding\_max\_config\_bytes\_node.maximum**(gauge)                           | Sharding maximum config bytes on node.*Shown as byte*                                                                                                      |
| **alibabacloud.mongodb.sharding\_max\_config\_bytes\_node.minimum**(gauge)                           | Sharding maximum config bytes on node.*Shown as byte*                                                                                                      |
| **alibabacloud.mongodb.sharding\_max\_page\_size.average**(gauge)                                    | Sharding maximum page size.*Shown as mebibyte*                                                                                                             |
| **alibabacloud.mongodb.sharding\_max\_page\_size.maximum**(gauge)                                    | Sharding maximum page size.*Shown as mebibyte*                                                                                                             |
| **alibabacloud.mongodb.sharding\_max\_page\_size.minimum**(gauge)                                    | Sharding maximum page size.*Shown as mebibyte*                                                                                                             |
| **alibabacloud.mongodb.sharding\_max\_page\_size\_node.average**(gauge)                              | Sharding maximum page size on node.*Shown as mebibyte*                                                                                                     |
| **alibabacloud.mongodb.sharding\_max\_page\_size\_node.maximum**(gauge)                              | Sharding maximum page size on node.*Shown as mebibyte*                                                                                                     |
| **alibabacloud.mongodb.sharding\_max\_page\_size\_node.minimum**(gauge)                              | Sharding maximum page size on node.*Shown as mebibyte*                                                                                                     |
| **alibabacloud.mongodb.sharding\_memory\_utilization.average**(gauge)                                | Sharding memory usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.mongodb.sharding\_memory\_utilization.maximum**(gauge)                                | Sharding memory usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.mongodb.sharding\_memory\_utilization.minimum**(gauge)                                | Sharding memory usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.mongodb.sharding\_memory\_utilization\_node.average**(gauge)                          | Sharding memory usage on node.*Shown as percent*                                                                                                           |
| **alibabacloud.mongodb.sharding\_memory\_utilization\_node.maximum**(gauge)                          | Sharding memory usage on node.*Shown as percent*                                                                                                           |
| **alibabacloud.mongodb.sharding\_memory\_utilization\_node.minimum**(gauge)                          | Sharding memory usage on node.*Shown as percent*                                                                                                           |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_avg\_wtime.average**(gauge)              | Sharding get last error average wait time.*Shown as millisecond*                                                                                           |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_avg\_wtime.maximum**(gauge)              | Sharding get last error average wait time.*Shown as millisecond*                                                                                           |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_avg\_wtime.minimum**(gauge)              | Sharding get last error average wait time.*Shown as millisecond*                                                                                           |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_avg\_wtime\_node.average**(gauge)        | Sharding get last error average wait time on node.*Shown as millisecond*                                                                                   |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_avg\_wtime\_node.maximum**(gauge)        | Sharding get last error average wait time on node.*Shown as millisecond*                                                                                   |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_avg\_wtime\_node.minimum**(gauge)        | Sharding get last error average wait time on node.*Shown as millisecond*                                                                                   |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_wtimeouts.average**(gauge)               | Sharding get last error wait timeouts.*Shown as timeout*                                                                                                   |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_wtimeouts.maximum**(gauge)               | Sharding get last error wait timeouts.*Shown as timeout*                                                                                                   |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_wtimeouts.minimum**(gauge)               | Sharding get last error wait timeouts.*Shown as timeout*                                                                                                   |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_wtimeouts\_node.average**(gauge)         | Sharding get last error wait timeouts on node.*Shown as timeout*                                                                                           |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_wtimeouts\_node.maximum**(gauge)         | Sharding get last error wait timeouts on node.*Shown as timeout*                                                                                           |
| **alibabacloud.mongodb.sharding\_metrics\_get\_last\_error\_wtimeouts\_node.minimum**(gauge)         | Sharding get last error wait timeouts on node.*Shown as timeout*                                                                                           |
| **alibabacloud.mongodb.sharding\_metrics\_query\_multiplanner\_classic\_works.average**(gauge)       | Sharding query multiplanner classic works.*Shown as operation*                                                                                             |
| **alibabacloud.mongodb.sharding\_metrics\_query\_multiplanner\_classic\_works.maximum**(gauge)       | Sharding query multiplanner classic works.*Shown as operation*                                                                                             |
| **alibabacloud.mongodb.sharding\_metrics\_query\_multiplanner\_classic\_works.minimum**(gauge)       | Sharding query multiplanner classic works.*Shown as operation*                                                                                             |
| **alibabacloud.mongodb.sharding\_metrics\_query\_multiplanner\_classic\_works\_node.average**(gauge) | Sharding query multiplanner classic works on node.*Shown as operation*                                                                                     |
| **alibabacloud.mongodb.sharding\_metrics\_query\_multiplanner\_classic\_works\_node.maximum**(gauge) | Sharding query multiplanner classic works on node.*Shown as operation*                                                                                     |
| **alibabacloud.mongodb.sharding\_metrics\_query\_multiplanner\_classic\_works\_node.minimum**(gauge) | Sharding query multiplanner classic works on node.*Shown as operation*                                                                                     |
| **alibabacloud.mongodb.sharding\_move\_chunk\_deleter\_task.average**(gauge)                         | Sharding move chunk deleter tasks.*Shown as task*                                                                                                          |
| **alibabacloud.mongodb.sharding\_move\_chunk\_deleter\_task.maximum**(gauge)                         | Sharding move chunk deleter tasks.*Shown as task*                                                                                                          |
| **alibabacloud.mongodb.sharding\_move\_chunk\_deleter\_task.minimum**(gauge)                         | Sharding move chunk deleter tasks.*Shown as task*                                                                                                          |
| **alibabacloud.mongodb.sharding\_move\_chunk\_deleter\_task\_node.average**(gauge)                   | Sharding move chunk deleter tasks on node.*Shown as task*                                                                                                  |
| **alibabacloud.mongodb.sharding\_move\_chunk\_deleter\_task\_node.maximum**(gauge)                   | Sharding move chunk deleter tasks on node.*Shown as task*                                                                                                  |
| **alibabacloud.mongodb.sharding\_move\_chunk\_deleter\_task\_node.minimum**(gauge)                   | Sharding move chunk deleter tasks on node.*Shown as task*                                                                                                  |
| **alibabacloud.mongodb.sharding\_msg.average**(gauge)                                                | Sharding messages.*Shown as message*                                                                                                                       |
| **alibabacloud.mongodb.sharding\_msg.maximum**(gauge)                                                | Sharding messages.*Shown as message*                                                                                                                       |
| **alibabacloud.mongodb.sharding\_msg.minimum**(gauge)                                                | Sharding messages.*Shown as message*                                                                                                                       |
| **alibabacloud.mongodb.sharding\_msg\_node.average**(gauge)                                          | Sharding messages on node.*Shown as message*                                                                                                               |
| **alibabacloud.mongodb.sharding\_msg\_node.maximum**(gauge)                                          | Sharding messages on node.*Shown as message*                                                                                                               |
| **alibabacloud.mongodb.sharding\_msg\_node.minimum**(gauge)                                          | Sharding messages on node.*Shown as message*                                                                                                               |
| **alibabacloud.mongodb.sharding\_no\_timeout\_cursors.average**(gauge)                               | Sharding no timeout cursors.*Shown as cursor*                                                                                                              |
| **alibabacloud.mongodb.sharding\_no\_timeout\_cursors.maximum**(gauge)                               | Sharding no timeout cursors.*Shown as cursor*                                                                                                              |
| **alibabacloud.mongodb.sharding\_no\_timeout\_cursors.minimum**(gauge)                               | Sharding no timeout cursors.*Shown as cursor*                                                                                                              |
| **alibabacloud.mongodb.sharding\_no\_timeout\_cursors\_node.average**(gauge)                         | Sharding no timeout cursors on node.*Shown as cursor*                                                                                                      |
| **alibabacloud.mongodb.sharding\_no\_timeout\_cursors\_node.maximum**(gauge)                         | Sharding no timeout cursors on node.*Shown as cursor*                                                                                                      |
| **alibabacloud.mongodb.sharding\_no\_timeout\_cursors\_node.minimum**(gauge)                         | Sharding no timeout cursors on node.*Shown as cursor*                                                                                                      |
| **alibabacloud.mongodb.sharding\_number\_requests.average**(gauge)                                   | Sharding request count.*Shown as request*                                                                                                                  |
| **alibabacloud.mongodb.sharding\_number\_requests\_node.average**(gauge)                             | Sharding request count on node.*Shown as request*                                                                                                          |
| **alibabacloud.mongodb.sharding\_op\_command.average**(gauge)                                        | Sharding command operations.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.sharding\_op\_command.maximum**(gauge)                                        | Sharding command operations.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.sharding\_op\_command.minimum**(gauge)                                        | Sharding command operations.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.sharding\_op\_command\_node.average**(gauge)                                  | Sharding command operations on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.sharding\_op\_command\_node.maximum**(gauge)                                  | Sharding command operations on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.sharding\_op\_command\_node.minimum**(gauge)                                  | Sharding command operations on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.sharding\_op\_delete.average**(gauge)                                         | Sharding delete operations.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_op\_delete.maximum**(gauge)                                         | Sharding delete operations.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_op\_delete.minimum**(gauge)                                         | Sharding delete operations.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_op\_delete\_node.average**(gauge)                                   | Sharding delete operations on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_op\_delete\_node.maximum**(gauge)                                   | Sharding delete operations on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_op\_delete\_node.minimum**(gauge)                                   | Sharding delete operations on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_op\_getmore.average**(gauge)                                        | Sharding getMore operations.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.sharding\_op\_getmore.maximum**(gauge)                                        | Sharding getMore operations.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.sharding\_op\_getmore.minimum**(gauge)                                        | Sharding getMore operations.*Shown as operation*                                                                                                           |
| **alibabacloud.mongodb.sharding\_op\_getmore\_node.average**(gauge)                                  | Sharding getMore operations on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.sharding\_op\_getmore\_node.maximum**(gauge)                                  | Sharding getMore operations on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.sharding\_op\_getmore\_node.minimum**(gauge)                                  | Sharding getMore operations on node.*Shown as operation*                                                                                                   |
| **alibabacloud.mongodb.sharding\_op\_insert.average**(gauge)                                         | Sharding insert operations.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_op\_insert.maximum**(gauge)                                         | Sharding insert operations.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_op\_insert.minimum**(gauge)                                         | Sharding insert operations.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_op\_insert\_node.average**(gauge)                                   | Sharding insert operations on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_op\_insert\_node.maximum**(gauge)                                   | Sharding insert operations on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_op\_insert\_node.minimum**(gauge)                                   | Sharding insert operations on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_op\_query.average**(gauge)                                          | Sharding query operations.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.sharding\_op\_query.maximum**(gauge)                                          | Sharding query operations.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.sharding\_op\_query.minimum**(gauge)                                          | Sharding query operations.*Shown as operation*                                                                                                             |
| **alibabacloud.mongodb.sharding\_op\_query\_node.average**(gauge)                                    | Sharding query operations on node.*Shown as operation*                                                                                                     |
| **alibabacloud.mongodb.sharding\_op\_query\_node.maximum**(gauge)                                    | Sharding query operations on node.*Shown as operation*                                                                                                     |
| **alibabacloud.mongodb.sharding\_op\_query\_node.minimum**(gauge)                                    | Sharding query operations on node.*Shown as operation*                                                                                                     |
| **alibabacloud.mongodb.sharding\_op\_update.average**(gauge)                                         | Sharding update operations.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_op\_update.maximum**(gauge)                                         | Sharding update operations.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_op\_update.minimum**(gauge)                                         | Sharding update operations.*Shown as operation*                                                                                                            |
| **alibabacloud.mongodb.sharding\_op\_update\_node.average**(gauge)                                   | Sharding update operations on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_op\_update\_node.maximum**(gauge)                                   | Sharding update operations on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_op\_update\_node.minimum**(gauge)                                   | Sharding update operations on node.*Shown as operation*                                                                                                    |
| **alibabacloud.mongodb.sharding\_opened\_fd\_mem.average**(gauge)                                    | Sharding opened file descriptor memory.*Shown as mebibyte*                                                                                                 |
| **alibabacloud.mongodb.sharding\_opened\_fd\_mem.maximum**(gauge)                                    | Sharding opened file descriptor memory.*Shown as mebibyte*                                                                                                 |
| **alibabacloud.mongodb.sharding\_opened\_fd\_mem.minimum**(gauge)                                    | Sharding opened file descriptor memory.*Shown as mebibyte*                                                                                                 |
| **alibabacloud.mongodb.sharding\_opened\_fd\_mem\_node.average**(gauge)                              | Sharding opened file descriptor memory on node.*Shown as mebibyte*                                                                                         |
| **alibabacloud.mongodb.sharding\_opened\_fd\_mem\_node.maximum**(gauge)                              | Sharding opened file descriptor memory on node.*Shown as mebibyte*                                                                                         |
| **alibabacloud.mongodb.sharding\_opened\_fd\_mem\_node.minimum**(gauge)                              | Sharding opened file descriptor memory on node.*Shown as mebibyte*                                                                                         |
| **alibabacloud.mongodb.sharding\_opened\_fd\_num.average**(gauge)                                    | Sharding opened file descriptors.*Shown as file*                                                                                                           |
| **alibabacloud.mongodb.sharding\_opened\_fd\_num.maximum**(gauge)                                    | Sharding opened file descriptors.*Shown as file*                                                                                                           |
| **alibabacloud.mongodb.sharding\_opened\_fd\_num.minimum**(gauge)                                    | Sharding opened file descriptors.*Shown as file*                                                                                                           |
| **alibabacloud.mongodb.sharding\_opened\_fd\_num\_node.average**(gauge)                              | Sharding opened file descriptors on node.*Shown as file*                                                                                                   |
| **alibabacloud.mongodb.sharding\_opened\_fd\_num\_node.maximum**(gauge)                              | Sharding opened file descriptors on node.*Shown as file*                                                                                                   |
| **alibabacloud.mongodb.sharding\_opened\_fd\_num\_node.minimum**(gauge)                              | Sharding opened file descriptors on node.*Shown as file*                                                                                                   |
| **alibabacloud.mongodb.sharding\_oplog\_time\_interval.average**(gauge)                              | Sharding oplog time interval.*Shown as hour*                                                                                                               |
| **alibabacloud.mongodb.sharding\_oplog\_time\_interval.maximum**(gauge)                              | Sharding oplog time interval.*Shown as hour*                                                                                                               |
| **alibabacloud.mongodb.sharding\_oplog\_time\_interval.minimum**(gauge)                              | Sharding oplog time interval.*Shown as hour*                                                                                                               |
| **alibabacloud.mongodb.sharding\_oplog\_time\_interval\_node.average**(gauge)                        | Sharding oplog time interval on node.*Shown as hour*                                                                                                       |
| **alibabacloud.mongodb.sharding\_oplog\_time\_interval\_node.maximum**(gauge)                        | Sharding oplog time interval on node.*Shown as hour*                                                                                                       |
| **alibabacloud.mongodb.sharding\_oplog\_time\_interval\_node.minimum**(gauge)                        | Sharding oplog time interval on node.*Shown as hour*                                                                                                       |
| **alibabacloud.mongodb.sharding\_page\_acquire\_eviction\_blocked.average**(gauge)                   | Sharding page acquire eviction blocked.*Shown as event*                                                                                                    |
| **alibabacloud.mongodb.sharding\_page\_acquire\_eviction\_blocked.maximum**(gauge)                   | Sharding page acquire eviction blocked.*Shown as event*                                                                                                    |
| **alibabacloud.mongodb.sharding\_page\_acquire\_eviction\_blocked.minimum**(gauge)                   | Sharding page acquire eviction blocked.*Shown as event*                                                                                                    |
| **alibabacloud.mongodb.sharding\_page\_acquire\_eviction\_blocked\_node.average**(gauge)             | Sharding page acquire eviction blocked on node.*Shown as event*                                                                                            |
| **alibabacloud.mongodb.sharding\_page\_acquire\_eviction\_blocked\_node.maximum**(gauge)             | Sharding page acquire eviction blocked on node.*Shown as event*                                                                                            |
| **alibabacloud.mongodb.sharding\_page\_acquire\_eviction\_blocked\_node.minimum**(gauge)             | Sharding page acquire eviction blocked on node.*Shown as event*                                                                                            |
| **alibabacloud.mongodb.sharding\_page\_acquire\_locked\_blocked.average**(gauge)                     | Sharding page acquire locked blocked.*Shown as event*                                                                                                      |
| **alibabacloud.mongodb.sharding\_page\_acquire\_locked\_blocked.maximum**(gauge)                     | Sharding page acquire locked blocked.*Shown as event*                                                                                                      |
| **alibabacloud.mongodb.sharding\_page\_acquire\_locked\_blocked.minimum**(gauge)                     | Sharding page acquire locked blocked.*Shown as event*                                                                                                      |
| **alibabacloud.mongodb.sharding\_page\_acquire\_locked\_blocked\_node.average**(gauge)               | Sharding page acquire locked blocked on node.*Shown as event*                                                                                              |
| **alibabacloud.mongodb.sharding\_page\_acquire\_locked\_blocked\_node.maximum**(gauge)               | Sharding page acquire locked blocked on node.*Shown as event*                                                                                              |
| **alibabacloud.mongodb.sharding\_page\_acquire\_locked\_blocked\_node.minimum**(gauge)               | Sharding page acquire locked blocked on node.*Shown as event*                                                                                              |
| **alibabacloud.mongodb.sharding\_page\_acquire\_time\_sleeping.average**(gauge)                      | Sharding page acquire time sleeping.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.sharding\_page\_acquire\_time\_sleeping.maximum**(gauge)                      | Sharding page acquire time sleeping.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.sharding\_page\_acquire\_time\_sleeping.minimum**(gauge)                      | Sharding page acquire time sleeping.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.sharding\_page\_acquire\_time\_sleeping\_node.average**(gauge)                | Sharding page acquire time sleeping on node.*Shown as microsecond*                                                                                         |
| **alibabacloud.mongodb.sharding\_page\_acquire\_time\_sleeping\_node.maximum**(gauge)                | Sharding page acquire time sleeping on node.*Shown as microsecond*                                                                                         |
| **alibabacloud.mongodb.sharding\_page\_acquire\_time\_sleeping\_node.minimum**(gauge)                | Sharding page acquire time sleeping on node.*Shown as microsecond*                                                                                         |
| **alibabacloud.mongodb.sharding\_pages\_evicted\_by\_application\_threads.average**(gauge)           | Sharding pages evicted by application threads.*Shown as page*                                                                                              |
| **alibabacloud.mongodb.sharding\_pages\_evicted\_by\_application\_threads.maximum**(gauge)           | Sharding pages evicted by application threads.*Shown as page*                                                                                              |
| **alibabacloud.mongodb.sharding\_pages\_evicted\_by\_application\_threads.minimum**(gauge)           | Sharding pages evicted by application threads.*Shown as page*                                                                                              |
| **alibabacloud.mongodb.sharding\_pages\_evicted\_by\_application\_threads\_node.average**(gauge)     | Sharding pages evicted by application threads on node.*Shown as page*                                                                                      |
| **alibabacloud.mongodb.sharding\_pages\_evicted\_by\_application\_threads\_node.maximum**(gauge)     | Sharding pages evicted by application threads on node.*Shown as page*                                                                                      |
| **alibabacloud.mongodb.sharding\_pages\_evicted\_by\_application\_threads\_node.minimum**(gauge)     | Sharding pages evicted by application threads on node.*Shown as page*                                                                                      |
| **alibabacloud.mongodb.sharding\_pages\_selected\_count.average**(gauge)                             | Sharding pages selected count.*Shown as page*                                                                                                              |
| **alibabacloud.mongodb.sharding\_pages\_selected\_count.maximum**(gauge)                             | Sharding pages selected count.*Shown as page*                                                                                                              |
| **alibabacloud.mongodb.sharding\_pages\_selected\_count.minimum**(gauge)                             | Sharding pages selected count.*Shown as page*                                                                                                              |
| **alibabacloud.mongodb.sharding\_pages\_selected\_count\_node.average**(gauge)                       | Sharding pages selected count on node.*Shown as page*                                                                                                      |
| **alibabacloud.mongodb.sharding\_pages\_selected\_count\_node.maximum**(gauge)                       | Sharding pages selected count on node.*Shown as page*                                                                                                      |
| **alibabacloud.mongodb.sharding\_pages\_selected\_count\_node.minimum**(gauge)                       | Sharding pages selected count on node.*Shown as page*                                                                                                      |
| **alibabacloud.mongodb.sharding\_pages\_selected\_unable\_to\_evict\_count.average**(gauge)          | Sharding pages selected unable to evict.*Shown as page*                                                                                                    |
| **alibabacloud.mongodb.sharding\_pages\_selected\_unable\_to\_evict\_count.maximum**(gauge)          | Sharding pages selected unable to evict.*Shown as page*                                                                                                    |
| **alibabacloud.mongodb.sharding\_pages\_selected\_unable\_to\_evict\_count.minimum**(gauge)          | Sharding pages selected unable to evict.*Shown as page*                                                                                                    |
| **alibabacloud.mongodb.sharding\_pages\_selected\_unable\_to\_evict\_count\_node.average**(gauge)    | Sharding pages selected unable to evict on node.*Shown as page*                                                                                            |
| **alibabacloud.mongodb.sharding\_pages\_selected\_unable\_to\_evict\_count\_node.maximum**(gauge)    | Sharding pages selected unable to evict on node.*Shown as page*                                                                                            |
| **alibabacloud.mongodb.sharding\_pages\_selected\_unable\_to\_evict\_count\_node.minimum**(gauge)    | Sharding pages selected unable to evict on node.*Shown as page*                                                                                            |
| **alibabacloud.mongodb.sharding\_pinned\_cursors.average**(gauge)                                    | Sharding pinned cursors.*Shown as cursor*                                                                                                                  |
| **alibabacloud.mongodb.sharding\_pinned\_cursors.maximum**(gauge)                                    | Sharding pinned cursors.*Shown as cursor*                                                                                                                  |
| **alibabacloud.mongodb.sharding\_pinned\_cursors.minimum**(gauge)                                    | Sharding pinned cursors.*Shown as cursor*                                                                                                                  |
| **alibabacloud.mongodb.sharding\_pinned\_cursors\_node.average**(gauge)                              | Sharding pinned cursors on node.*Shown as cursor*                                                                                                          |
| **alibabacloud.mongodb.sharding\_pinned\_cursors\_node.maximum**(gauge)                              | Sharding pinned cursors on node.*Shown as cursor*                                                                                                          |
| **alibabacloud.mongodb.sharding\_pinned\_cursors\_node.minimum**(gauge)                              | Sharding pinned cursors on node.*Shown as cursor*                                                                                                          |
| **alibabacloud.mongodb.sharding\_qps.average**(rate)                                                 | Sharding queries per second.*Shown as query*                                                                                                               |
| **alibabacloud.mongodb.sharding\_qps.maximum**(rate)                                                 | Sharding queries per second.*Shown as query*                                                                                                               |
| **alibabacloud.mongodb.sharding\_qps.minimum**(rate)                                                 | Sharding queries per second.*Shown as query*                                                                                                               |
| **alibabacloud.mongodb.sharding\_qps\_node.average**(rate)                                           | Sharding queries per second on node.*Shown as query*                                                                                                       |
| **alibabacloud.mongodb.sharding\_qps\_node.maximum**(rate)                                           | Sharding queries per second on node.*Shown as query*                                                                                                       |
| **alibabacloud.mongodb.sharding\_qps\_node.minimum**(rate)                                           | Sharding queries per second on node.*Shown as query*                                                                                                       |
| **alibabacloud.mongodb.sharding\_read\_avg\_rt.average**(gauge)                                      | Sharding read average response time.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.sharding\_read\_avg\_rt.maximum**(gauge)                                      | Sharding read average response time.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.sharding\_read\_avg\_rt.minimum**(gauge)                                      | Sharding read average response time.*Shown as microsecond*                                                                                                 |
| **alibabacloud.mongodb.sharding\_read\_avg\_rt\_node.average**(gauge)                                | Sharding read average response time on node.*Shown as microsecond*                                                                                         |
| **alibabacloud.mongodb.sharding\_read\_avg\_rt\_node.maximum**(gauge)                                | Sharding read average response time on node.*Shown as microsecond*                                                                                         |
| **alibabacloud.mongodb.sharding\_read\_avg\_rt\_node.minimum**(gauge)                                | Sharding read average response time on node.*Shown as microsecond*                                                                                         |
| **alibabacloud.mongodb.sharding\_read\_bandwidth.average**(rate)                                     | Sharding read bandwidth.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.mongodb.sharding\_read\_bandwidth.maximum**(rate)                                     | Sharding read bandwidth.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.mongodb.sharding\_read\_bandwidth.minimum**(rate)                                     | Sharding read bandwidth.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.mongodb.sharding\_read\_bandwidth\_node.average**(rate)                               | Sharding read bandwidth on node.*Shown as mebibyte*                                                                                                        |
| **alibabacloud.mongodb.sharding\_read\_bandwidth\_node.maximum**(rate)                               | Sharding read bandwidth on node.*Shown as mebibyte*                                                                                                        |
| **alibabacloud.mongodb.sharding\_read\_bandwidth\_node.minimum**(rate)                               | Sharding read bandwidth on node.*Shown as mebibyte*                                                                                                        |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_avail.average**(gauge)                     | Sharding read transactions concurrent available.*Shown as operation*                                                                                       |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_avail.maximum**(gauge)                     | Sharding read transactions concurrent available.*Shown as operation*                                                                                       |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_avail.minimum**(gauge)                     | Sharding read transactions concurrent available.*Shown as operation*                                                                                       |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_avail\_node.average**(gauge)               | Sharding read transactions concurrent available on node.*Shown as operation*                                                                               |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_avail\_node.maximum**(gauge)               | Sharding read transactions concurrent available on node.*Shown as operation*                                                                               |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_avail\_node.minimum**(gauge)               | Sharding read transactions concurrent available on node.*Shown as operation*                                                                               |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_out.average**(gauge)                       | Sharding read transactions concurrent out.*Shown as operation*                                                                                             |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_out.maximum**(gauge)                       | Sharding read transactions concurrent out.*Shown as operation*                                                                                             |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_out.minimum**(gauge)                       | Sharding read transactions concurrent out.*Shown as operation*                                                                                             |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_out\_node.average**(gauge)                 | Sharding read transactions concurrent out on node.*Shown as operation*                                                                                     |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_out\_node.maximum**(gauge)                 | Sharding read transactions concurrent out on node.*Shown as operation*                                                                                     |
| **alibabacloud.mongodb.sharding\_read\_trans\_concurrent\_out\_node.minimum**(gauge)                 | Sharding read transactions concurrent out on node.*Shown as operation*                                                                                     |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps.average**(rate)                                  | Sharding reads latency per second.*Shown as microsecond*                                                                                                   |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps.maximum**(rate)                                  | Sharding reads latency per second.*Shown as microsecond*                                                                                                   |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps.minimum**(rate)                                  | Sharding reads latency per second.*Shown as microsecond*                                                                                                   |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps\_node.average**(rate)                            | Sharding reads latency per second on node.*Shown as microsecond*                                                                                           |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps\_node.maximum**(rate)                            | Sharding reads latency per second on node.*Shown as microsecond*                                                                                           |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps\_node.minimum**(rate)                            | Sharding reads latency per second on node.*Shown as microsecond*                                                                                           |
| **alibabacloud.mongodb.sharding\_recipient\_chunk\_starts.average**(gauge)                           | Sharding recipient chunk starts.*Shown as operation*                                                                                                       |
| **alibabacloud.mongodb.sharding\_recipient\_chunk\_starts.maximum**(gauge)                           | Sharding recipient chunk starts.*Shown as operation*                                                                                                       |
| **alibabacloud.mongodb.sharding\_recipient\_chunk\_starts.minimum**(gauge)                           | Sharding recipient chunk starts.*Shown as operation*                                                                                                       |
| **alibabacloud.mongodb.sharding\_recipient\_chunk\_starts\_node.average**(gauge)                     | Sharding recipient chunk starts on node.*Shown as operation*                                                                                               |
| **alibabacloud.mongodb.sharding\_recipient\_chunk\_starts\_node.maximum**(gauge)                     | Sharding recipient chunk starts on node.*Shown as operation*                                                                                               |
| **alibabacloud.mongodb.sharding\_recipient\_chunk\_starts\_node.minimum**(gauge)                     | Sharding recipient chunk starts on node.*Shown as operation*                                                                                               |
| **alibabacloud.mongodb.sharding\_regular.average**(gauge)                                            | Sharding regular cursors.*Shown as cursor*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_regular.maximum**(gauge)                                            | Sharding regular cursors.*Shown as cursor*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_regular.minimum**(gauge)                                            | Sharding regular cursors.*Shown as cursor*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_regular\_node.average**(gauge)                                      | Sharding regular cursors on node.*Shown as cursor*                                                                                                         |
| **alibabacloud.mongodb.sharding\_regular\_node.maximum**(gauge)                                      | Sharding regular cursors on node.*Shown as cursor*                                                                                                         |
| **alibabacloud.mongodb.sharding\_regular\_node.minimum**(gauge)                                      | Sharding regular cursors on node.*Shown as cursor*                                                                                                         |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_max\_size.average**(gauge)                            | Sharding replication buffer max size.*Shown as mebibyte*                                                                                                   |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_max\_size.maximum**(gauge)                            | Sharding replication buffer max size.*Shown as mebibyte*                                                                                                   |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_max\_size.minimum**(gauge)                            | Sharding replication buffer max size.*Shown as mebibyte*                                                                                                   |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_max\_size\_node.average**(gauge)                      | Sharding replication buffer max size on node.*Shown as mebibyte*                                                                                           |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_max\_size\_node.maximum**(gauge)                      | Sharding replication buffer max size on node.*Shown as mebibyte*                                                                                           |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_max\_size\_node.minimum**(gauge)                      | Sharding replication buffer max size on node.*Shown as mebibyte*                                                                                           |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_size.average**(gauge)                                 | Sharding replication buffer size.*Shown as mebibyte*                                                                                                       |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_size.maximum**(gauge)                                 | Sharding replication buffer size.*Shown as mebibyte*                                                                                                       |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_size.minimum**(gauge)                                 | Sharding replication buffer size.*Shown as mebibyte*                                                                                                       |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_size\_node.average**(gauge)                           | Sharding replication buffer size on node.*Shown as mebibyte*                                                                                               |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_size\_node.maximum**(gauge)                           | Sharding replication buffer size on node.*Shown as mebibyte*                                                                                               |
| **alibabacloud.mongodb.sharding\_repl\_buffer\_size\_node.minimum**(gauge)                           | Sharding replication buffer size on node.*Shown as mebibyte*                                                                                               |
| **alibabacloud.mongodb.sharding\_repl\_cmds.average**(gauge)                                         | Sharding replication commands.*Shown as command*                                                                                                           |
| **alibabacloud.mongodb.sharding\_repl\_cmds.maximum**(gauge)                                         | Sharding replication commands.*Shown as command*                                                                                                           |
| **alibabacloud.mongodb.sharding\_repl\_cmds.minimum**(gauge)                                         | Sharding replication commands.*Shown as command*                                                                                                           |
| **alibabacloud.mongodb.sharding\_repl\_cmds\_node.average**(gauge)                                   | Sharding replication commands on node.*Shown as command*                                                                                                   |
| **alibabacloud.mongodb.sharding\_repl\_cmds\_node.maximum**(gauge)                                   | Sharding replication commands on node.*Shown as command*                                                                                                   |
| **alibabacloud.mongodb.sharding\_repl\_cmds\_node.minimum**(gauge)                                   | Sharding replication commands on node.*Shown as command*                                                                                                   |
| **alibabacloud.mongodb.sharding\_repl\_deletes.average**(gauge)                                      | Sharding replication deletes.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.sharding\_repl\_deletes.maximum**(gauge)                                      | Sharding replication deletes.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.sharding\_repl\_deletes.minimum**(gauge)                                      | Sharding replication deletes.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.sharding\_repl\_deletes\_node.average**(gauge)                                | Sharding replication deletes on node.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_repl\_deletes\_node.maximum**(gauge)                                | Sharding replication deletes on node.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_repl\_deletes\_node.minimum**(gauge)                                | Sharding replication deletes on node.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_repl\_getmores.average**(gauge)                                     | Sharding replication getMore operations.*Shown as operation*                                                                                               |
| **alibabacloud.mongodb.sharding\_repl\_getmores.maximum**(gauge)                                     | Sharding replication getMore operations.*Shown as operation*                                                                                               |
| **alibabacloud.mongodb.sharding\_repl\_getmores.minimum**(gauge)                                     | Sharding replication getMore operations.*Shown as operation*                                                                                               |
| **alibabacloud.mongodb.sharding\_repl\_getmores\_node.average**(gauge)                               | Sharding replication getMore operations on node.*Shown as operation*                                                                                       |
| **alibabacloud.mongodb.sharding\_repl\_getmores\_node.maximum**(gauge)                               | Sharding replication getMore operations on node.*Shown as operation*                                                                                       |
| **alibabacloud.mongodb.sharding\_repl\_getmores\_node.minimum**(gauge)                               | Sharding replication getMore operations on node.*Shown as operation*                                                                                       |
| **alibabacloud.mongodb.sharding\_repl\_inserts.average**(gauge)                                      | Sharding replication inserts.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.sharding\_repl\_inserts.maximum**(gauge)                                      | Sharding replication inserts.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.sharding\_repl\_inserts.minimum**(gauge)                                      | Sharding replication inserts.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.sharding\_repl\_inserts\_node.average**(gauge)                                | Sharding replication inserts on node.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_repl\_inserts\_node.maximum**(gauge)                                | Sharding replication inserts on node.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_repl\_inserts\_node.minimum**(gauge)                                | Sharding replication inserts on node.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_repl\_queries.average**(gauge)                                      | Sharding replication queries.*Shown as query*                                                                                                              |
| **alibabacloud.mongodb.sharding\_repl\_queries.maximum**(gauge)                                      | Sharding replication queries.*Shown as query*                                                                                                              |
| **alibabacloud.mongodb.sharding\_repl\_queries.minimum**(gauge)                                      | Sharding replication queries.*Shown as query*                                                                                                              |
| **alibabacloud.mongodb.sharding\_repl\_queries\_node.average**(gauge)                                | Sharding replication queries on node.*Shown as query*                                                                                                      |
| **alibabacloud.mongodb.sharding\_repl\_queries\_node.maximum**(gauge)                                | Sharding replication queries on node.*Shown as query*                                                                                                      |
| **alibabacloud.mongodb.sharding\_repl\_queries\_node.minimum**(gauge)                                | Sharding replication queries on node.*Shown as query*                                                                                                      |
| **alibabacloud.mongodb.sharding\_repl\_updates.average**(gauge)                                      | Sharding replication updates.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.sharding\_repl\_updates.maximum**(gauge)                                      | Sharding replication updates.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.sharding\_repl\_updates.minimum**(gauge)                                      | Sharding replication updates.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.sharding\_repl\_updates\_node.average**(gauge)                                | Sharding replication updates on node.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_repl\_updates\_node.maximum**(gauge)                                | Sharding replication updates on node.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_repl\_updates\_node.minimum**(gauge)                                | Sharding replication updates on node.*Shown as operation*                                                                                                  |
| **alibabacloud.mongodb.sharding\_replication\_lag.average**(gauge)                                   | Sharding replication lag.*Shown as second*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_replication\_lag.maximum**(gauge)                                   | Sharding replication lag.*Shown as second*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_replication\_lag.minimum**(gauge)                                   | Sharding replication lag.*Shown as second*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_replication\_lag\_node.average**(gauge)                             | Sharding replication lag on node.*Shown as second*                                                                                                         |
| **alibabacloud.mongodb.sharding\_replication\_lag\_node.maximum**(gauge)                             | Sharding replication lag on node.*Shown as second*                                                                                                         |
| **alibabacloud.mongodb.sharding\_replication\_lag\_node.minimum**(gauge)                             | Sharding replication lag on node.*Shown as second*                                                                                                         |
| **alibabacloud.mongodb.sharding\_scan\_order\_ops\_ps.average**(rate)                                | Sharding scan order operations per second.*Shown as operation*                                                                                             |
| **alibabacloud.mongodb.sharding\_scan\_order\_ops\_ps.maximum**(rate)                                | Sharding scan order operations per second.*Shown as operation*                                                                                             |
| **alibabacloud.mongodb.sharding\_scan\_order\_ops\_ps.minimum**(rate)                                | Sharding scan order operations per second.*Shown as operation*                                                                                             |
| **alibabacloud.mongodb.sharding\_scan\_order\_ops\_ps\_node.average**(rate)                          | Sharding scan order operations per second on node.*Shown as operation*                                                                                     |
| **alibabacloud.mongodb.sharding\_scan\_order\_ops\_ps\_node.maximum**(rate)                          | Sharding scan order operations per second on node.*Shown as operation*                                                                                     |
| **alibabacloud.mongodb.sharding\_scan\_order\_ops\_ps\_node.minimum**(rate)                          | Sharding scan order operations per second on node.*Shown as operation*                                                                                     |
| **alibabacloud.mongodb.sharding\_scanned\_docs.average**(gauge)                                      | Sharding scanned documents.*Shown as document*                                                                                                             |
| **alibabacloud.mongodb.sharding\_scanned\_docs.maximum**(gauge)                                      | Sharding scanned documents.*Shown as document*                                                                                                             |
| **alibabacloud.mongodb.sharding\_scanned\_docs.minimum**(gauge)                                      | Sharding scanned documents.*Shown as document*                                                                                                             |
| **alibabacloud.mongodb.sharding\_scanned\_docs\_node.average**(gauge)                                | Sharding scanned documents on node.*Shown as document*                                                                                                     |
| **alibabacloud.mongodb.sharding\_scanned\_docs\_node.maximum**(gauge)                                | Sharding scanned documents on node.*Shown as document*                                                                                                     |
| **alibabacloud.mongodb.sharding\_scanned\_docs\_node.minimum**(gauge)                                | Sharding scanned documents on node.*Shown as document*                                                                                                     |
| **alibabacloud.mongodb.sharding\_scanned\_keys.average**(gauge)                                      | Sharding scanned keys.*Shown as key*                                                                                                                       |
| **alibabacloud.mongodb.sharding\_scanned\_keys.maximum**(gauge)                                      | Sharding scanned keys.*Shown as key*                                                                                                                       |
| **alibabacloud.mongodb.sharding\_scanned\_keys.minimum**(gauge)                                      | Sharding scanned keys.*Shown as key*                                                                                                                       |
| **alibabacloud.mongodb.sharding\_scanned\_keys\_node.average**(gauge)                                | Sharding scanned keys on node.*Shown as key*                                                                                                               |
| **alibabacloud.mongodb.sharding\_scanned\_keys\_node.maximum**(gauge)                                | Sharding scanned keys on node.*Shown as key*                                                                                                               |
| **alibabacloud.mongodb.sharding\_scanned\_keys\_node.minimum**(gauge)                                | Sharding scanned keys on node.*Shown as key*                                                                                                               |
| **alibabacloud.mongodb.sharding\_session\_closed\_cursors.average**(gauge)                           | Sharding session closed cursors.*Shown as cursor*                                                                                                          |
| **alibabacloud.mongodb.sharding\_session\_closed\_cursors.maximum**(gauge)                           | Sharding session closed cursors.*Shown as cursor*                                                                                                          |
| **alibabacloud.mongodb.sharding\_session\_closed\_cursors.minimum**(gauge)                           | Sharding session closed cursors.*Shown as cursor*                                                                                                          |
| **alibabacloud.mongodb.sharding\_session\_closed\_cursors\_node.average**(gauge)                     | Sharding session closed cursors on node.*Shown as cursor*                                                                                                  |
| **alibabacloud.mongodb.sharding\_session\_closed\_cursors\_node.maximum**(gauge)                     | Sharding session closed cursors on node.*Shown as cursor*                                                                                                  |
| **alibabacloud.mongodb.sharding\_session\_closed\_cursors\_node.minimum**(gauge)                     | Sharding session closed cursors on node.*Shown as cursor*                                                                                                  |
| **alibabacloud.mongodb.sharding\_slow\_log\_count.sum**(count)                                       | Sharding slow query count.*Shown as query*                                                                                                                 |
| **alibabacloud.mongodb.sharding\_tcmalloc\_cache\_mem\_ratio.average**(gauge)                        | Sharding tcmalloc cache memory ratio.*Shown as percent*                                                                                                    |
| **alibabacloud.mongodb.sharding\_tcmalloc\_cache\_mem\_ratio.maximum**(gauge)                        | Sharding tcmalloc cache memory ratio.*Shown as percent*                                                                                                    |
| **alibabacloud.mongodb.sharding\_tcmalloc\_cache\_mem\_ratio.minimum**(gauge)                        | Sharding tcmalloc cache memory ratio.*Shown as percent*                                                                                                    |
| **alibabacloud.mongodb.sharding\_tcmalloc\_cache\_mem\_ratio\_node.average**(gauge)                  | Sharding tcmalloc cache memory ratio on node.*Shown as percent*                                                                                            |
| **alibabacloud.mongodb.sharding\_tcmalloc\_cache\_mem\_ratio\_node.maximum**(gauge)                  | Sharding tcmalloc cache memory ratio on node.*Shown as percent*                                                                                            |
| **alibabacloud.mongodb.sharding\_tcmalloc\_cache\_mem\_ratio\_node.minimum**(gauge)                  | Sharding tcmalloc cache memory ratio on node.*Shown as percent*                                                                                            |
| **alibabacloud.mongodb.sharding\_total\_cursors.average**(gauge)                                     | Sharding total cursors.*Shown as cursor*                                                                                                                   |
| **alibabacloud.mongodb.sharding\_total\_cursors.maximum**(gauge)                                     | Sharding total cursors.*Shown as cursor*                                                                                                                   |
| **alibabacloud.mongodb.sharding\_total\_cursors.minimum**(gauge)                                     | Sharding total cursors.*Shown as cursor*                                                                                                                   |
| **alibabacloud.mongodb.sharding\_total\_cursors\_node.average**(gauge)                               | Sharding total cursors on node.*Shown as cursor*                                                                                                           |
| **alibabacloud.mongodb.sharding\_total\_cursors\_node.maximum**(gauge)                               | Sharding total cursors on node.*Shown as cursor*                                                                                                           |
| **alibabacloud.mongodb.sharding\_total\_cursors\_node.minimum**(gauge)                               | Sharding total cursors on node.*Shown as cursor*                                                                                                           |
| **alibabacloud.mongodb.sharding\_total\_mbps\_usage.average**(gauge)                                 | Sharding total network bandwidth usage.*Shown as percent*                                                                                                  |
| **alibabacloud.mongodb.sharding\_total\_mbps\_usage.maximum**(gauge)                                 | Sharding total network bandwidth usage.*Shown as percent*                                                                                                  |
| **alibabacloud.mongodb.sharding\_total\_mbps\_usage.minimum**(gauge)                                 | Sharding total network bandwidth usage.*Shown as percent*                                                                                                  |
| **alibabacloud.mongodb.sharding\_total\_mbps\_usage\_node.average**(gauge)                           | Sharding total network bandwidth usage on node.*Shown as percent*                                                                                          |
| **alibabacloud.mongodb.sharding\_total\_mbps\_usage\_node.maximum**(gauge)                           | Sharding total network bandwidth usage on node.*Shown as percent*                                                                                          |
| **alibabacloud.mongodb.sharding\_total\_mbps\_usage\_node.minimum**(gauge)                           | Sharding total network bandwidth usage on node.*Shown as percent*                                                                                          |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps.average**(rate)                                  | Sharding transaction latency per second.*Shown as microsecond*                                                                                             |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps.maximum**(rate)                                  | Sharding transaction latency per second.*Shown as microsecond*                                                                                             |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps.minimum**(rate)                                  | Sharding transaction latency per second.*Shown as microsecond*                                                                                             |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps\_node.average**(rate)                            | Sharding transaction latency per second on node.*Shown as microsecond*                                                                                     |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps\_node.maximum**(rate)                            | Sharding transaction latency per second on node.*Shown as microsecond*                                                                                     |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps\_node.minimum**(rate)                            | Sharding transaction latency per second on node.*Shown as microsecond*                                                                                     |
| **alibabacloud.mongodb.sharding\_trans\_total\_aborted\_ps.average**(rate)                           | Sharding total aborted transactions per second.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.sharding\_trans\_total\_aborted\_ps.maximum**(rate)                           | Sharding total aborted transactions per second.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.sharding\_trans\_total\_aborted\_ps.minimum**(rate)                           | Sharding total aborted transactions per second.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.sharding\_trans\_total\_aborted\_ps\_node.average**(rate)                     | Sharding total aborted transactions per second on node.*Shown as transaction*                                                                              |
| **alibabacloud.mongodb.sharding\_trans\_total\_aborted\_ps\_node.maximum**(rate)                     | Sharding total aborted transactions per second on node.*Shown as transaction*                                                                              |
| **alibabacloud.mongodb.sharding\_trans\_total\_aborted\_ps\_node.minimum**(rate)                     | Sharding total aborted transactions per second on node.*Shown as transaction*                                                                              |
| **alibabacloud.mongodb.sharding\_trans\_total\_commited\_ps.average**(rate)                          | Sharding total committed transactions per second.*Shown as transaction*                                                                                    |
| **alibabacloud.mongodb.sharding\_trans\_total\_commited\_ps.maximum**(rate)                          | Sharding total committed transactions per second.*Shown as transaction*                                                                                    |
| **alibabacloud.mongodb.sharding\_trans\_total\_commited\_ps.minimum**(rate)                          | Sharding total committed transactions per second.*Shown as transaction*                                                                                    |
| **alibabacloud.mongodb.sharding\_trans\_total\_commited\_ps\_node.average**(rate)                    | Sharding total committed transactions per second on node.*Shown as transaction*                                                                            |
| **alibabacloud.mongodb.sharding\_trans\_total\_commited\_ps\_node.maximum**(rate)                    | Sharding total committed transactions per second on node.*Shown as transaction*                                                                            |
| **alibabacloud.mongodb.sharding\_trans\_total\_commited\_ps\_node.minimum**(rate)                    | Sharding total committed transactions per second on node.*Shown as transaction*                                                                            |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_ps.average**(rate)                          | Sharding total prepared transactions per second.*Shown as transaction*                                                                                     |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_ps.maximum**(rate)                          | Sharding total prepared transactions per second.*Shown as transaction*                                                                                     |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_ps.minimum**(rate)                          | Sharding total prepared transactions per second.*Shown as transaction*                                                                                     |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_ps\_node.average**(rate)                    | Sharding total prepared transactions per second on node.*Shown as transaction*                                                                             |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_ps\_node.maximum**(rate)                    | Sharding total prepared transactions per second on node.*Shown as transaction*                                                                             |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_ps\_node.minimum**(rate)                    | Sharding total prepared transactions per second on node.*Shown as transaction*                                                                             |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_aborted\_ps.average**(rate)           | Sharding total prepared then aborted transactions per second.*Shown as transaction*                                                                        |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_aborted\_ps.maximum**(rate)           | Sharding total prepared then aborted transactions per second.*Shown as transaction*                                                                        |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_aborted\_ps.minimum**(rate)           | Sharding total prepared then aborted transactions per second.*Shown as transaction*                                                                        |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_aborted\_ps\_node.average**(rate)     | Sharding total prepared then aborted transactions per second on node.*Shown as transaction*                                                                |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_aborted\_ps\_node.maximum**(rate)     | Sharding total prepared then aborted transactions per second on node.*Shown as transaction*                                                                |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_aborted\_ps\_node.minimum**(rate)     | Sharding total prepared then aborted transactions per second on node.*Shown as transaction*                                                                |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_commited\_ps.average**(rate)          | Sharding total prepared then committed transactions per second.*Shown as transaction*                                                                      |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_commited\_ps.maximum**(rate)          | Sharding total prepared then committed transactions per second.*Shown as transaction*                                                                      |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_commited\_ps.minimum**(rate)          | Sharding total prepared then committed transactions per second.*Shown as transaction*                                                                      |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_commited\_ps\_node.average**(rate)    | Sharding total prepared then committed transactions per second on node.*Shown as transaction*                                                              |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_commited\_ps\_node.maximum**(rate)    | Sharding total prepared then committed transactions per second on node.*Shown as transaction*                                                              |
| **alibabacloud.mongodb.sharding\_trans\_total\_prepared\_then\_commited\_ps\_node.minimum**(rate)    | Sharding total prepared then committed transactions per second on node.*Shown as transaction*                                                              |
| **alibabacloud.mongodb.sharding\_trans\_total\_started\_ps.average**(rate)                           | Sharding total started transactions per second.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.sharding\_trans\_total\_started\_ps.maximum**(rate)                           | Sharding total started transactions per second.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.sharding\_trans\_total\_started\_ps.minimum**(rate)                           | Sharding total started transactions per second.*Shown as transaction*                                                                                      |
| **alibabacloud.mongodb.sharding\_trans\_total\_started\_ps\_node.average**(rate)                     | Sharding total started transactions per second on node.*Shown as transaction*                                                                              |
| **alibabacloud.mongodb.sharding\_trans\_total\_started\_ps\_node.maximum**(rate)                     | Sharding total started transactions per second on node.*Shown as transaction*                                                                              |
| **alibabacloud.mongodb.sharding\_trans\_total\_started\_ps\_node.minimum**(rate)                     | Sharding total started transactions per second on node.*Shown as transaction*                                                                              |
| **alibabacloud.mongodb.sharding\_ttl\_deleted\_ps.average**(rate)                                    | Sharding TTL deleted per second.*Shown as document*                                                                                                        |
| **alibabacloud.mongodb.sharding\_ttl\_deleted\_ps.maximum**(rate)                                    | Sharding TTL deleted per second.*Shown as document*                                                                                                        |
| **alibabacloud.mongodb.sharding\_ttl\_deleted\_ps.minimum**(rate)                                    | Sharding TTL deleted per second.*Shown as document*                                                                                                        |
| **alibabacloud.mongodb.sharding\_ttl\_deleted\_ps\_node.average**(rate)                              | Sharding TTL deleted per second on node.*Shown as document*                                                                                                |
| **alibabacloud.mongodb.sharding\_ttl\_deleted\_ps\_node.maximum**(rate)                              | Sharding TTL deleted per second on node.*Shown as document*                                                                                                |
| **alibabacloud.mongodb.sharding\_ttl\_deleted\_ps\_node.minimum**(rate)                              | Sharding TTL deleted per second on node.*Shown as document*                                                                                                |
| **alibabacloud.mongodb.sharding\_ttl\_passes\_ps.average**(rate)                                     | Sharding TTL passes per second.*Shown as scan*                                                                                                             |
| **alibabacloud.mongodb.sharding\_ttl\_passes\_ps.maximum**(rate)                                     | Sharding TTL passes per second.*Shown as scan*                                                                                                             |
| **alibabacloud.mongodb.sharding\_ttl\_passes\_ps.minimum**(rate)                                     | Sharding TTL passes per second.*Shown as scan*                                                                                                             |
| **alibabacloud.mongodb.sharding\_ttl\_passes\_ps\_node.average**(rate)                               | Sharding TTL passes per second on node.*Shown as scan*                                                                                                     |
| **alibabacloud.mongodb.sharding\_ttl\_passes\_ps\_node.maximum**(rate)                               | Sharding TTL passes per second on node.*Shown as scan*                                                                                                     |
| **alibabacloud.mongodb.sharding\_ttl\_passes\_ps\_node.minimum**(rate)                               | Sharding TTL passes per second on node.*Shown as scan*                                                                                                     |
| **alibabacloud.mongodb.sharding\_txn\_avg\_rt.average**(gauge)                                       | Sharding transaction average response time.*Shown as microsecond*                                                                                          |
| **alibabacloud.mongodb.sharding\_txn\_avg\_rt.maximum**(gauge)                                       | Sharding transaction average response time.*Shown as microsecond*                                                                                          |
| **alibabacloud.mongodb.sharding\_txn\_avg\_rt.minimum**(gauge)                                       | Sharding transaction average response time.*Shown as microsecond*                                                                                          |
| **alibabacloud.mongodb.sharding\_txn\_avg\_rt\_node.average**(gauge)                                 | Sharding transaction average response time on node.*Shown as microsecond*                                                                                  |
| **alibabacloud.mongodb.sharding\_txn\_avg\_rt\_node.maximum**(gauge)                                 | Sharding transaction average response time on node.*Shown as microsecond*                                                                                  |
| **alibabacloud.mongodb.sharding\_txn\_avg\_rt\_node.minimum**(gauge)                                 | Sharding transaction average response time on node.*Shown as microsecond*                                                                                  |
| **alibabacloud.mongodb.sharding\_user.average**(gauge)                                               | Sharding user cursors.*Shown as cursor*                                                                                                                    |
| **alibabacloud.mongodb.sharding\_user.maximum**(gauge)                                               | Sharding user cursors.*Shown as cursor*                                                                                                                    |
| **alibabacloud.mongodb.sharding\_user.minimum**(gauge)                                               | Sharding user cursors.*Shown as cursor*                                                                                                                    |
| **alibabacloud.mongodb.sharding\_user\_node.average**(gauge)                                         | Sharding user cursors on node.*Shown as cursor*                                                                                                            |
| **alibabacloud.mongodb.sharding\_user\_node.maximum**(gauge)                                         | Sharding user cursors on node.*Shown as cursor*                                                                                                            |
| **alibabacloud.mongodb.sharding\_user\_node.minimum**(gauge)                                         | Sharding user cursors on node.*Shown as cursor*                                                                                                            |
| **alibabacloud.mongodb.sharding\_warning.average**(gauge)                                            | Sharding warnings.                                                                                                                                         |
| **alibabacloud.mongodb.sharding\_warning.maximum**(gauge)                                            | Sharding warnings.                                                                                                                                         |
| **alibabacloud.mongodb.sharding\_warning.minimum**(gauge)                                            | Sharding warnings.                                                                                                                                         |
| **alibabacloud.mongodb.sharding\_warning\_node.average**(gauge)                                      | Sharding warnings on node.                                                                                                                                 |
| **alibabacloud.mongodb.sharding\_warning\_node.maximum**(gauge)                                      | Sharding warnings on node.                                                                                                                                 |
| **alibabacloud.mongodb.sharding\_warning\_node.minimum**(gauge)                                      | Sharding warnings on node.                                                                                                                                 |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_cache\_updates\_usage.average**(gauge)                | Sharding WiredTiger cache updates usage.*Shown as percent*                                                                                                 |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_cache\_updates\_usage.maximum**(gauge)                | Sharding WiredTiger cache updates usage.*Shown as percent*                                                                                                 |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_cache\_updates\_usage.minimum**(gauge)                | Sharding WiredTiger cache updates usage.*Shown as percent*                                                                                                 |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_check\_point\_lock.average**(gauge)                   | Sharding WiredTiger checkpoint lock acquisitions.*Shown as lock*                                                                                           |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_check\_point\_lock.maximum**(gauge)                   | Sharding WiredTiger checkpoint lock acquisitions.*Shown as lock*                                                                                           |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_check\_point\_lock.minimum**(gauge)                   | Sharding WiredTiger checkpoint lock acquisitions.*Shown as lock*                                                                                           |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_check\_point\_lock\_node.average**(gauge)             | Sharding WiredTiger checkpoint lock acquisitions on node.*Shown as lock*                                                                                   |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_check\_point\_lock\_node.maximum**(gauge)             | Sharding WiredTiger checkpoint lock acquisitions on node.*Shown as lock*                                                                                   |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_check\_point\_lock\_node.minimum**(gauge)             | Sharding WiredTiger checkpoint lock acquisitions on node.*Shown as lock*                                                                                   |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_read\_lock.average**(gauge)                  | Sharding WiredTiger dhandle read lock acquisitions.*Shown as lock*                                                                                         |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_read\_lock.maximum**(gauge)                  | Sharding WiredTiger dhandle read lock acquisitions.*Shown as lock*                                                                                         |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_read\_lock.minimum**(gauge)                  | Sharding WiredTiger dhandle read lock acquisitions.*Shown as lock*                                                                                         |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_read\_lock\_node.average**(gauge)            | Sharding WiredTiger dhandle read lock acquisitions on node.*Shown as lock*                                                                                 |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_read\_lock\_node.maximum**(gauge)            | Sharding WiredTiger dhandle read lock acquisitions on node.*Shown as lock*                                                                                 |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_read\_lock\_node.minimum**(gauge)            | Sharding WiredTiger dhandle read lock acquisitions on node.*Shown as lock*                                                                                 |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_write\_lock.average**(gauge)                 | Sharding WiredTiger dhandle write lock acquisitions.*Shown as lock*                                                                                        |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_write\_lock.maximum**(gauge)                 | Sharding WiredTiger dhandle write lock acquisitions.*Shown as lock*                                                                                        |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_write\_lock.minimum**(gauge)                 | Sharding WiredTiger dhandle write lock acquisitions.*Shown as lock*                                                                                        |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_write\_lock\_node.average**(gauge)           | Sharding WiredTiger dhandle write lock acquisitions on node.*Shown as lock*                                                                                |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_write\_lock\_node.maximum**(gauge)           | Sharding WiredTiger dhandle write lock acquisitions on node.*Shown as lock*                                                                                |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_dhandle\_write\_lock\_node.minimum**(gauge)           | Sharding WiredTiger dhandle write lock acquisitions on node.*Shown as lock*                                                                                |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_metadata\_lock.average**(gauge)                       | Sharding WiredTiger metadata lock acquisitions.*Shown as lock*                                                                                             |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_metadata\_lock.maximum**(gauge)                       | Sharding WiredTiger metadata lock acquisitions.*Shown as lock*                                                                                             |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_metadata\_lock.minimum**(gauge)                       | Sharding WiredTiger metadata lock acquisitions.*Shown as lock*                                                                                             |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_metadata\_lock\_node.average**(gauge)                 | Sharding WiredTiger metadata lock acquisitions on node.*Shown as lock*                                                                                     |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_metadata\_lock\_node.maximum**(gauge)                 | Sharding WiredTiger metadata lock acquisitions on node.*Shown as lock*                                                                                     |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_metadata\_lock\_node.minimum**(gauge)                 | Sharding WiredTiger metadata lock acquisitions on node.*Shown as lock*                                                                                     |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_schema\_lock.average**(gauge)                         | Sharding WiredTiger schema lock acquisitions.*Shown as lock*                                                                                               |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_schema\_lock.maximum**(gauge)                         | Sharding WiredTiger schema lock acquisitions.*Shown as lock*                                                                                               |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_schema\_lock.minimum**(gauge)                         | Sharding WiredTiger schema lock acquisitions.*Shown as lock*                                                                                               |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_schema\_lock\_node.average**(gauge)                   | Sharding WiredTiger schema lock acquisitions on node.*Shown as lock*                                                                                       |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_schema\_lock\_node.maximum**(gauge)                   | Sharding WiredTiger schema lock acquisitions on node.*Shown as lock*                                                                                       |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_schema\_lock\_node.minimum**(gauge)                   | Sharding WiredTiger schema lock acquisitions on node.*Shown as lock*                                                                                       |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_read\_lock.average**(gauge)                    | Sharding WiredTiger table read lock acquisitions.*Shown as lock*                                                                                           |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_read\_lock.maximum**(gauge)                    | Sharding WiredTiger table read lock acquisitions.*Shown as lock*                                                                                           |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_read\_lock.minimum**(gauge)                    | Sharding WiredTiger table read lock acquisitions.*Shown as lock*                                                                                           |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_read\_lock\_node.average**(gauge)              | Sharding WiredTiger table read lock acquisitions on node.*Shown as lock*                                                                                   |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_read\_lock\_node.maximum**(gauge)              | Sharding WiredTiger table read lock acquisitions on node.*Shown as lock*                                                                                   |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_read\_lock\_node.minimum**(gauge)              | Sharding WiredTiger table read lock acquisitions on node.*Shown as lock*                                                                                   |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_write\_lock.average**(gauge)                   | Sharding WiredTiger table write lock acquisitions.*Shown as lock*                                                                                          |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_write\_lock.maximum**(gauge)                   | Sharding WiredTiger table write lock acquisitions.*Shown as lock*                                                                                          |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_write\_lock.minimum**(gauge)                   | Sharding WiredTiger table write lock acquisitions.*Shown as lock*                                                                                          |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_write\_lock\_node.average**(gauge)             | Sharding WiredTiger table write lock acquisitions on node.*Shown as lock*                                                                                  |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_write\_lock\_node.maximum**(gauge)             | Sharding WiredTiger table write lock acquisitions on node.*Shown as lock*                                                                                  |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_table\_write\_lock\_node.minimum**(gauge)             | Sharding WiredTiger table write lock acquisitions on node.*Shown as lock*                                                                                  |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_read\_lock.average**(gauge)              | Sharding WiredTiger transaction global read lock acquisitions.*Shown as lock*                                                                              |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_read\_lock.maximum**(gauge)              | Sharding WiredTiger transaction global read lock acquisitions.*Shown as lock*                                                                              |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_read\_lock.minimum**(gauge)              | Sharding WiredTiger transaction global read lock acquisitions.*Shown as lock*                                                                              |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_read\_lock\_node.average**(gauge)        | Sharding WiredTiger transaction global read lock acquisitions on node.*Shown as lock*                                                                      |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_read\_lock\_node.maximum**(gauge)        | Sharding WiredTiger transaction global read lock acquisitions on node.*Shown as lock*                                                                      |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_read\_lock\_node.minimum**(gauge)        | Sharding WiredTiger transaction global read lock acquisitions on node.*Shown as lock*                                                                      |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_write\_lock.average**(gauge)             | Sharding WiredTiger transaction global write lock acquisitions.*Shown as lock*                                                                             |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_write\_lock.maximum**(gauge)             | Sharding WiredTiger transaction global write lock acquisitions.*Shown as lock*                                                                             |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_write\_lock.minimum**(gauge)             | Sharding WiredTiger transaction global write lock acquisitions.*Shown as lock*                                                                             |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_write\_lock\_node.average**(gauge)       | Sharding WiredTiger transaction global write lock acquisitions on node.*Shown as lock*                                                                     |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_write\_lock\_node.maximum**(gauge)       | Sharding WiredTiger transaction global write lock acquisitions on node.*Shown as lock*                                                                     |
| **alibabacloud.mongodb.sharding\_wired\_tiger\_txn\_global\_write\_lock\_node.minimum**(gauge)       | Sharding WiredTiger transaction global write lock acquisitions on node.*Shown as lock*                                                                     |
| **alibabacloud.mongodb.sharding\_write\_avg\_rt.average**(gauge)                                     | Sharding write average response time.*Shown as microsecond*                                                                                                |
| **alibabacloud.mongodb.sharding\_write\_avg\_rt.maximum**(gauge)                                     | Sharding write average response time.*Shown as microsecond*                                                                                                |
| **alibabacloud.mongodb.sharding\_write\_avg\_rt.minimum**(gauge)                                     | Sharding write average response time.*Shown as microsecond*                                                                                                |
| **alibabacloud.mongodb.sharding\_write\_avg\_rt\_node.average**(gauge)                               | Sharding write average response time on node.*Shown as microsecond*                                                                                        |
| **alibabacloud.mongodb.sharding\_write\_avg\_rt\_node.maximum**(gauge)                               | Sharding write average response time on node.*Shown as microsecond*                                                                                        |
| **alibabacloud.mongodb.sharding\_write\_avg\_rt\_node.minimum**(gauge)                               | Sharding write average response time on node.*Shown as microsecond*                                                                                        |
| **alibabacloud.mongodb.sharding\_write\_bandwidth.average**(rate)                                    | Sharding write bandwidth.*Shown as mebibyte*                                                                                                               |
| **alibabacloud.mongodb.sharding\_write\_bandwidth.maximum**(rate)                                    | Sharding write bandwidth.*Shown as mebibyte*                                                                                                               |
| **alibabacloud.mongodb.sharding\_write\_bandwidth.minimum**(rate)                                    | Sharding write bandwidth.*Shown as mebibyte*                                                                                                               |
| **alibabacloud.mongodb.sharding\_write\_bandwidth\_node.average**(rate)                              | Sharding write bandwidth on node.*Shown as mebibyte*                                                                                                       |
| **alibabacloud.mongodb.sharding\_write\_bandwidth\_node.maximum**(rate)                              | Sharding write bandwidth on node.*Shown as mebibyte*                                                                                                       |
| **alibabacloud.mongodb.sharding\_write\_bandwidth\_node.minimum**(rate)                              | Sharding write bandwidth on node.*Shown as mebibyte*                                                                                                       |
| **alibabacloud.mongodb.sharding\_write\_conflicts.average**(gauge)                                   | Sharding write conflicts.                                                                                                                                  |
| **alibabacloud.mongodb.sharding\_write\_conflicts.maximum**(gauge)                                   | Sharding write conflicts.                                                                                                                                  |
| **alibabacloud.mongodb.sharding\_write\_conflicts.minimum**(gauge)                                   | Sharding write conflicts.                                                                                                                                  |
| **alibabacloud.mongodb.sharding\_write\_conflicts\_node.average**(gauge)                             | Sharding write conflicts on node.                                                                                                                          |
| **alibabacloud.mongodb.sharding\_write\_conflicts\_node.maximum**(gauge)                             | Sharding write conflicts on node.                                                                                                                          |
| **alibabacloud.mongodb.sharding\_write\_conflicts\_node.minimum**(gauge)                             | Sharding write conflicts on node.                                                                                                                          |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_avail.average**(gauge)                    | Sharding write transactions concurrent available.*Shown as operation*                                                                                      |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_avail.maximum**(gauge)                    | Sharding write transactions concurrent available.*Shown as operation*                                                                                      |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_avail.minimum**(gauge)                    | Sharding write transactions concurrent available.*Shown as operation*                                                                                      |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_avail\_node.average**(gauge)              | Sharding write transactions concurrent available on node.*Shown as operation*                                                                              |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_avail\_node.maximum**(gauge)              | Sharding write transactions concurrent available on node.*Shown as operation*                                                                              |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_avail\_node.minimum**(gauge)              | Sharding write transactions concurrent available on node.*Shown as operation*                                                                              |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_out.average**(gauge)                      | Sharding write transactions concurrent out.*Shown as operation*                                                                                            |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_out.maximum**(gauge)                      | Sharding write transactions concurrent out.*Shown as operation*                                                                                            |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_out.minimum**(gauge)                      | Sharding write transactions concurrent out.*Shown as operation*                                                                                            |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_out\_node.average**(gauge)                | Sharding write transactions concurrent out on node.*Shown as operation*                                                                                    |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_out\_node.maximum**(gauge)                | Sharding write transactions concurrent out on node.*Shown as operation*                                                                                    |
| **alibabacloud.mongodb.sharding\_write\_trans\_concurrent\_out\_node.minimum**(gauge)                | Sharding write transactions concurrent out on node.*Shown as operation*                                                                                    |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps.average**(rate)                                 | Sharding writes latency per second.*Shown as microsecond*                                                                                                  |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps.maximum**(rate)                                 | Sharding writes latency per second.*Shown as microsecond*                                                                                                  |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps.minimum**(rate)                                 | Sharding writes latency per second.*Shown as microsecond*                                                                                                  |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps\_node.average**(rate)                           | Sharding writes latency per second on node.*Shown as microsecond*                                                                                          |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps\_node.maximum**(rate)                           | Sharding writes latency per second on node.*Shown as microsecond*                                                                                          |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps\_node.minimum**(rate)                           | Sharding writes latency per second on node.*Shown as microsecond*                                                                                          |
| **alibabacloud.mongodb.sharding\_wt\_cache\_dirty\_usage.average**(gauge)                            | Sharding WiredTiger cache dirty usage.*Shown as percent*                                                                                                   |
| **alibabacloud.mongodb.sharding\_wt\_cache\_dirty\_usage.maximum**(gauge)                            | Sharding WiredTiger cache dirty usage.*Shown as percent*                                                                                                   |
| **alibabacloud.mongodb.sharding\_wt\_cache\_dirty\_usage.minimum**(gauge)                            | Sharding WiredTiger cache dirty usage.*Shown as percent*                                                                                                   |
| **alibabacloud.mongodb.sharding\_wt\_cache\_dirty\_usage\_node.average**(gauge)                      | Sharding WiredTiger cache dirty usage on node.*Shown as percent*                                                                                           |
| **alibabacloud.mongodb.sharding\_wt\_cache\_dirty\_usage\_node.maximum**(gauge)                      | Sharding WiredTiger cache dirty usage on node.*Shown as percent*                                                                                           |
| **alibabacloud.mongodb.sharding\_wt\_cache\_dirty\_usage\_node.minimum**(gauge)                      | Sharding WiredTiger cache dirty usage on node.*Shown as percent*                                                                                           |
| **alibabacloud.mongodb.sharding\_wt\_cache\_updates\_usage\_node.average**(gauge)                    | Sharding WiredTiger cache updates usage on node.*Shown as percent*                                                                                         |
| **alibabacloud.mongodb.sharding\_wt\_cache\_updates\_usage\_node.maximum**(gauge)                    | Sharding WiredTiger cache updates usage on node.*Shown as percent*                                                                                         |
| **alibabacloud.mongodb.sharding\_wt\_cache\_updates\_usage\_node.minimum**(gauge)                    | Sharding WiredTiger cache updates usage on node.*Shown as percent*                                                                                         |
| **alibabacloud.mongodb.sharding\_wt\_cache\_usage.average**(gauge)                                   | Sharding WiredTiger cache usage.*Shown as percent*                                                                                                         |
| **alibabacloud.mongodb.sharding\_wt\_cache\_usage.maximum**(gauge)                                   | Sharding WiredTiger cache usage.*Shown as percent*                                                                                                         |
| **alibabacloud.mongodb.sharding\_wt\_cache\_usage.minimum**(gauge)                                   | Sharding WiredTiger cache usage.*Shown as percent*                                                                                                         |
| **alibabacloud.mongodb.sharding\_wt\_cache\_usage\_node.average**(gauge)                             | Sharding WiredTiger cache usage on node.*Shown as percent*                                                                                                 |
| **alibabacloud.mongodb.sharding\_wt\_cache\_usage\_node.maximum**(gauge)                             | Sharding WiredTiger cache usage on node.*Shown as percent*                                                                                                 |
| **alibabacloud.mongodb.sharding\_wt\_cache\_usage\_node.minimum**(gauge)                             | Sharding WiredTiger cache usage on node.*Shown as percent*                                                                                                 |
| **alibabacloud.mongodb.sharding\_wt\_file\_num.average**(gauge)                                      | Sharding WiredTiger file count.*Shown as file*                                                                                                             |
| **alibabacloud.mongodb.sharding\_wt\_file\_num.maximum**(gauge)                                      | Sharding WiredTiger file count.*Shown as file*                                                                                                             |
| **alibabacloud.mongodb.sharding\_wt\_file\_num.minimum**(gauge)                                      | Sharding WiredTiger file count.*Shown as file*                                                                                                             |
| **alibabacloud.mongodb.sharding\_wt\_file\_num\_node.average**(gauge)                                | Sharding WiredTiger file count on node.*Shown as file*                                                                                                     |
| **alibabacloud.mongodb.sharding\_wt\_file\_num\_node.maximum**(gauge)                                | Sharding WiredTiger file count on node.*Shown as file*                                                                                                     |
| **alibabacloud.mongodb.sharding\_wt\_file\_num\_node.minimum**(gauge)                                | Sharding WiredTiger file count on node.*Shown as file*                                                                                                     |
| **alibabacloud.mongodb.single\_node\_cpu\_utilization.average**(gauge)                               | Single node CPU usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.mongodb.single\_node\_cpu\_utilization.maximum**(gauge)                               | Single node CPU usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.mongodb.single\_node\_cpu\_utilization.minimum**(gauge)                               | Single node CPU usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.mongodb.single\_node\_connection\_amount.average**(gauge)                             | Single node used connections.*Shown as connection*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_connection\_amount.maximum**(gauge)                             | Single node used connections.*Shown as connection*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_connection\_amount.minimum**(gauge)                             | Single node used connections.*Shown as connection*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_connection\_utilization.average**(gauge)                        | Single node connection usage.*Shown as percent*                                                                                                            |
| **alibabacloud.mongodb.single\_node\_connection\_utilization.maximum**(gauge)                        | Single node connection usage.*Shown as percent*                                                                                                            |
| **alibabacloud.mongodb.single\_node\_connection\_utilization.minimum**(gauge)                        | Single node connection usage.*Shown as percent*                                                                                                            |
| **alibabacloud.mongodb.single\_node\_data\_disk\_amount.average**(gauge)                             | Single node data disk space used.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.single\_node\_data\_disk\_amount.maximum**(gauge)                             | Single node data disk space used.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.single\_node\_data\_disk\_amount.minimum**(gauge)                             | Single node data disk space used.*Shown as byte*                                                                                                           |
| **alibabacloud.mongodb.single\_node\_disk\_utilization.average**(gauge)                              | Single node disk usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.single\_node\_disk\_utilization.maximum**(gauge)                              | Single node disk usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.single\_node\_disk\_utilization.minimum**(gauge)                              | Single node disk usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.mongodb.single\_node\_intranet\_in.average**(gauge)                                   | Single node inbound network traffic.*Shown as byte*                                                                                                        |
| **alibabacloud.mongodb.single\_node\_intranet\_in.maximum**(gauge)                                   | Single node inbound network traffic.*Shown as byte*                                                                                                        |
| **alibabacloud.mongodb.single\_node\_intranet\_in.minimum**(gauge)                                   | Single node inbound network traffic.*Shown as byte*                                                                                                        |
| **alibabacloud.mongodb.single\_node\_intranet\_out.average**(gauge)                                  | Single node outbound network traffic.*Shown as byte*                                                                                                       |
| **alibabacloud.mongodb.single\_node\_intranet\_out.maximum**(gauge)                                  | Single node outbound network traffic.*Shown as byte*                                                                                                       |
| **alibabacloud.mongodb.single\_node\_intranet\_out.minimum**(gauge)                                  | Single node outbound network traffic.*Shown as byte*                                                                                                       |
| **alibabacloud.mongodb.single\_node\_memory\_utilization.average**(gauge)                            | Single node memory usage.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.single\_node\_memory\_utilization.maximum**(gauge)                            | Single node memory usage.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.single\_node\_memory\_utilization.minimum**(gauge)                            | Single node memory usage.*Shown as percent*                                                                                                                |
| **alibabacloud.mongodb.single\_node\_number\_requests.average**(gauge)                               | Single node request count.*Shown as request*                                                                                                               |
| **alibabacloud.mongodb.single\_node\_number\_requests.maximum**(gauge)                               | Single node request count.*Shown as request*                                                                                                               |
| **alibabacloud.mongodb.single\_node\_number\_requests.minimum**(gauge)                               | Single node request count.*Shown as request*                                                                                                               |
| **alibabacloud.mongodb.single\_node\_op\_command.average**(gauge)                                    | Single node command operations.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.single\_node\_op\_command.maximum**(gauge)                                    | Single node command operations.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.single\_node\_op\_command.minimum**(gauge)                                    | Single node command operations.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.single\_node\_op\_delete.average**(gauge)                                     | Single node delete operations.*Shown as operation*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_op\_delete.maximum**(gauge)                                     | Single node delete operations.*Shown as operation*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_op\_delete.minimum**(gauge)                                     | Single node delete operations.*Shown as operation*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_op\_getmore.average**(gauge)                                    | Single node getMore operations.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.single\_node\_op\_getmore.maximum**(gauge)                                    | Single node getMore operations.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.single\_node\_op\_getmore.minimum**(gauge)                                    | Single node getMore operations.*Shown as operation*                                                                                                        |
| **alibabacloud.mongodb.single\_node\_op\_insert.average**(gauge)                                     | Single node insert operations.*Shown as operation*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_op\_insert.maximum**(gauge)                                     | Single node insert operations.*Shown as operation*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_op\_insert.minimum**(gauge)                                     | Single node insert operations.*Shown as operation*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_op\_query.average**(gauge)                                      | Single node query operations.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.single\_node\_op\_query.maximum**(gauge)                                      | Single node query operations.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.single\_node\_op\_query.minimum**(gauge)                                      | Single node query operations.*Shown as operation*                                                                                                          |
| **alibabacloud.mongodb.single\_node\_op\_update.average**(gauge)                                     | Single node update operations.*Shown as operation*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_op\_update.maximum**(gauge)                                     | Single node update operations.*Shown as operation*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_op\_update.minimum**(gauge)                                     | Single node update operations.*Shown as operation*                                                                                                         |
| **alibabacloud.mongodb.single\_node\_qps.average**(gauge)                                            | Single node queries per second.*Shown as query*                                                                                                            |
| **alibabacloud.mongodb.single\_node\_qps.maximum**(gauge)                                            | Single node queries per second.*Shown as query*                                                                                                            |
| **alibabacloud.mongodb.single\_node\_qps.minimum**(gauge)                                            | Single node queries per second.*Shown as query*                                                                                                            |
| **alibabacloud.nat\_gateway.snat\_connection.maximum**(rate)                                         | Number of SNAT connections.*Shown as connection*                                                                                                           |
| **alibabacloud.nat\_gateway.snat\_connection\_drop\_concurrent\_connection\_limit.maximum**(rate)    | Limit of Concurrent SNAT connections.*Shown as connection*                                                                                                 |
| **alibabacloud.nat\_gateway.snat\_connection\_drop\_connection\_rate\_limit.maximum**(rate)          | Limit of SNAT connection rate.*Shown as connection*                                                                                                        |
| **alibabacloud.oceanbase.active\_memstore\_percent\_by\_trigger\_tenant.average**(gauge)             | Active MemStore Memory Usage for Tenant.*Shown as percent*                                                                                                 |
| **alibabacloud.oceanbase.active\_memstore\_used**(gauge)                                             | Active MemStore memory used.*Shown as mebibyte*                                                                                                            |
| **alibabacloud.oceanbase.active\_session.average**(gauge)                                            | Active sessions.*Shown as session*                                                                                                                         |
| **alibabacloud.oceanbase.active\_sessions.sum**(rate)                                                | Active sessions.*Shown as session*                                                                                                                         |
| **alibabacloud.oceanbase.active\_sessions\_instance.average**(gauge)                                 | Active sessions on instance.*Shown as session*                                                                                                             |
| **alibabacloud.oceanbase.active\_sessions\_max\_tenant.max**(gauge)                                  | Maximum active sessions for tenant.*Shown as percent*                                                                                                      |
| **alibabacloud.oceanbase.active\_sessions\_tenant.sum**(gauge)                                       | Active sessions on tenant.*Shown as session*                                                                                                               |
| **alibabacloud.oceanbase.all\_session.average**(gauge)                                               | Total sessions.*Shown as session*                                                                                                                          |
| **alibabacloud.oceanbase.block\_cache\_hit\_ratio**(gauge)                                           | Block cache hit rate.*Shown as percent*                                                                                                                    |
| **alibabacloud.oceanbase.block\_cache\_req\_total**(gauge)                                           | Block cache requests.*Shown as request*                                                                                                                    |
| **alibabacloud.oceanbase.block\_cache\_size**(gauge)                                                 | Block cache size.*Shown as mebibyte*                                                                                                                       |
| **alibabacloud.oceanbase.bloom\_filter\_cache\_hit\_ratio**(gauge)                                   | Bloom filter cache hit rate.*Shown as percent*                                                                                                             |
| **alibabacloud.oceanbase.bloom\_filter\_cache\_req\_total**(gauge)                                   | Bloom filter cache requests.*Shown as request*                                                                                                             |
| **alibabacloud.oceanbase.bloom\_filter\_cache\_size**(gauge)                                         | Bloom filter cache size.*Shown as mebibyte*                                                                                                                |
| **alibabacloud.oceanbase.clog\_cache\_hit\_ratio**(gauge)                                            | Commit log cache hit rate.*Shown as percent*                                                                                                               |
| **alibabacloud.oceanbase.clog\_cache\_req\_total**(gauge)                                            | Commit log cache requests.*Shown as request*                                                                                                               |
| **alibabacloud.oceanbase.clog\_cache\_size**(gauge)                                                  | Commit log cache size.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.oceanbase.clog\_trans\_log\_total\_size**(gauge)                                      | Commit log trans log total size.*Shown as byte*                                                                                                            |
| **alibabacloud.oceanbase.core\_count\_instance.average**(gauge)                                      | CPU cores on instance.*Shown as core*                                                                                                                      |
| **alibabacloud.oceanbase.cpu\_percent.average**(gauge)                                               | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.oceanbase.cpu\_usage\_avg\_tenant.average**(gauge)                                    | Average Number of CPU Cores Used for Tenant.*Shown as percent*                                                                                             |
| **alibabacloud.oceanbase.cpu\_usage\_max\_tenant.max**(gauge)                                        | Maximum Number of CPU Cores Used for Tenant.*Shown as percent*                                                                                             |
| **alibabacloud.oceanbase.cpu\_usage\_percent\_max\_tenant.max**(gauge)                               | Maximum CPU Utilization of Tenant.*Shown as percent*                                                                                                       |
| **alibabacloud.oceanbase.cpu\_usage\_percent\_tenant.average**(gauge)                                | Average CPU Utilization of Tenant.*Shown as percent*                                                                                                       |
| **alibabacloud.oceanbase.cpu\_util\_instance.average**(gauge)                                        | Node CPU Usage.*Shown as percent*                                                                                                                          |
| **alibabacloud.oceanbase.disk\_data\_size\_instance.average**(gauge)                                 | Data Disk Space Used.*Shown as gibibyte*                                                                                                                   |
| **alibabacloud.oceanbase.disk\_data\_usage\_instance.average**(gauge)                                | Disk Data Space Usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.oceanbase.disk\_genernal\_size\_instance.average**(gauge)                             | General Disk Space Used for OceanBase Instance.*Shown as gibibyte*                                                                                         |
| **alibabacloud.oceanbase.disk\_genernal\_usage\_instance.average**(gauge)                            | General Disk Space Usage for OceanBase Instance.*Shown as percent*                                                                                         |
| **alibabacloud.oceanbase.disk\_log\_size\_instance.average**(gauge)                                  | Log Disk Spaced Used for Node.*Shown as gibibyte*                                                                                                          |
| **alibabacloud.oceanbase.disk\_log\_usage\_instance.average**(gauge)                                 | Log Disk Spaced Usage for Node.*Shown as percent*                                                                                                          |
| **alibabacloud.oceanbase.disk\_ob\_data\_size.max**(gauge)                                           | Disk OceanBase data size.*Shown as byte*                                                                                                                   |
| **alibabacloud.oceanbase.disk\_ob\_data\_size\_instance.average**(gauge)                             | Data Disk Space Used for Node.*Shown as gibibyte*                                                                                                          |
| **alibabacloud.oceanbase.disk\_ob\_data\_size\_tenant.max**(gauge)                                   | Disk OceanBase data size tenant.*Shown as byte*                                                                                                            |
| **alibabacloud.oceanbase.disk\_ob\_data\_usage.max**(gauge)                                          | Disk OceanBase data usage.*Shown as percent*                                                                                                               |
| **alibabacloud.oceanbase.disk\_ob\_data\_usage\_instance.average**(gauge)                            | Node Data Disk Usage.*Shown as percent*                                                                                                                    |
| **alibabacloud.oceanbase.election\_event\_history\_row\_count.average**(gauge)                       | Election event history row count.*Shown as row*                                                                                                            |
| **alibabacloud.oceanbase.idle\_sessions\_instance.average**(gauge)                                   | Number of Idle Connections of OceanBase Instance.*Shown as session*                                                                                        |
| **alibabacloud.oceanbase.io\_await\_instance.average**(gauge)                                        | Disk I/O Waiting.*Shown as millisecond*                                                                                                                    |
| **alibabacloud.oceanbase.io\_read.average**(gauge)                                                   | I/O read operations.*Shown as operation*                                                                                                                   |
| **alibabacloud.oceanbase.io\_read\_byte.average**(gauge)                                             | I/O bytes read.*Shown as mebibyte*                                                                                                                         |
| **alibabacloud.oceanbase.io\_read\_bytes.sum**(gauge)                                                | I/O bytes read.*Shown as byte*                                                                                                                             |
| **alibabacloud.oceanbase.io\_read\_bytes\_instance.average**(rate)                                   | Number of Bytes Read per Second by Node from Disk.*Shown as byte*                                                                                          |
| **alibabacloud.oceanbase.io\_read\_bytes\_tenant.sum**(gauge)                                        | I/O bytes read by tenant.*Shown as byte*                                                                                                                   |
| **alibabacloud.oceanbase.io\_read\_count.sum**(gauge)                                                | I/O read count.*Shown as operation*                                                                                                                        |
| **alibabacloud.oceanbase.io\_read\_count\_instance.average**(gauge)                                  | I/O read operations on instance.*Shown as operation*                                                                                                       |
| **alibabacloud.oceanbase.io\_read\_count\_tenant.sum**(gauge)                                        | I/O read operations by tenant.*Shown as operation*                                                                                                         |
| **alibabacloud.oceanbase.io\_read\_delay.sum**(gauge)                                                | Read Latency for Cluster.*Shown as millisecond*                                                                                                            |
| **alibabacloud.oceanbase.io\_read\_delay\_instance.average**(gauge)                                  | I/O read latency on instance.*Shown as millisecond*                                                                                                        |
| **alibabacloud.oceanbase.io\_read\_delay\_tenant.sum**(gauge)                                        | I/O read latency for tenant.*Shown as millisecond*                                                                                                         |
| **alibabacloud.oceanbase.io\_read\_rt.average**(gauge)                                               | Disk Read Response Time.*Shown as millisecond*                                                                                                             |
| **alibabacloud.oceanbase.io\_read\_rt\_instance.average**(gauge)                                     | Disk Read Response Time.*Shown as millisecond*                                                                                                             |
| **alibabacloud.oceanbase.io\_read\_rt\_tenant.average**(gauge)                                       | Disk Read Response Time.*Shown as millisecond*                                                                                                             |
| **alibabacloud.oceanbase.io\_read\_time.average**(gauge)                                             | I/O read duration.*Shown as millisecond*                                                                                                                   |
| **alibabacloud.oceanbase.io\_write.average**(gauge)                                                  | I/O write operations.*Shown as operation*                                                                                                                  |
| **alibabacloud.oceanbase.io\_write\_byte.average**(gauge)                                            | I/O bytes written.*Shown as mebibyte*                                                                                                                      |
| **alibabacloud.oceanbase.io\_write\_bytes.sum**(gauge)                                               | I/O bytes written.*Shown as byte*                                                                                                                          |
| **alibabacloud.oceanbase.io\_write\_bytes\_instance.average**(rate)                                  | Number of Bytes Written to Disk.*Shown as byte*                                                                                                            |
| **alibabacloud.oceanbase.io\_write\_bytes\_tenant.sum**(gauge)                                       | I/O bytes written by tenant.*Shown as byte*                                                                                                                |
| **alibabacloud.oceanbase.io\_write\_count.sum**(gauge)                                               | I/O write count.*Shown as operation*                                                                                                                       |
| **alibabacloud.oceanbase.io\_write\_count\_instance.average**(gauge)                                 | I/O write operations on instance.*Shown as operation*                                                                                                      |
| **alibabacloud.oceanbase.io\_write\_count\_tenant.sum**(gauge)                                       | I/O write operations by tenant.*Shown as operation*                                                                                                        |
| **alibabacloud.oceanbase.io\_write\_delay.sum**(gauge)                                               | Disk Writes.*Shown as millisecond*                                                                                                                         |
| **alibabacloud.oceanbase.io\_write\_delay\_instance.average**(gauge)                                 | I/O write latency on instance.*Shown as millisecond*                                                                                                       |
| **alibabacloud.oceanbase.io\_write\_delay\_tenant.sum**(gauge)                                       | I/O write latency for tenant.*Shown as microsecond*                                                                                                        |
| **alibabacloud.oceanbase.io\_write\_rt.average**(gauge)                                              | Disk Write Response Time.*Shown as millisecond*                                                                                                            |
| **alibabacloud.oceanbase.io\_write\_rt\_instance.average**(gauge)                                    | Disk Write Response Time.*Shown as millisecond*                                                                                                            |
| **alibabacloud.oceanbase.io\_write\_rt\_tenant.average**(gauge)                                      | Disk Write Response Time.*Shown as millisecond*                                                                                                            |
| **alibabacloud.oceanbase.io\_write\_time.average**(gauge)                                            | I/O write duration.*Shown as millisecond*                                                                                                                  |
| **alibabacloud.oceanbase.load1.average**(gauge)                                                      | System load (1 minute).                                                                                                                                    |
| **alibabacloud.oceanbase.load15.average**(gauge)                                                     | System load (15 minutes).                                                                                                                                  |
| **alibabacloud.oceanbase.load5.average**(gauge)                                                      | System load (5 minutes).                                                                                                                                   |
| **alibabacloud.oceanbase.load\_load1\_instance.average**(gauge)                                      | Average CPU Load in Last 1 Minute.*Shown as percent*                                                                                                       |
| **alibabacloud.oceanbase.location\_cache\_hit\_percent.average**(gauge)                              | Location cache hit rate.*Shown as percent*                                                                                                                 |
| **alibabacloud.oceanbase.location\_cache\_hit\_percent\_instance.average**(gauge)                    | Location cache hit rate.*Shown as percent*                                                                                                                 |
| **alibabacloud.oceanbase.location\_cache\_hit\_percent\_tenant.average**(gauge)                      | Location cache hit rate.*Shown as percent*                                                                                                                 |
| **alibabacloud.oceanbase.location\_cache\_hit\_ratio**(gauge)                                        | Location cache hit rate.*Shown as percent*                                                                                                                 |
| **alibabacloud.oceanbase.location\_cache\_req\_total**(gauge)                                        | Location cache requests.*Shown as request*                                                                                                                 |
| **alibabacloud.oceanbase.location\_cache\_size**(gauge)                                              | Location cache size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.oceanbase.machine\_mem\_used\_percent\_instance.average**(gauge)                      | Server Memory Usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.oceanbase.major\_freeze\_trigger**(gauge)                                             | Major freeze trigger.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.oceanbase.memory\_buffers.average**(gauge)                                            | Buffer memory.*Shown as gibibyte*                                                                                                                          |
| **alibabacloud.oceanbase.memory\_cached.average**(gauge)                                             | Cached memory.*Shown as gibibyte*                                                                                                                          |
| **alibabacloud.oceanbase.memory\_free.average**(gauge)                                               | Free memory.*Shown as gibibyte*                                                                                                                            |
| **alibabacloud.oceanbase.memory\_percent**(gauge)                                                    | Host Memory Usage.*Shown as percent*                                                                                                                       |
| **alibabacloud.oceanbase.memory\_usage\_tenant.max**(gauge)                                          | Memory Usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.oceanbase.memstore\_limit**(gauge)                                                    | MemStore memory limit.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.oceanbase.memstore\_percent**(gauge)                                                  | MemStore usage percentage.*Shown as percent*                                                                                                               |
| **alibabacloud.oceanbase.memstore\_write\_lock\_fail\_count**(rate)                                  | MemStore write lock fail count.*Shown as operation*                                                                                                        |
| **alibabacloud.oceanbase.memstore\_write\_lock\_succ\_count**(rate)                                  | MemStore write lock succ count.*Shown as operation*                                                                                                        |
| **alibabacloud.oceanbase.memstore\_write\_lock\_wait\_time**(gauge)                                  | MemStore write lock wait time.*Shown as microsecond*                                                                                                       |
| **alibabacloud.oceanbase.net\_recv.average**(gauge)                                                  | Network bytes received.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.oceanbase.net\_send.average**(gauge)                                                  | Network bytes sent.*Shown as mebibyte*                                                                                                                     |
| **alibabacloud.oceanbase.net\_throughput**(gauge)                                                    | Network throughput.*Shown as mebibyte*                                                                                                                     |
| **alibabacloud.oceanbase.ntp\_offset\_instance.average**(gauge)                                      | NTP Offset.*Shown as millisecond*                                                                                                                          |
| **alibabacloud.oceanbase.ntp\_offset\_milliseconds**(gauge)                                          | NTP offset milliseconds.*Shown as millisecond*                                                                                                             |
| **alibabacloud.oceanbase.ob\_clog\_disk\_percent.average**(gauge)                                    | OceanBase commit log disk percent.*Shown as percent*                                                                                                       |
| **alibabacloud.oceanbase.ob\_clog\_io**(rate)                                                        | OceanBase commit log I/O operations.*Shown as operation*                                                                                                   |
| **alibabacloud.oceanbase.ob\_clog\_io\_read**(rate)                                                  | OceanBase commit log I/O read.*Shown as operation*                                                                                                         |
| **alibabacloud.oceanbase.ob\_clog\_io\_read\_byte**(gauge)                                           | OceanBase commit log I/O read byte.*Shown as mebibyte*                                                                                                     |
| **alibabacloud.oceanbase.ob\_clog\_io\_read\_ms**(gauge)                                             | Log Disk I/O Read Duration.*Shown as millisecond*                                                                                                          |
| **alibabacloud.oceanbase.ob\_clog\_io\_util**(gauge)                                                 | OceanBase commit log I/O util.*Shown as percent*                                                                                                           |
| **alibabacloud.oceanbase.ob\_clog\_io\_write**(rate)                                                 | OceanBase commit log I/O write.*Shown as operation*                                                                                                        |
| **alibabacloud.oceanbase.ob\_clog\_io\_write\_byte**(gauge)                                          | OceanBase commit log I/O write byte.*Shown as mebibyte*                                                                                                    |
| **alibabacloud.oceanbase.ob\_clog\_io\_write\_ms**(gauge)                                            | Log Disk I/O Write Duration.*Shown as millisecond*                                                                                                         |
| **alibabacloud.oceanbase.ob\_cluster.disk\_data\_size**(gauge)                                       | OceanBase cluster disk data size.*Shown as byte*                                                                                                           |
| **alibabacloud.oceanbase.ob\_cluster.disk\_data\_usage**(gauge)                                      | Disk Usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.oceanbase.ob\_cpu\_percent**(gauge)                                                   | OceanBase CPU percent.*Shown as percent*                                                                                                                   |
| **alibabacloud.oceanbase.ob\_cpu\_percent\_by\_node**(gauge)                                         | OceanBase CPU percent by node.*Shown as percent*                                                                                                           |
| **alibabacloud.oceanbase.ob\_data\_disk\_percent.average**(gauge)                                    | OceanBase data disk percent.*Shown as percent*                                                                                                             |
| **alibabacloud.oceanbase.ob\_data\_io**(rate)                                                        | OceanBase data disk I/O operations.*Shown as operation*                                                                                                    |
| **alibabacloud.oceanbase.ob\_data\_io\_read**(rate)                                                  | OceanBase data I/O read.*Shown as operation*                                                                                                               |
| **alibabacloud.oceanbase.ob\_data\_io\_read\_byte**(gauge)                                           | OceanBase data I/O read byte.*Shown as mebibyte*                                                                                                           |
| **alibabacloud.oceanbase.ob\_data\_io\_read\_ms**(gauge)                                             | Data Disk I/O Read Duration.*Shown as millisecond*                                                                                                         |
| **alibabacloud.oceanbase.ob\_data\_io\_util**(gauge)                                                 | OceanBase data I/O util.*Shown as percent*                                                                                                                 |
| **alibabacloud.oceanbase.ob\_data\_io\_write**(rate)                                                 | OceanBase data I/O write.*Shown as operation*                                                                                                              |
| **alibabacloud.oceanbase.ob\_data\_io\_write\_byte**(gauge)                                          | OceanBase data I/O write byte.*Shown as mebibyte*                                                                                                          |
| **alibabacloud.oceanbase.ob\_data\_io\_write\_ms**(gauge)                                            | Data Disk I/O Write Duration.*Shown as millisecond*                                                                                                        |
| **alibabacloud.oceanbase.ob\_process\_exists**(gauge)                                                | OceanBase process exists.                                                                                                                                  |
| **alibabacloud.oceanbase.ob\_server\_inactive\_count\_instance.average**(gauge)                      | Number of Active Connections for OceanBase Server.*Shown as instance*                                                                                      |
| **alibabacloud.oceanbase.ob\_standby\_cluster\_delay\_time**(gauge)                                  | OceanBase standby cluster delay time.*Shown as second*                                                                                                     |
| **alibabacloud.oceanbase.ob\_sys\_clog\_unsync\_instance.average**(gauge)                            | OceanBase sys commit log unsync instance.*Shown as instance*                                                                                               |
| **alibabacloud.oceanbase.ob\_sys\_daily\_merge\_error\_instance.average**(gauge)                     | OceanBase sys daily merge error instance.*Shown as instance*                                                                                               |
| **alibabacloud.oceanbase.ob\_sys\_daily\_merge\_stopped\_instance.average**(gauge)                   | OceanBase sys daily merge stopped instance.*Shown as instance*                                                                                             |
| **alibabacloud.oceanbase.ob\_sys\_daily\_merge\_timeout\_instance.average**(gauge)                   | OceanBase sys daily merge timeout instance.*Shown as instance*                                                                                             |
| **alibabacloud.oceanbase.ob\_sys\_disk\_invalid\_instance.average**(gauge)                           | Node Disk Exceptions.*Shown as instance*                                                                                                                   |
| **alibabacloud.oceanbase.ob\_sys\_election\_info\_instance.average**(gauge)                          | OceanBase sys election info instance.*Shown as instance*                                                                                                   |
| **alibabacloud.oceanbase.ob\_sys\_leader\_election\_instance.average**(gauge)                        | OceanBase sys leader election instance.*Shown as instance*                                                                                                 |
| **alibabacloud.oceanbase.ob\_tenant.active\_memstore\_percent\_by\_node.average**(gauge)             | Percentage of Active Memory on Single Node for Tenant.*Shown as percent*                                                                                   |
| **alibabacloud.oceanbase.ob\_tenant.cpu\_percent\_by\_node.average**(gauge)                          | Single-node Load for Tenant.*Shown as percent*                                                                                                             |
| **alibabacloud.oceanbase.ob\_tenant.disk\_data\_size**(gauge)                                        | OceanBase tenant disk data size.*Shown as byte*                                                                                                            |
| **alibabacloud.oceanbase.ob\_tenant.total\_memstore\_percent\_by\_node.average**(gauge)              | Percentage of Active MemStore on Single Node for Tenant.*Shown as percent*                                                                                 |
| **alibabacloud.oceanbase.ob\_tenant\_memory\_percent.average**(gauge)                                | OceanBase tenant memory percent.*Shown as percent*                                                                                                         |
| **alibabacloud.oceanbase.observer\_process\_id.average**(gauge)                                      | Observer process id.                                                                                                                                       |
| **alibabacloud.oceanbase.observer\_process\_kernel\_status.average**(gauge)                          | OBServer Process Status.                                                                                                                                   |
| **alibabacloud.oceanbase.odp\_cpu\_percent**(gauge)                                                  | ODP CPU usage.*Shown as percent*                                                                                                                           |
| **alibabacloud.oceanbase.odp\_load1**(gauge)                                                         | ODP system load (1 minute).                                                                                                                                |
| **alibabacloud.oceanbase.odp\_load15**(gauge)                                                        | ODP system load (15 minutes).                                                                                                                              |
| **alibabacloud.oceanbase.odp\_load5**(gauge)                                                         | ODP system load (5 minutes).                                                                                                                               |
| **alibabacloud.oceanbase.odp\_memory\_free**(gauge)                                                  | ODP free memory.*Shown as gibibyte*                                                                                                                        |
| **alibabacloud.oceanbase.opened\_cursors\_count**(gauge)                                             | Open cursors.*Shown as connection*                                                                                                                         |
| **alibabacloud.oceanbase.plan\_cache\_hit\_ratio**(gauge)                                            | Plan cache hit rate.*Shown as percent*                                                                                                                     |
| **alibabacloud.oceanbase.plan\_cache\_size**(gauge)                                                  | Plan cache size.*Shown as mebibyte*                                                                                                                        |
| **alibabacloud.oceanbase.qps.sum**(gauge)                                                            | Queries per second.*Shown as query*                                                                                                                        |
| **alibabacloud.oceanbase.qps\_instance.average**(gauge)                                              | Queries per second instance.*Shown as query*                                                                                                               |
| **alibabacloud.oceanbase.qps\_rt.average**(gauge)                                                    | Read Request Response Time.*Shown as millisecond*                                                                                                          |
| **alibabacloud.oceanbase.qps\_rt\_instance.average**(gauge)                                          | Read Request Response Time.*Shown as millisecond*                                                                                                          |
| **alibabacloud.oceanbase.qps\_rt\_tenant.average**(gauge)                                            | Read Request Response Time.*Shown as millisecond*                                                                                                          |
| **alibabacloud.oceanbase.qps\_tenant.sum**(gauge)                                                    | Queries per second tenant.*Shown as query*                                                                                                                 |
| **alibabacloud.oceanbase.request\_dequeue\_count\_tenant.sum**(gauge)                                | Tenant request dequeue count.*Shown as request*                                                                                                            |
| **alibabacloud.oceanbase.request\_queue\_rt.average**(gauge)                                         | Waiting Queue.*Shown as millisecond*                                                                                                                       |
| **alibabacloud.oceanbase.request\_queue\_rt\_tenant.average**(gauge)                                 | Waiting Queue.*Shown as millisecond*                                                                                                                       |
| **alibabacloud.oceanbase.request\_queue\_time**(gauge)                                               | Request queue time.*Shown as microsecond*                                                                                                                  |
| **alibabacloud.oceanbase.rootservice\_event\_history\_row\_count.average**(gauge)                    | Rootservice event history row count.*Shown as row*                                                                                                         |
| **alibabacloud.oceanbase.row\_cache\_hit\_ratio**(gauge)                                             | Row cache hit rate.*Shown as percent*                                                                                                                      |
| **alibabacloud.oceanbase.row\_cache\_req\_total**(gauge)                                             | Row cache requests.*Shown as request*                                                                                                                      |
| **alibabacloud.oceanbase.row\_cache\_size**(gauge)                                                   | Row cache size.*Shown as mebibyte*                                                                                                                         |
| **alibabacloud.oceanbase.rpc\_packet\_in**(gauge)                                                    | RPC inbound packets.*Shown as byte*                                                                                                                        |
| **alibabacloud.oceanbase.rpc\_packet\_in\_bytes\_ps\_tenant.sum**(gauge)                             | RPC inbound bytes per second for tenant.*Shown as byte*                                                                                                    |
| **alibabacloud.oceanbase.rpc\_packet\_in\_rt**(gauge)                                                | RPC inbound packet response time.*Shown as microsecond*                                                                                                    |
| **alibabacloud.oceanbase.rpc\_packet\_out**(gauge)                                                   | RPC outbound packets.*Shown as byte*                                                                                                                       |
| **alibabacloud.oceanbase.rpc\_packet\_out\_rt**(gauge)                                               | RPC outbound packet response time.*Shown as microsecond*                                                                                                   |
| **alibabacloud.oceanbase.server\_event\_history\_row\_count.average**(gauge)                         | Server event history row count.*Shown as row*                                                                                                              |
| **alibabacloud.oceanbase.slb\_active\_connections.sum**(gauge)                                       | Active load balancer connections.*Shown as connection*                                                                                                     |
| **alibabacloud.oceanbase.slb\_concurrent\_connections.sum**(gauge)                                   | Concurrent load balancer connections.*Shown as connection*                                                                                                 |
| **alibabacloud.oceanbase.slb\_drop\_connections.sum**(gauge)                                         | Dropped load balancer connections.*Shown as connection*                                                                                                    |
| **alibabacloud.oceanbase.slb\_drop\_in\_traffic.sum**(gauge)                                         | Dropped inbound load balancer traffic.*Shown as byte*                                                                                                      |
| **alibabacloud.oceanbase.slb\_drop\_out\_traffic.sum**(gauge)                                        | Dropped outbound load balancer traffic.*Shown as byte*                                                                                                     |
| **alibabacloud.oceanbase.slow\_sql\_count.average**(gauge)                                           | Slow query count.*Shown as query*                                                                                                                          |
| **alibabacloud.oceanbase.sql\_all\_count.sum**(rate)                                                 | Total SQL operations.*Shown as query*                                                                                                                      |
| **alibabacloud.oceanbase.sql\_all\_rt.average**(gauge)                                               | SQL all response time.*Shown as millisecond*                                                                                                               |
| **alibabacloud.oceanbase.sql\_delete\_count.sum**(gauge)                                             | SQL delete operations.*Shown as query*                                                                                                                     |
| **alibabacloud.oceanbase.sql\_delete\_count\_instance.average**(gauge)                               | SQL delete operations on instance.*Shown as query*                                                                                                         |
| **alibabacloud.oceanbase.sql\_delete\_count\_tenant.sum**(gauge)                                     | SQL delete operations on tenant.*Shown as query*                                                                                                           |
| **alibabacloud.oceanbase.sql\_delete\_rt.average**(gauge)                                            | Average Response Time of delete SQL Requests for Tenant.*Shown as millisecond*                                                                             |
| **alibabacloud.oceanbase.sql\_delete\_rt\_instance.average**(gauge)                                  | DELETE Request Response Time.*Shown as millisecond*                                                                                                        |
| **alibabacloud.oceanbase.sql\_delete\_rt\_tenant.average**(gauge)                                    | DELETE Request Response Time.*Shown as millisecond*                                                                                                        |
| **alibabacloud.oceanbase.sql\_delete\_rt\_tenant\_node.average**(gauge)                              | Average Response Time of Delete SQL Requests on Tenant Node.*Shown as millisecond*                                                                         |
| **alibabacloud.oceanbase.sql\_distributed\_count.sum**(gauge)                                        | Distributed SQL operations.*Shown as query*                                                                                                                |
| **alibabacloud.oceanbase.sql\_distributed\_count\_instance.average**(gauge)                          | Distributed SQL operations on instance.*Shown as query*                                                                                                    |
| **alibabacloud.oceanbase.sql\_distributed\_count\_tenant.sum**(gauge)                                | Distributed SQL operations on tenant.*Shown as query*                                                                                                      |
| **alibabacloud.oceanbase.sql\_dml\_rt.sum**(gauge)                                                   | Average Write Request Latency.*Shown as millisecond*                                                                                                       |
| **alibabacloud.oceanbase.sql\_dml\_rt\_instance.average**(gauge)                                     | Average Write Request Latency.*Shown as millisecond*                                                                                                       |
| **alibabacloud.oceanbase.sql\_dml\_rt\_tenant.average**(gauge)                                       | Average Write Request Latency.*Shown as millisecond*                                                                                                       |
| **alibabacloud.oceanbase.sql\_insert\_count.sum**(gauge)                                             | SQL insert operations.*Shown as query*                                                                                                                     |
| **alibabacloud.oceanbase.sql\_insert\_count\_instance.average**(gauge)                               | SQL insert operations on instance.*Shown as query*                                                                                                         |
| **alibabacloud.oceanbase.sql\_insert\_count\_tenant.sum**(gauge)                                     | SQL insert operations on tenant.*Shown as query*                                                                                                           |
| **alibabacloud.oceanbase.sql\_insert\_rt.average**(gauge)                                            | Average Response Time of insert SQL Requests for Tenant.*Shown as millisecond*                                                                             |
| **alibabacloud.oceanbase.sql\_insert\_rt\_instance.average**(gauge)                                  | Average Response Time for INSERT Requests.*Shown as millisecond*                                                                                           |
| **alibabacloud.oceanbase.sql\_insert\_rt\_tenant.average**(gauge)                                    | INSERT Request Response Time.*Shown as millisecond*                                                                                                        |
| **alibabacloud.oceanbase.sql\_insert\_rt\_tenant\_node.average**(gauge)                              | Average Response Time of Insert SQL Requests on Tenant Node.*Shown as millisecond*                                                                         |
| **alibabacloud.oceanbase.sql\_local\_count.sum**(rate)                                               | Local SQL operations.*Shown as query*                                                                                                                      |
| **alibabacloud.oceanbase.sql\_other\_count.sum**(rate)                                               | Other SQL operations.*Shown as query*                                                                                                                      |
| **alibabacloud.oceanbase.sql\_other\_rt.average**(gauge)                                             | SQL other response time.*Shown as millisecond*                                                                                                             |
| **alibabacloud.oceanbase.sql\_other\_rt\_tenant\_node.average**(gauge)                               | Average Response Time of Other SQL Requests on Tenant Node.*Shown as millisecond*                                                                          |
| **alibabacloud.oceanbase.sql\_remote\_count.sum**(gauge)                                             | Remote SQL operations.*Shown as query*                                                                                                                     |
| **alibabacloud.oceanbase.sql\_remote\_count\_instance.average**(gauge)                               | Remote SQL operations on instance.*Shown as query*                                                                                                         |
| **alibabacloud.oceanbase.sql\_remote\_count\_tenant.sum**(gauge)                                     | Remote SQL operations on tenant.*Shown as query*                                                                                                           |
| **alibabacloud.oceanbase.sql\_replace\_count.sum**(gauge)                                            | SQL replace operations.*Shown as query*                                                                                                                    |
| **alibabacloud.oceanbase.sql\_replace\_count\_instance.average**(gauge)                              | SQL replace operations on instance.*Shown as query*                                                                                                        |
| **alibabacloud.oceanbase.sql\_replace\_count\_tenant.sum**(gauge)                                    | SQL replace operations on tenant.*Shown as query*                                                                                                          |
| **alibabacloud.oceanbase.sql\_replace\_rt.average**(gauge)                                           | Average Response Time of replace SQL Requests for Tenant.*Shown as millisecond*                                                                            |
| **alibabacloud.oceanbase.sql\_replace\_rt\_instance.average**(gauge)                                 | REPLACE Request Response Time.*Shown as millisecond*                                                                                                       |
| **alibabacloud.oceanbase.sql\_replace\_rt\_tenant.average**(gauge)                                   | REPLACE Request Response Time.*Shown as millisecond*                                                                                                       |
| **alibabacloud.oceanbase.sql\_replace\_rt\_tenant\_node.average**(gauge)                             | Average Response Time of Replace SQL Requests on Tenant Node.*Shown as millisecond*                                                                        |
| **alibabacloud.oceanbase.sql\_select\_count.sum**(gauge)                                             | SQL select operations.*Shown as query*                                                                                                                     |
| **alibabacloud.oceanbase.sql\_select\_count\_instance.average**(gauge)                               | SQL select operations on instance.*Shown as query*                                                                                                         |
| **alibabacloud.oceanbase.sql\_select\_count\_tenant.sum**(gauge)                                     | SQL select operations on tenant.*Shown as query*                                                                                                           |
| **alibabacloud.oceanbase.sql\_select\_rt.average**(gauge)                                            | Average Response Time of select SQL Requests for Tenant.*Shown as millisecond*                                                                             |
| **alibabacloud.oceanbase.sql\_select\_rt\_instance.average**(gauge)                                  | SQL select response time instance.*Shown as microsecond*                                                                                                   |
| **alibabacloud.oceanbase.sql\_select\_rt\_tenant.average**(gauge)                                    | Average Response Time of SELECT Requests.*Shown as millisecond*                                                                                            |
| **alibabacloud.oceanbase.sql\_select\_rt\_tenant\_node.average**(gauge)                              | Average Response Time of Select SQL Requests on Tenant Node.*Shown as millisecond*                                                                         |
| **alibabacloud.oceanbase.sql\_update\_count.sum**(gauge)                                             | SQL update operations.*Shown as query*                                                                                                                     |
| **alibabacloud.oceanbase.sql\_update\_count\_instance.average**(gauge)                               | SQL update operations on instance.*Shown as query*                                                                                                         |
| **alibabacloud.oceanbase.sql\_update\_count\_tenant.sum**(gauge)                                     | SQL update operations on tenant.*Shown as query*                                                                                                           |
| **alibabacloud.oceanbase.sql\_update\_rt.average**(gauge)                                            | Average Response Time of update SQL Requests for Tenant.*Shown as millisecond*                                                                             |
| **alibabacloud.oceanbase.sql\_update\_rt\_instance.average**(gauge)                                  | SQL update response time instance.*Shown as microsecond*                                                                                                   |
| **alibabacloud.oceanbase.sql\_update\_rt\_tenant.average**(gauge)                                    | Average Response Time of UPDATE Requests.*Shown as millisecond*                                                                                            |
| **alibabacloud.oceanbase.sql\_update\_rt\_tenant\_node.average**(gauge)                              | Average Response Time of Update SQL Requests on Tenant Node.*Shown as millisecond*                                                                         |
| **alibabacloud.oceanbase.storage\_delete\_row\_count.sum**(gauge)                                    | Storage rows deleted.*Shown as row*                                                                                                                        |
| **alibabacloud.oceanbase.storage\_delete\_row\_count\_instance.average**(gauge)                      | Storage rows deleted on instance.*Shown as row*                                                                                                            |
| **alibabacloud.oceanbase.storage\_delete\_row\_count\_tenant.sum**(gauge)                            | Storage rows deleted on tenant.*Shown as row*                                                                                                              |
| **alibabacloud.oceanbase.storage\_insert\_row\_count.sum**(gauge)                                    | Storage rows inserted.*Shown as row*                                                                                                                       |
| **alibabacloud.oceanbase.storage\_insert\_row\_count\_instance.average**(gauge)                      | Storage rows inserted on instance.*Shown as row*                                                                                                           |
| **alibabacloud.oceanbase.storage\_insert\_row\_count\_tenant.sum**(gauge)                            | Storage rows inserted on tenant.*Shown as row*                                                                                                             |
| **alibabacloud.oceanbase.storage\_read\_row\_count.sum**(gauge)                                      | Storage rows read.*Shown as row*                                                                                                                           |
| **alibabacloud.oceanbase.storage\_read\_row\_count\_instance.average**(gauge)                        | Storage rows read on instance.*Shown as row*                                                                                                               |
| **alibabacloud.oceanbase.storage\_update\_row\_count.sum**(gauge)                                    | Storage rows updated.*Shown as row*                                                                                                                        |
| **alibabacloud.oceanbase.storage\_update\_row\_count\_instance.average**(gauge)                      | Storage rows updated on instance.*Shown as row*                                                                                                            |
| **alibabacloud.oceanbase.storage\_update\_row\_count\_tenant.sum**(gauge)                            | Storage rows updated on tenant.*Shown as row*                                                                                                              |
| **alibabacloud.oceanbase.system\_event\_internal\_time\_waited**(gauge)                              | Internal wait time.*Shown as millisecond*                                                                                                                  |
| **alibabacloud.oceanbase.system\_event\_internal\_total\_waits**(rate)                               | Internal wait events per second.*Shown as event*                                                                                                           |
| **alibabacloud.oceanbase.system\_event\_io\_total\_waits.sum**(rate)                                 | I/O wait events per second.*Shown as event*                                                                                                                |
| **alibabacloud.oceanbase.system\_event\_latch\_total\_waits**(rate)                                  | Latch wait events per second.*Shown as event*                                                                                                              |
| **alibabacloud.oceanbase.system\_event\_other\_total\_waits**(rate)                                  | Other wait events per second.*Shown as event*                                                                                                              |
| **alibabacloud.oceanbase.system\_event\_row\_lock\_wait\_total\_waits**(rate)                        | Row lock wait events per second.*Shown as event*                                                                                                           |
| **alibabacloud.oceanbase.system\_event\_sync\_rpc\_total\_waits.sum**(rate)                          | Sync RPC wait events per second.*Shown as event*                                                                                                           |
| **alibabacloud.oceanbase.tcp\_retran\_instance.average**(gauge)                                      | Server TCP Retransmission Rate.*Shown as percent*                                                                                                          |
| **alibabacloud.oceanbase.total\_memstore\_percent\_by\_limit\_tenant.max**(gauge)                    | MemStore Memory Usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.oceanbase.total\_memstore\_used**(gauge)                                              | Total MemStore memory used.*Shown as mebibyte*                                                                                                             |
| **alibabacloud.oceanbase.total\_memstore\_used\_instance.average**(gauge)                            | MemStore Size Used.*Shown as byte*                                                                                                                         |
| **alibabacloud.oceanbase.total\_memstore\_used\_tenant.sum**(gauge)                                  | Total MemStore used tenant.*Shown as byte*                                                                                                                 |
| **alibabacloud.oceanbase.total\_sessions\_instance.average**(gauge)                                  | Number of Connections of OceanBase Instance.*Shown as session*                                                                                             |
| **alibabacloud.oceanbase.tps.sum**(gauge)                                                            | Transactions per second.*Shown as transaction*                                                                                                             |
| **alibabacloud.oceanbase.tps\_instance.average**(gauge)                                              | Transactions per second instance.*Shown as transaction*                                                                                                    |
| **alibabacloud.oceanbase.tps\_rt.average**(gauge)                                                    | Write Request Response Time.*Shown as millisecond*                                                                                                         |
| **alibabacloud.oceanbase.tps\_rt\_instance.average**(gauge)                                          | Write Request Response Time.*Shown as millisecond*                                                                                                         |
| **alibabacloud.oceanbase.tps\_rt\_tenant.max**(gauge)                                                | Write Request Response Time.*Shown as millisecond*                                                                                                         |
| **alibabacloud.oceanbase.tps\_tenant.sum**(gauge)                                                    | Transactions per second tenant.*Shown as transaction*                                                                                                      |
| **alibabacloud.oceanbase.traffic\_bytin\_instance.average**(rate)                                    | Inbound Server Packet Rate.*Shown as byte*                                                                                                                 |
| **alibabacloud.oceanbase.traffic\_bytout\_instance.average**(rate)                                   | Outbound Server Packet Rate.*Shown as byte*                                                                                                                |
| **alibabacloud.oceanbase.trans\_commit\_count.sum**(gauge)                                           | Transaction commits.*Shown as transaction*                                                                                                                 |
| **alibabacloud.oceanbase.trans\_commit\_count\_instance.average**(gauge)                             | Transaction commits on instance.*Shown as transaction*                                                                                                     |
| **alibabacloud.oceanbase.trans\_commit\_count\_tenant.sum**(gauge)                                   | Transaction commits on tenant.*Shown as transaction*                                                                                                       |
| **alibabacloud.oceanbase.trans\_commit\_log\_count**(rate)                                           | Trans commit log count.*Shown as transaction*                                                                                                              |
| **alibabacloud.oceanbase.trans\_commit\_log\_sync\_rt**(gauge)                                       | Trans commit log sync response time.*Shown as second*                                                                                                      |
| **alibabacloud.oceanbase.trans\_commit\_rt.average**(gauge)                                          | Transaction Commission Response Time.*Shown as millisecond*                                                                                                |
| **alibabacloud.oceanbase.trans\_commit\_rt\_instance.average**(gauge)                                | Transaction Commission Response Time.*Shown as millisecond*                                                                                                |
| **alibabacloud.oceanbase.trans\_commit\_rt\_tenant.max**(gauge)                                      | Transaction Commission Response Time.*Shown as millisecond*                                                                                                |
| **alibabacloud.oceanbase.trans\_multi\_partition\_count.average**(gauge)                             | Multi-partition transactions.*Shown as transaction*                                                                                                        |
| **alibabacloud.oceanbase.trans\_multi\_partition\_count\_tenant.sum**(gauge)                         | Multi-partition transactions on tenant.*Shown as transaction*                                                                                              |
| **alibabacloud.oceanbase.trans\_rollback\_count.sum**(gauge)                                         | Transaction rollbacks.*Shown as transaction*                                                                                                               |
| **alibabacloud.oceanbase.trans\_rollback\_count\_instance.average**(gauge)                           | Transaction rollbacks on instance.*Shown as transaction*                                                                                                   |
| **alibabacloud.oceanbase.trans\_rollback\_count\_tenant.sum**(gauge)                                 | Transaction rollbacks on tenant.*Shown as transaction*                                                                                                     |
| **alibabacloud.oceanbase.trans\_rollback\_rt.average**(gauge)                                        | Transaction Rollback Response Time.*Shown as millisecond*                                                                                                  |
| **alibabacloud.oceanbase.trans\_rollback\_rt\_instance.average**(gauge)                              | Transaction Rollback Response Time.*Shown as millisecond*                                                                                                  |
| **alibabacloud.oceanbase.trans\_rollback\_rt\_tenant.average**(gauge)                                | Transaction Rollback Response Time.*Shown as millisecond*                                                                                                  |
| **alibabacloud.oceanbase.trans\_single\_partition\_count.sum**(gauge)                                | Single-partition transactions.*Shown as transaction*                                                                                                       |
| **alibabacloud.oceanbase.trans\_single\_partition\_count\_instance.average**(gauge)                  | Single-partition transactions on instance.*Shown as transaction*                                                                                           |
| **alibabacloud.oceanbase.trans\_single\_partition\_count\_tenant.sum**(gauge)                        | Single-partition transactions on tenant.*Shown as transaction*                                                                                             |
| **alibabacloud.oceanbase.trans\_timeout\_count.sum**(gauge)                                          | Transaction timeouts.*Shown as transaction*                                                                                                                |
| **alibabacloud.oceanbase.trans\_timeout\_count\_instance.average**(gauge)                            | Transaction timeouts on instance.*Shown as transaction*                                                                                                    |
| **alibabacloud.oceanbase.trans\_timeout\_count\_tenant.sum**(gauge)                                  | Transaction timeouts on tenant.*Shown as transaction*                                                                                                      |
| **alibabacloud.oceanbase.transaction\_commit\_count**(rate)                                          | Transaction commit rate.*Shown as transaction*                                                                                                             |
| **alibabacloud.oceanbase.transaction\_commit\_rt**(gauge)                                            | Transaction commit response time.*Shown as millisecond*                                                                                                    |
| **alibabacloud.oceanbase.transaction\_count**(rate)                                                  | Transaction rate.*Shown as transaction*                                                                                                                    |
| **alibabacloud.oceanbase.transaction\_multi\_partition\_count**(rate)                                | Transaction multi partition count.*Shown as transaction*                                                                                                   |
| **alibabacloud.oceanbase.transaction\_partition\_count**(rate)                                       | Transaction partition count.*Shown as transaction*                                                                                                         |
| **alibabacloud.oceanbase.transaction\_rollback\_count**(rate)                                        | Transaction rollback rate.*Shown as transaction*                                                                                                           |
| **alibabacloud.oceanbase.transaction\_rollback\_rt**(gauge)                                          | Transaction rollback response time.*Shown as millisecond*                                                                                                  |
| **alibabacloud.oceanbase.transaction\_rt**(gauge)                                                    | Transaction response time.*Shown as millisecond*                                                                                                           |
| **alibabacloud.oceanbase.transaction\_single\_partition\_count**(rate)                               | Transaction single partition count.*Shown as transaction*                                                                                                  |
| **alibabacloud.oceanbase.transaction\_timeout\_count**(rate)                                         | Transaction timeout rate.*Shown as transaction*                                                                                                            |
| **alibabacloud.oceanbase.wait\_event\_count**(rate)                                                  | Wait events per second.*Shown as event*                                                                                                                    |
| **alibabacloud.express\_connect.bytes\_out\_from\_vpc\_to\_idc**(gauge)                              | Number of outbound bytes from VPC to IDC.*Shown as byte*                                                                                                   |
| **alibabacloud.express\_connect.pkgs\_drop\_in\_from\_idc\_to\_vpc**(rate)                           | Number of dropped incoming packets per second from IDC to VPC.*Shown as packet*                                                                            |
| **alibabacloud.express\_connect.pkgs\_drop\_out\_from\_vpc\_to\_idc**(rate)                          | Number of dropped outgoing packets per second from VPC to IDC.*Shown as packet*                                                                            |
| **alibabacloud.express\_connect.pkgs\_in\_from\_idc\_to\_vpc**(rate)                                 | Number of incoming packets per second from IDC to VPC.*Shown as packet*                                                                                    |
| **alibabacloud.express\_connect.pkgs\_out\_from\_vpc\_to\_idc**(rate)                                | Number of outgoing packets per second from VPC to IDC.*Shown as packet*                                                                                    |
| **alibabacloud.express\_connect.rate\_in\_from\_idc\_to\_vpc**(rate)                                 | Number of incoming bits per second from IDC to VPC.*Shown as bit*                                                                                          |
| **alibabacloud.express\_connect.rate\_out\_from\_vpc\_to\_idc**(rate)                                | Number of outgoing bits per second from VPC to IDC.*Shown as bit*                                                                                          |
| **alibabacloud.express\_connect.vbr\_healthy\_check\_latency**(gauge)                                | VBR latency.*Shown as microsecond*                                                                                                                         |
| **alibabacloud.express\_connect.vbr\_healthy\_check\_loss\_rate**(gauge)                             | VBR loss rate.*Shown as percent*                                                                                                                           |
| **alibabacloud.rds.connection\_usage.average**(gauge)                                                | Connection usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.rds.connection\_usage.minimum**(gauge)                                                | Connection usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.rds.connection\_usage.maximum**(gauge)                                                | Connection usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.rds.cpu\_usage.average**(gauge)                                                       | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.rds.cpu\_usage.minimum**(gauge)                                                       | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.rds.cpu\_usage.maximum**(gauge)                                                       | CPU usage.*Shown as percent*                                                                                                                               |
| **alibabacloud.rds.data\_delay.average**(gauge)                                                      | Read-only instance latency.*Shown as second*                                                                                                               |
| **alibabacloud.rds.data\_delay.minimum**(gauge)                                                      | Read-only instance latency.*Shown as second*                                                                                                               |
| **alibabacloud.rds.data\_delay.maximum**(gauge)                                                      | Read-only instance latency.*Shown as second*                                                                                                               |
| **alibabacloud.rds.disk\_usage.average**(gauge)                                                      | Disk usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.rds.disk\_usage.minimum**(gauge)                                                      | Disk usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.rds.disk\_usage.maximum**(gauge)                                                      | Disk usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.rds.group\_cpu\_utilization.average**(gauge)                                          | Group CPU utilization.*Shown as percent*                                                                                                                   |
| **alibabacloud.rds.group\_cpu\_utilization.minimum**(gauge)                                          | Group CPU utilization.*Shown as percent*                                                                                                                   |
| **alibabacloud.rds.group\_cpu\_utilization.maximum**(gauge)                                          | Group CPU utilization.*Shown as percent*                                                                                                                   |
| **alibabacloud.rds.group\_connection\_utilization.average**(gauge)                                   | Group connection utilization.*Shown as percent*                                                                                                            |
| **alibabacloud.rds.group\_connection\_utilization.minimum**(gauge)                                   | Group connection utilization.*Shown as percent*                                                                                                            |
| **alibabacloud.rds.group\_connection\_utilization.maximum**(gauge)                                   | Group connection utilization.*Shown as percent*                                                                                                            |
| **alibabacloud.rds.group\_disk\_utilization.average**(gauge)                                         | Group disk utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.rds.group\_disk\_utilization.minimum**(gauge)                                         | Group disk utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.rds.group\_disk\_utilization.maximum**(gauge)                                         | Group disk utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.rds.group\_iops\_utilization.average**(gauge)                                         | Group IOPS utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.rds.group\_iops\_utilization.minimum**(gauge)                                         | Group IOPS utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.rds.group\_iops\_utilization.maximum**(gauge)                                         | Group IOPS utilization.*Shown as percent*                                                                                                                  |
| **alibabacloud.rds.iops\_usage.average**(gauge)                                                      | IOPS usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.rds.iops\_usage.minimum**(gauge)                                                      | IOPS usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.rds.iops\_usage.maximum**(gauge)                                                      | IOPS usage.*Shown as percent*                                                                                                                              |
| **alibabacloud.rds.memory\_usage.average**(gauge)                                                    | Memory usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.rds.memory\_usage.minimum**(gauge)                                                    | Memory usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.rds.memory\_usage.maximum**(gauge)                                                    | Memory usage.*Shown as percent*                                                                                                                            |
| **alibabacloud.rds.my\_sql\_active\_sessions.average**(gauge)                                        | MySQL active sessions.*Shown as connection*                                                                                                                |
| **alibabacloud.rds.my\_sql\_active\_sessions.minimum**(gauge)                                        | MySQL active sessions.*Shown as connection*                                                                                                                |
| **alibabacloud.rds.my\_sql\_active\_sessions.maximum**(gauge)                                        | MySQL active sessions.*Shown as connection*                                                                                                                |
| **alibabacloud.rds.my\_sql\_bin\_log\_size.average**(gauge)                                          | MySQL binary log size.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_bin\_log\_size.minimum**(gauge)                                          | MySQL binary log size.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_bin\_log\_size.maximum**(gauge)                                          | MySQL binary log size.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_com\_delete.average**(rate)                                              | MySQL delete operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_delete.minimum**(rate)                                              | MySQL delete operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_delete.maximum**(rate)                                              | MySQL delete operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_insert.average**(rate)                                              | MySQL insert operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_insert.minimum**(rate)                                              | MySQL insert operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_insert.maximum**(rate)                                              | MySQL insert operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_insert\_select.average**(rate)                                      | MySQL insert-select operations per second.*Shown as operation*                                                                                             |
| **alibabacloud.rds.my\_sql\_com\_insert\_select.minimum**(rate)                                      | MySQL insert-select operations per second.*Shown as operation*                                                                                             |
| **alibabacloud.rds.my\_sql\_com\_insert\_select.maximum**(rate)                                      | MySQL insert-select operations per second.*Shown as operation*                                                                                             |
| **alibabacloud.rds.my\_sql\_com\_replace.average**(rate)                                             | MySQL replace operations per second.*Shown as operation*                                                                                                   |
| **alibabacloud.rds.my\_sql\_com\_replace.minimum**(rate)                                             | MySQL replace operations per second.*Shown as operation*                                                                                                   |
| **alibabacloud.rds.my\_sql\_com\_replace.maximum**(rate)                                             | MySQL replace operations per second.*Shown as operation*                                                                                                   |
| **alibabacloud.rds.my\_sql\_com\_replace\_select.average**(rate)                                     | MySQL replace-select operations per second.*Shown as operation*                                                                                            |
| **alibabacloud.rds.my\_sql\_com\_replace\_select.minimum**(rate)                                     | MySQL replace-select operations per second.*Shown as operation*                                                                                            |
| **alibabacloud.rds.my\_sql\_com\_replace\_select.maximum**(rate)                                     | MySQL replace-select operations per second.*Shown as operation*                                                                                            |
| **alibabacloud.rds.my\_sql\_com\_select.average**(rate)                                              | MySQL select operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_select.minimum**(rate)                                              | MySQL select operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_select.maximum**(rate)                                              | MySQL select operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_update.average**(rate)                                              | MySQL update operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_update.minimum**(rate)                                              | MySQL update operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_com\_update.maximum**(rate)                                              | MySQL update operations per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_data\_disk\_size.average**(gauge)                                        | MySQL data disk size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_data\_disk\_size.minimum**(gauge)                                        | MySQL data disk size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_data\_disk\_size.maximum**(gauge)                                        | MySQL data disk size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_data\_io\_bytes\_ps.average**(rate)                                      | MySQL data I/O throughput.*Shown as byte*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_data\_io\_bytes\_ps.minimum**(rate)                                      | MySQL data I/O throughput.*Shown as byte*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_data\_io\_bytes\_ps.maximum**(rate)                                      | MySQL data I/O throughput.*Shown as byte*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_general\_log\_size.average**(gauge)                                      | MySQL general log size.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_general\_log\_size.minimum**(gauge)                                      | MySQL general log size.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_general\_log\_size.maximum**(gauge)                                      | MySQL general log size.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_iops.average**(rate)                                                     | MySQL IOPS.*Shown as operation*                                                                                                                            |
| **alibabacloud.rds.my\_sql\_iops.minimum**(rate)                                                     | MySQL IOPS.*Shown as operation*                                                                                                                            |
| **alibabacloud.rds.my\_sql\_iops.maximum**(rate)                                                     | MySQL IOPS.*Shown as operation*                                                                                                                            |
| **alibabacloud.rds.my\_sql\_ibuf\_dirty\_ratio.average**(gauge)                                      | MySQL buffer pool dirty page ratio.*Shown as percent*                                                                                                      |
| **alibabacloud.rds.my\_sql\_ibuf\_dirty\_ratio.minimum**(gauge)                                      | MySQL buffer pool dirty page ratio.*Shown as percent*                                                                                                      |
| **alibabacloud.rds.my\_sql\_ibuf\_dirty\_ratio.maximum**(gauge)                                      | MySQL buffer pool dirty page ratio.*Shown as percent*                                                                                                      |
| **alibabacloud.rds.my\_sql\_ibuf\_read\_hit.average**(gauge)                                         | MySQL buffer pool read hit ratio.*Shown as percent*                                                                                                        |
| **alibabacloud.rds.my\_sql\_ibuf\_read\_hit.minimum**(gauge)                                         | MySQL buffer pool read hit ratio.*Shown as percent*                                                                                                        |
| **alibabacloud.rds.my\_sql\_ibuf\_read\_hit.maximum**(gauge)                                         | MySQL buffer pool read hit ratio.*Shown as percent*                                                                                                        |
| **alibabacloud.rds.my\_sql\_ibuf\_request\_r.average**(rate)                                         | MySQL logical reads per second.*Shown as operation*                                                                                                        |
| **alibabacloud.rds.my\_sql\_ibuf\_request\_r.minimum**(rate)                                         | MySQL logical reads per second.*Shown as operation*                                                                                                        |
| **alibabacloud.rds.my\_sql\_ibuf\_request\_r.maximum**(rate)                                         | MySQL logical reads per second.*Shown as operation*                                                                                                        |
| **alibabacloud.rds.my\_sql\_ibuf\_request\_w.average**(rate)                                         | MySQL logical writes per second.*Shown as operation*                                                                                                       |
| **alibabacloud.rds.my\_sql\_ibuf\_request\_w.minimum**(rate)                                         | MySQL logical writes per second.*Shown as operation*                                                                                                       |
| **alibabacloud.rds.my\_sql\_ibuf\_request\_w.maximum**(rate)                                         | MySQL logical writes per second.*Shown as operation*                                                                                                       |
| **alibabacloud.rds.my\_sql\_ibuf\_use\_ratio.average**(gauge)                                        | MySQL buffer pool utilization.*Shown as percent*                                                                                                           |
| **alibabacloud.rds.my\_sql\_ibuf\_use\_ratio.minimum**(gauge)                                        | MySQL buffer pool utilization.*Shown as percent*                                                                                                           |
| **alibabacloud.rds.my\_sql\_ibuf\_use\_ratio.maximum**(gauge)                                        | MySQL buffer pool utilization.*Shown as percent*                                                                                                           |
| **alibabacloud.rds.my\_sql\_inno\_db\_data\_read.average**(gauge)                                    | MySQL InnoDB data read.*Shown as kibibyte*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_inno\_db\_data\_read.minimum**(gauge)                                    | MySQL InnoDB data read.*Shown as kibibyte*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_inno\_db\_data\_read.maximum**(gauge)                                    | MySQL InnoDB data read.*Shown as kibibyte*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_inno\_db\_data\_written.average**(gauge)                                 | MySQL InnoDB data written.*Shown as kibibyte*                                                                                                              |
| **alibabacloud.rds.my\_sql\_inno\_db\_data\_written.minimum**(gauge)                                 | MySQL InnoDB data written.*Shown as kibibyte*                                                                                                              |
| **alibabacloud.rds.my\_sql\_inno\_db\_data\_written.maximum**(gauge)                                 | MySQL InnoDB data written.*Shown as kibibyte*                                                                                                              |
| **alibabacloud.rds.my\_sql\_inno\_db\_log\_fsync.average**(rate)                                     | MySQL InnoDB log fsync per second.*Shown as operation*                                                                                                     |
| **alibabacloud.rds.my\_sql\_inno\_db\_log\_fsync.minimum**(rate)                                     | MySQL InnoDB log fsync per second.*Shown as operation*                                                                                                     |
| **alibabacloud.rds.my\_sql\_inno\_db\_log\_fsync.maximum**(rate)                                     | MySQL InnoDB log fsync per second.*Shown as operation*                                                                                                     |
| **alibabacloud.rds.my\_sql\_inno\_db\_log\_write\_requests.average**(rate)                           | MySQL InnoDB log write requests per second.*Shown as operation*                                                                                            |
| **alibabacloud.rds.my\_sql\_inno\_db\_log\_write\_requests.minimum**(rate)                           | MySQL InnoDB log write requests per second.*Shown as operation*                                                                                            |
| **alibabacloud.rds.my\_sql\_inno\_db\_log\_write\_requests.maximum**(rate)                           | MySQL InnoDB log write requests per second.*Shown as operation*                                                                                            |
| **alibabacloud.rds.my\_sql\_inno\_db\_log\_writes.average**(rate)                                    | MySQL InnoDB log writes per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_inno\_db\_log\_writes.minimum**(rate)                                    | MySQL InnoDB log writes per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_inno\_db\_log\_writes.maximum**(rate)                                    | MySQL InnoDB log writes per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_inno\_db\_num\_open\_files.average**(gauge)                              | MySQL InnoDB open files.*Shown as file*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_inno\_db\_num\_open\_files.minimum**(gauge)                              | MySQL InnoDB open files.*Shown as file*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_inno\_db\_num\_open\_files.maximum**(gauge)                              | MySQL InnoDB open files.*Shown as file*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_delete.average**(rate)                                    | MySQL InnoDB rows deleted per second.*Shown as row*                                                                                                        |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_delete.minimum**(rate)                                    | MySQL InnoDB rows deleted per second.*Shown as row*                                                                                                        |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_delete.maximum**(rate)                                    | MySQL InnoDB rows deleted per second.*Shown as row*                                                                                                        |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_insert.average**(rate)                                    | MySQL InnoDB rows inserted per second.*Shown as row*                                                                                                       |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_insert.minimum**(rate)                                    | MySQL InnoDB rows inserted per second.*Shown as row*                                                                                                       |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_insert.maximum**(rate)                                    | MySQL InnoDB rows inserted per second.*Shown as row*                                                                                                       |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_lock\_time\_ps.average**(gauge)                           | MySQL InnoDB row lock wait time per second.*Shown as millisecond*                                                                                          |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_lock\_time\_ps.minimum**(gauge)                           | MySQL InnoDB row lock wait time per second.*Shown as millisecond*                                                                                          |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_lock\_time\_ps.maximum**(gauge)                           | MySQL InnoDB row lock wait time per second.*Shown as millisecond*                                                                                          |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_read.average**(rate)                                      | MySQL InnoDB rows read per second.*Shown as row*                                                                                                           |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_read.minimum**(rate)                                      | MySQL InnoDB rows read per second.*Shown as row*                                                                                                           |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_read.maximum**(rate)                                      | MySQL InnoDB rows read per second.*Shown as row*                                                                                                           |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_update.average**(rate)                                    | MySQL InnoDB rows updated per second.*Shown as row*                                                                                                        |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_update.minimum**(rate)                                    | MySQL InnoDB rows updated per second.*Shown as row*                                                                                                        |
| **alibabacloud.rds.my\_sql\_inno\_db\_row\_update.maximum**(rate)                                    | MySQL InnoDB rows updated per second.*Shown as row*                                                                                                        |
| **alibabacloud.rds.my\_sql\_ins\_size.average**(gauge)                                               | MySQL instance size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_ins\_size.minimum**(gauge)                                               | MySQL instance size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_ins\_size.maximum**(gauge)                                               | MySQL instance size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_instance\_disk\_size.average**(gauge)                                    | MySQL instance disk size.*Shown as mebibyte*                                                                                                               |
| **alibabacloud.rds.my\_sql\_instance\_disk\_size.minimum**(gauge)                                    | MySQL instance disk size.*Shown as mebibyte*                                                                                                               |
| **alibabacloud.rds.my\_sql\_instance\_disk\_size.maximum**(gauge)                                    | MySQL instance disk size.*Shown as mebibyte*                                                                                                               |
| **alibabacloud.rds.my\_sql\_log\_disk\_size.average**(gauge)                                         | MySQL log disk size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_log\_disk\_size.minimum**(gauge)                                         | MySQL log disk size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_log\_disk\_size.maximum**(gauge)                                         | MySQL log disk size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_m\_bps\_usage.average**(gauge)                                           | MySQL MBPS usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.rds.my\_sql\_m\_bps\_usage.minimum**(gauge)                                           | MySQL MBPS usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.rds.my\_sql\_m\_bps\_usage.maximum**(gauge)                                           | MySQL MBPS usage.*Shown as percent*                                                                                                                        |
| **alibabacloud.rds.my\_sql\_m\_bps\_usage\_of\_burst.average**(gauge)                                | MySQL MBPS usage with burst.*Shown as percent*                                                                                                             |
| **alibabacloud.rds.my\_sql\_m\_bps\_usage\_of\_burst.minimum**(gauge)                                | MySQL MBPS usage with burst.*Shown as percent*                                                                                                             |
| **alibabacloud.rds.my\_sql\_m\_bps\_usage\_of\_burst.maximum**(gauge)                                | MySQL MBPS usage with burst.*Shown as percent*                                                                                                             |
| **alibabacloud.rds.my\_sql\_mdl\_lock\_session.average**(gauge)                                      | MySQL MDL lock blocked sessions.*Shown as connection*                                                                                                      |
| **alibabacloud.rds.my\_sql\_mdl\_lock\_session.minimum**(gauge)                                      | MySQL MDL lock blocked sessions.*Shown as connection*                                                                                                      |
| **alibabacloud.rds.my\_sql\_mdl\_lock\_session.maximum**(gauge)                                      | MySQL MDL lock blocked sessions.*Shown as connection*                                                                                                      |
| **alibabacloud.rds.my\_sql\_network\_in\_new.average**(rate)                                         | MySQL inbound network traffic per second.*Shown as bit*                                                                                                    |
| **alibabacloud.rds.my\_sql\_network\_in\_new.minimum**(rate)                                         | MySQL inbound network traffic per second.*Shown as bit*                                                                                                    |
| **alibabacloud.rds.my\_sql\_network\_in\_new.maximum**(rate)                                         | MySQL inbound network traffic per second.*Shown as bit*                                                                                                    |
| **alibabacloud.rds.my\_sql\_network\_out\_new.average**(rate)                                        | MySQL outbound network traffic per second.*Shown as bit*                                                                                                   |
| **alibabacloud.rds.my\_sql\_network\_out\_new.minimum**(rate)                                        | MySQL outbound network traffic per second.*Shown as bit*                                                                                                   |
| **alibabacloud.rds.my\_sql\_network\_out\_new.maximum**(rate)                                        | MySQL outbound network traffic per second.*Shown as bit*                                                                                                   |
| **alibabacloud.rds.my\_sql\_open\_files.average**(gauge)                                             | MySQL open files.*Shown as file*                                                                                                                           |
| **alibabacloud.rds.my\_sql\_open\_files.minimum**(gauge)                                             | MySQL open files.*Shown as file*                                                                                                                           |
| **alibabacloud.rds.my\_sql\_open\_files.maximum**(gauge)                                             | MySQL open files.*Shown as file*                                                                                                                           |
| **alibabacloud.rds.my\_sql\_open\_tables.average**(gauge)                                            | MySQL open tables.*Shown as table*                                                                                                                         |
| **alibabacloud.rds.my\_sql\_open\_tables.minimum**(gauge)                                            | MySQL open tables.*Shown as table*                                                                                                                         |
| **alibabacloud.rds.my\_sql\_open\_tables.maximum**(gauge)                                            | MySQL open tables.*Shown as table*                                                                                                                         |
| **alibabacloud.rds.my\_sql\_other\_disk\_size.average**(gauge)                                       | MySQL other disk size.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_other\_disk\_size.minimum**(gauge)                                       | MySQL other disk size.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_other\_disk\_size.maximum**(gauge)                                       | MySQL other disk size.*Shown as mebibyte*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_proxy\_cpu\_utilization.average**(gauge)                                 | MySQL proxy CPU utilization.*Shown as percent*                                                                                                             |
| **alibabacloud.rds.my\_sql\_proxy\_cpu\_utilization.minimum**(gauge)                                 | MySQL proxy CPU utilization.*Shown as percent*                                                                                                             |
| **alibabacloud.rds.my\_sql\_proxy\_cpu\_utilization.maximum**(gauge)                                 | MySQL proxy CPU utilization.*Shown as percent*                                                                                                             |
| **alibabacloud.rds.my\_sql\_proxy\_cpu\_usage.average**(gauge)                                       | MySQL proxy CPU usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_proxy\_cpu\_usage.minimum**(gauge)                                       | MySQL proxy CPU usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_proxy\_cpu\_usage.maximum**(gauge)                                       | MySQL proxy CPU usage.*Shown as percent*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_qps.average**(rate)                                                      | MySQL queries per second.*Shown as query*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_qps.minimum**(rate)                                                      | MySQL queries per second.*Shown as query*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_qps.maximum**(rate)                                                      | MySQL queries per second.*Shown as query*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_redo\_log\_size.average**(gauge)                                         | MySQL redo log size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_redo\_log\_size.minimum**(gauge)                                         | MySQL redo log size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_redo\_log\_size.maximum**(gauge)                                         | MySQL redo log size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_relay\_log\_size.average**(gauge)                                        | MySQL relay log size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_relay\_log\_size.minimum**(gauge)                                        | MySQL relay log size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_relay\_log\_size.maximum**(gauge)                                        | MySQL relay log size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_select\_scan.average**(rate)                                             | MySQL full table scans per second.*Shown as operation*                                                                                                     |
| **alibabacloud.rds.my\_sql\_select\_scan.minimum**(rate)                                             | MySQL full table scans per second.*Shown as operation*                                                                                                     |
| **alibabacloud.rds.my\_sql\_select\_scan.maximum**(rate)                                             | MySQL full table scans per second.*Shown as operation*                                                                                                     |
| **alibabacloud.rds.my\_sql\_slave\_io\_running.average**(gauge)                                      | MySQL slave IO running status.*Shown as unit*                                                                                                              |
| **alibabacloud.rds.my\_sql\_slave\_io\_running.minimum**(gauge)                                      | MySQL slave IO running status.*Shown as unit*                                                                                                              |
| **alibabacloud.rds.my\_sql\_slave\_io\_running.maximum**(gauge)                                      | MySQL slave IO running status.*Shown as unit*                                                                                                              |
| **alibabacloud.rds.my\_sql\_slave\_sql\_running.average**(gauge)                                     | MySQL slave SQL running status.*Shown as unit*                                                                                                             |
| **alibabacloud.rds.my\_sql\_slave\_sql\_running.minimum**(gauge)                                     | MySQL slave SQL running status.*Shown as unit*                                                                                                             |
| **alibabacloud.rds.my\_sql\_slave\_sql\_running.maximum**(gauge)                                     | MySQL slave SQL running status.*Shown as unit*                                                                                                             |
| **alibabacloud.rds.my\_sql\_slow\_log\_size.average**(gauge)                                         | MySQL slow log size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_slow\_log\_size.minimum**(gauge)                                         | MySQL slow log size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_slow\_log\_size.maximum**(gauge)                                         | MySQL slow log size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_slow\_queries.average**(rate)                                            | MySQL slow queries per second.*Shown as query*                                                                                                             |
| **alibabacloud.rds.my\_sql\_slow\_queries.minimum**(rate)                                            | MySQL slow queries per second.*Shown as query*                                                                                                             |
| **alibabacloud.rds.my\_sql\_slow\_queries.maximum**(rate)                                            | MySQL slow queries per second.*Shown as query*                                                                                                             |
| **alibabacloud.rds.my\_sql\_standby\_sync\_lag.average**(gauge)                                      | MySQL standby sync lag.*Shown as second*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_standby\_sync\_lag.minimum**(gauge)                                      | MySQL standby sync lag.*Shown as second*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_standby\_sync\_lag.maximum**(gauge)                                      | MySQL standby sync lag.*Shown as second*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_sys\_data\_size.average**(gauge)                                         | MySQL system data size.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_sys\_data\_size.minimum**(gauge)                                         | MySQL system data size.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_sys\_data\_size.maximum**(gauge)                                         | MySQL system data size.*Shown as mebibyte*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_tps.average**(rate)                                                      | MySQL transactions per second.*Shown as transaction*                                                                                                       |
| **alibabacloud.rds.my\_sql\_tps.minimum**(rate)                                                      | MySQL transactions per second.*Shown as transaction*                                                                                                       |
| **alibabacloud.rds.my\_sql\_tps.maximum**(rate)                                                      | MySQL transactions per second.*Shown as transaction*                                                                                                       |
| **alibabacloud.rds.my\_sql\_temp\_disk\_table\_creates.average**(rate)                               | MySQL temp disk tables created per second.*Shown as table*                                                                                                 |
| **alibabacloud.rds.my\_sql\_temp\_disk\_table\_creates.minimum**(rate)                               | MySQL temp disk tables created per second.*Shown as table*                                                                                                 |
| **alibabacloud.rds.my\_sql\_temp\_disk\_table\_creates.maximum**(rate)                               | MySQL temp disk tables created per second.*Shown as table*                                                                                                 |
| **alibabacloud.rds.my\_sql\_temp\_file\_size.average**(gauge)                                        | MySQL temp file size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_temp\_file\_size.minimum**(gauge)                                        | MySQL temp file size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_temp\_file\_size.maximum**(gauge)                                        | MySQL temp file size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_threads\_connected.average**(gauge)                                      | MySQL connected threads.*Shown as thread*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_threads\_connected.minimum**(gauge)                                      | MySQL connected threads.*Shown as thread*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_threads\_connected.maximum**(gauge)                                      | MySQL connected threads.*Shown as thread*                                                                                                                  |
| **alibabacloud.rds.my\_sql\_threads\_running.average**(gauge)                                        | MySQL running threads.*Shown as thread*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_threads\_running.minimum**(gauge)                                        | MySQL running threads.*Shown as thread*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_threads\_running.maximum**(gauge)                                        | MySQL running threads.*Shown as thread*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_tmp\_disk\_size.average**(gauge)                                         | MySQL tmp disk size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_tmp\_disk\_size.minimum**(gauge)                                         | MySQL tmp disk size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_tmp\_disk\_size.maximum**(gauge)                                         | MySQL tmp disk size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_total\_sessions.average**(gauge)                                         | MySQL total sessions.*Shown as connection*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_total\_sessions.minimum**(gauge)                                         | MySQL total sessions.*Shown as connection*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_total\_sessions.maximum**(gauge)                                         | MySQL total sessions.*Shown as connection*                                                                                                                 |
| **alibabacloud.rds.my\_sql\_undo\_log\_size.average**(gauge)                                         | MySQL undo log size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_undo\_log\_size.minimum**(gauge)                                         | MySQL undo log size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_undo\_log\_size.maximum**(gauge)                                         | MySQL undo log size.*Shown as mebibyte*                                                                                                                    |
| **alibabacloud.rds.my\_sql\_user\_data\_size.average**(gauge)                                        | MySQL user data size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_user\_data\_size.minimum**(gauge)                                        | MySQL user data size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_user\_data\_size.maximum**(gauge)                                        | MySQL user data size.*Shown as mebibyte*                                                                                                                   |
| **alibabacloud.rds.my\_sql\_ibuf\_pool\_reads.average**(rate)                                        | MySQL buffer pool reads per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_ibuf\_pool\_reads.minimum**(rate)                                        | MySQL buffer pool reads per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.my\_sql\_ibuf\_pool\_reads.maximum**(rate)                                        | MySQL buffer pool reads per second.*Shown as operation*                                                                                                    |
| **alibabacloud.rds.sql\_server\_active\_session.average**(gauge)                                     | SQLServer active sessions.*Shown as connection*                                                                                                            |
| **alibabacloud.rds.sql\_server\_active\_session.minimum**(gauge)                                     | SQLServer active sessions.*Shown as connection*                                                                                                            |
| **alibabacloud.rds.sql\_server\_active\_session.maximum**(gauge)                                     | SQLServer active sessions.*Shown as connection*                                                                                                            |
| **alibabacloud.rds.sql\_server\_ag\_sync\_lag\_secs.average**(gauge)                                 | SQLServer AG sync lag.*Shown as second*                                                                                                                    |
| **alibabacloud.rds.sql\_server\_ag\_sync\_lag\_secs.minimum**(gauge)                                 | SQLServer AG sync lag.*Shown as second*                                                                                                                    |
| **alibabacloud.rds.sql\_server\_ag\_sync\_lag\_secs.maximum**(gauge)                                 | SQLServer AG sync lag.*Shown as second*                                                                                                                    |
| **alibabacloud.rds.sql\_server\_buffer\_cache\_hit\_ratio.average**(gauge)                           | SQLServer buffer cache hit ratio.*Shown as percent*                                                                                                        |
| **alibabacloud.rds.sql\_server\_buffer\_cache\_hit\_ratio.minimum**(gauge)                           | SQLServer buffer cache hit ratio.*Shown as percent*                                                                                                        |
| **alibabacloud.rds.sql\_server\_buffer\_cache\_hit\_ratio.maximum**(gauge)                           | SQLServer buffer cache hit ratio.*Shown as percent*                                                                                                        |
| **alibabacloud.rds.sql\_server\_cache\_hit\_ratio.average**(gauge)                                   | SQLServer cache hit ratio.*Shown as percent*                                                                                                               |
| **alibabacloud.rds.sql\_server\_cache\_hit\_ratio.minimum**(gauge)                                   | SQLServer cache hit ratio.*Shown as percent*                                                                                                               |
| **alibabacloud.rds.sql\_server\_cache\_hit\_ratio.maximum**(gauge)                                   | SQLServer cache hit ratio.*Shown as percent*                                                                                                               |
| **alibabacloud.rds.sql\_server\_checkpoint\_pages\_rer\_sec.average**(rate)                          | SQLServer checkpoint pages per second.*Shown as page*                                                                                                      |
| **alibabacloud.rds.sql\_server\_checkpoint\_pages\_rer\_sec.minimum**(rate)                          | SQLServer checkpoint pages per second.*Shown as page*                                                                                                      |
| **alibabacloud.rds.sql\_server\_checkpoint\_pages\_rer\_sec.maximum**(rate)                          | SQLServer checkpoint pages per second.*Shown as page*                                                                                                      |
| **alibabacloud.rds.sql\_server\_cpu\_usage.average**(gauge)                                          | SQLServer CPU usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.rds.sql\_server\_cpu\_usage.minimum**(gauge)                                          | SQLServer CPU usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.rds.sql\_server\_cpu\_usage.maximum**(gauge)                                          | SQLServer CPU usage.*Shown as percent*                                                                                                                     |
| **alibabacloud.rds.sql\_server\_disk\_usage.average**(gauge)                                         | SQLServer disk usage.*Shown as percent*                                                                                                                    |
| **alibabacloud.rds.sql\_server\_disk\_usage.minimum**(gauge)                                         | SQLServer disk usage.*Shown as percent*                                                                                                                    |
| **alibabacloud.rds.sql\_server\_disk\_usage.maximum**(gauge)                                         | SQLServer disk usage.*Shown as percent*                                                                                                                    |
| **alibabacloud.rds.sql\_server\_full\_scans.average**(rate)                                          | SQLServer full scans per second.*Shown as operation*                                                                                                       |
| **alibabacloud.rds.sql\_server\_full\_scans.minimum**(rate)                                          | SQLServer full scans per second.*Shown as operation*                                                                                                       |
| **alibabacloud.rds.sql\_server\_full\_scans.maximum**(rate)                                          | SQLServer full scans per second.*Shown as operation*                                                                                                       |
| **alibabacloud.rds.sql\_server\_iops.average**(rate)                                                 | SQLServer IOPS.*Shown as operation*                                                                                                                        |
| **alibabacloud.rds.sql\_server\_iops.minimum**(rate)                                                 | SQLServer IOPS.*Shown as operation*                                                                                                                        |
| **alibabacloud.rds.sql\_server\_iops.maximum**(rate)                                                 | SQLServer IOPS.*Shown as operation*                                                                                                                        |
| **alibabacloud.rds.sql\_server\_iops\_usage\_burst.average**(gauge)                                  | SQLServer IOPS usage with burst.*Shown as percent*                                                                                                         |
| **alibabacloud.rds.sql\_server\_iops\_usage\_burst.minimum**(gauge)                                  | SQLServer IOPS usage with burst.*Shown as percent*                                                                                                         |
| **alibabacloud.rds.sql\_server\_iops\_usage\_burst.maximum**(gauge)                                  | SQLServer IOPS usage with burst.*Shown as percent*                                                                                                         |
| **alibabacloud.rds.sql\_server\_iops\_usage\_no\_burst.average**(gauge)                              | SQLServer IOPS usage without burst.*Shown as percent*                                                                                                      |
| **alibabacloud.rds.sql\_server\_iops\_usage\_no\_burst.minimum**(gauge)                              | SQLServer IOPS usage without burst.*Shown as percent*                                                                                                      |
| **alibabacloud.rds.sql\_server\_iops\_usage\_no\_burst.maximum**(gauge)                              | SQLServer IOPS usage without burst.*Shown as percent*                                                                                                      |
| **alibabacloud.rds.sql\_server\_lazy\_writes\_per\_sec.average**(rate)                               | SQLServer lazy writes per second.*Shown as operation*                                                                                                      |
| **alibabacloud.rds.sql\_server\_lazy\_writes\_per\_sec.minimum**(rate)                               | SQLServer lazy writes per second.*Shown as operation*                                                                                                      |
| **alibabacloud.rds.sql\_server\_lazy\_writes\_per\_sec.maximum**(rate)                               | SQLServer lazy writes per second.*Shown as operation*                                                                                                      |
| **alibabacloud.rds.sql\_server\_lock\_timeouts\_per\_sec.average**(rate)                             | SQLServer lock timeouts per second.*Shown as timeout*                                                                                                      |
| **alibabacloud.rds.sql\_server\_lock\_timeouts\_per\_sec.minimum**(rate)                             | SQLServer lock timeouts per second.*Shown as timeout*                                                                                                      |
| **alibabacloud.rds.sql\_server\_lock\_timeouts\_per\_sec.maximum**(rate)                             | SQLServer lock timeouts per second.*Shown as timeout*                                                                                                      |
| **alibabacloud.rds.sql\_server\_lock\_waits\_per\_sec.average**(rate)                                | SQLServer lock waits per second.*Shown as wait*                                                                                                            |
| **alibabacloud.rds.sql\_server\_lock\_waits\_per\_sec.minimum**(rate)                                | SQLServer lock waits per second.*Shown as wait*                                                                                                            |
| **alibabacloud.rds.sql\_server\_lock\_waits\_per\_sec.maximum**(rate)                                | SQLServer lock waits per second.*Shown as wait*                                                                                                            |
| **alibabacloud.rds.sql\_server\_logins\_per\_sec.average**(rate)                                     | SQLServer logins per second.*Shown as operation*                                                                                                           |
| **alibabacloud.rds.sql\_server\_logins\_per\_sec.minimum**(rate)                                     | SQLServer logins per second.*Shown as operation*                                                                                                           |
| **alibabacloud.rds.sql\_server\_logins\_per\_sec.maximum**(rate)                                     | SQLServer logins per second.*Shown as operation*                                                                                                           |
| **alibabacloud.rds.sql\_server\_logouts\_per\_sec.average**(rate)                                    | SQLServer logouts per second.*Shown as operation*                                                                                                          |
| **alibabacloud.rds.sql\_server\_logouts\_per\_sec.minimum**(rate)                                    | SQLServer logouts per second.*Shown as operation*                                                                                                          |
| **alibabacloud.rds.sql\_server\_logouts\_per\_sec.maximum**(rate)                                    | SQLServer logouts per second.*Shown as operation*                                                                                                          |
| **alibabacloud.rds.sql\_server\_mbps.average**(rate)                                                 | SQLServer MBPS.*Shown as mebibyte*                                                                                                                         |
| **alibabacloud.rds.sql\_server\_mbps.minimum**(rate)                                                 | SQLServer MBPS.*Shown as mebibyte*                                                                                                                         |
| **alibabacloud.rds.sql\_server\_mbps.maximum**(rate)                                                 | SQLServer MBPS.*Shown as mebibyte*                                                                                                                         |
| **alibabacloud.rds.sql\_server\_mbps\_usage\_burst.average**(gauge)                                  | SQLServer MBPS usage with burst.*Shown as percent*                                                                                                         |
| **alibabacloud.rds.sql\_server\_mbps\_usage\_burst.minimum**(gauge)                                  | SQLServer MBPS usage with burst.*Shown as percent*                                                                                                         |
| **alibabacloud.rds.sql\_server\_mbps\_usage\_burst.maximum**(gauge)                                  | SQLServer MBPS usage with burst.*Shown as percent*                                                                                                         |
| **alibabacloud.rds.sql\_server\_mbps\_usage\_no\_burst.average**(gauge)                              | SQLServer MBPS usage without burst.*Shown as percent*                                                                                                      |
| **alibabacloud.rds.sql\_server\_mbps\_usage\_no\_burst.minimum**(gauge)                              | SQLServer MBPS usage without burst.*Shown as percent*                                                                                                      |
| **alibabacloud.rds.sql\_server\_mbps\_usage\_no\_burst.maximum**(gauge)                              | SQLServer MBPS usage without burst.*Shown as percent*                                                                                                      |
| **alibabacloud.rds.sql\_server\_memory\_usage.average**(gauge)                                       | SQLServer memory usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.rds.sql\_server\_memory\_usage.minimum**(gauge)                                       | SQLServer memory usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.rds.sql\_server\_memory\_usage.maximum**(gauge)                                       | SQLServer memory usage.*Shown as percent*                                                                                                                  |
| **alibabacloud.rds.sql\_server\_network\_in\_new.average**(rate)                                     | SQLServer inbound network traffic per second.*Shown as bit*                                                                                                |
| **alibabacloud.rds.sql\_server\_network\_in\_new.minimum**(rate)                                     | SQLServer inbound network traffic per second.*Shown as bit*                                                                                                |
| **alibabacloud.rds.sql\_server\_network\_in\_new.maximum**(rate)                                     | SQLServer inbound network traffic per second.*Shown as bit*                                                                                                |
| **alibabacloud.rds.sql\_server\_network\_out\_new.average**(rate)                                    | SQLServer outbound network traffic per second.*Shown as bit*                                                                                               |
| **alibabacloud.rds.sql\_server\_network\_out\_new.minimum**(rate)                                    | SQLServer outbound network traffic per second.*Shown as bit*                                                                                               |
| **alibabacloud.rds.sql\_server\_network\_out\_new.maximum**(rate)                                    | SQLServer outbound network traffic per second.*Shown as bit*                                                                                               |
| **alibabacloud.rds.sql\_server\_network\_read.average**(rate)                                        | SQLServer network read.*Shown as bit*                                                                                                                      |
| **alibabacloud.rds.sql\_server\_network\_read.minimum**(rate)                                        | SQLServer network read.*Shown as bit*                                                                                                                      |
| **alibabacloud.rds.sql\_server\_network\_read.maximum**(rate)                                        | SQLServer network read.*Shown as bit*                                                                                                                      |
| **alibabacloud.rds.sql\_server\_network\_write.average**(rate)                                       | SQLServer network write.*Shown as bit*                                                                                                                     |
| **alibabacloud.rds.sql\_server\_network\_write.minimum**(rate)                                       | SQLServer network write.*Shown as bit*                                                                                                                     |
| **alibabacloud.rds.sql\_server\_network\_write.maximum**(rate)                                       | SQLServer network write.*Shown as bit*                                                                                                                     |
| **alibabacloud.rds.sql\_server\_number\_of\_deadlocks\_per\_sec.average**(rate)                      | SQLServer deadlocks per second.*Shown as lock*                                                                                                             |
| **alibabacloud.rds.sql\_server\_number\_of\_deadlocks\_per\_sec.minimum**(rate)                      | SQLServer deadlocks per second.*Shown as lock*                                                                                                             |
| **alibabacloud.rds.sql\_server\_number\_of\_deadlocks\_per\_sec.maximum**(rate)                      | SQLServer deadlocks per second.*Shown as lock*                                                                                                             |
| **alibabacloud.rds.sql\_server\_qps.average**(rate)                                                  | SQLServer queries per second.*Shown as query*                                                                                                              |
| **alibabacloud.rds.sql\_server\_qps.minimum**(rate)                                                  | SQLServer queries per second.*Shown as query*                                                                                                              |
| **alibabacloud.rds.sql\_server\_qps.maximum**(rate)                                                  | SQLServer queries per second.*Shown as query*                                                                                                              |
| **alibabacloud.rds.sql\_server\_sql\_compilations.average**(rate)                                    | SQLServer SQL compilations per second.*Shown as operation*                                                                                                 |
| **alibabacloud.rds.sql\_server\_sql\_compilations.minimum**(rate)                                    | SQLServer SQL compilations per second.*Shown as operation*                                                                                                 |
| **alibabacloud.rds.sql\_server\_sql\_compilations.maximum**(rate)                                    | SQLServer SQL compilations per second.*Shown as operation*                                                                                                 |
| **alibabacloud.rds.sql\_server\_tps.average**(rate)                                                  | SQLServer transactions per second.*Shown as transaction*                                                                                                   |
| **alibabacloud.rds.sql\_server\_tps.minimum**(rate)                                                  | SQLServer transactions per second.*Shown as transaction*                                                                                                   |
| **alibabacloud.rds.sql\_server\_tps.maximum**(rate)                                                  | SQLServer transactions per second.*Shown as transaction*                                                                                                   |
| **alibabacloud.rds.sql\_server\_tota\_conn.average**(gauge)                                          | SQLServer total connections.*Shown as connection*                                                                                                          |
| **alibabacloud.rds.sql\_server\_tota\_conn.minimum**(gauge)                                          | SQLServer total connections.*Shown as connection*                                                                                                          |
| **alibabacloud.rds.sql\_server\_tota\_conn.maximum**(gauge)                                          | SQLServer total connections.*Shown as connection*                                                                                                          |
| **alibabacloud.slb.heathy\_server\_count.average**(gauge)                                            | Number of healthy backend ECS instances.*Shown as instance*                                                                                                |
| **alibabacloud.slb.heathy\_server\_count.minimum**(gauge)                                            | Number of healthy backend ECS instances.*Shown as instance*                                                                                                |
| **alibabacloud.slb.heathy\_server\_count.maximum**(gauge)                                            | Number of healthy backend ECS instances.*Shown as instance*                                                                                                |
| **alibabacloud.slb.unhealthy\_server\_count.average**(gauge)                                         | Number of faulty backend ECS instances.*Shown as instance*                                                                                                 |
| **alibabacloud.slb.unhealthy\_server\_count.minimum**(gauge)                                         | Number of faulty backend ECS instances.*Shown as instance*                                                                                                 |
| **alibabacloud.slb.unhealthy\_server\_count.maximum**(gauge)                                         | Number of faulty backend ECS instances.*Shown as instance*                                                                                                 |
| **alibabacloud.slb.packet\_tx.average**(rate)                                                        | Number of outgoing packets per second on the port.*Shown as packet*                                                                                        |
| **alibabacloud.slb.packet\_tx.minimum**(rate)                                                        | Number of outgoing packets per second on the port.*Shown as packet*                                                                                        |
| **alibabacloud.slb.packet\_tx.maximum**(rate)                                                        | Number of outgoing packets per second on the port.*Shown as packet*                                                                                        |
| **alibabacloud.slb.packet\_rx.average**(rate)                                                        | Number of incoming packets per second on the port.*Shown as packet*                                                                                        |
| **alibabacloud.slb.packet\_rx.minimum**(rate)                                                        | Number of incoming packets per second on the port.*Shown as packet*                                                                                        |
| **alibabacloud.slb.packet\_rx.maximum**(rate)                                                        | Number of incoming packets per second on the port.*Shown as packet*                                                                                        |
| **alibabacloud.slb.traffic\_rx\_new.average**(rate)                                                  | Inbound data volume per second on the port.*Shown as bit*                                                                                                  |
| **alibabacloud.slb.traffic\_rx\_new.minimum**(rate)                                                  | Inbound data volume per second on the port.*Shown as bit*                                                                                                  |
| **alibabacloud.slb.traffic\_rx\_new.maximum**(rate)                                                  | Inbound data volume per second on the port.*Shown as bit*                                                                                                  |
| **alibabacloud.slb.traffic\_tx\_new.average**(rate)                                                  | Outbound data volume per second on the port.*Shown as bit*                                                                                                 |
| **alibabacloud.slb.traffic\_tx\_new.minimum**(rate)                                                  | Outbound data volume per second on the port.*Shown as bit*                                                                                                 |
| **alibabacloud.slb.traffic\_tx\_new.maximum**(rate)                                                  | Outbound data volume per second on the port.*Shown as bit*                                                                                                 |
| **alibabacloud.slb.active\_connection.average**(gauge)                                               | Number of active connections on the port, that is, the number of connections that clients set up to access Server Load Balancer.*Shown as connection*      |
| **alibabacloud.slb.active\_connection.minimum**(gauge)                                               | Number of active connections on the port, that is, the number of connections that clients set up to access Server Load Balancer.*Shown as connection*      |
| **alibabacloud.slb.active\_connection.maximum**(gauge)                                               | Number of active connections on the port, that is, the number of connections that clients set up to access Server Load Balancer.*Shown as connection*      |
| **alibabacloud.slb.inactive\_connection.average**(gauge)                                             | Number of inactive connections on the port, that is, the number of connections that are idle after access to Server Load Balancer.*Shown as connection*    |
| **alibabacloud.slb.inactive\_connection.minimum**(gauge)                                             | Number of inactive connections on the port, that is, the number of connections that are idle after access to Server Load Balancer.*Shown as connection*    |
| **alibabacloud.slb.inactive\_connection.maximum**(gauge)                                             | Number of inactive connections on the port, that is, the number of connections that are idle after access to Server Load Balancer.*Shown as connection*    |
| **alibabacloud.slb.new\_connection.average**(gauge)                                                  | Current number of new connections on the port.*Shown as connection*                                                                                        |
| **alibabacloud.slb.new\_connection.minimum**(gauge)                                                  | Current number of new connections on the port.*Shown as connection*                                                                                        |
| **alibabacloud.slb.new\_connection.maximum**(gauge)                                                  | Current number of new connections on the port.*Shown as connection*                                                                                        |
| **alibabacloud.slb.max\_connection.average**(gauge)                                                  | Number of concurrent connections on the port.*Shown as connection*                                                                                         |
| **alibabacloud.slb.max\_connection.minimum**(gauge)                                                  | Number of concurrent connections on the port.*Shown as connection*                                                                                         |
| **alibabacloud.slb.max\_connection.maximum**(gauge)                                                  | Number of concurrent connections on the port.*Shown as connection*                                                                                         |
| **alibabacloud.slb.drop\_connection.average**(rate)                                                  | Number of dropped connections per second during monitoring.*Shown as connection*                                                                           |
| **alibabacloud.slb.drop\_connection.minimum**(rate)                                                  | Number of dropped connections per second during monitoring.*Shown as connection*                                                                           |
| **alibabacloud.slb.drop\_connection.maximum**(rate)                                                  | Number of dropped connections per second during monitoring.*Shown as connection*                                                                           |
| **alibabacloud.slb.drop\_packet\_rx.average**(rate)                                                  | Number of dropped incoming packets per second during monitoring.*Shown as packet*                                                                          |
| **alibabacloud.slb.drop\_packet\_rx.minimum**(rate)                                                  | Number of dropped incoming packets per second during monitoring.*Shown as packet*                                                                          |
| **alibabacloud.slb.drop\_packet\_rx.maximum**(rate)                                                  | Number of dropped incoming packets per second during monitoring.*Shown as packet*                                                                          |
| **alibabacloud.slb.drop\_packet\_tx.average**(rate)                                                  | Number of dropped outgoing packets per second during monitoring.*Shown as packet*                                                                          |
| **alibabacloud.slb.drop\_packet\_tx.minimum**(rate)                                                  | Number of dropped outgoing packets per second during monitoring.*Shown as packet*                                                                          |
| **alibabacloud.slb.drop\_packet\_tx.maximum**(rate)                                                  | Number of dropped outgoing packets per second during monitoring.*Shown as packet*                                                                          |
| **alibabacloud.slb.drop\_traffic\_rx.average**(rate)                                                 | Number of dropped incoming bits per second during monitoring.*Shown as bit*                                                                                |
| **alibabacloud.slb.drop\_traffic\_rx.minimum**(rate)                                                 | Number of dropped incoming bits per second during monitoring.*Shown as bit*                                                                                |
| **alibabacloud.slb.drop\_traffic\_rx.maximum**(rate)                                                 | Number of dropped incoming bits per second during monitoring.*Shown as bit*                                                                                |
| **alibabacloud.slb.drop\_traffic\_tx.average**(rate)                                                 | Number of dropped outgoing bits per second during monitoring.*Shown as bit*                                                                                |
| **alibabacloud.slb.drop\_traffic\_tx.minimum**(rate)                                                 | Number of dropped outgoing bits per second during monitoring.*Shown as bit*                                                                                |
| **alibabacloud.slb.drop\_traffic\_tx.maximum**(rate)                                                 | Number of dropped outgoing bits per second during monitoring.*Shown as bit*                                                                                |
| **alibabacloud.slb.instance\_active\_connection.average**(rate)                                      | Number of active connections per second on the instance.*Shown as connection*                                                                              |
| **alibabacloud.slb.instance\_active\_connection.minimum**(rate)                                      | Number of active connections per second on the instance.*Shown as connection*                                                                              |
| **alibabacloud.slb.instance\_active\_connection.maximum**(rate)                                      | Number of active connections per second on the instance.*Shown as connection*                                                                              |
| **alibabacloud.slb.instance\_drop\_connection.average**(rate)                                        | Number of dropped connections per second on the instance.*Shown as connection*                                                                             |
| **alibabacloud.slb.instance\_drop\_connection.minimum**(rate)                                        | Number of dropped connections per second on the instance.*Shown as connection*                                                                             |
| **alibabacloud.slb.instance\_drop\_connection.maximum**(rate)                                        | Number of dropped connections per second on the instance.*Shown as connection*                                                                             |
| **alibabacloud.slb.instance\_drop\_packet\_rx.average**(rate)                                        | Number of dropped incoming packets per second on the instance.*Shown as packet*                                                                            |
| **alibabacloud.slb.instance\_drop\_packet\_rx.minimum**(rate)                                        | Number of dropped incoming packets per second on the instance.*Shown as packet*                                                                            |
| **alibabacloud.slb.instance\_drop\_packet\_rx.maximum**(rate)                                        | Number of dropped incoming packets per second on the instance.*Shown as packet*                                                                            |
| **alibabacloud.slb.instance\_drop\_packet\_tx.average**(rate)                                        | Number of dropped outgoing packets per second on the instance.*Shown as packet*                                                                            |
| **alibabacloud.slb.instance\_drop\_packet\_tx.minimum**(rate)                                        | Number of dropped outgoing packets per second on the instance.*Shown as packet*                                                                            |
| **alibabacloud.slb.instance\_drop\_packet\_tx.maximum**(rate)                                        | Number of dropped outgoing packets per second on the instance.*Shown as packet*                                                                            |
| **alibabacloud.slb.instance\_drop\_traffic\_rx.average**(rate)                                       | Number of dropped incoming bits per second on the instance.*Shown as bit*                                                                                  |
| **alibabacloud.slb.instance\_drop\_traffic\_rx.minimum**(rate)                                       | Number of dropped incoming bits per second on the instance.*Shown as bit*                                                                                  |
| **alibabacloud.slb.instance\_drop\_traffic\_rx.maximum**(rate)                                       | Number of dropped incoming bits per second on the instance.*Shown as bit*                                                                                  |
| **alibabacloud.slb.instance\_drop\_traffic\_tx.average**(rate)                                       | Number of dropped outgoing bits per second on the instance.*Shown as bit*                                                                                  |
| **alibabacloud.slb.instance\_drop\_traffic\_tx.minimum**(rate)                                       | Number of dropped outgoing bits per second on the instance.*Shown as bit*                                                                                  |
| **alibabacloud.slb.instance\_drop\_traffic\_tx.maximum**(rate)                                       | Number of dropped outgoing bits per second on the instance.*Shown as bit*                                                                                  |
| **alibabacloud.slb.instance\_inactive\_connection.average**(rate)                                    | Number of inactive connections per second on the instance.*Shown as connection*                                                                            |
| **alibabacloud.slb.instance\_inactive\_connection.minimum**(rate)                                    | Number of inactive connections per second on the instance.*Shown as connection*                                                                            |
| **alibabacloud.slb.instance\_inactive\_connection.maximum**(rate)                                    | Number of inactive connections per second on the instance.*Shown as connection*                                                                            |
| **alibabacloud.slb.instance\_max\_connection.average**(rate)                                         | Maximum number of concurrent connections per second on the instance.*Shown as connection*                                                                  |
| **alibabacloud.slb.instance\_max\_connection.minimum**(rate)                                         | Maximum number of concurrent connections per second on the instance.*Shown as connection*                                                                  |
| **alibabacloud.slb.instance\_max\_connection.maximum**(rate)                                         | Maximum number of concurrent connections per second on the instance.*Shown as connection*                                                                  |
| **alibabacloud.slb.instance\_new\_connection.average**(rate)                                         | Number of new connections per second on the instance.*Shown as connection*                                                                                 |
| **alibabacloud.slb.instance\_new\_connection.minimum**(rate)                                         | Number of new connections per second on the instance.*Shown as connection*                                                                                 |
| **alibabacloud.slb.instance\_new\_connection.maximum**(rate)                                         | Number of new connections per second on the instance.*Shown as connection*                                                                                 |
| **alibabacloud.slb.instance\_packet\_rx.average**(rate)                                              | Number of incoming packets per second on the instance.*Shown as packet*                                                                                    |
| **alibabacloud.slb.instance\_packet\_rx.minimum**(rate)                                              | Number of incoming packets per second on the instance.*Shown as packet*                                                                                    |
| **alibabacloud.slb.instance\_packet\_rx.maximum**(rate)                                              | Number of incoming packets per second on the instance.*Shown as packet*                                                                                    |
| **alibabacloud.slb.instance\_packet\_tx.average**(rate)                                              | Number of outgoing packets per second on the instance.*Shown as packet*                                                                                    |
| **alibabacloud.slb.instance\_packet\_tx.minimum**(rate)                                              | Number of outgoing packets per second on the instance.*Shown as packet*                                                                                    |
| **alibabacloud.slb.instance\_packet\_tx.maximum**(rate)                                              | Number of outgoing packets per second on the instance.*Shown as packet*                                                                                    |
| **alibabacloud.slb.instance\_traffic\_rx.average**(rate)                                             | Number of incoming bits per second on the instance.*Shown as bit*                                                                                          |
| **alibabacloud.slb.instance\_traffic\_rx.minimum**(rate)                                             | Number of incoming bits per second on the instance.*Shown as bit*                                                                                          |
| **alibabacloud.slb.instance\_traffic\_rx.maximum**(rate)                                             | Number of incoming bits per second on the instance.*Shown as bit*                                                                                          |
| **alibabacloud.slb.instance\_traffic\_tx.average**(rate)                                             | Number of outgoing bits per second on the instance.*Shown as bit*                                                                                          |
| **alibabacloud.slb.instance\_traffic\_tx.minimum**(rate)                                             | Number of outgoing bits per second on the instance.*Shown as bit*                                                                                          |
| **alibabacloud.slb.instance\_traffic\_tx.maximum**(rate)                                             | Number of outgoing bits per second on the instance.*Shown as bit*                                                                                          |
| **alibabacloud.slb.qps.average**(rate)                                                               | Layer 7 protocol port queries per second.*Shown as query*                                                                                                  |
| **alibabacloud.slb.rt.average**(gauge)                                                               | Layer 7 protocol port response time.*Shown as millisecond*                                                                                                 |
| **alibabacloud.slb.status\_code2xx.average**(rate)                                                   | Layer 7 protocol port 2xx status codes.                                                                                                                    |
| **alibabacloud.slb.status\_code3xx.average**(rate)                                                   | Layer 7 protocol port 3xx status codes.                                                                                                                    |
| **alibabacloud.slb.status\_code4xx.average**(rate)                                                   | Layer 7 protocol port 4xx status codes.                                                                                                                    |
| **alibabacloud.slb.status\_code5xx.average**(rate)                                                   | Layer 7 protocol port 5xx status codes.                                                                                                                    |
| **alibabacloud.slb.status\_code\_other.average**(rate)                                               | Layer 7 protocol port other codes.                                                                                                                         |
| **alibabacloud.slb.upstream\_code4xx.average**(rate)                                                 | Layer 7 protocol port upstream 4xx status codes.                                                                                                           |
| **alibabacloud.slb.upstream\_code5xx.average**(rate)                                                 | Layer 7 protocol port upstream 5xx status codes.                                                                                                           |
| **alibabacloud.slb.upstream\_rt.average**(gauge)                                                     | Layer 7 protocol port upstream response time.*Shown as millisecond*                                                                                        |
| **alibabacloud.slb.instance\_qps.average**(rate)                                                     | Layer 7 protocol instance queries per second.*Shown as query*                                                                                              |
| **alibabacloud.slb.instance\_rt.average**(gauge)                                                     | Layer 7 protocol instance response time.*Shown as millisecond*                                                                                             |
| **alibabacloud.slb.instance\_status\_code2xx.average**(rate)                                         | Layer 7 protocol instance 2xx status codes.                                                                                                                |
| **alibabacloud.slb.instance\_status\_code3xx.average**(rate)                                         | Layer 7 protocol instance 3xx status codes.                                                                                                                |
| **alibabacloud.slb.instance\_status\_code4xx.average**(rate)                                         | Layer 7 protocol instance 4xx status codes.                                                                                                                |
| **alibabacloud.slb.instance\_status\_code5xx.average**(rate)                                         | Layer 7 protocol instance 5xx status codes.                                                                                                                |
| **alibabacloud.slb.instance\_status\_code\_other.average**(rate)                                     | Layer 7 protocol instance other status codes.                                                                                                              |
| **alibabacloud.slb.instance\_upstream\_code4xx.average**(rate)                                       | Layer 7 protocol instance upstream 4xx status codes.                                                                                                       |
| **alibabacloud.slb.instance\_upstream\_code5xx.average**(rate)                                       | Layer 7 protocol instance upstream 5xx status codes.                                                                                                       |
| **alibabacloud.slb.instance\_upstream\_rt.average**(gauge)                                           | Layer 7 protocol instance upstream response time.*Shown as millisecond*                                                                                    |
| **alibabacloud.eip.net\_rx.rate**(rate)                                                              | Inbound bandwidth.*Shown as bit*                                                                                                                           |
| **alibabacloud.eip.net\_rx\_pkgs.rate**(rate)                                                        | Inbound Packet Rate.*Shown as packet*                                                                                                                      |
| **alibabacloud.eip.net\_tx.rate**(rate)                                                              | Outbound Bandwidth.*Shown as bit*                                                                                                                          |
| **alibabacloud.eip.net\_tx\_pkgs.rate**(rate)                                                        | Outbound Packet Rate.*Shown as packet*                                                                                                                     |
| **alibabacloud.eip.out\_ratelimit\_drop\_speed.minimum**(rate)                                       | Outbound Rate-Limited Packet Drop Rate.*Shown as packet*                                                                                                   |
| **alibabacloud.eip.out\_ratelimit\_drop\_speed.maximum**(rate)                                       | Outbound Rate-Limited Packet Drop Rate.*Shown as packet*                                                                                                   |
| **alibabacloud.eip.out\_ratelimit\_drop\_speed.average**(rate)                                       | Outbound Rate-Limited Packet Drop Rate.*Shown as packet*                                                                                                   |

### Events{% #events %}

Events from Alibaba Cloud are collected on a per Alibaba Cloud-service basis.

## Troubleshooting{% #troubleshooting %}

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

## Further Reading{% #further-reading %}

- [Monitor Alibaba Cloud with Datadog](https://www.datadoghq.com/blog/monitor-alibaba-cloud-datadog/)
