---
title: Strimzi
description: Strimzi
breadcrumbs: Docs > Integrations > Strimzi
---

# Strimzi
Supported OS Integration version4.4.1
## Overview{% #overview %}

This check monitors [Strimzi](https://strimzi.io/) through the Datadog Agent.

**Minimum Agent version:** 7.47.0

## Setup{% #setup %}

### Installation{% #installation %}

The Strimzi check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. No additional installation is needed on your server.

{% alert level="warning" %}
This check uses [OpenMetrics](https://docs.datadoghq.com/integrations/openmetrics.md), which requires Python 3.
{% /alert %}

### Configuration{% #configuration %}

The Strimzi check collects Prometheus-formatted metrics on the following operators:

- Cluster
- Topic
- User

**Note**: For monitoring Kafka and Zookeeper, please use the [Kafka](https://docs.datadoghq.com/integrations/kafka.md), [Kafka Consumer](https://docs.datadoghq.com/integrations/kafka.md?tab=host#kafka-consumer-integration) and [Zookeeper](https://docs.datadoghq.com/integrations/zk.md) checks respectively.

Follow the instructions below to enable and configure this check for an Agent.

#### Host{% #host %}

1. Edit the `strimzi.d/conf.yaml` file, in the `conf.d/` folder at the root of your Agent's configuration directory to start collecting your Strimzi performance data. See the [sample strimzi.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/strimzi/datadog_checks/strimzi/data/conf.yaml.example) for all available configuration options.

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

#### Containerized{% #containerized %}

For containerized environments, refer to the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations.md) for guidance on applying these instructions. Here's an example of how to configure this on the different Operator manifests using pod annotations:

##### Cluster Operator:{% #cluster-operator %}

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: strimzi-cluster-operator
  labels:
    app: strimzi
  namespace: kafka
spec:
  replicas: 1
  selector:
    matchLabels:
      name: strimzi-cluster-operator
      strimzi.io/kind: cluster-operator
  template:
    metadata:
      labels:
        name: strimzi-cluster-operator
        strimzi.io/kind: cluster-operator
      annotations:
        ad.datadoghq.com/strimzi-cluster-operator.checks: |
          {
            "strimzi": {
              "instances":[
                {
                  "cluster_operator_endpoint": "http://%%host%%:8080/metrics"
                }
              ]
            }
          }
      spec:
        containers:
        - name: strimzi-cluster-operator
...
```

**Note**: The template used for this example can be found [here](https://github.com/strimzi/strimzi-kafka-operator/blob/release-0.34.x/install/cluster-operator/060-Deployment-strimzi-cluster-operator.yaml).

##### Topic and User Operators:{% #topic-and-user-operators %}

```yaml
apiVersion: kafka.strimzi.io/v1beta2
kind: Kafka
metadata:
  name: my-cluster
spec:
...
  entityOperator:
    topicOperator: {}
    userOperator: {}
    template:
      pod:
        metadata:
          annotations:
            ad.datadoghq.com/topic-operator.checks: |
              {
                "strimzi": {
                  "instances":[
                    {
                      "topic_operator_endpoint": "http://%%host%%:8080/metrics"
                    }
                  ]
                }
              }
            ad.datadoghq.com/user-operator.checks: |
              {
                "strimzi": {
                  "instances":[
                    {
                      "user_operator_endpoint": "http://%%host%%:8081/metrics"
                    }
                  ]
                }
              } 
...
```

**Note**: The template used as for this example can be found [here](https://github.com/strimzi/strimzi-kafka-operator/blob/release-0.34.x/examples/kafka/kafka-ephemeral-single.yaml).

See the [sample strimzi.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/strimzi/datadog_checks/strimzi/data/conf.yaml.example) for all available configuration options.

#### Kafka and Zookeeper{% #kafka-and-zookeeper %}

The Kafka and Zookeeper components of Strimzi can be monitored using the [Kafka](https://docs.datadoghq.com/integrations/kafka.md), [Kafka Consumer](https://docs.datadoghq.com/integrations/kafka.md?tab=host#kafka-consumer-integration) and [Zookeeper](https://docs.datadoghq.com/integrations/zk.md) checks. Kafka metrics are collected through JMX. For more information on enabling JMX, see the [Strimzi documentation on JMX options](https://strimzi.io/docs/operators/0.20.0/full/using.html#assembly-jmx-options-deployment-configuration-kafka). Here's an example of how to configure the Kafka, Kafka Consumer and Zookeeper checks using Pod annotations:

```yaml
apiVersion: kafka.strimzi.io/v1beta2
kind: Kafka
metadata:
  name: my-cluster
spec:
  kafka:
    jmxOptions: {}
    version: 3.4.0
    replicas: 1
    listeners:
      - name: plain
        port: 9092
        type: internal
        tls: false
    template:
      pod:
        metadata:  
          annotations:
            ad.datadoghq.com/kafka.checks: |
              {
                "kafka": {
                  "init_config": {
                    "is_jmx": true, 
                    "collect_default_metrics": true, 
                    "new_gc_metrics": true
                  },
                  "instances":[
                    {
                      "host": "%%host%%",
                      "port": "9999"
                    }
                  ]
                },
                "kafka_consumer": {
                  "init_config": {},
                  "instances": [
                    {
                      "kafka_connect_str": "%%host%%:9092",
                      "monitor_unlisted_consumer_groups": "true"
                    }
                  ]
                }
              }        
    config:
      offsets.topic.replication.factor: 1
      transaction.state.log.replication.factor: 1
      transaction.state.log.min.isr: 1
      inter.broker.protocol.version: "3.4"
    storage:
      type: ephemeral
  zookeeper:
    replicas: 1
    storage:
      type: ephemeral
    template:
      pod:
        metadata:
          annotations:
            ad.datadoghq.com/zookeeper.checks: |
              {
                "zk": {
                  "instances":[
                    {
                      "host":"%%host%%","port":"2181"
                    }
                  ]
                }
              } 
```

**Note**: The template used for this example can be found [here](https://github.com/strimzi/strimzi-kafka-operator/blob/release-0.34.x/examples/kafka/kafka-ephemeral-single.yaml).

#### Log collection{% #log-collection %}

*Available for Agent versions >6.0*

Strimzi logs can be collected from the different Strimzi pods through Kubernetes. Collecting logs is disabled by default in the Datadog Agent. To enable it, see [Kubernetes Log Collection](https://docs.datadoghq.com/agent/kubernetes/log.md).

See the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations.md) for guidance on applying the parameters below.

| Parameter      | Value                                                |
| -------------- | ---------------------------------------------------- |
| `<LOG_CONFIG>` | `{"source": "strimzi", "service": "<SERVICE_NAME>"}` |

### Validation{% #validation %}

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

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

### Metrics{% #metrics %}

|  |
|  |
| **strimzi.cluster\_operator.jvm.buffer.count\_buffers**(gauge)                        | An estimate of the number of buffers in the pool.                                                                                                                                 |
| **strimzi.cluster\_operator.jvm.buffer.memory\_used\_bytes**(gauge)                   | An estimate of the memory that the Java virtual machine is using for this buffer pool.*Shown as byte*                                                                             |
| **strimzi.cluster\_operator.jvm.buffer.total\_capacity\_bytes**(gauge)                | An estimate of the total capacity of the buffers in this pool.*Shown as byte*                                                                                                     |
| **strimzi.cluster\_operator.jvm.classes.loaded\_classes**(gauge)                      | The number of classes that are currently loaded in the Java virtual machine.                                                                                                      |
| **strimzi.cluster\_operator.jvm.classes.unloaded\_classes.count**(count)              | The total number of classes unloaded since the Java virtual machine has started execution.                                                                                        |
| **strimzi.cluster\_operator.jvm.gc.live\_data\_size\_bytes**(gauge)                   | Size of long-lived heap memory pool after reclamation.*Shown as byte*                                                                                                             |
| **strimzi.cluster\_operator.jvm.gc.max\_data\_size\_bytes**(gauge)                    | Max size of long-lived heap memory pool.*Shown as byte*                                                                                                                           |
| **strimzi.cluster\_operator.jvm.gc.memory\_allocated\_bytes.count**(count)            | Incremented for an increase in the size of the (young) heap memory pool after one GC.                                                                                             |
| **strimzi.cluster\_operator.jvm.gc.memory\_promoted\_bytes.count**(count)             | Count of positive increases in the size of the old generation memory pool before GC to after GC.                                                                                  |
| **strimzi.cluster\_operator.jvm.gc.pause\_seconds.count**(count)                      | Time spent in GC pause.                                                                                                                                                           |
| **strimzi.cluster\_operator.jvm.gc.pause\_seconds.max**(gauge)                        | Max time spent in GC pause.                                                                                                                                                       |
| **strimzi.cluster\_operator.jvm.gc.pause\_seconds.quantile**(gauge)                   | Quantile of time spent in GC pause.                                                                                                                                               |
| **strimzi.cluster\_operator.jvm.gc.pause\_seconds.sum**(count)                        | Sum of time spent in GC pause.                                                                                                                                                    |
| **strimzi.cluster\_operator.jvm.memory.committed\_bytes**(gauge)                      | The amount of memory in bytes that is committed for the Java virtual machine to use.                                                                                              |
| **strimzi.cluster\_operator.jvm.memory.max\_bytes**(gauge)                            | The maximum amount of memory in bytes that can be used for memory management.*Shown as byte*                                                                                      |
| **strimzi.cluster\_operator.jvm.memory.used\_bytes**(gauge)                           | An estimate of the memory that the Java virtual machine is using for this buffer pool.*Shown as byte*                                                                             |
| **strimzi.cluster\_operator.jvm.threads.daemon\_threads**(gauge)                      | The current number of live daemon threads.                                                                                                                                        |
| **strimzi.cluster\_operator.jvm.threads.live\_threads**(gauge)                        | The current number of live threads including both daemon and non-daemon threads.                                                                                                  |
| **strimzi.cluster\_operator.jvm.threads.peak\_threads**(gauge)                        | The peak live thread count since the Java virtual machine started or peak was reset.                                                                                              |
| **strimzi.cluster\_operator.jvm.threads.states\_threads**(gauge)                      | The current number of threads.                                                                                                                                                    |
| **strimzi.cluster\_operator.process.cpu\_usage**(gauge)                               | The recent cpu usage for the Java Virtual Machine process.                                                                                                                        |
| **strimzi.cluster\_operator.reconciliations.already\_enqueued.count**(count)          | Number of reconciliations skipped because another reconciliation for the same resource was still running.                                                                         |
| **strimzi.cluster\_operator.reconciliations.count**(count)                            | Number of reconciliations done by the operator for individual resources                                                                                                           |
| **strimzi.cluster\_operator.reconciliations.duration\_seconds.bucket**(count)         | The time the reconciliation takes to complete.*Shown as second*                                                                                                                   |
| **strimzi.cluster\_operator.reconciliations.duration\_seconds.count**(count)          | The time the reconciliation takes to complete.                                                                                                                                    |
| **strimzi.cluster\_operator.reconciliations.duration\_seconds.max**(gauge)            | The maximum time the reconciliation takes to complete.*Shown as second*                                                                                                           |
| **strimzi.cluster\_operator.reconciliations.duration\_seconds.sum**(count)            | The time the reconciliation takes to complete.*Shown as second*                                                                                                                   |
| **strimzi.cluster\_operator.reconciliations.failed.count**(count)                     | Number of reconciliations done by the operator for individual resources which failed.                                                                                             |
| **strimzi.cluster\_operator.reconciliations.locked.count**(count)                     | Number of reconciliations skipped because another reconciliation for the same resource was still running.                                                                         |
| **strimzi.cluster\_operator.reconciliations.periodical.count**(count)                 | Number of periodical reconciliations done by the operator.                                                                                                                        |
| **strimzi.cluster\_operator.reconciliations.successful.count**(count)                 | Number of reconciliations done by the operator for individual resources which were successful.                                                                                    |
| **strimzi.cluster\_operator.resource.state**(gauge)                                   | Current state of the resource: 1 ready, 0 fail.                                                                                                                                   |
| **strimzi.cluster\_operator.resources**(gauge)                                        | Number of custom resources the operator sees.                                                                                                                                     |
| **strimzi.cluster\_operator.resources.paused**(gauge)                                 | Number of custom resources the operator sees but does not reconcile due to paused reconciliations.                                                                                |
| **strimzi.cluster\_operator.system.cpu\_count**(gauge)                                | The number of processors available to the Java virtual machine                                                                                                                    |
| **strimzi.cluster\_operator.system.cpu\_usage**(gauge)                                | The recent cpu usage of the system the application is running in.                                                                                                                 |
| **strimzi.cluster\_operator.system.load\_average\_1m**(gauge)                         | The sum of the number of runnable entities queued to available processors and the number of runnable entities running on the available processors averaged over a period of time. |
| **strimzi.cluster\_operator.vertx.http\_client.active\_connections**(gauge)           | Number of connections to the remote host currently opened.                                                                                                                        |
| **strimzi.cluster\_operator.vertx.http\_client.active\_requests**(gauge)              | Number of requests being processed, waiting for a response.                                                                                                                       |
| **strimzi.cluster\_operator.vertx.http\_client.active\_ws\_connections**(gauge)       | Number of websockets currently opened.                                                                                                                                            |
| **strimzi.cluster\_operator.vertx.http\_client.bytes\_read.count**(count)             | Number of bytes received from the remote host.*Shown as byte*                                                                                                                     |
| **strimzi.cluster\_operator.vertx.http\_client.bytes\_written.count**(count)          | Number of bytes sent to the remote host.*Shown as byte*                                                                                                                           |
| **strimzi.cluster\_operator.vertx.http\_client.errors.count**(count)                  | Number of errors.                                                                                                                                                                 |
| **strimzi.cluster\_operator.vertx.http\_client.queue\_pending**(gauge)                | Number of pending elements in queue.                                                                                                                                              |
| **strimzi.cluster\_operator.vertx.http\_client.queue\_time\_seconds.count**(count)    | Time spent in queue before being processed, in seconds.                                                                                                                           |
| **strimzi.cluster\_operator.vertx.http\_client.queue\_time\_seconds.max**(gauge)      | Time spent in queue before being processed, in seconds.*Shown as second*                                                                                                          |
| **strimzi.cluster\_operator.vertx.http\_client.queue\_time\_seconds.sum**(count)      | Time spent in queue before being processed, in seconds.*Shown as second*                                                                                                          |
| **strimzi.cluster\_operator.vertx.http\_client.request\_bytes.count**(count)          | Size in bytes of the requests.                                                                                                                                                    |
| **strimzi.cluster\_operator.vertx.http\_client.request\_bytes.max**(gauge)            | Size in bytes of the requests.*Shown as byte*                                                                                                                                     |
| **strimzi.cluster\_operator.vertx.http\_client.request\_bytes.sum**(count)            | Size in bytes of the requests.*Shown as byte*                                                                                                                                     |
| **strimzi.cluster\_operator.vertx.http\_client.requests.count**(count)                | Number of requests sent.                                                                                                                                                          |
| **strimzi.cluster\_operator.vertx.http\_client.response\_bytes.count**(count)         | Size in bytes of the responses.                                                                                                                                                   |
| **strimzi.cluster\_operator.vertx.http\_client.response\_bytes.max**(gauge)           | Size in bytes of the responses.*Shown as byte*                                                                                                                                    |
| **strimzi.cluster\_operator.vertx.http\_client.response\_bytes.sum**(count)           | Size in bytes of the responses.*Shown as byte*                                                                                                                                    |
| **strimzi.cluster\_operator.vertx.http\_client.response\_time\_seconds.count**(count) | Response time in seconds.                                                                                                                                                         |
| **strimzi.cluster\_operator.vertx.http\_client.response\_time\_seconds.max**(gauge)   | Response time in seconds.*Shown as second*                                                                                                                                        |
| **strimzi.cluster\_operator.vertx.http\_client.response\_time\_seconds.sum**(count)   | Response time in seconds.*Shown as second*                                                                                                                                        |
| **strimzi.cluster\_operator.vertx.http\_client.responses.count**(count)               | Number of received responses.                                                                                                                                                     |
| **strimzi.cluster\_operator.vertx.http\_server.active\_connections**(gauge)           | Number of opened connections to the HTTP Server.                                                                                                                                  |
| **strimzi.cluster\_operator.vertx.http\_server.active\_requests**(gauge)              | Number of requests being processed.                                                                                                                                               |
| **strimzi.cluster\_operator.vertx.http\_server.active\_ws\_connections**(gauge)       | Number of websockets currently opened.                                                                                                                                            |
| **strimzi.cluster\_operator.vertx.http\_server.bytes\_read.count**(count)             | Number of bytes received by the HTTP Server.*Shown as byte*                                                                                                                       |
| **strimzi.cluster\_operator.vertx.http\_server.bytes\_written.count**(count)          | Number of bytes sent by the HTTP Server.*Shown as byte*                                                                                                                           |
| **strimzi.cluster\_operator.vertx.http\_server.errors.count**(count)                  | Number of errors.                                                                                                                                                                 |
| **strimzi.cluster\_operator.vertx.http\_server.request\_bytes.count**(count)          | Size in bytes of the requests.                                                                                                                                                    |
| **strimzi.cluster\_operator.vertx.http\_server.request\_bytes.max**(gauge)            | Size in bytes of the requests.*Shown as byte*                                                                                                                                     |
| **strimzi.cluster\_operator.vertx.http\_server.request\_bytes.sum**(count)            | Size in bytes of the requests.*Shown as byte*                                                                                                                                     |
| **strimzi.cluster\_operator.vertx.http\_server.request\_resets.count**(count)         | Number of request resets.                                                                                                                                                         |
| **strimzi.cluster\_operator.vertx.http\_server.requests.count**(count)                | Number of processed requests.                                                                                                                                                     |
| **strimzi.cluster\_operator.vertx.http\_server.response\_bytes.count**(count)         | Size in bytes of the responses.                                                                                                                                                   |
| **strimzi.cluster\_operator.vertx.http\_server.response\_bytes.max**(gauge)           | Size in bytes of the responses.*Shown as byte*                                                                                                                                    |
| **strimzi.cluster\_operator.vertx.http\_server.response\_bytes.sum**(count)           | Size in bytes of the responses.*Shown as byte*                                                                                                                                    |
| **strimzi.cluster\_operator.vertx.http\_server.response\_time\_seconds.count**(count) | Request processing time in seconds.                                                                                                                                               |
| **strimzi.cluster\_operator.vertx.http\_server.response\_time\_seconds.max**(gauge)   | Request processing time in seconds.*Shown as second*                                                                                                                              |
| **strimzi.cluster\_operator.vertx.http\_server.response\_time\_seconds.sum**(count)   | Request processing time in seconds.*Shown as second*                                                                                                                              |
| **strimzi.cluster\_operator.vertx.pool.completed.count**(count)                       | Number of elements done with the resource (i.e. total number of tasks executed for worker pools).                                                                                 |
| **strimzi.cluster\_operator.vertx.pool.in\_use**(gauge)                               | Number of resources used.                                                                                                                                                         |
| **strimzi.cluster\_operator.vertx.pool.queue\_pending**(gauge)                        | Number of pending elements in queue.                                                                                                                                              |
| **strimzi.cluster\_operator.vertx.pool.queue\_time\_seconds.count**(count)            | Time spent in queue before being processed, in seconds.                                                                                                                           |
| **strimzi.cluster\_operator.vertx.pool.queue\_time\_seconds.max**(gauge)              | Time spent in queue before being processed, in seconds.*Shown as second*                                                                                                          |
| **strimzi.cluster\_operator.vertx.pool.queue\_time\_seconds.sum**(count)              | Time spent in queue before being processed, in seconds.*Shown as second*                                                                                                          |
| **strimzi.cluster\_operator.vertx.pool.ratio**(gauge)                                 | Pool usage ratio, only present if maximum pool size could be determined.                                                                                                          |
| **strimzi.cluster\_operator.vertx.pool.usage\_seconds.count**(count)                  | Time using a resource (i.e. processing time for worker pools).                                                                                                                    |
| **strimzi.cluster\_operator.vertx.pool.usage\_seconds.max**(gauge)                    | Time using a resource (i.e. processing time for worker pools).*Shown as second*                                                                                                   |
| **strimzi.cluster\_operator.vertx.pool.usage\_seconds.sum**(count)                    | Time using a resource (i.e. processing time for worker pools).*Shown as second*                                                                                                   |
| **strimzi.topic\_operator.jvm.buffer.count\_buffers**(gauge)                          | An estimate of the number of buffers in the pool.                                                                                                                                 |
| **strimzi.topic\_operator.jvm.buffer.memory\_used\_bytes**(gauge)                     | An estimate of the memory that the Java virtual machine is using for this buffer pool.*Shown as byte*                                                                             |
| **strimzi.topic\_operator.jvm.buffer.total\_capacity\_bytes**(gauge)                  | An estimate of the total capacity of the buffers in this pool.*Shown as byte*                                                                                                     |
| **strimzi.topic\_operator.jvm.classes.loaded\_classes**(gauge)                        | The number of classes that are currently loaded in the Java virtual machine.                                                                                                      |
| **strimzi.topic\_operator.jvm.classes.unloaded\_classes.count**(count)                | The total number of classes unloaded since the Java virtual machine has started execution.                                                                                        |
| **strimzi.topic\_operator.jvm.gc.live\_data\_size\_bytes**(gauge)                     | Size of long-lived heap memory pool after reclamation.*Shown as byte*                                                                                                             |
| **strimzi.topic\_operator.jvm.gc.max\_data\_size\_bytes**(gauge)                      | Max size of long-lived heap memory pool.*Shown as byte*                                                                                                                           |
| **strimzi.topic\_operator.jvm.gc.memory\_allocated\_bytes.count**(count)              | Incremented for an increase in the size of the (young) heap memory pool after one GC.                                                                                             |
| **strimzi.topic\_operator.jvm.gc.memory\_promoted\_bytes.count**(count)               | Count of positive increases in the size of the old generation memory pool before GC to after GC.                                                                                  |
| **strimzi.topic\_operator.jvm.gc.pause\_seconds.count**(count)                        | Time spent in GC pause.                                                                                                                                                           |
| **strimzi.topic\_operator.jvm.gc.pause\_seconds.max**(gauge)                          | Max time spent in GC pause.                                                                                                                                                       |
| **strimzi.topic\_operator.jvm.gc.pause\_seconds.quantile**(gauge)                     | Quantile of time spent in GC pause.                                                                                                                                               |
| **strimzi.topic\_operator.jvm.gc.pause\_seconds.sum**(count)                          | Sum of time spent in GC pause.                                                                                                                                                    |
| **strimzi.topic\_operator.jvm.memory.committed\_bytes**(gauge)                        | The amount of memory in bytes that is committed for the Java virtual machine to use.                                                                                              |
| **strimzi.topic\_operator.jvm.memory.max\_bytes**(gauge)                              | The maximum amount of memory in bytes that can be used for memory management.*Shown as byte*                                                                                      |
| **strimzi.topic\_operator.jvm.memory.used\_bytes**(gauge)                             | An estimate of the memory that the Java virtual machine is using for this buffer pool.*Shown as byte*                                                                             |
| **strimzi.topic\_operator.jvm.threads.daemon\_threads**(gauge)                        | The current number of live daemon threads.                                                                                                                                        |
| **strimzi.topic\_operator.jvm.threads.live\_threads**(gauge)                          | The current number of live threads including both daemon and non-daemon threads.                                                                                                  |
| **strimzi.topic\_operator.jvm.threads.peak\_threads**(gauge)                          | The peak live thread count since the Java virtual machine started or peak was reset.                                                                                              |
| **strimzi.topic\_operator.jvm.threads.states\_threads**(gauge)                        | The current number of threads                                                                                                                                                     |
| **strimzi.topic\_operator.process.cpu\_usage**(gauge)                                 | The recent cpu usage for the Java Virtual Machine process.                                                                                                                        |
| **strimzi.topic\_operator.reconciliations.count**(count)                              | Number of reconciliations done by the operator for individual resources                                                                                                           |
| **strimzi.topic\_operator.reconciliations.duration\_seconds.bucket**(count)           | The time the reconciliation takes to complete.*Shown as second*                                                                                                                   |
| **strimzi.topic\_operator.reconciliations.duration\_seconds.count**(count)            | The time the reconciliation takes to complete.                                                                                                                                    |
| **strimzi.topic\_operator.reconciliations.duration\_seconds.max**(gauge)              | The maximum time the reconciliation takes to complete.*Shown as second*                                                                                                           |
| **strimzi.topic\_operator.reconciliations.duration\_seconds.sum**(count)              | The time the reconciliation takes to complete.*Shown as second*                                                                                                                   |
| **strimzi.topic\_operator.reconciliations.failed.count**(count)                       | Number of reconciliations done by the operator for individual resources which failed.                                                                                             |
| **strimzi.topic\_operator.reconciliations.locked.count**(count)                       | Number of reconciliations skipped because another reconciliation for the same resource was still running.                                                                         |
| **strimzi.topic\_operator.reconciliations.periodical.count**(count)                   | Number of periodical reconciliations done by the operator.                                                                                                                        |
| **strimzi.topic\_operator.reconciliations.successful.count**(count)                   | Number of reconciliations done by the operator for individual resources which were successful.                                                                                    |
| **strimzi.topic\_operator.resource.state**(gauge)                                     | Current state of the resource: 1 ready, 0 fail.                                                                                                                                   |
| **strimzi.topic\_operator.resources**(gauge)                                          | Number of custom resources the operator sees.                                                                                                                                     |
| **strimzi.topic\_operator.resources.paused**(gauge)                                   | Number of custom resources the operator sees but does not reconcile due to paused reconciliations.                                                                                |
| **strimzi.topic\_operator.system.cpu\_count**(gauge)                                  | The number of processors available to the Java virtual machine                                                                                                                    |
| **strimzi.topic\_operator.system.cpu\_usage**(gauge)                                  | The recent cpu usage of the system the application is running in                                                                                                                  |
| **strimzi.topic\_operator.system.load\_average\_1m**(gauge)                           | The sum of the number of runnable entities queued to available processors and the number of runnable entities running on the available processors averaged over a period of time. |
| **strimzi.topic\_operator.vertx.http\_client.active\_connections**(gauge)             | Number of connections to the remote host currently opened.                                                                                                                        |
| **strimzi.topic\_operator.vertx.http\_client.active\_requests**(gauge)                | Number of requests being processed, waiting for a response.                                                                                                                       |
| **strimzi.topic\_operator.vertx.http\_client.active\_ws\_connections**(gauge)         | Number of websockets currently opened.                                                                                                                                            |
| **strimzi.topic\_operator.vertx.http\_client.bytes\_read.count**(count)               | Number of bytes received from the remote host.*Shown as byte*                                                                                                                     |
| **strimzi.topic\_operator.vertx.http\_client.bytes\_written.count**(count)            | Number of bytes sent to the remote host.*Shown as byte*                                                                                                                           |
| **strimzi.topic\_operator.vertx.http\_client.errors.count**(count)                    | Number of errors.                                                                                                                                                                 |
| **strimzi.topic\_operator.vertx.http\_client.queue\_pending**(gauge)                  | Number of pending elements in queue.                                                                                                                                              |
| **strimzi.topic\_operator.vertx.http\_client.queue\_time\_seconds.count**(count)      | Time spent in queue before being processed, in seconds.                                                                                                                           |
| **strimzi.topic\_operator.vertx.http\_client.queue\_time\_seconds.max**(gauge)        | Time spent in queue before being processed, in seconds.*Shown as second*                                                                                                          |
| **strimzi.topic\_operator.vertx.http\_client.queue\_time\_seconds.sum**(count)        | Time spent in queue before being processed, in seconds.*Shown as second*                                                                                                          |
| **strimzi.topic\_operator.vertx.http\_client.request\_bytes.count**(count)            | Size in bytes of the requests.                                                                                                                                                    |
| **strimzi.topic\_operator.vertx.http\_client.request\_bytes.max**(gauge)              | Size in bytes of the requests.*Shown as byte*                                                                                                                                     |
| **strimzi.topic\_operator.vertx.http\_client.request\_bytes.sum**(count)              | Size in bytes of the requests.*Shown as byte*                                                                                                                                     |
| **strimzi.topic\_operator.vertx.http\_client.requests.count**(count)                  | Number of requests sent.                                                                                                                                                          |
| **strimzi.topic\_operator.vertx.http\_client.response\_bytes.count**(count)           | Size in bytes of the responses.                                                                                                                                                   |
| **strimzi.topic\_operator.vertx.http\_client.response\_bytes.max**(gauge)             | Size in bytes of the responses.*Shown as byte*                                                                                                                                    |
| **strimzi.topic\_operator.vertx.http\_client.response\_bytes.sum**(count)             | Size in bytes of the responses.*Shown as byte*                                                                                                                                    |
| **strimzi.topic\_operator.vertx.http\_client.response\_time\_seconds.count**(count)   | Response time in seconds.                                                                                                                                                         |
| **strimzi.topic\_operator.vertx.http\_client.response\_time\_seconds.max**(gauge)     | Response time in seconds.*Shown as second*                                                                                                                                        |
| **strimzi.topic\_operator.vertx.http\_client.response\_time\_seconds.sum**(count)     | Response time in seconds.*Shown as second*                                                                                                                                        |
| **strimzi.topic\_operator.vertx.http\_client.responses.count**(count)                 | Number of received responses.                                                                                                                                                     |
| **strimzi.topic\_operator.vertx.http\_server.active\_connections**(gauge)             | Number of opened connections to the HTTP Server.                                                                                                                                  |
| **strimzi.topic\_operator.vertx.http\_server.active\_requests**(gauge)                | Number of requests being processed.                                                                                                                                               |
| **strimzi.topic\_operator.vertx.http\_server.active\_ws\_connections**(gauge)         | Number of websockets currently opened.                                                                                                                                            |
| **strimzi.topic\_operator.vertx.http\_server.bytes\_read.count**(count)               | Number of bytes received by the HTTP Server.*Shown as byte*                                                                                                                       |
| **strimzi.topic\_operator.vertx.http\_server.bytes\_written.count**(count)            | Number of bytes sent by the HTTP Server.*Shown as byte*                                                                                                                           |
| **strimzi.topic\_operator.vertx.http\_server.errors.count**(count)                    | Number of errors.                                                                                                                                                                 |
| **strimzi.topic\_operator.vertx.http\_server.request\_bytes.count**(count)            | Size in bytes of the requests.                                                                                                                                                    |
| **strimzi.topic\_operator.vertx.http\_server.request\_bytes.max**(gauge)              | Size in bytes of the requests.*Shown as byte*                                                                                                                                     |
| **strimzi.topic\_operator.vertx.http\_server.request\_bytes.sum**(count)              | Size in bytes of the requests.*Shown as byte*                                                                                                                                     |
| **strimzi.topic\_operator.vertx.http\_server.request\_resets.count**(count)           | Number of request resets.                                                                                                                                                         |
| **strimzi.topic\_operator.vertx.http\_server.requests.count**(count)                  | Number of processed requests.                                                                                                                                                     |
| **strimzi.topic\_operator.vertx.http\_server.response\_bytes.count**(count)           | Size in bytes of the responses.                                                                                                                                                   |
| **strimzi.topic\_operator.vertx.http\_server.response\_bytes.max**(gauge)             | Size in bytes of the responses.*Shown as byte*                                                                                                                                    |
| **strimzi.topic\_operator.vertx.http\_server.response\_bytes.sum**(count)             | Size in bytes of the responses.*Shown as byte*                                                                                                                                    |
| **strimzi.topic\_operator.vertx.http\_server.response\_time\_seconds.count**(count)   | Request processing time in seconds.                                                                                                                                               |
| **strimzi.topic\_operator.vertx.http\_server.response\_time\_seconds.max**(gauge)     | Request processing time in seconds.*Shown as second*                                                                                                                              |
| **strimzi.topic\_operator.vertx.http\_server.response\_time\_seconds.sum**(count)     | Request processing time in seconds.*Shown as second*                                                                                                                              |
| **strimzi.topic\_operator.vertx.pool.completed.count**(count)                         | Number of elements done with the resource (i.e. total number of tasks executed for worker pools).                                                                                 |
| **strimzi.topic\_operator.vertx.pool.in\_use**(gauge)                                 | Number of resources used.                                                                                                                                                         |
| **strimzi.topic\_operator.vertx.pool.queue\_pending**(gauge)                          | Number of pending elements in queue.                                                                                                                                              |
| **strimzi.topic\_operator.vertx.pool.queue\_time\_seconds.count**(count)              | Time spent in queue before being processed, in seconds.                                                                                                                           |
| **strimzi.topic\_operator.vertx.pool.queue\_time\_seconds.max**(gauge)                | Time spent in queue before being processed, in seconds.*Shown as second*                                                                                                          |
| **strimzi.topic\_operator.vertx.pool.queue\_time\_seconds.sum**(count)                | Time spent in queue before being processed, in seconds.*Shown as second*                                                                                                          |
| **strimzi.topic\_operator.vertx.pool.ratio**(gauge)                                   | Pool usage ratio, only present if maximum pool size could be determined.                                                                                                          |
| **strimzi.topic\_operator.vertx.pool.usage\_seconds.count**(count)                    | Time using a resource (i.e. processing time for worker pools).                                                                                                                    |
| **strimzi.topic\_operator.vertx.pool.usage\_seconds.max**(gauge)                      | Time using a resource (i.e. processing time for worker pools).*Shown as second*                                                                                                   |
| **strimzi.topic\_operator.vertx.pool.usage\_seconds.sum**(count)                      | Time using a resource (i.e. processing time for worker pools).*Shown as second*                                                                                                   |
| **strimzi.user\_operator.jvm.buffer.count\_buffers**(gauge)                           | An estimate of the number of buffers in the pool.                                                                                                                                 |
| **strimzi.user\_operator.jvm.buffer.memory\_used\_bytes**(gauge)                      | An estimate of the memory that the Java virtual machine is using for this buffer pool.*Shown as byte*                                                                             |
| **strimzi.user\_operator.jvm.buffer.total\_capacity\_bytes**(gauge)                   | An estimate of the total capacity of the buffers in this pool.*Shown as byte*                                                                                                     |
| **strimzi.user\_operator.jvm.classes.loaded\_classes**(gauge)                         | The number of classes that are currently loaded in the Java virtual machine.                                                                                                      |
| **strimzi.user\_operator.jvm.classes.unloaded\_classes.count**(count)                 | The total number of classes unloaded since the Java virtual machine has started execution.                                                                                        |
| **strimzi.user\_operator.jvm.gc.live\_data\_size\_bytes**(gauge)                      | Size of long-lived heap memory pool after reclamation.*Shown as byte*                                                                                                             |
| **strimzi.user\_operator.jvm.gc.max\_data\_size\_bytes**(gauge)                       | Max size of long-lived heap memory pool.*Shown as byte*                                                                                                                           |
| **strimzi.user\_operator.jvm.gc.memory\_allocated\_bytes.count**(count)               | Incremented for an increase in the size of the (young) heap memory pool after one GC.                                                                                             |
| **strimzi.user\_operator.jvm.gc.memory\_promoted\_bytes.count**(count)                | Count of positive increases in the size of the old generation memory pool before GC to after GC.                                                                                  |
| **strimzi.user\_operator.jvm.gc.pause\_seconds.count**(count)                         | Time spent in GC pause.                                                                                                                                                           |
| **strimzi.user\_operator.jvm.gc.pause\_seconds.max**(gauge)                           | Max time spent in GC pause.                                                                                                                                                       |
| **strimzi.user\_operator.jvm.gc.pause\_seconds.quantile**(gauge)                      | Quantile of time spent in GC pause.                                                                                                                                               |
| **strimzi.user\_operator.jvm.gc.pause\_seconds.sum**(count)                           | Sum of time spent in GC pause.                                                                                                                                                    |
| **strimzi.user\_operator.jvm.memory.committed\_bytes**(gauge)                         | The amount of memory in bytes that is committed for the Java virtual machine to use.                                                                                              |
| **strimzi.user\_operator.jvm.memory.max\_bytes**(gauge)                               | The maximum amount of memory in bytes that can be used for memory management.*Shown as byte*                                                                                      |
| **strimzi.user\_operator.jvm.memory.used\_bytes**(gauge)                              | An estimate of the memory that the Java virtual machine is using for this buffer pool.*Shown as byte*                                                                             |
| **strimzi.user\_operator.jvm.threads.daemon\_threads**(gauge)                         | The current number of live daemon threads.                                                                                                                                        |
| **strimzi.user\_operator.jvm.threads.live\_threads**(gauge)                           | The current number of live threads including both daemon and non-daemon threads.                                                                                                  |
| **strimzi.user\_operator.jvm.threads.peak\_threads**(gauge)                           | The peak live thread count since the Java virtual machine started or peak was reset.                                                                                              |
| **strimzi.user\_operator.jvm.threads.states\_threads**(gauge)                         | The current number of threads                                                                                                                                                     |
| **strimzi.user\_operator.process.cpu\_usage**(gauge)                                  | The recent cpu usage for the Java Virtual Machine process.                                                                                                                        |
| **strimzi.user\_operator.reconciliations.count**(count)                               | Number of reconciliations done by the operator for individual resources                                                                                                           |
| **strimzi.user\_operator.reconciliations.duration\_seconds.bucket**(count)            | The time the reconciliation takes to complete.*Shown as second*                                                                                                                   |
| **strimzi.user\_operator.reconciliations.duration\_seconds.count**(count)             | The time the reconciliation takes to complete.                                                                                                                                    |
| **strimzi.user\_operator.reconciliations.duration\_seconds.max**(gauge)               | The maximum time the reconciliation takes to complete.*Shown as second*                                                                                                           |
| **strimzi.user\_operator.reconciliations.duration\_seconds.sum**(count)               | The time the reconciliation takes to complete.*Shown as second*                                                                                                                   |
| **strimzi.user\_operator.reconciliations.failed.count**(count)                        | Number of reconciliations done by the operator for individual resources which failed.                                                                                             |
| **strimzi.user\_operator.reconciliations.locked.count**(count)                        | Number of reconciliations skipped because another reconciliation for the same resource was still running.                                                                         |
| **strimzi.user\_operator.reconciliations.periodical.count**(count)                    | Number of periodical reconciliations done by the operator.                                                                                                                        |
| **strimzi.user\_operator.reconciliations.successful.count**(count)                    | Number of reconciliations done by the operator for individual resources which were successful.                                                                                    |
| **strimzi.user\_operator.resource.state**(gauge)                                      | Current state of the resource: 1 ready, 0 fail.                                                                                                                                   |
| **strimzi.user\_operator.resources**(gauge)                                           | Number of custom resources the operator sees.                                                                                                                                     |
| **strimzi.user\_operator.resources.paused**(gauge)                                    | Number of custom resources the operator sees but does not reconcile due to paused reconciliations.                                                                                |
| **strimzi.user\_operator.system.cpu\_count**(gauge)                                   | The number of processors available to the Java virtual machine                                                                                                                    |
| **strimzi.user\_operator.system.cpu\_usage**(gauge)                                   | The recent cpu usage of the system the application is running in                                                                                                                  |
| **strimzi.user\_operator.system.load\_average\_1m**(gauge)                            | The sum of the number of runnable entities queued to available processors and the number of runnable entities running on the available processors averaged over a period of time. |

### Events{% #events %}

The Strimzi integration does not include any events.

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

**strimzi.cluster\_operator.openmetrics.health**

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

*Statuses: ok, critical*

**strimzi.topic\_operator.openmetrics.health**

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

*Statuses: ok, critical*

**strimzi.user\_operator.openmetrics.health**

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

*Statuses: ok, critical*

## Troubleshooting{% #troubleshooting %}

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

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

- [Integration roundup: Monitoring your container-native technologies](https://www.datadoghq.com/blog/container-native-integrations/#messaging-and-streaming-with-strimzi)
