---
title: Alibaba Cloud MongoDB
description: >-
  Monitor Alibaba Cloud ApsaraDB for MongoDB connections, CPU, memory,
  read/write latency, and cache metrics.
breadcrumbs: Docs > Integrations > Alibaba Cloud MongoDB
---

# Alibaba Cloud MongoDB
Integration version1.0.0
{% callout %}
# Important note for users on the following Datadog sites: us2.ddog-gov.com

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

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

{% /callout %}

## Overview{% #overview %}

Alibaba Cloud ApsaraDB for MongoDB is a fully managed, highly available document database service compatible with MongoDB. It supports replica set and sharded cluster deployments with automatic failover, backup, and scaling.

This integration allows you to monitor connections, CPU utilization, memory usage, read/write latency, and cache performance across your MongoDB instances to ensure availability and performance.

## Setup{% #setup %}

### Installation{% #installation %}

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

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

### Metrics{% #metrics %}

|  |
|  |
| **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**(gauge)                                        | The latency of processing all successful requests.*Shown as microsecond*                      |
| **alibabacloud.mongodb.commands\_latency\_ps.maximum**(gauge)                                        | The latency of processing all successful requests.*Shown as microsecond*                      |
| **alibabacloud.mongodb.commands\_latency\_ps.minimum**(gauge)                                        | The latency of processing all successful requests.*Shown as microsecond*                      |
| **alibabacloud.mongodb.commands\_latency\_ps\_node.average**(gauge)                                  | The latency of processing all successful requests.*Shown as microsecond*                      |
| **alibabacloud.mongodb.commands\_latency\_ps\_node.maximum**(gauge)                                  | The latency of processing all successful requests.*Shown as microsecond*                      |
| **alibabacloud.mongodb.commands\_latency\_ps\_node.minimum**(gauge)                                  | The latency of processing all successful requests.*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**(gauge)                                           | Reads latency.*Shown as microsecond*                                                          |
| **alibabacloud.mongodb.reads\_latency\_ps.maximum**(gauge)                                           | Reads latency.*Shown as microsecond*                                                          |
| **alibabacloud.mongodb.reads\_latency\_ps.minimum**(gauge)                                           | Reads latency.*Shown as microsecond*                                                          |
| **alibabacloud.mongodb.reads\_latency\_ps\_node.average**(gauge)                                     | Reads latency on node.*Shown as microsecond*                                                  |
| **alibabacloud.mongodb.reads\_latency\_ps\_node.maximum**(gauge)                                     | Reads latency on node.*Shown as microsecond*                                                  |
| **alibabacloud.mongodb.reads\_latency\_ps\_node.minimum**(gauge)                                     | Reads latency 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**(gauge)                                           | Transaction latency.*Shown as microsecond*                                                    |
| **alibabacloud.mongodb.trans\_latency\_ps.maximum**(gauge)                                           | Transaction latency.*Shown as microsecond*                                                    |
| **alibabacloud.mongodb.trans\_latency\_ps.minimum**(gauge)                                           | Transaction latency.*Shown as microsecond*                                                    |
| **alibabacloud.mongodb.trans\_latency\_ps\_node.average**(gauge)                                     | Transaction latency on node.*Shown as microsecond*                                            |
| **alibabacloud.mongodb.trans\_latency\_ps\_node.maximum**(gauge)                                     | Transaction latency on node.*Shown as microsecond*                                            |
| **alibabacloud.mongodb.trans\_latency\_ps\_node.minimum**(gauge)                                     | Transaction latency 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**(gauge)                                          | Writes latency.*Shown as microsecond*                                                         |
| **alibabacloud.mongodb.writes\_latency\_ps.maximum**(gauge)                                          | Writes latency.*Shown as microsecond*                                                         |
| **alibabacloud.mongodb.writes\_latency\_ps.minimum**(gauge)                                          | Writes latency.*Shown as microsecond*                                                         |
| **alibabacloud.mongodb.writes\_latency\_ps\_node.average**(gauge)                                    | Writes latency on node.*Shown as microsecond*                                                 |
| **alibabacloud.mongodb.writes\_latency\_ps\_node.maximum**(gauge)                                    | Writes latency on node.*Shown as microsecond*                                                 |
| **alibabacloud.mongodb.writes\_latency\_ps\_node.minimum**(gauge)                                    | Writes latency 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**(gauge)                              | Sharding commands latency.*Shown as microsecond*                                              |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps.maximum**(gauge)                              | Sharding commands latency.*Shown as microsecond*                                              |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps.minimum**(gauge)                              | Sharding commands latency.*Shown as microsecond*                                              |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps\_node.average**(gauge)                        | Sharding commands latency on node.*Shown as microsecond*                                      |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps\_node.maximum**(gauge)                        | Sharding commands latency on node.*Shown as microsecond*                                      |
| **alibabacloud.mongodb.sharding\_commands\_latency\_ps\_node.minimum**(gauge)                        | Sharding commands latency 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**(gauge)                                 | Sharding reads latency.*Shown as microsecond*                                                 |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps.maximum**(gauge)                                 | Sharding reads latency.*Shown as microsecond*                                                 |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps.minimum**(gauge)                                 | Sharding reads latency.*Shown as microsecond*                                                 |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps\_node.average**(gauge)                           | Sharding reads latency on node.*Shown as microsecond*                                         |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps\_node.maximum**(gauge)                           | Sharding reads latency on node.*Shown as microsecond*                                         |
| **alibabacloud.mongodb.sharding\_reads\_latency\_ps\_node.minimum**(gauge)                           | Sharding reads latency 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**(gauge)                                 | Sharding transaction latency.*Shown as microsecond*                                           |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps.maximum**(gauge)                                 | Sharding transaction latency.*Shown as microsecond*                                           |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps.minimum**(gauge)                                 | Sharding transaction latency.*Shown as microsecond*                                           |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps\_node.average**(gauge)                           | Sharding transaction latency on node.*Shown as microsecond*                                   |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps\_node.maximum**(gauge)                           | Sharding transaction latency on node.*Shown as microsecond*                                   |
| **alibabacloud.mongodb.sharding\_trans\_latency\_ps\_node.minimum**(gauge)                           | Sharding transaction latency 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**(gauge)                                | Sharding writes latency.*Shown as microsecond*                                                |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps.maximum**(gauge)                                | Sharding writes latency.*Shown as microsecond*                                                |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps.minimum**(gauge)                                | Sharding writes latency.*Shown as microsecond*                                                |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps\_node.average**(gauge)                          | Sharding writes latency on node.*Shown as microsecond*                                        |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps\_node.maximum**(gauge)                          | Sharding writes latency on node.*Shown as microsecond*                                        |
| **alibabacloud.mongodb.sharding\_writes\_latency\_ps\_node.minimum**(gauge)                          | Sharding writes latency 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*                                               |

### Events{% #events %}

Alibaba Cloud MongoDB does not include any events.

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

Alibaba Cloud MongoDB does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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