---
title: Amazon MSK (Agent)
description: Monitor the health and performance of your Amazon MSK clusters.
breadcrumbs: Docs > Integrations > Amazon MSK (Agent)
---

# Amazon MSK (Agent)
Supported OS Integration version7.5.0
## Overview{% #overview %}

Amazon Managed Streaming for Apache Kafka (MSK) is a fully managed service that makes it easy to build and run applications that use Apache Kafka to process streaming data.

You can collect metrics from this integration in two ways-with the Datadog Agent or with a [Crawler](https://docs.datadoghq.com/integrations/amazon_msk) that collects metrics from CloudWatch.

Consider [Data Streams Monitoring](https://docs.datadoghq.com/data_streams/) to enhance your MSK integration. This solution enables pipeline visualization and lag tracking, helping you identify and resolve bottlenecks.

**Minimum Agent version:** 7.16.1

## Setup{% #setup %}

The Agent check monitors Amazon Managed Streaming for Apache Kafka ([Amazon MSK](https://aws.amazon.com/msk)) through the Datadog Agent.

Follow the instructions below to install and configure this check for an Agent running on a host. For containerized environments, see the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations/) for guidance on applying these instructions.

This OpenMetrics-based integration has a latest mode (`use_openmetrics`: true) and a legacy mode (`use_openmetrics`: false). To get all the most up-to-date features, Datadog recommends enabling the latest mode. For more information, see [Latest and Legacy Versioning For OpenMetrics-based Integrations](https://docs.datadoghq.com/integrations/guide/versions-for-openmetrics-based-integrations).

### Installation{% #installation %}

1. [Create a client machine](https://docs.aws.amazon.com/msk/latest/developerguide/create-client-machine.html) if one does not already exist.
1. Ensure the client machine has been [granted](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role) the permission policy [arn:aws:iam::aws:policy/AmazonMSKReadOnlyAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonMSKReadOnlyAccess) or equivalent [credentials](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#configuring-credentials) are available.
1. Enable [open monitoring with Prometheus](https://docs.aws.amazon.com/msk/latest/developerguide/open-monitoring.html) on the MSK side to enable the JmxExporter and the NodeExporter.
1. Install the [Datadog Agent](https://docs.datadoghq.com/agent/) on the client machine just created.

### Configuration{% #configuration %}

1. Edit the `amazon_msk.d/conf.yaml` file, in the `conf.d/` folder at the root of your Agent's configuration directory to start collecting your Amazon MSK performance data.

Include custom [tags](https://docs.datadoghq.com/getting_started/tagging/) that attach to every metric and service check provided by this integration.

   ```
   tags:
     - <KEY_1>:<VALUE_1>
     - <KEY_2>:<VALUE_2>
   ```

See the [sample amazon_msk.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/amazon_msk/datadog_checks/amazon_msk/data/conf.yaml.example) for all available configuration options for the latest mode. For the legacy mode of this integration, see the [legacy example](https://github.com/DataDog/integrations-core/blob/7.31.x/amazon_msk/datadog_checks/amazon_msk/data/conf.yaml.example).

1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent).

### Validation{% #validation %}

[Run the Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information) and look for `amazon_msk` under the Checks section.

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

### Metrics{% #metrics %}

|  |
|  |
| **aws.msk.go.gc.duration.seconds.count**(count)                                                      | GC invocation durations count. This is a count on OpenMetricsV2 and a gauge on OpenMetricsV1.                                                                                                                                                              |
| **aws.msk.go.gc.duration.seconds.quantile**(gauge)                                                   | GC invocation duration quantile.*Shown as second*                                                                                                                                                                                                          |
| **aws.msk.go.gc.duration.seconds.sum**(count)                                                        | GC invocation duration total. This is a count on OpenMetricsV2 and a gauge on OpenMetricsV1.*Shown as second*                                                                                                                                              |
| **aws.msk.go.goroutines**(gauge)                                                                     | Number of goroutines that currently exist.*Shown as thread*                                                                                                                                                                                                |
| **aws.msk.go.info**(gauge)                                                                           | Information about the Go environment.                                                                                                                                                                                                                      |
| **aws.msk.go.memstats.alloc.bytes**(gauge)                                                           | Number of bytes allocated and still in use.*Shown as byte*                                                                                                                                                                                                 |
| **aws.msk.go.memstats.alloc.bytes.count**(count)                                                     | [OpenMetricsV2] Total number of bytes allocated, even if freed.*Shown as byte*                                                                                                                                                                             |
| **aws.msk.go.memstats.alloc.bytes.total**(count)                                                     | [OpenMetricsV1] Total number of bytes allocated, even if freed.*Shown as byte*                                                                                                                                                                             |
| **aws.msk.go.memstats.buck.hash.sys.bytes**(gauge)                                                   | Number of bytes used by the profiling bucket hash table.*Shown as byte*                                                                                                                                                                                    |
| **aws.msk.go.memstats.frees.count**(count)                                                           | [OpenMetricsV2] Total number of frees.                                                                                                                                                                                                                     |
| **aws.msk.go.memstats.frees.total**(count)                                                           | Total number of frees.                                                                                                                                                                                                                                     |
| **aws.msk.go.memstats.gc.cpu.fraction**(gauge)                                                       | The fraction of this program's available CPU time used by the GC since the program started.                                                                                                                                                                |
| **aws.msk.go.memstats.gc.sys.bytes**(gauge)                                                          | Number of bytes used for garbage collection system metadata.*Shown as byte*                                                                                                                                                                                |
| **aws.msk.go.memstats.heap.alloc.bytes**(gauge)                                                      | Number of heap bytes allocated and still in use.*Shown as byte*                                                                                                                                                                                            |
| **aws.msk.go.memstats.heap.idle.bytes**(gauge)                                                       | Number of heap bytes waiting to be used.*Shown as byte*                                                                                                                                                                                                    |
| **aws.msk.go.memstats.heap.inuse.bytes**(gauge)                                                      | Number of heap bytes that are in use.*Shown as byte*                                                                                                                                                                                                       |
| **aws.msk.go.memstats.heap.objects**(gauge)                                                          | Number of allocated objects.                                                                                                                                                                                                                               |
| **aws.msk.go.memstats.heap.released.bytes**(gauge)                                                   | Number of heap bytes released to OS.*Shown as byte*                                                                                                                                                                                                        |
| **aws.msk.go.memstats.heap.sys.bytes**(gauge)                                                        | Number of heap bytes obtained from system.*Shown as byte*                                                                                                                                                                                                  |
| **aws.msk.go.memstats.last.gc.time.seconds**(gauge)                                                  | Number of seconds since 1970 of last garbage collection.*Shown as second*                                                                                                                                                                                  |
| **aws.msk.go.memstats.lookups.count**(count)                                                         | [OpenMetricsV2] Total number of pointer lookups.                                                                                                                                                                                                           |
| **aws.msk.go.memstats.lookups.total**(count)                                                         | [OpenMetricsV1] Total number of pointer lookups.                                                                                                                                                                                                           |
| **aws.msk.go.memstats.mallocs.count**(count)                                                         | [OpenMetricsV2] Total number of mallocs.                                                                                                                                                                                                                   |
| **aws.msk.go.memstats.mallocs.total**(count)                                                         | [OpenMetricsV1] Total number of mallocs.                                                                                                                                                                                                                   |
| **aws.msk.go.memstats.mcache.inuse.bytes**(gauge)                                                    | Number of bytes in use by mcache structures.*Shown as byte*                                                                                                                                                                                                |
| **aws.msk.go.memstats.mcache.sys.bytes**(gauge)                                                      | Number of bytes used for mcache structures obtained from system.*Shown as byte*                                                                                                                                                                            |
| **aws.msk.go.memstats.mspan.inuse.bytes**(gauge)                                                     | Number of bytes in use by mspan structures.*Shown as byte*                                                                                                                                                                                                 |
| **aws.msk.go.memstats.mspan.sys.bytes**(gauge)                                                       | Number of bytes used for mspan structures obtained from system.*Shown as byte*                                                                                                                                                                             |
| **aws.msk.go.memstats.next.gc.bytes**(gauge)                                                         | Number of heap bytes when next garbage collection will take place.*Shown as byte*                                                                                                                                                                          |
| **aws.msk.go.memstats.other.sys.bytes**(gauge)                                                       | Number of bytes used for other system allocations.*Shown as byte*                                                                                                                                                                                          |
| **aws.msk.go.memstats.stack.inuse.bytes**(gauge)                                                     | Number of bytes in use by the stack allocator.*Shown as byte*                                                                                                                                                                                              |
| **aws.msk.go.memstats.stack.sys.bytes**(gauge)                                                       | Number of bytes obtained from system for stack allocator.*Shown as byte*                                                                                                                                                                                   |
| **aws.msk.go.memstats.sys.bytes**(gauge)                                                             | Number of bytes obtained from system.*Shown as byte*                                                                                                                                                                                                       |
| **aws.msk.go.threads**(gauge)                                                                        | Number of OS threads created.*Shown as thread*                                                                                                                                                                                                             |
| **aws.msk.jmx.config.reload.failure.count**(count)                                                   | [OpenMetricsV2] Number of times configuration have failed to be reloaded.                                                                                                                                                                                  |
| **aws.msk.jmx.config.reload.failure.total**(count)                                                   | [OpenMetricsV1] Number of times configuration have failed to be reloaded.                                                                                                                                                                                  |
| **aws.msk.jmx.config.reload.success.count**(count)                                                   | [OpenMetricsV2] Number of times configuration have successfully been reloaded.                                                                                                                                                                             |
| **aws.msk.jmx.config.reload.success.total**(count)                                                   | [OpenMetricsV1] Number of times configuration have successfully been reloaded.                                                                                                                                                                             |
| **aws.msk.jmx.exporter.build.info**(gauge)                                                           | A metric with a constant '1' value labeled with the version of the JMX exporter.                                                                                                                                                                           |
| **aws.msk.jmx.scrape.duration.seconds**(gauge)                                                       | Time this JMX scrape took, in seconds.*Shown as second*                                                                                                                                                                                                    |
| **aws.msk.jmx.scrape.error**(gauge)                                                                  | Non-zero if this scrape failed.                                                                                                                                                                                                                            |
| **aws.msk.kafka.cluster.Partition.Value**(gauge)                                                     | Attribute exposed for management (kafka.cluster<type=Partition, name=InSyncReplicasCount, topic=test-topic-15, partition=70><>Value)                                                                                                                       |
| **aws.msk.kafka.consumer.group.ConsumerLagMetrics.Value**(gauge)                                     | Attribute exposed for management (kafka.consumer.group<type=ConsumerLagMetrics, name=EstimatedTimeLag, groupId=test-group, partition=1, topic=test-topic><>Value)                                                                                          |
| **aws.msk.kafka.controller.ControllerChannelManager.50thPercentile**(gauge)                          | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>50thPercentile)                                                                                                            |
| **aws.msk.kafka.controller.ControllerChannelManager.75thPercentile**(gauge)                          | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>75thPercentile)                                                                                                            |
| **aws.msk.kafka.controller.ControllerChannelManager.95thPercentile**(gauge)                          | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>95thPercentile)                                                                                                            |
| **aws.msk.kafka.controller.ControllerChannelManager.98thPercentile**(gauge)                          | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>98thPercentile)                                                                                                            |
| **aws.msk.kafka.controller.ControllerChannelManager.999thPercentile**(gauge)                         | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>999thPercentile)                                                                                                           |
| **aws.msk.kafka.controller.ControllerChannelManager.99thPercentile**(gauge)                          | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>99thPercentile)                                                                                                            |
| **aws.msk.kafka.controller.ControllerChannelManager.Count**(gauge)                                   | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>Count)                                                                                                                     |
| **aws.msk.kafka.controller.ControllerChannelManager.Count.count**(count)                             | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>Count) as monotonic count                                                                                                  |
| **aws.msk.kafka.controller.ControllerChannelManager.FifteenMinuteRate**(gauge)                       | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>FifteenMinuteRate)                                                                                                         |
| **aws.msk.kafka.controller.ControllerChannelManager.FiveMinuteRate**(gauge)                          | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>FiveMinuteRate)                                                                                                            |
| **aws.msk.kafka.controller.ControllerChannelManager.Max**(gauge)                                     | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>Max)                                                                                                                       |
| **aws.msk.kafka.controller.ControllerChannelManager.Mean**(gauge)                                    | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>Mean)                                                                                                                      |
| **aws.msk.kafka.controller.ControllerChannelManager.MeanRate**(gauge)                                | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>MeanRate)                                                                                                                  |
| **aws.msk.kafka.controller.ControllerChannelManager.Min**(gauge)                                     | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>Min)                                                                                                                       |
| **aws.msk.kafka.controller.ControllerChannelManager.OneMinuteRate**(gauge)                           | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>OneMinuteRate)                                                                                                             |
| **aws.msk.kafka.controller.ControllerChannelManager.StdDev**(gauge)                                  | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=RequestRateAndQueueTimeMs, broker-id=1><>StdDev)                                                                                                                    |
| **aws.msk.kafka.controller.ControllerChannelManager.Value**(gauge)                                   | Attribute exposed for management (kafka.controller<type=ControllerChannelManager, name=TotalQueueSize><>Value)                                                                                                                                             |
| **aws.msk.kafka.controller.ControllerEventManager.50thPercentile**(gauge)                            | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>50thPercentile)                                                                                                                                    |
| **aws.msk.kafka.controller.ControllerEventManager.75thPercentile**(gauge)                            | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>75thPercentile)                                                                                                                                    |
| **aws.msk.kafka.controller.ControllerEventManager.95thPercentile**(gauge)                            | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>95thPercentile)                                                                                                                                    |
| **aws.msk.kafka.controller.ControllerEventManager.98thPercentile**(gauge)                            | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>98thPercentile)                                                                                                                                    |
| **aws.msk.kafka.controller.ControllerEventManager.999thPercentile**(gauge)                           | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>999thPercentile)                                                                                                                                   |
| **aws.msk.kafka.controller.ControllerEventManager.99thPercentile**(gauge)                            | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>99thPercentile)                                                                                                                                    |
| **aws.msk.kafka.controller.ControllerEventManager.Count**(gauge)                                     | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>Count)                                                                                                                                             |
| **aws.msk.kafka.controller.ControllerEventManager.Count.count**(count)                               | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>Count) as monotonic count                                                                                                                          |
| **aws.msk.kafka.controller.ControllerEventManager.Max**(gauge)                                       | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>Max)                                                                                                                                               |
| **aws.msk.kafka.controller.ControllerEventManager.Mean**(gauge)                                      | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>Mean)                                                                                                                                              |
| **aws.msk.kafka.controller.ControllerEventManager.Min**(gauge)                                       | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>Min)                                                                                                                                               |
| **aws.msk.kafka.controller.ControllerEventManager.StdDev**(gauge)                                    | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueTimeMs><>StdDev)                                                                                                                                            |
| **aws.msk.kafka.controller.ControllerEventManager.Value**(gauge)                                     | Attribute exposed for management (kafka.controller<type=ControllerEventManager, name=EventQueueSize><>Value)                                                                                                                                               |
| **aws.msk.kafka.controller.ControllerStats.50thPercentile**(gauge)                                   | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>50thPercentile)                                                                                                                            |
| **aws.msk.kafka.controller.ControllerStats.75thPercentile**(gauge)                                   | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>75thPercentile)                                                                                                                            |
| **aws.msk.kafka.controller.ControllerStats.95thPercentile**(gauge)                                   | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>95thPercentile)                                                                                                                            |
| **aws.msk.kafka.controller.ControllerStats.98thPercentile**(gauge)                                   | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>98thPercentile)                                                                                                                            |
| **aws.msk.kafka.controller.ControllerStats.999thPercentile**(gauge)                                  | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>999thPercentile)                                                                                                                           |
| **aws.msk.kafka.controller.ControllerStats.99thPercentile**(gauge)                                   | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>99thPercentile)                                                                                                                            |
| **aws.msk.kafka.controller.ControllerStats.Count**(gauge)                                            | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>Count)                                                                                                                                     |
| **aws.msk.kafka.controller.ControllerStats.Count.count**(count)                                      | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>Count) as monotonic count                                                                                                                  |
| **aws.msk.kafka.controller.ControllerStats.FifteenMinuteRate**(gauge)                                | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>FifteenMinuteRate)                                                                                                                         |
| **aws.msk.kafka.controller.ControllerStats.FiveMinuteRate**(gauge)                                   | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>FiveMinuteRate)                                                                                                                            |
| **aws.msk.kafka.controller.ControllerStats.Max**(gauge)                                              | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>Max)                                                                                                                                       |
| **aws.msk.kafka.controller.ControllerStats.Mean**(gauge)                                             | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>Mean)                                                                                                                                      |
| **aws.msk.kafka.controller.ControllerStats.MeanRate**(gauge)                                         | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>MeanRate)                                                                                                                                  |
| **aws.msk.kafka.controller.ControllerStats.Min**(gauge)                                              | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>Min)                                                                                                                                       |
| **aws.msk.kafka.controller.ControllerStats.OneMinuteRate**(gauge)                                    | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>OneMinuteRate)                                                                                                                             |
| **aws.msk.kafka.controller.ControllerStats.StdDev**(gauge)                                           | Attribute exposed for management (kafka.controller<type=ControllerStats, name=ControlledShutdownRateAndTimeMs><>StdDev)                                                                                                                                    |
| **aws.msk.kafka.controller.KafkaController.Value**(gauge)                                            | Attribute exposed for management (kafka.controller<type=KafkaController, name=GlobalPartitionCount><>Value)                                                                                                                                                |
| **aws.msk.kafka.coordinator.group.GroupMetadataManager.Value**(gauge)                                | Attribute exposed for management (kafka.coordinator.group<type=GroupMetadataManager, name=NumGroupsDead><>Value)                                                                                                                                           |
| **aws.msk.kafka.coordinator.transaction.TransactionMarkerChannelManager.Value**(gauge)               | Attribute exposed for management (kafka.coordinator.transaction<type=TransactionMarkerChannelManager, name=LogAppendRetryQueueSize><>Value)                                                                                                                |
| **aws.msk.kafka.log.Log.Value**(gauge)                                                               | Attribute exposed for management (kafka.log<type=Log, name=LogStartOffset, topic=test-topic-5, partition=22><>Value)                                                                                                                                       |
| **aws.msk.kafka.log.LogCleaner.Value**(gauge)                                                        | Attribute exposed for management (kafka.log<type=LogCleaner, name=cleaner-recopy-percent><>Value)                                                                                                                                                          |
| **aws.msk.kafka.log.LogCleanerManager.Value**(gauge)                                                 | Attribute exposed for management (kafka.log<type=LogCleanerManager, name=max-dirty-percent><>Value)                                                                                                                                                        |
| **aws.msk.kafka.log.LogManager.Value**(gauge)                                                        | Attribute exposed for management (kafka.log<type=LogManager, name=OfflineLogDirectoryCount><>Value)                                                                                                                                                        |
| **aws.msk.kafka.network.Acceptor.Count**(gauge)                                                      | Attribute exposed for management (kafka.network<type=Acceptor, name=AcceptorBlockedPercent, listener=CLIENT><>Count)                                                                                                                                       |
| **aws.msk.kafka.network.Acceptor.Count.count**(count)                                                | Attribute exposed for management (kafka.network<type=Acceptor, name=AcceptorBlockedPercent, listener=CLIENT><>Count) as monotonic count                                                                                                                    |
| **aws.msk.kafka.network.Acceptor.FifteenMinuteRate**(gauge)                                          | Attribute exposed for management (kafka.network<type=Acceptor, name=AcceptorBlockedPercent, listener=CLIENT><>FifteenMinuteRate)                                                                                                                           |
| **aws.msk.kafka.network.Acceptor.FiveMinuteRate**(gauge)                                             | Attribute exposed for management (kafka.network<type=Acceptor, name=AcceptorBlockedPercent, listener=CLIENT><>FiveMinuteRate)                                                                                                                              |
| **aws.msk.kafka.network.Acceptor.MeanRate**(gauge)                                                   | Attribute exposed for management (kafka.network<type=Acceptor, name=AcceptorBlockedPercent, listener=CLIENT><>MeanRate)                                                                                                                                    |
| **aws.msk.kafka.network.Acceptor.OneMinuteRate**(gauge)                                              | Attribute exposed for management (kafka.network<type=Acceptor, name=AcceptorBlockedPercent, listener=CLIENT><>OneMinuteRate)                                                                                                                               |
| **aws.msk.kafka.network.Processor.Value**(gauge)                                                     | Attribute exposed for management (kafka.network<type=Processor, name=IdlePercent, networkProcessor=8><>Value)                                                                                                                                              |
| **aws.msk.kafka.network.RequestChannel.Value**(gauge)                                                | Attribute exposed for management (kafka.network<type=RequestChannel, name=ResponseQueueSize, processor=8><>Value)                                                                                                                                          |
| **aws.msk.kafka.network.RequestMetrics.50thPercentile**(gauge)                                       | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>50thPercentile)                                                                                                                        |
| **aws.msk.kafka.network.RequestMetrics.75thPercentile**(gauge)                                       | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>75thPercentile)                                                                                                                        |
| **aws.msk.kafka.network.RequestMetrics.95thPercentile**(gauge)                                       | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>95thPercentile)                                                                                                                        |
| **aws.msk.kafka.network.RequestMetrics.98thPercentile**(gauge)                                       | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>98thPercentile)                                                                                                                        |
| **aws.msk.kafka.network.RequestMetrics.999thPercentile**(gauge)                                      | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>999thPercentile)                                                                                                                       |
| **aws.msk.kafka.network.RequestMetrics.99thPercentile**(gauge)                                       | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>99thPercentile)                                                                                                                        |
| **aws.msk.kafka.network.RequestMetrics.Count**(gauge)                                                | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>Count)                                                                                                                                 |
| **aws.msk.kafka.network.RequestMetrics.Count.count**(count)                                          | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>Count) as monotonic count                                                                                                              |
| **aws.msk.kafka.network.RequestMetrics.FifteenMinuteRate**(gauge)                                    | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ErrorsPerSec, request=UpdateMetadata, error=NONE><>FifteenMinuteRate)                                                                                                            |
| **aws.msk.kafka.network.RequestMetrics.FiveMinuteRate**(gauge)                                       | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ErrorsPerSec, request=UpdateMetadata, error=NONE><>FiveMinuteRate)                                                                                                               |
| **aws.msk.kafka.network.RequestMetrics.Max**(gauge)                                                  | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>Max)                                                                                                                                   |
| **aws.msk.kafka.network.RequestMetrics.Mean**(gauge)                                                 | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>Mean)                                                                                                                                  |
| **aws.msk.kafka.network.RequestMetrics.MeanRate**(gauge)                                             | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ErrorsPerSec, request=UpdateMetadata, error=NONE><>MeanRate)                                                                                                                     |
| **aws.msk.kafka.network.RequestMetrics.Min**(gauge)                                                  | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>Min)                                                                                                                                   |
| **aws.msk.kafka.network.RequestMetrics.OneMinuteRate**(gauge)                                        | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ErrorsPerSec, request=UpdateMetadata, error=NONE><>OneMinuteRate)                                                                                                                |
| **aws.msk.kafka.network.RequestMetrics.StdDev**(gauge)                                               | Attribute exposed for management (kafka.network<type=RequestMetrics, name=ResponseQueueTimeMs, request=ListGroups><>StdDev)                                                                                                                                |
| **aws.msk.kafka.network.SocketServer.Value**(gauge)                                                  | Attribute exposed for management (kafka.network<type=SocketServer, name=ExpiredConnectionsKilledCount><>Value)                                                                                                                                             |
| **aws.msk.kafka.network.request.ErrorsPerSec**(gauge)                                                | *Shown as error*                                                                                                                                                                                                                                           |
| **aws.msk.kafka.network.request.ErrorsPerSec.count**(count)                                          | count version of aws.msk.kafka.network.request.ErrorsPerSec*Shown as error*                                                                                                                                                                                |
| **aws.msk.kafka.network.request.LocalTimeMs**(gauge)                                                 | *Shown as millisecond*                                                                                                                                                                                                                                     |
| **aws.msk.kafka.network.request.LocalTimeMs.count**(count)                                           | count version of aws.msk.kafka.network.request.LocalTimeMs*Shown as millisecond*                                                                                                                                                                           |
| **aws.msk.kafka.network.request.MessageConversionsTimeMs**(gauge)                                    | *Shown as millisecond*                                                                                                                                                                                                                                     |
| **aws.msk.kafka.network.request.MessageConversionsTimeMs.count**(count)                              | count version of aws.msk.kafka.network.request.MessageConversionsTimeMs*Shown as millisecond*                                                                                                                                                              |
| **aws.msk.kafka.network.request.RemoteTimeMs**(gauge)                                                | *Shown as millisecond*                                                                                                                                                                                                                                     |
| **aws.msk.kafka.network.request.RemoteTimeMs.count**(count)                                          | count version of aws.msk.kafka.network.request.RemoteTimeMs*Shown as millisecond*                                                                                                                                                                          |
| **aws.msk.kafka.network.request.RequestBytes**(gauge)                                                | *Shown as byte*                                                                                                                                                                                                                                            |
| **aws.msk.kafka.network.request.RequestBytes.count**(count)                                          | count version of aws.msk.kafka.network.request.RequestBytes*Shown as byte*                                                                                                                                                                                 |
| **aws.msk.kafka.network.request.RequestQueueTimeMs**(gauge)                                          | *Shown as millisecond*                                                                                                                                                                                                                                     |
| **aws.msk.kafka.network.request.RequestQueueTimeMs.count**(count)                                    | count version of aws.msk.kafka.network.request.RequestQueueTimeMs*Shown as millisecond*                                                                                                                                                                    |
| **aws.msk.kafka.network.request.RequestsPerSec**(gauge)                                              | *Shown as request*                                                                                                                                                                                                                                         |
| **aws.msk.kafka.network.request.RequestsPerSec.count**(count)                                        | count version of aws.msk.kafka.network.request.RequestsPerSec*Shown as request*                                                                                                                                                                            |
| **aws.msk.kafka.network.request.ResponseQueueTimeMs**(gauge)                                         | *Shown as millisecond*                                                                                                                                                                                                                                     |
| **aws.msk.kafka.network.request.ResponseQueueTimeMs.count**(count)                                   | count version of aws.msk.kafka.network.request.ResponseQueueTimeMs*Shown as millisecond*                                                                                                                                                                   |
| **aws.msk.kafka.network.request.ResponseSendTimeMs**(gauge)                                          | *Shown as millisecond*                                                                                                                                                                                                                                     |
| **aws.msk.kafka.network.request.ResponseSendTimeMs.count**(count)                                    | count version of aws.msk.kafka.network.request.ResponseSendTimeMs*Shown as millisecond*                                                                                                                                                                    |
| **aws.msk.kafka.network.request.TemporaryMemoryBytes**(gauge)                                        | *Shown as byte*                                                                                                                                                                                                                                            |
| **aws.msk.kafka.network.request.TemporaryMemoryBytes.count**(count)                                  | count version of aws.msk.kafka.network.request.TemporaryMemoryBytes*Shown as byte*                                                                                                                                                                         |
| **aws.msk.kafka.network.request.ThrottleTimeMs**(gauge)                                              | *Shown as millisecond*                                                                                                                                                                                                                                     |
| **aws.msk.kafka.network.request.ThrottleTimeMs.count**(count)                                        | count version of aws.msk.kafka.network.request.ThrottleTimeMs*Shown as millisecond*                                                                                                                                                                        |
| **aws.msk.kafka.network.request.TotalTimeMs**(gauge)                                                 | *Shown as millisecond*                                                                                                                                                                                                                                     |
| **aws.msk.kafka.network.request.TotalTimeMs.count**(count)                                           | count version of aws.msk.kafka.network.request.TotalTimeMs*Shown as millisecond*                                                                                                                                                                           |
| **aws.msk.kafka.security.SimpleAclAuthorizer.Count**(gauge)                                          | Attribute exposed for management (kafka.security<type=SimpleAclAuthorizer, name=ZooKeeperExpiresPerSec><>Count)                                                                                                                                            |
| **aws.msk.kafka.security.SimpleAclAuthorizer.Count.count**(count)                                    | Attribute exposed for management (kafka.security<type=SimpleAclAuthorizer, name=ZooKeeperExpiresPerSec><>Count) as monotonic count                                                                                                                         |
| **aws.msk.kafka.security.SimpleAclAuthorizer.FifteenMinuteRate**(gauge)                              | Attribute exposed for management (kafka.security<type=SimpleAclAuthorizer, name=ZooKeeperExpiresPerSec><>FifteenMinuteRate)                                                                                                                                |
| **aws.msk.kafka.security.SimpleAclAuthorizer.FiveMinuteRate**(gauge)                                 | Attribute exposed for management (kafka.security<type=SimpleAclAuthorizer, name=ZooKeeperExpiresPerSec><>FiveMinuteRate)                                                                                                                                   |
| **aws.msk.kafka.security.SimpleAclAuthorizer.MeanRate**(gauge)                                       | Attribute exposed for management (kafka.security<type=SimpleAclAuthorizer, name=ZooKeeperExpiresPerSec><>MeanRate)                                                                                                                                         |
| **aws.msk.kafka.security.SimpleAclAuthorizer.OneMinuteRate**(gauge)                                  | Attribute exposed for management (kafka.security<type=SimpleAclAuthorizer, name=ZooKeeperExpiresPerSec><>OneMinuteRate)                                                                                                                                    |
| **aws.msk.kafka.server.BrokerTopicMetrics.Count**(gauge)                                             | Attribute exposed for management (kafka.server<type=BrokerTopicMetrics, name=BytesInPerSec><>Count)                                                                                                                                                        |
| **aws.msk.kafka.server.BrokerTopicMetrics.Count.count**(count)                                       | Attribute exposed for management (kafka.server<type=BrokerTopicMetrics, name=BytesInPerSec><>Count) as monotonic count                                                                                                                                     |
| **aws.msk.kafka.server.BrokerTopicMetrics.FifteenMinuteRate**(gauge)                                 | Attribute exposed for management (kafka.server<type=BrokerTopicMetrics, name=BytesInPerSec><>FifteenMinuteRate)                                                                                                                                            |
| **aws.msk.kafka.server.BrokerTopicMetrics.FiveMinuteRate**(gauge)                                    | Attribute exposed for management (kafka.server<type=BrokerTopicMetrics, name=BytesInPerSec><>FiveMinuteRate)                                                                                                                                               |
| **aws.msk.kafka.server.BrokerTopicMetrics.MeanRate**(gauge)                                          | Attribute exposed for management (kafka.server<type=BrokerTopicMetrics, name=BytesInPerSec><>MeanRate)                                                                                                                                                     |
| **aws.msk.kafka.server.BrokerTopicMetrics.OneMinuteRate**(gauge)                                     | Attribute exposed for management (kafka.server<type=BrokerTopicMetrics, name=BytesInPerSec><>OneMinuteRate)                                                                                                                                                |
| **aws.msk.kafka.server.DelayedFetchMetrics.Count**(gauge)                                            | Attribute exposed for management (kafka.server<type=DelayedFetchMetrics, name=ExpiresPerSec, fetcherType=consumer><>Count)                                                                                                                                 |
| **aws.msk.kafka.server.DelayedFetchMetrics.Count.count**(count)                                      | Attribute exposed for management (kafka.server<type=DelayedFetchMetrics, name=ExpiresPerSec, fetcherType=consumer><>Count) as monotonic count                                                                                                              |
| **aws.msk.kafka.server.DelayedFetchMetrics.FifteenMinuteRate**(gauge)                                | Attribute exposed for management (kafka.server<type=DelayedFetchMetrics, name=ExpiresPerSec, fetcherType=consumer><>FifteenMinuteRate)                                                                                                                     |
| **aws.msk.kafka.server.DelayedFetchMetrics.FiveMinuteRate**(gauge)                                   | Attribute exposed for management (kafka.server<type=DelayedFetchMetrics, name=ExpiresPerSec, fetcherType=consumer><>FiveMinuteRate)                                                                                                                        |
| **aws.msk.kafka.server.DelayedFetchMetrics.MeanRate**(gauge)                                         | Attribute exposed for management (kafka.server<type=DelayedFetchMetrics, name=ExpiresPerSec, fetcherType=consumer><>MeanRate)                                                                                                                              |
| **aws.msk.kafka.server.DelayedFetchMetrics.OneMinuteRate**(gauge)                                    | Attribute exposed for management (kafka.server<type=DelayedFetchMetrics, name=ExpiresPerSec, fetcherType=consumer><>OneMinuteRate)                                                                                                                         |
| **aws.msk.kafka.server.DelayedOperationPurgatory.Value**(gauge)                                      | Attribute exposed for management (kafka.server<type=DelayedOperationPurgatory, name=PurgatorySize, delayedOperation=topic><>Value)                                                                                                                         |
| **aws.msk.kafka.server.Fetch.queue.size**(gauge)                                                     | Tracks the size of the delay queue (kafka.server<type=Fetch><>queue-size)                                                                                                                                                                                  |
| **aws.msk.kafka.server.FetchSessionCache.Count**(gauge)                                              | Attribute exposed for management (kafka.server<type=FetchSessionCache, name=IncrementalFetchSessionEvictionsPerSec><>Count)                                                                                                                                |
| **aws.msk.kafka.server.FetchSessionCache.Count.count**(count)                                        | Attribute exposed for management (kafka.server<type=FetchSessionCache, name=IncrementalFetchSessionEvictionsPerSec><>Count) as monotonic count                                                                                                             |
| **aws.msk.kafka.server.FetchSessionCache.FifteenMinuteRate**(gauge)                                  | Attribute exposed for management (kafka.server<type=FetchSessionCache, name=IncrementalFetchSessionEvictionsPerSec><>FifteenMinuteRate)                                                                                                                    |
| **aws.msk.kafka.server.FetchSessionCache.FiveMinuteRate**(gauge)                                     | Attribute exposed for management (kafka.server<type=FetchSessionCache, name=IncrementalFetchSessionEvictionsPerSec><>FiveMinuteRate)                                                                                                                       |
| **aws.msk.kafka.server.FetchSessionCache.MeanRate**(gauge)                                           | Attribute exposed for management (kafka.server<type=FetchSessionCache, name=IncrementalFetchSessionEvictionsPerSec><>MeanRate)                                                                                                                             |
| **aws.msk.kafka.server.FetchSessionCache.OneMinuteRate**(gauge)                                      | Attribute exposed for management (kafka.server<type=FetchSessionCache, name=IncrementalFetchSessionEvictionsPerSec><>OneMinuteRate)                                                                                                                        |
| **aws.msk.kafka.server.FetchSessionCache.Value**(gauge)                                              | Attribute exposed for management (kafka.server<type=FetchSessionCache, name=NumIncrementalFetchPartitionsCached><>Value)                                                                                                                                   |
| **aws.msk.kafka.server.FetcherLagMetrics.Value**(gauge)                                              | Attribute exposed for management (kafka.server<type=FetcherLagMetrics, name=ConsumerLag, clientId=ReplicaFetcherThread-1-3, topic=test-topic-13, partition=38><>Value)                                                                                     |
| **aws.msk.kafka.server.FetcherStats.Count**(gauge)                                                   | Attribute exposed for management (kafka.server<type=FetcherStats, name=RequestsPerSec, clientId=ReplicaFetcherThread-1-3, brokerHost=b-3-internal.kafka111cluster-vpc1-4.8fhm2b.c1.kafka.us-east-1.hnahas.net, brokerPort=9093><>Count)                    |
| **aws.msk.kafka.server.FetcherStats.Count.count**(count)                                             | Attribute exposed for management (kafka.server<type=FetcherStats, name=RequestsPerSec, clientId=ReplicaFetcherThread-1-3, brokerHost=b-3-internal.kafka111cluster-vpc1-4.8fhm2b.c1.kafka.us-east-1.hnahas.net, brokerPort=9093><>Count) as monotonic count |
| **aws.msk.kafka.server.FetcherStats.FifteenMinuteRate**(gauge)                                       | Attribute exposed for management (kafka.server<type=FetcherStats, name=RequestsPerSec, clientId=ReplicaFetcherThread-1-3, brokerHost=b-3-internal.kafka111cluster-vpc1-4.8fhm2b.c1.kafka.us-east-1.hnahas.net, brokerPort=9093><>FifteenMinuteRate)        |
| **aws.msk.kafka.server.FetcherStats.FiveMinuteRate**(gauge)                                          | Attribute exposed for management (kafka.server<type=FetcherStats, name=RequestsPerSec, clientId=ReplicaFetcherThread-1-3, brokerHost=b-3-internal.kafka111cluster-vpc1-4.8fhm2b.c1.kafka.us-east-1.hnahas.net, brokerPort=9093><>FiveMinuteRate)           |
| **aws.msk.kafka.server.FetcherStats.MeanRate**(gauge)                                                | Attribute exposed for management (kafka.server<type=FetcherStats, name=RequestsPerSec, clientId=ReplicaFetcherThread-1-3, brokerHost=b-3-internal.kafka111cluster-vpc1-4.8fhm2b.c1.kafka.us-east-1.hnahas.net, brokerPort=9093><>MeanRate)                 |
| **aws.msk.kafka.server.FetcherStats.OneMinuteRate**(gauge)                                           | Attribute exposed for management (kafka.server<type=FetcherStats, name=RequestsPerSec, clientId=ReplicaFetcherThread-1-3, brokerHost=b-3-internal.kafka111cluster-vpc1-4.8fhm2b.c1.kafka.us-east-1.hnahas.net, brokerPort=9093><>OneMinuteRate)            |
| **aws.msk.kafka.server.KafkaRequestHandlerPool.Count**(gauge)                                        | Attribute exposed for management (kafka.server<type=KafkaRequestHandlerPool, name=RequestHandlerAvgIdlePercent><>Count)                                                                                                                                    |
| **aws.msk.kafka.server.KafkaRequestHandlerPool.Count.count**(count)                                  | Attribute exposed for management (kafka.server<type=KafkaRequestHandlerPool, name=RequestHandlerAvgIdlePercent><>Count) as monotonic count                                                                                                                 |
| **aws.msk.kafka.server.KafkaRequestHandlerPool.FifteenMinuteRate**(gauge)                            | Attribute exposed for management (kafka.server<type=KafkaRequestHandlerPool, name=RequestHandlerAvgIdlePercent><>FifteenMinuteRate)                                                                                                                        |
| **aws.msk.kafka.server.KafkaRequestHandlerPool.FiveMinuteRate**(gauge)                               | Attribute exposed for management (kafka.server<type=KafkaRequestHandlerPool, name=RequestHandlerAvgIdlePercent><>FiveMinuteRate)                                                                                                                           |
| **aws.msk.kafka.server.KafkaRequestHandlerPool.MeanRate**(gauge)                                     | Attribute exposed for management (kafka.server<type=KafkaRequestHandlerPool, name=RequestHandlerAvgIdlePercent><>MeanRate)                                                                                                                                 |
| **aws.msk.kafka.server.KafkaRequestHandlerPool.OneMinuteRate**(gauge)                                | Attribute exposed for management (kafka.server<type=KafkaRequestHandlerPool, name=RequestHandlerAvgIdlePercent><>OneMinuteRate)                                                                                                                            |
| **aws.msk.kafka.server.KafkaServer.Value**(gauge)                                                    | Attribute exposed for management (kafka.server<type=KafkaServer, name=BrokerState><>Value)                                                                                                                                                                 |
| **aws.msk.kafka.server.LeaderReplication.byte.rate**(gauge)                                          | Tracking byte-rate for LeaderReplication (kafka.server<type=LeaderReplication><>byte-rate)                                                                                                                                                                 |
| **aws.msk.kafka.server.Produce.queue.size**(gauge)                                                   | Tracks the size of the delay queue (kafka.server<type=Produce><>queue-size)                                                                                                                                                                                |
| **aws.msk.kafka.server.ReplicaAlterLogDirsManager.Value**(gauge)                                     | Attribute exposed for management (kafka.server<type=ReplicaAlterLogDirsManager, name=MaxLag, clientId=ReplicaAlterLogDirs><>Value)                                                                                                                         |
| **aws.msk.kafka.server.ReplicaFetcherManager.Value**(gauge)                                          | Attribute exposed for management (kafka.server<type=ReplicaFetcherManager, name=MinFetchRate, clientId=Replica><>Value)                                                                                                                                    |
| **aws.msk.kafka.server.ReplicaManager.Count**(gauge)                                                 | Attribute exposed for management (kafka.server<type=ReplicaManager, name=IsrShrinksPerSec><>Count)                                                                                                                                                         |
| **aws.msk.kafka.server.ReplicaManager.Count.count**(count)                                           | Attribute exposed for management (kafka.server<type=ReplicaManager, name=IsrShrinksPerSec><>Count) as monotonic count                                                                                                                                      |
| **aws.msk.kafka.server.ReplicaManager.FifteenMinuteRate**(gauge)                                     | Attribute exposed for management (kafka.server<type=ReplicaManager, name=IsrShrinksPerSec><>FifteenMinuteRate)                                                                                                                                             |
| **aws.msk.kafka.server.ReplicaManager.FiveMinuteRate**(gauge)                                        | Attribute exposed for management (kafka.server<type=ReplicaManager, name=IsrShrinksPerSec><>FiveMinuteRate)                                                                                                                                                |
| **aws.msk.kafka.server.ReplicaManager.MeanRate**(gauge)                                              | Attribute exposed for management (kafka.server<type=ReplicaManager, name=IsrShrinksPerSec><>MeanRate)                                                                                                                                                      |
| **aws.msk.kafka.server.ReplicaManager.OneMinuteRate**(gauge)                                         | Attribute exposed for management (kafka.server<type=ReplicaManager, name=IsrShrinksPerSec><>OneMinuteRate)                                                                                                                                                 |
| **aws.msk.kafka.server.ReplicaManager.Value**(gauge)                                                 | Attribute exposed for management (kafka.server<type=ReplicaManager, name=OfflineReplicaCount><>Value)                                                                                                                                                      |
| **aws.msk.kafka.server.ReplicaManager.Value.count**(count)                                           | Attribute exposed for management (kafka.server<type=ReplicaManager, name=OfflineReplicaCount><>Value) as monotonic count                                                                                                                                   |
| **aws.msk.kafka.server.Request.queue.size**(gauge)                                                   | Tracks the size of the delay queue (kafka.server<type=Request><>queue-size)                                                                                                                                                                                |
| **aws.msk.kafka.server.SessionExpireListener.Count**(gauge)                                          | Attribute exposed for management (kafka.server<type=SessionExpireListener, name=ZooKeeperSaslAuthenticationsPerSec><>Count)                                                                                                                                |
| **aws.msk.kafka.server.SessionExpireListener.Count.count**(count)                                    | Attribute exposed for management (kafka.server<type=SessionExpireListener, name=ZooKeeperSaslAuthenticationsPerSec><>Count) as monotonic count                                                                                                             |
| **aws.msk.kafka.server.SessionExpireListener.FifteenMinuteRate**(gauge)                              | Attribute exposed for management (kafka.server<type=SessionExpireListener, name=ZooKeeperSaslAuthenticationsPerSec><>FifteenMinuteRate)                                                                                                                    |
| **aws.msk.kafka.server.SessionExpireListener.FiveMinuteRate**(gauge)                                 | Attribute exposed for management (kafka.server<type=SessionExpireListener, name=ZooKeeperSaslAuthenticationsPerSec><>FiveMinuteRate)                                                                                                                       |
| **aws.msk.kafka.server.SessionExpireListener.MeanRate**(gauge)                                       | Attribute exposed for management (kafka.server<type=SessionExpireListener, name=ZooKeeperSaslAuthenticationsPerSec><>MeanRate)                                                                                                                             |
| **aws.msk.kafka.server.SessionExpireListener.OneMinuteRate**(gauge)                                  | Attribute exposed for management (kafka.server<type=SessionExpireListener, name=ZooKeeperSaslAuthenticationsPerSec><>OneMinuteRate)                                                                                                                        |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.50thPercentile**(gauge)                                | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>50thPercentile)                                                                                                                               |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.75thPercentile**(gauge)                                | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>75thPercentile)                                                                                                                               |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.95thPercentile**(gauge)                                | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>95thPercentile)                                                                                                                               |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.98thPercentile**(gauge)                                | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>98thPercentile)                                                                                                                               |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.999thPercentile**(gauge)                               | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>999thPercentile)                                                                                                                              |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.99thPercentile**(gauge)                                | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>99thPercentile)                                                                                                                               |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.Count**(gauge)                                         | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>Count)                                                                                                                                        |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.Count.count**(count)                                   | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>Count) as monotonic count                                                                                                                     |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.Max**(gauge)                                           | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>Max)                                                                                                                                          |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.Mean**(gauge)                                          | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>Mean)                                                                                                                                         |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.Min**(gauge)                                           | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>Min)                                                                                                                                          |
| **aws.msk.kafka.server.ZooKeeperClientMetrics.StdDev**(gauge)                                        | Attribute exposed for management (kafka.server<type=ZooKeeperClientMetrics, name=ZooKeeperRequestLatencyMs><>StdDev)                                                                                                                                       |
| **aws.msk.kafka.server.broker\_topics.BytesInPerSec**(gauge)                                         | *Shown as byte*                                                                                                                                                                                                                                            |
| **aws.msk.kafka.server.broker\_topics.BytesInPerSec.count**(count)                                   | count version of aws.msk.kafka.server.broker_topics.BytesInPerSec*Shown as byte*                                                                                                                                                                           |
| **aws.msk.kafka.server.broker\_topics.BytesOutPerSec**(gauge)                                        | *Shown as byte*                                                                                                                                                                                                                                            |
| **aws.msk.kafka.server.broker\_topics.BytesOutPerSec.count**(count)                                  | count version of aws.msk.kafka.server.broker_topics.BytesOutPerSec*Shown as byte*                                                                                                                                                                          |
| **aws.msk.kafka.server.broker\_topics.BytesRejectedPerSec**(gauge)                                   | *Shown as byte*                                                                                                                                                                                                                                            |
| **aws.msk.kafka.server.broker\_topics.BytesRejectedPerSec.count**(count)                             | count version of aws.msk.kafka.server.broker_topics.BytesRejectedPerSec*Shown as byte*                                                                                                                                                                     |
| **aws.msk.kafka.server.broker\_topics.FailedFetchRequestsPerSec**(gauge)                             | *Shown as request*                                                                                                                                                                                                                                         |
| **aws.msk.kafka.server.broker\_topics.FailedFetchRequestsPerSec.count**(count)                       | count version of aws.msk.kafka.server.broker_topics.FailedFetchRequestsPerSec*Shown as request*                                                                                                                                                            |
| **aws.msk.kafka.server.broker\_topics.FailedProduceRequestsPerSec**(gauge)                           | *Shown as request*                                                                                                                                                                                                                                         |
| **aws.msk.kafka.server.broker\_topics.FailedProduceRequestsPerSec.count**(count)                     | count version of aws.msk.kafka.server.broker_topics.FailedProduceRequestsPerSec*Shown as request*                                                                                                                                                          |
| **aws.msk.kafka.server.broker\_topics.FetchMessageConversionsPerSec**(gauge)                         |
| **aws.msk.kafka.server.broker\_topics.FetchMessageConversionsPerSec.count**(count)                   | count version of aws.msk.kafka.server.broker_topics.FetchMessageConversionsPerSec                                                                                                                                                                          |
| **aws.msk.kafka.server.broker\_topics.MessagesInPerSec**(gauge)                                      | *Shown as message*                                                                                                                                                                                                                                         |
| **aws.msk.kafka.server.broker\_topics.MessagesInPerSec.count**(count)                                | count version of aws.msk.kafka.server.broker_topics.MessagesInPerSec*Shown as message*                                                                                                                                                                     |
| **aws.msk.kafka.server.broker\_topics.ProduceMessageConversionsPerSec**(gauge)                       |
| **aws.msk.kafka.server.broker\_topics.ProduceMessageConversionsPerSec.count**(count)                 | count version of aws.msk.kafka.server.broker_topics.ProduceMessageConversionsPerSec                                                                                                                                                                        |
| **aws.msk.kafka.server.broker\_topics.ReplicationBytesInPerSec**(gauge)                              | *Shown as byte*                                                                                                                                                                                                                                            |
| **aws.msk.kafka.server.broker\_topics.ReplicationBytesInPerSec.count**(count)                        | count version of aws.msk.kafka.server.broker_topics.ReplicationBytesInPerSec*Shown as byte*                                                                                                                                                                |
| **aws.msk.kafka.server.broker\_topics.ReplicationBytesOutPerSec**(gauge)                             | *Shown as byte*                                                                                                                                                                                                                                            |
| **aws.msk.kafka.server.broker\_topics.ReplicationBytesOutPerSec.count**(count)                       | count version of aws.msk.kafka.server.broker_topics.ReplicationBytesOutPerSec*Shown as byte*                                                                                                                                                               |
| **aws.msk.kafka.server.broker\_topics.TotalFetchRequestsPerSec**(gauge)                              | *Shown as byte*                                                                                                                                                                                                                                            |
| **aws.msk.kafka.server.broker\_topics.TotalFetchRequestsPerSec.count**(count)                        | count version of aws.msk.kafka.server.broker_topics.TotalFetchRequestsPerSec*Shown as byte*                                                                                                                                                                |
| **aws.msk.kafka.server.broker\_topics.TotalProduceRequestsPerSec**(gauge)                            | *Shown as byte*                                                                                                                                                                                                                                            |
| **aws.msk.kafka.server.broker\_topics.TotalProduceRequestsPerSec.count**(count)                      | count version of aws.msk.kafka.server.broker_topics.TotalProduceRequestsPerSec*Shown as byte*                                                                                                                                                              |
| **aws.msk.kafka.server.controller.channel.metrics.connection.close.rate**(gauge)                     | The number of connections closed per second (kafka.server<type=controller-channel-metrics, broker-id=3><>connection-close-rate)*Shown as connection*                                                                                                       |
| **aws.msk.kafka.server.controller.channel.metrics.connection.close.total**(gauge)                    | The total number of connections closed (kafka.server<type=controller-channel-metrics, broker-id=3><>connection-close-total)*Shown as connection*                                                                                                           |
| **aws.msk.kafka.server.controller.channel.metrics.connection.count**(gauge)                          | The current number of active connections. (kafka.server<type=controller-channel-metrics, broker-id=3><>connection-count)*Shown as connection*                                                                                                              |
| **aws.msk.kafka.server.controller.channel.metrics.connection.creation.rate**(gauge)                  | The number of new connections established per second (kafka.server<type=controller-channel-metrics, broker-id=3><>connection-creation-rate)                                                                                                                |
| **aws.msk.kafka.server.controller.channel.metrics.connection.creation.total**(gauge)                 | The total number of new connections established (kafka.server<type=controller-channel-metrics, broker-id=3><>connection-creation-total)                                                                                                                    |
| **aws.msk.kafka.server.controller.channel.metrics.failed.authentication.rate**(gauge)                | The number of connections with failed authentication per second (kafka.server<type=controller-channel-metrics, broker-id=3><>failed-authentication-rate)                                                                                                   |
| **aws.msk.kafka.server.controller.channel.metrics.failed.authentication.total**(gauge)               | The total number of connections with failed authentication (kafka.server<type=controller-channel-metrics, broker-id=3><>failed-authentication-total)                                                                                                       |
| **aws.msk.kafka.server.controller.channel.metrics.failed.reauthentication.rate**(gauge)              | The number of failed re-authentication of connections per second (kafka.server<type=controller-channel-metrics, broker-id=3><>failed-reauthentication-rate)                                                                                                |
| **aws.msk.kafka.server.controller.channel.metrics.failed.reauthentication.total**(gauge)             | The total number of failed re-authentication of connections (kafka.server<type=controller-channel-metrics, broker-id=3><>failed-reauthentication-total)                                                                                                    |
| **aws.msk.kafka.server.controller.channel.metrics.incoming.byte.rate**(gauge)                        | The number of bytes read off all sockets per second (kafka.server<type=controller-channel-metrics, broker-id=3><>incoming-byte-rate)*Shown as byte*                                                                                                        |
| **aws.msk.kafka.server.controller.channel.metrics.incoming.byte.total**(gauge)                       | The total number of bytes read off all sockets (kafka.server<type=controller-channel-metrics, broker-id=3><>incoming-byte-total)*Shown as byte*                                                                                                            |
| **aws.msk.kafka.server.controller.channel.metrics.io.ratio**(gauge)                                  | The fraction of time the I/O thread spent doing I/O (kafka.server<type=controller-channel-metrics, broker-id=3><>io-ratio)                                                                                                                                 |
| **aws.msk.kafka.server.controller.channel.metrics.io.time.ns.avg**(gauge)                            | The average length of time for I/O per select call in nanoseconds. (kafka.server<type=controller-channel-metrics, broker-id=3><>io-time-ns-avg)                                                                                                            |
| **aws.msk.kafka.server.controller.channel.metrics.io.wait.ratio**(gauge)                             | The fraction of time the I/O thread spent waiting (kafka.server<type=controller-channel-metrics, broker-id=3><>io-wait-ratio)                                                                                                                              |
| **aws.msk.kafka.server.controller.channel.metrics.io.wait.time.ns.avg**(gauge)                       | The average length of time the I/O thread spent waiting for a socket ready for reads or writes in nanoseconds. (kafka.server<type=controller-channel-metrics, broker-id=3><>io-wait-time-ns-avg)                                                           |
| **aws.msk.kafka.server.controller.channel.metrics.io.waittime.total**(gauge)                         | The total time the I/O thread spent waiting (kafka.server<type=controller-channel-metrics, broker-id=3><>io-waittime-total)                                                                                                                                |
| **aws.msk.kafka.server.controller.channel.metrics.iotime.total**(gauge)                              | The total time the I/O thread spent doing I/O (kafka.server<type=controller-channel-metrics, broker-id=3><>iotime-total)                                                                                                                                   |
| **aws.msk.kafka.server.controller.channel.metrics.network.io.rate**(gauge)                           | The number of network operations (reads or writes) on all connections per second (kafka.server<type=controller-channel-metrics, broker-id=3><>network-io-rate)                                                                                             |
| **aws.msk.kafka.server.controller.channel.metrics.network.io.total**(gauge)                          | The total number of network operations (reads or writes) on all connections (kafka.server<type=controller-channel-metrics, broker-id=3><>network-io-total)                                                                                                 |
| **aws.msk.kafka.server.controller.channel.metrics.outgoing.byte.rate**(gauge)                        | The number of outgoing bytes sent to all servers per second (kafka.server<type=controller-channel-metrics, broker-id=3><>outgoing-byte-rate)*Shown as byte*                                                                                                |
| **aws.msk.kafka.server.controller.channel.metrics.outgoing.byte.total**(gauge)                       | The total number of outgoing bytes sent to all servers (kafka.server<type=controller-channel-metrics, broker-id=3><>outgoing-byte-total)*Shown as byte*                                                                                                    |
| **aws.msk.kafka.server.controller.channel.metrics.reauthentication.latency.avg**(gauge)              | The average latency observed due to re-authentication (kafka.server<type=controller-channel-metrics, broker-id=3><>reauthentication-latency-avg)                                                                                                           |
| **aws.msk.kafka.server.controller.channel.metrics.reauthentication.latency.max**(gauge)              | The max latency observed due to re-authentication (kafka.server<type=controller-channel-metrics, broker-id=3><>reauthentication-latency-max)                                                                                                               |
| **aws.msk.kafka.server.controller.channel.metrics.request.rate**(gauge)                              | The number of requests sent per second (kafka.server<type=controller-channel-metrics, broker-id=3><>request-rate)                                                                                                                                          |
| **aws.msk.kafka.server.controller.channel.metrics.request.size.avg**(gauge)                          | The average size of requests sent. (kafka.server<type=controller-channel-metrics, broker-id=3><>request-size-avg)                                                                                                                                          |
| **aws.msk.kafka.server.controller.channel.metrics.request.size.max**(gauge)                          | The maximum size of any request sent. (kafka.server<type=controller-channel-metrics, broker-id=3><>request-size-max)                                                                                                                                       |
| **aws.msk.kafka.server.controller.channel.metrics.request.total**(gauge)                             | The total number of requests sent (kafka.server<type=controller-channel-metrics, broker-id=3><>request-total)                                                                                                                                              |
| **aws.msk.kafka.server.controller.channel.metrics.response.rate**(gauge)                             | The number of responses received per second (kafka.server<type=controller-channel-metrics, broker-id=3><>response-rate)                                                                                                                                    |
| **aws.msk.kafka.server.controller.channel.metrics.response.total**(gauge)                            | The total number of responses received (kafka.server<type=controller-channel-metrics, broker-id=3><>response-total)                                                                                                                                        |
| **aws.msk.kafka.server.controller.channel.metrics.select.rate**(gauge)                               | The number of times the I/O layer checked for new I/O to perform per second (kafka.server<type=controller-channel-metrics, broker-id=3><>select-rate)                                                                                                      |
| **aws.msk.kafka.server.controller.channel.metrics.select.total**(gauge)                              | The total number of times the I/O layer checked for new I/O to perform (kafka.server<type=controller-channel-metrics, broker-id=3><>select-total)                                                                                                          |
| **aws.msk.kafka.server.controller.channel.metrics.successful.authentication.no.reauth.total**(gauge) | The total number of connections with successful authentication where the client does not support re-authentication (kafka.server<type=controller-channel-metrics, broker-id=3><>successful-authentication-no-reauth-total)                                 |
| **aws.msk.kafka.server.controller.channel.metrics.successful.authentication.rate**(gauge)            | The number of connections with successful authentication per second (kafka.server<type=controller-channel-metrics, broker-id=3><>successful-authentication-rate)                                                                                           |
| **aws.msk.kafka.server.controller.channel.metrics.successful.authentication.total**(gauge)           | The total number of connections with successful authentication (kafka.server<type=controller-channel-metrics, broker-id=3><>successful-authentication-total)                                                                                               |
| **aws.msk.kafka.server.controller.channel.metrics.successful.reauthentication.rate**(gauge)          | The number of successful re-authentication of connections per second (kafka.server<type=controller-channel-metrics, broker-id=3><>successful-reauthentication-rate)                                                                                        |
| **aws.msk.kafka.server.controller.channel.metrics.successful.reauthentication.total**(gauge)         | The total number of successful re-authentication of connections (kafka.server<type=controller-channel-metrics, broker-id=3><>successful-reauthentication-total)                                                                                            |
| **aws.msk.kafka.server.kafka.metrics.count.count**(gauge)                                            | total number of registered metrics (kafka.server<type=kafka-metrics-count><>count)                                                                                                                                                                         |
| **aws.msk.kafka.server.replica.fetcher.metrics.connection.close.rate**(gauge)                        | The number of connections closed per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>connection-close-rate)                                                                                                                 |
| **aws.msk.kafka.server.replica.fetcher.metrics.connection.close.total**(gauge)                       | The total number of connections closed (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>connection-close-total)                                                                                                                     |
| **aws.msk.kafka.server.replica.fetcher.metrics.connection.count**(gauge)                             | The current number of active connections. (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>connection-count)                                                                                                                        |
| **aws.msk.kafka.server.replica.fetcher.metrics.connection.creation.rate**(gauge)                     | The number of new connections established per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>connection-creation-rate)                                                                                                     |
| **aws.msk.kafka.server.replica.fetcher.metrics.connection.creation.total**(gauge)                    | The total number of new connections established (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>connection-creation-total)                                                                                                         |
| **aws.msk.kafka.server.replica.fetcher.metrics.failed.authentication.rate**(gauge)                   | The number of connections with failed authentication per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>failed-authentication-rate)                                                                                        |
| **aws.msk.kafka.server.replica.fetcher.metrics.failed.authentication.total**(gauge)                  | The total number of connections with failed authentication (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>failed-authentication-total)                                                                                            |
| **aws.msk.kafka.server.replica.fetcher.metrics.incoming.byte.rate**(gauge)                           | The number of bytes read off all sockets per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>incoming-byte-rate)*Shown as byte*                                                                                             |
| **aws.msk.kafka.server.replica.fetcher.metrics.incoming.byte.total**(gauge)                          | The total number of bytes read off all sockets (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>incoming-byte-total)*Shown as byte*                                                                                                 |
| **aws.msk.kafka.server.replica.fetcher.metrics.io.ratio**(gauge)                                     | The fraction of time the I/O thread spent doing I/O (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>io-ratio)                                                                                                                      |
| **aws.msk.kafka.server.replica.fetcher.metrics.io.time.ns.avg**(gauge)                               | The average length of time for I/O per select call in nanoseconds. (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>io-time-ns-avg)                                                                                                 |
| **aws.msk.kafka.server.replica.fetcher.metrics.io.wait.ratio**(gauge)                                | The fraction of time the I/O thread spent waiting (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>io-wait-ratio)                                                                                                                   |
| **aws.msk.kafka.server.replica.fetcher.metrics.io.wait.time.ns.avg**(gauge)                          | The average length of time the I/O thread spent waiting for a socket ready for reads or writes in nanoseconds. (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>io-wait-time-ns-avg)                                                |
| **aws.msk.kafka.server.replica.fetcher.metrics.io.waittime.total**(gauge)                            | The total time the I/O thread spent waiting (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>io-waittime-total)                                                                                                                     |
| **aws.msk.kafka.server.replica.fetcher.metrics.iotime.total**(gauge)                                 | The total time the I/O thread spent doing I/O (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>iotime-total)                                                                                                                        |
| **aws.msk.kafka.server.replica.fetcher.metrics.network.io.rate**(gauge)                              | The number of network operations (reads or writes) on all connections per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>network-io-rate)                                                                                  |
| **aws.msk.kafka.server.replica.fetcher.metrics.network.io.total**(gauge)                             | The total number of network operations (reads or writes) on all connections (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>network-io-total)                                                                                      |
| **aws.msk.kafka.server.replica.fetcher.metrics.outgoing.byte.rate**(gauge)                           | The number of outgoing bytes sent to all servers per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>outgoing-byte-rate)*Shown as byte*                                                                                     |
| **aws.msk.kafka.server.replica.fetcher.metrics.outgoing.byte.total**(gauge)                          | The total number of outgoing bytes sent to all servers (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>outgoing-byte-total)*Shown as byte*                                                                                         |
| **aws.msk.kafka.server.replica.fetcher.metrics.request.rate**(gauge)                                 | The number of requests sent per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>request-rate)                                                                                                                               |
| **aws.msk.kafka.server.replica.fetcher.metrics.request.size.avg**(gauge)                             | The average size of requests sent. (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>request-size-avg)                                                                                                                               |
| **aws.msk.kafka.server.replica.fetcher.metrics.request.size.max**(gauge)                             | The maximum size of any request sent. (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>request-size-max)                                                                                                                            |
| **aws.msk.kafka.server.replica.fetcher.metrics.request.total**(gauge)                                | The total number of requests sent (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>request-total)                                                                                                                                   |
| **aws.msk.kafka.server.replica.fetcher.metrics.response.rate**(gauge)                                | The number of responses received per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>response-rate)                                                                                                                         |
| **aws.msk.kafka.server.replica.fetcher.metrics.response.total**(gauge)                               | The total number of responses received (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>response-total)                                                                                                                             |
| **aws.msk.kafka.server.replica.fetcher.metrics.select.rate**(gauge)                                  | The number of times the I/O layer checked for new I/O to perform per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>select-rate)                                                                                           |
| **aws.msk.kafka.server.replica.fetcher.metrics.select.total**(gauge)                                 | The total number of times the I/O layer checked for new I/O to perform (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>select-total)                                                                                               |
| **aws.msk.kafka.server.replica.fetcher.metrics.successful.authentication.rate**(gauge)               | The number of connections with successful authentication per second (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>successful-authentication-rate)                                                                                |
| **aws.msk.kafka.server.replica.fetcher.metrics.successful.authentication.total**(gauge)              | The total number of connections with successful authentication (kafka.server<type=replica-fetcher-metrics, broker-id=2, fetcher-id=0><>successful-authentication-total)                                                                                    |
| **aws.msk.kafka.server.replica\_manager.LeaderCount**(gauge)                                         |
| **aws.msk.kafka.server.replica\_manager.LeaderCount.count**(count)                                   | count version of aws.msk.kafka.server.replica_manager.LeaderCount                                                                                                                                                                                          |
| **aws.msk.kafka.server.replica\_manager.OfflineReplicaCount**(gauge)                                 |
| **aws.msk.kafka.server.replica\_manager.OfflineReplicaCount.count**(count)                           | count version of aws.msk.kafka.server.replica_manager.OfflineReplicaCount                                                                                                                                                                                  |
| **aws.msk.kafka.server.replica\_manager.PartitionCount**(gauge)                                      |
| **aws.msk.kafka.server.replica\_manager.PartitionCount.count**(count)                                | count version of aws.msk.kafka.server.replica_manager.PartitionCount                                                                                                                                                                                       |
| **aws.msk.kafka.server.replica\_manager.UnderMinIsrPartitionCount**(gauge)                           |
| **aws.msk.kafka.server.replica\_manager.UnderMinIsrPartitionCount.count**(count)                     | count version of aws.msk.kafka.server.replica_manager.UnderMinIsrPartitionCountcount version of aws.msk.kafka.server.replica_manager.UnderMinIsrPartitionCount                                                                                             |
| **aws.msk.kafka.server.replica\_manager.UnderReplicatedPartitions**(gauge)                           |
| **aws.msk.kafka.server.replica\_manager.UnderReplicatedPartitions.count**(count)                     | count version of aws.msk.kafka.server.replica_manager.UnderReplicatedPartitions                                                                                                                                                                            |
| **aws.msk.kafka.server.socket.server.metrics.MemoryPoolAvgDepletedPercent**(gauge)                   | (kafka.server<type=socket-server-metrics><>MemoryPoolAvgDepletedPercent)                                                                                                                                                                                   |
| **aws.msk.kafka.server.socket.server.metrics.MemoryPoolDepletedTimeTotal**(gauge)                    | (kafka.server<type=socket-server-metrics><>MemoryPoolDepletedTimeTotal)                                                                                                                                                                                    |
| **aws.msk.kafka.server.socket.server.metrics.connection.close.rate**(gauge)                          | The number of connections closed per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>connection-close-rate)                                                                                                         |
| **aws.msk.kafka.server.socket.server.metrics.connection.close.total**(gauge)                         | The total number of connections closed (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>connection-close-total)                                                                                                             |
| **aws.msk.kafka.server.socket.server.metrics.connection.count**(gauge)                               | The current number of active connections. (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>connection-count)                                                                                                                |
| **aws.msk.kafka.server.socket.server.metrics.connection.creation.rate**(gauge)                       | The number of new connections established per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>connection-creation-rate)                                                                                             |
| **aws.msk.kafka.server.socket.server.metrics.connection.creation.total**(gauge)                      | The total number of new connections established (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>connection-creation-total)                                                                                                 |
| **aws.msk.kafka.server.socket.server.metrics.expired.connections.killed.count**(gauge)               | (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>expired-connections-killed-count)                                                                                                                                          |
| **aws.msk.kafka.server.socket.server.metrics.failed.authentication.rate**(gauge)                     | The number of connections with failed authentication per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>failed-authentication-rate)                                                                                |
| **aws.msk.kafka.server.socket.server.metrics.failed.authentication.total**(gauge)                    | The total number of connections with failed authentication (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>failed-authentication-total)                                                                                    |
| **aws.msk.kafka.server.socket.server.metrics.failed.reauthentication.rate**(gauge)                   | The number of failed re-authentication of connections per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>failed-reauthentication-rate)                                                                             |
| **aws.msk.kafka.server.socket.server.metrics.failed.reauthentication.total**(gauge)                  | The total number of failed re-authentication of connections (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>failed-reauthentication-total)                                                                                 |
| **aws.msk.kafka.server.socket.server.metrics.incoming.byte.rate**(gauge)                             | The number of bytes read off all sockets per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>incoming-byte-rate)                                                                                                    |
| **aws.msk.kafka.server.socket.server.metrics.incoming.byte.total**(gauge)                            | The total number of bytes read off all sockets (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>incoming-byte-total)                                                                                                        |
| **aws.msk.kafka.server.socket.server.metrics.io.ratio**(gauge)                                       | The fraction of time the I/O thread spent doing I/O (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>io-ratio)                                                                                                              |
| **aws.msk.kafka.server.socket.server.metrics.io.time.ns.avg**(gauge)                                 | The average length of time for I/O per select call in nanoseconds. (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>io-time-ns-avg)                                                                                         |
| **aws.msk.kafka.server.socket.server.metrics.io.wait.ratio**(gauge)                                  | The fraction of time the I/O thread spent waiting (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>io-wait-ratio)                                                                                                           |
| **aws.msk.kafka.server.socket.server.metrics.io.wait.time.ns.avg**(gauge)                            | The average length of time the I/O thread spent waiting for a socket ready for reads or writes in nanoseconds. (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>io-wait-time-ns-avg)                                        |
| **aws.msk.kafka.server.socket.server.metrics.io.waittime.total**(gauge)                              | The total time the I/O thread spent waiting (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>io-waittime-total)                                                                                                             |
| **aws.msk.kafka.server.socket.server.metrics.iotime.total**(gauge)                                   | The total time the I/O thread spent doing I/O (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>iotime-total)                                                                                                                |
| **aws.msk.kafka.server.socket.server.metrics.network.io.rate**(gauge)                                | The number of network operations (reads or writes) on all connections per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>network-io-rate)                                                                          |
| **aws.msk.kafka.server.socket.server.metrics.network.io.total**(gauge)                               | The total number of network operations (reads or writes) on all connections (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>network-io-total)                                                                              |
| **aws.msk.kafka.server.socket.server.metrics.outgoing.byte.rate**(gauge)                             | The number of outgoing bytes sent to all servers per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>outgoing-byte-rate)                                                                                            |
| **aws.msk.kafka.server.socket.server.metrics.outgoing.byte.total**(gauge)                            | The total number of outgoing bytes sent to all servers (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>outgoing-byte-total)                                                                                                |
| **aws.msk.kafka.server.socket.server.metrics.reauthentication.latency.avg**(gauge)                   | The average latency observed due to re-authentication (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>reauthentication-latency-avg)                                                                                        |
| **aws.msk.kafka.server.socket.server.metrics.reauthentication.latency.max**(gauge)                   | The max latency observed due to re-authentication (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>reauthentication-latency-max)                                                                                            |
| **aws.msk.kafka.server.socket.server.metrics.request.rate**(gauge)                                   | The number of requests sent per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>request-rate)                                                                                                                       |
| **aws.msk.kafka.server.socket.server.metrics.request.size.avg**(gauge)                               | The average size of requests sent. (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>request-size-avg)                                                                                                                       |
| **aws.msk.kafka.server.socket.server.metrics.request.size.max**(gauge)                               | The maximum size of any request sent. (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>request-size-max)                                                                                                                    |
| **aws.msk.kafka.server.socket.server.metrics.request.total**(gauge)                                  | The total number of requests sent (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>request-total)                                                                                                                           |
| **aws.msk.kafka.server.socket.server.metrics.response.rate**(gauge)                                  | The number of responses received per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>response-rate)                                                                                                                 |
| **aws.msk.kafka.server.socket.server.metrics.response.total**(gauge)                                 | The total number of responses received (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>response-total)                                                                                                                     |
| **aws.msk.kafka.server.socket.server.metrics.select.rate**(gauge)                                    | The number of times the I/O layer checked for new I/O to perform per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>select-rate)                                                                                   |
| **aws.msk.kafka.server.socket.server.metrics.select.total**(gauge)                                   | The total number of times the I/O layer checked for new I/O to perform (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>select-total)                                                                                       |
| **aws.msk.kafka.server.socket.server.metrics.successful.authentication.no.reauth.total**(gauge)      | The total number of connections with successful authentication where the client does not support re-authentication (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>successful-authentication-no-reauth-total)              |
| **aws.msk.kafka.server.socket.server.metrics.successful.authentication.rate**(gauge)                 | The number of connections with successful authentication per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>successful-authentication-rate)                                                                        |
| **aws.msk.kafka.server.socket.server.metrics.successful.authentication.total**(gauge)                | The total number of connections with successful authentication (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>successful-authentication-total)                                                                            |
| **aws.msk.kafka.server.socket.server.metrics.successful.reauthentication.rate**(gauge)               | The number of successful re-authentication of connections per second (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>successful-reauthentication-rate)                                                                     |
| **aws.msk.kafka.server.socket.server.metrics.successful.reauthentication.total**(gauge)              | The total number of successful re-authentication of connections (kafka.server<type=socket-server-metrics, listener=CLIENT, networkProcessor=4><>successful-reauthentication-total)                                                                         |
| **aws.msk.kafka.server.txn.marker.channel.metrics.connection.close.rate**(gauge)                     | The number of connections closed per second (kafka.server<type=txn-marker-channel-metrics><>connection-close-rate)                                                                                                                                         |
| **aws.msk.kafka.server.txn.marker.channel.metrics.connection.close.total**(gauge)                    | The total number of connections closed (kafka.server<type=txn-marker-channel-metrics><>connection-close-total)                                                                                                                                             |
| **aws.msk.kafka.server.txn.marker.channel.metrics.connection.count**(gauge)                          | The current number of active connections. (kafka.server<type=txn-marker-channel-metrics><>connection-count)                                                                                                                                                |
| **aws.msk.kafka.server.txn.marker.channel.metrics.connection.creation.rate**(gauge)                  | The number of new connections established per second (kafka.server<type=txn-marker-channel-metrics><>connection-creation-rate)                                                                                                                             |
| **aws.msk.kafka.server.txn.marker.channel.metrics.connection.creation.total**(gauge)                 | The total number of new connections established (kafka.server<type=txn-marker-channel-metrics><>connection-creation-total)                                                                                                                                 |
| **aws.msk.kafka.server.txn.marker.channel.metrics.failed.authentication.rate**(gauge)                | The number of connections with failed authentication per second (kafka.server<type=txn-marker-channel-metrics><>failed-authentication-rate)                                                                                                                |
| **aws.msk.kafka.server.txn.marker.channel.metrics.failed.authentication.total**(gauge)               | The total number of connections with failed authentication (kafka.server<type=txn-marker-channel-metrics><>failed-authentication-total)                                                                                                                    |
| **aws.msk.kafka.server.txn.marker.channel.metrics.failed.reauthentication.rate**(gauge)              | The number of failed re-authentication of connections per second (kafka.server<type=txn-marker-channel-metrics><>failed-reauthentication-rate)                                                                                                             |
| **aws.msk.kafka.server.txn.marker.channel.metrics.failed.reauthentication.total**(gauge)             | The total number of failed re-authentication of connections (kafka.server<type=txn-marker-channel-metrics><>failed-reauthentication-total)                                                                                                                 |
| **aws.msk.kafka.server.txn.marker.channel.metrics.incoming.byte.rate**(gauge)                        | The number of bytes read off all sockets per second (kafka.server<type=txn-marker-channel-metrics><>incoming-byte-rate)                                                                                                                                    |
| **aws.msk.kafka.server.txn.marker.channel.metrics.incoming.byte.total**(gauge)                       | The total number of bytes read off all sockets (kafka.server<type=txn-marker-channel-metrics><>incoming-byte-total)                                                                                                                                        |
| **aws.msk.kafka.server.txn.marker.channel.metrics.io.ratio**(gauge)                                  | The fraction of time the I/O thread spent doing I/O (kafka.server<type=txn-marker-channel-metrics><>io-ratio)                                                                                                                                              |
| **aws.msk.kafka.server.txn.marker.channel.metrics.io.time.ns.avg**(gauge)                            | The average length of time for I/O per select call in nanoseconds. (kafka.server<type=txn-marker-channel-metrics><>io-time-ns-avg)                                                                                                                         |
| **aws.msk.kafka.server.txn.marker.channel.metrics.io.wait.ratio**(gauge)                             | The fraction of time the I/O thread spent waiting (kafka.server<type=txn-marker-channel-metrics><>io-wait-ratio)                                                                                                                                           |
| **aws.msk.kafka.server.txn.marker.channel.metrics.io.wait.time.ns.avg**(gauge)                       | The average length of time the I/O thread spent waiting for a socket ready for reads or writes in nanoseconds. (kafka.server<type=txn-marker-channel-metrics><>io-wait-time-ns-avg)                                                                        |
| **aws.msk.kafka.server.txn.marker.channel.metrics.io.waittime.total**(gauge)                         | The total time the I/O thread spent waiting (kafka.server<type=txn-marker-channel-metrics><>io-waittime-total)                                                                                                                                             |
| **aws.msk.kafka.server.txn.marker.channel.metrics.iotime.total**(gauge)                              | The total time the I/O thread spent doing I/O (kafka.server<type=txn-marker-channel-metrics><>iotime-total)                                                                                                                                                |
| **aws.msk.kafka.server.txn.marker.channel.metrics.network.io.rate**(gauge)                           | The number of network operations (reads or writes) on all connections per second (kafka.server<type=txn-marker-channel-metrics><>network-io-rate)                                                                                                          |
| **aws.msk.kafka.server.txn.marker.channel.metrics.network.io.total**(gauge)                          | The total number of network operations (reads or writes) on all connections (kafka.server<type=txn-marker-channel-metrics><>network-io-total)                                                                                                              |
| **aws.msk.kafka.server.txn.marker.channel.metrics.outgoing.byte.rate**(gauge)                        | The number of outgoing bytes sent to all servers per second (kafka.server<type=txn-marker-channel-metrics><>outgoing-byte-rate)                                                                                                                            |
| **aws.msk.kafka.server.txn.marker.channel.metrics.outgoing.byte.total**(gauge)                       | The total number of outgoing bytes sent to all servers (kafka.server<type=txn-marker-channel-metrics><>outgoing-byte-total)                                                                                                                                |
| **aws.msk.kafka.server.txn.marker.channel.metrics.reauthentication.latency.avg**(gauge)              | The average latency observed due to re-authentication (kafka.server<type=txn-marker-channel-metrics><>reauthentication-latency-avg)                                                                                                                        |
| **aws.msk.kafka.server.txn.marker.channel.metrics.reauthentication.latency.max**(gauge)              | The max latency observed due to re-authentication (kafka.server<type=txn-marker-channel-metrics><>reauthentication-latency-max)                                                                                                                            |
| **aws.msk.kafka.server.txn.marker.channel.metrics.request.rate**(gauge)                              | The number of requests sent per second (kafka.server<type=txn-marker-channel-metrics><>request-rate)                                                                                                                                                       |
| **aws.msk.kafka.server.txn.marker.channel.metrics.request.size.avg**(gauge)                          | The average size of requests sent. (kafka.server<type=txn-marker-channel-metrics><>request-size-avg)                                                                                                                                                       |
| **aws.msk.kafka.server.txn.marker.channel.metrics.request.size.max**(gauge)                          | The maximum size of any request sent. (kafka.server<type=txn-marker-channel-metrics><>request-size-max)                                                                                                                                                    |
| **aws.msk.kafka.server.txn.marker.channel.metrics.request.total**(gauge)                             | The total number of requests sent (kafka.server<type=txn-marker-channel-metrics><>request-total)                                                                                                                                                           |
| **aws.msk.kafka.server.txn.marker.channel.metrics.response.rate**(gauge)                             | The number of responses received per second (kafka.server<type=txn-marker-channel-metrics><>response-rate)                                                                                                                                                 |
| **aws.msk.kafka.server.txn.marker.channel.metrics.response.total**(gauge)                            | The total number of responses received (kafka.server<type=txn-marker-channel-metrics><>response-total)                                                                                                                                                     |
| **aws.msk.kafka.server.txn.marker.channel.metrics.select.rate**(gauge)                               | The number of times the I/O layer checked for new I/O to perform per second (kafka.server<type=txn-marker-channel-metrics><>select-rate)                                                                                                                   |
| **aws.msk.kafka.server.txn.marker.channel.metrics.select.total**(gauge)                              | The total number of times the I/O layer checked for new I/O to perform (kafka.server<type=txn-marker-channel-metrics><>select-total)                                                                                                                       |
| **aws.msk.kafka.server.txn.marker.channel.metrics.successful.authentication.no.reauth.total**(gauge) | The total number of connections with successful authentication where the client does not support re-authentication (kafka.server<type=txn-marker-channel-metrics><>successful-authentication-no-reauth-total)                                              |
| **aws.msk.kafka.server.txn.marker.channel.metrics.successful.authentication.rate**(gauge)            | The number of connections with successful authentication per second (kafka.server<type=txn-marker-channel-metrics><>successful-authentication-rate)                                                                                                        |
| **aws.msk.kafka.server.txn.marker.channel.metrics.successful.authentication.total**(gauge)           | The total number of connections with successful authentication (kafka.server<type=txn-marker-channel-metrics><>successful-authentication-total)                                                                                                            |
| **aws.msk.kafka.server.txn.marker.channel.metrics.successful.reauthentication.rate**(gauge)          | The number of successful re-authentication of connections per second (kafka.server<type=txn-marker-channel-metrics><>successful-reauthentication-rate)                                                                                                     |
| **aws.msk.kafka.server.txn.marker.channel.metrics.successful.reauthentication.total**(gauge)         | The total number of successful re-authentication of connections (kafka.server<type=txn-marker-channel-metrics><>successful-reauthentication-total)                                                                                                         |
| **aws.msk.kafka.utils.Throttler.Count**(gauge)                                                       | Attribute exposed for management (kafka.utils<type=Throttler, name=cleaner-io><>Count)                                                                                                                                                                     |
| **aws.msk.kafka.utils.Throttler.Count.count**(count)                                                 | Attribute exposed for management (kafka.utils<type=Throttler, name=cleaner-io><>Count) as monotonic count                                                                                                                                                  |
| **aws.msk.kafka.utils.Throttler.FifteenMinuteRate**(gauge)                                           | Attribute exposed for management (kafka.utils<type=Throttler, name=cleaner-io><>FifteenMinuteRate)                                                                                                                                                         |
| **aws.msk.kafka.utils.Throttler.FiveMinuteRate**(gauge)                                              | Attribute exposed for management (kafka.utils<type=Throttler, name=cleaner-io><>FiveMinuteRate)                                                                                                                                                            |
| **aws.msk.kafka.utils.Throttler.MeanRate**(gauge)                                                    | Attribute exposed for management (kafka.utils<type=Throttler, name=cleaner-io><>MeanRate)                                                                                                                                                                  |
| **aws.msk.kafka.utils.Throttler.OneMinuteRate**(gauge)                                               | Attribute exposed for management (kafka.utils<type=Throttler, name=cleaner-io><>OneMinuteRate)                                                                                                                                                             |
| **aws.msk.node.cpu.seconds.count**(count)                                                            | [OpenMetricsV2] Seconds the cpus spent in each mode.                                                                                                                                                                                                       |
| **aws.msk.node.cpu.seconds.total**(count)                                                            | [OpenMetricsV1] Seconds the cpus spent in each mode.                                                                                                                                                                                                       |
| **aws.msk.node.exporter.build.info**(gauge)                                                          | A metric with a constant '1' value labeled by version, revision, branch, and goversion from which node_exporter was built.                                                                                                                                 |
| **aws.msk.node.filesystem.avail.bytes**(gauge)                                                       | Filesystem space available to non-root users in bytes.*Shown as byte*                                                                                                                                                                                      |
| **aws.msk.node.filesystem.device.error**(gauge)                                                      | Whether an error occurred while getting statistics for the given device.                                                                                                                                                                                   |
| **aws.msk.node.filesystem.files**(gauge)                                                             | Filesystem total file nodes.                                                                                                                                                                                                                               |
| **aws.msk.node.filesystem.files.free**(gauge)                                                        | Filesystem total free file nodes.                                                                                                                                                                                                                          |
| **aws.msk.node.filesystem.free.bytes**(gauge)                                                        | Filesystem free space in bytes.*Shown as byte*                                                                                                                                                                                                             |
| **aws.msk.node.filesystem.readonly**(gauge)                                                          | Filesystem read-only status.                                                                                                                                                                                                                               |
| **aws.msk.node.filesystem.size.bytes**(gauge)                                                        | Filesystem size in bytes.*Shown as byte*                                                                                                                                                                                                                   |
| **aws.msk.node.scrape.collector.duration.seconds**(gauge)                                            | node_exporter: Duration of a collector scrape.*Shown as second*                                                                                                                                                                                            |
| **aws.msk.node.scrape.collector.success**(gauge)                                                     | node_exporter: Whether a collector succeeded.                                                                                                                                                                                                              |
| **aws.msk.process.cpu.seconds.count**(count)                                                         | [OpenMetricsV2] Total user and system CPU time spent in seconds.                                                                                                                                                                                           |
| **aws.msk.process.cpu.seconds.total**(count)                                                         | [OpenMetricsV1] Total user and system CPU time spent in seconds.                                                                                                                                                                                           |
| **aws.msk.process.max.fds**(gauge)                                                                   | Maximum number of open file descriptors.                                                                                                                                                                                                                   |
| **aws.msk.process.open.fds**(gauge)                                                                  | Number of open file descriptors.                                                                                                                                                                                                                           |
| **aws.msk.process.resident.memory.bytes**(gauge)                                                     | Resident memory size in bytes.*Shown as byte*                                                                                                                                                                                                              |
| **aws.msk.process.start.time.seconds**(gauge)                                                        | Start time of the process since unix epoch in seconds.*Shown as second*                                                                                                                                                                                    |
| **aws.msk.process.virtual.memory.bytes**(gauge)                                                      | Virtual memory size in bytes.*Shown as byte*                                                                                                                                                                                                               |
| **aws.msk.process.virtual.memory.max.bytes**(gauge)                                                  | Maximum amount of virtual memory available in bytes.*Shown as byte*                                                                                                                                                                                        |
| **aws.msk.promhttp.metric.handler.requests.count**(count)                                            | [OpenMetricsV2] Total number of scrapes by HTTP status code.                                                                                                                                                                                               |
| **aws.msk.promhttp.metric.handler.requests.in.flight**(gauge)                                        | Current number of scrapes being served.                                                                                                                                                                                                                    |
| **aws.msk.promhttp.metric.handler.requests.total**(count)                                            | [OpenMetricsV1] Total number of scrapes by HTTP status code.                                                                                                                                                                                               |

### Events{% #events %}

The Amazon MSK check does not include any events.

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

**aws.msk.can\_connect**

Returns `CRITICAL` if the Agent is unable to discover nodes of the MSK cluster. Otherwise, returns `OK`.

*Statuses: ok, critical*

**aws.msk.prometheus.health**

Returns `CRITICAL` if the check cannot access a Metrics endpoint. Otherwise, returns `OK`.

*Statuses: ok, critical*

**aws.msk.openmetrics.health**

Returns `CRITICAL` if the Agent is unable to connect to the OpenMetrics endpoint, otherwise returns `OK`.

*Statuses: ok, critical*

## Troubleshooting{% #troubleshooting %}

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

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

- [Monitor Amazon Managed Streaming for Apache Kafka with Datadog](https://www.datadoghq.com/blog/monitor-amazon-msk/)
