---
title: Datadog Operator
description: Monitor the Datadog Operator
breadcrumbs: Docs > Integrations > Datadog Operator
---

# Datadog Operator
Supported OS Integration version1.0.0
## Overview{% #overview %}

This check monitors the [Datadog Operator](https://docs.datadoghq.com/containers/datadog_operator/) through the Datadog Agent.

**Minimum Agent version:** 7.43.2

## Setup{% #setup %}

### Installation{% #installation %}

Please see the documentation for [Datadog Operator](https://docs.datadoghq.com/containers/datadog_operator/).

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

### Metrics{% #metrics %}

|  |
|  |
| **datadog.operator.admission\_controller.feature.enabled**(gauge)               | `1` if the Admission Controller feature is enabled                                                                                                                                                                                                    |
| **datadog.operator.agent.deployment.success**(gauge)                            | `1` if the desired number of Agent replicas equals the number of available Agent pods. `0` otherwise.                                                                                                                                                 |
| **datadog.operator.cluster\_checks.feature.enabled**(gauge)                     | `1` if the Cluster checks feature is enabled                                                                                                                                                                                                          |
| **datadog.operator.clusteragent.deployment.success**(gauge)                     | `1` if the desired number of Cluster Agent replicas equals the number of available Cluster Agent pods. `0` otherwise.                                                                                                                                 |
| **datadog.operator.clusterchecksrunner.deployment.success**(gauge)              | `1` if the desired number of Cluster Check Runner replicas equals the number of available Cluster Check Runner pods. `0` otherwise.                                                                                                                   |
| **datadog.operator.controller\_runtime\_active\_workers**(gauge)                | Number of currently used workers per controller*Shown as worker*                                                                                                                                                                                      |
| **datadog.operator.controller\_runtime\_max\_concurrent\_reconciles**(gauge)    | Maximum number of concurrent reconciles per controller*Shown as operation*                                                                                                                                                                            |
| **datadog.operator.controller\_runtime\_reconcile\_errors\_total**(count)       | Total number of reconciliation errors per controller*Shown as error*                                                                                                                                                                                  |
| **datadog.operator.controller\_runtime\_reconcile\_time\_seconds.count**(count) | Count of time per reconciliation per controller*Shown as second*                                                                                                                                                                                      |
| **datadog.operator.controller\_runtime\_reconcile\_time\_seconds.sum**(count)   | Sum of time per reconciliation per controller*Shown as second*                                                                                                                                                                                        |
| **datadog.operator.controller\_runtime\_reconcile\_total**(count)               | Total number of reconciliations per controller*Shown as operation*                                                                                                                                                                                    |
| **datadog.operator.default.feature.enabled**(gauge)                             |
| **datadog.operator.dogstatsd.feature.enabled**(gauge)                           | `1` if the DogStatsD feature is enabled                                                                                                                                                                                                               |
| **datadog.operator.eds\_controller\_leader**(gauge)                             |
| **datadog.operator.event\_collection.feature.enabled**(gauge)                   | `1` if the Event Collection feature is enabled                                                                                                                                                                                                        |
| **datadog.operator.go\_gc\_duration\_seconds.count**(count)                     | Count of the GC invocation durations*Shown as second*                                                                                                                                                                                                 |
| **datadog.operator.go\_gc\_duration\_seconds.quantile**(gauge)                  | Quantiles of the GC invocation durations*Shown as second*                                                                                                                                                                                             |
| **datadog.operator.go\_gc\_duration\_seconds.sum**(count)                       | Sum of the GC invocation durations*Shown as second*                                                                                                                                                                                                   |
| **datadog.operator.go\_goroutines**(gauge)                                      | Number of goroutines that currently exist*Shown as thread*                                                                                                                                                                                            |
| **datadog.operator.go\_info**(gauge)                                            | Go version                                                                                                                                                                                                                                            |
| **datadog.operator.go\_memstats\_alloc\_bytes**(gauge)                          | Number of bytes allocated and still in use*Shown as byte*                                                                                                                                                                                             |
| **datadog.operator.go\_memstats\_alloc\_bytes\_total**(count)                   | Total number of bytes allocated even if freed*Shown as byte*                                                                                                                                                                                          |
| **datadog.operator.go\_memstats\_buck\_hash\_sys\_bytes**(gauge)                | Number of bytes used by the profiling bucket hash table*Shown as byte*                                                                                                                                                                                |
| **datadog.operator.go\_memstats\_frees\_total**(count)                          | Total number of frees                                                                                                                                                                                                                                 |
| **datadog.operator.go\_memstats\_gc\_cpu\_fraction**(gauge)                     | The fraction of this program's available CPU time used by the GC since the program started*Shown as fraction*                                                                                                                                         |
| **datadog.operator.go\_memstats\_gc\_sys\_bytes**(gauge)                        | Number of bytes used for garbage collection system metadata*Shown as byte*                                                                                                                                                                            |
| **datadog.operator.go\_memstats\_heap\_alloc\_bytes**(gauge)                    | Number of heap bytes allocated and still in use*Shown as byte*                                                                                                                                                                                        |
| **datadog.operator.go\_memstats\_heap\_idle\_bytes**(gauge)                     | Number of heap bytes waiting to be used*Shown as byte*                                                                                                                                                                                                |
| **datadog.operator.go\_memstats\_heap\_inuse\_bytes**(gauge)                    | Number of heap bytes that are in use*Shown as byte*                                                                                                                                                                                                   |
| **datadog.operator.go\_memstats\_heap\_objects**(gauge)                         | Number of allocated objects*Shown as object*                                                                                                                                                                                                          |
| **datadog.operator.go\_memstats\_heap\_released\_bytes**(gauge)                 | Number of heap bytes released to OS*Shown as byte*                                                                                                                                                                                                    |
| **datadog.operator.go\_memstats\_heap\_sys\_bytes**(gauge)                      | Number of heap bytes obtained from system*Shown as byte*                                                                                                                                                                                              |
| **datadog.operator.go\_memstats\_last\_gc\_time\_seconds**(gauge)               | Number of seconds since 1970 of last garbage collection                                                                                                                                                                                               |
| **datadog.operator.go\_memstats\_lookups\_total**(count)                        | Total number of pointer lookups                                                                                                                                                                                                                       |
| **datadog.operator.go\_memstats\_mallocs\_total**(count)                        | TTotal number of mallocs                                                                                                                                                                                                                              |
| **datadog.operator.go\_memstats\_mcache\_inuse\_bytes**(gauge)                  | Number of bytes in use by mcache structures*Shown as byte*                                                                                                                                                                                            |
| **datadog.operator.go\_memstats\_mcache\_sys\_bytes**(gauge)                    | Number of bytes used for mcache structures obtained from system*Shown as byte*                                                                                                                                                                        |
| **datadog.operator.go\_memstats\_mspan\_inuse\_bytes**(gauge)                   | Number of bytes in use by mspan structures*Shown as byte*                                                                                                                                                                                             |
| **datadog.operator.go\_memstats\_mspan\_sys\_bytes**(gauge)                     | Number of bytes used for mspan structures obtained from system                                                                                                                                                                                        |
| **datadog.operator.go\_memstats\_next\_gc\_bytes**(gauge)                       | Number of heap bytes when next garbage collection will take place*Shown as byte*                                                                                                                                                                      |
| **datadog.operator.go\_memstats\_other\_sys\_bytes**(gauge)                     | Number of bytes used for other system allocations*Shown as byte*                                                                                                                                                                                      |
| **datadog.operator.go\_memstats\_stack\_inuse\_bytes**(gauge)                   | Number of bytes in use by the stack allocator*Shown as byte*                                                                                                                                                                                          |
| **datadog.operator.go\_memstats\_stack\_sys\_bytes**(gauge)                     | Number of bytes obtained from system for stack allocator*Shown as byte*                                                                                                                                                                               |
| **datadog.operator.go\_memstats\_sys\_bytes**(gauge)                            | Number of bytes obtained from system*Shown as byte*                                                                                                                                                                                                   |
| **datadog.operator.go\_threads**(gauge)                                         | Number of OS threads created*Shown as thread*                                                                                                                                                                                                         |
| **datadog.operator.ksm.feature.enabled**(gauge)                                 | `1` if the Kubernetes State Metrics Core feature is enabled                                                                                                                                                                                           |
| **datadog.operator.live\_container.feature.enabled**(gauge)                     | `1` if the Live Containers feature is enabled                                                                                                                                                                                                         |
| **datadog.operator.log\_collection.feature.enabled**(gauge)                     | `1` if the Log Collection feature is enabled                                                                                                                                                                                                          |
| **datadog.operator.orchestrator\_explorer.feature.enabled**(gauge)              | `1` if the Kubernetes Orchestrator Explorer feature is enabled                                                                                                                                                                                        |
| **datadog.operator.process\_cpu\_seconds\_total**(count)                        | Total user and system CPU time spent in seconds*Shown as second*                                                                                                                                                                                      |
| **datadog.operator.process\_max\_fds**(gauge)                                   | Maximum number of open file descriptors*Shown as file*                                                                                                                                                                                                |
| **datadog.operator.process\_open\_fds**(gauge)                                  | Number of open file descriptors*Shown as file*                                                                                                                                                                                                        |
| **datadog.operator.process\_resident\_memory\_bytes**(gauge)                    | Resident memory size in bytes*Shown as byte*                                                                                                                                                                                                          |
| **datadog.operator.process\_start\_time\_seconds**(gauge)                       | Start time of the process since unix epoch in seconds                                                                                                                                                                                                 |
| **datadog.operator.process\_virtual\_memory\_bytes**(gauge)                     | Virtual memory size in bytes*Shown as byte*                                                                                                                                                                                                           |
| **datadog.operator.process\_virtual\_memory\_max\_bytes**(gauge)                | Maximum amount of virtual memory available in bytes*Shown as byte*                                                                                                                                                                                    |
| **datadog.operator.reconcile.success**(gauge)                                   | `1` if the last recorded reconcile error is null, `0` otherwise. The `reconcile_err` tag describes the last recorded error.                                                                                                                           |
| **datadog.operator.remote\_config.feature.enabled**(gauge)                      | `1` if the Remote Configuration feature is enabled                                                                                                                                                                                                    |
| **datadog.operator.rest\_client\_requests\_total**(count)                       | Number of HTTP requests, partitioned by status code, method, and host*Shown as request*                                                                                                                                                               |
| **datadog.operator.workqueue\_adds\_total**(count)                              | Total number of adds handled by workqueue                                                                                                                                                                                                             |
| **datadog.operator.workqueue\_depth**(gauge)                                    | Current depth of workqueue                                                                                                                                                                                                                            |
| **datadog.operator.workqueue\_longest\_running\_processor\_seconds**(gauge)     | How many seconds has the longest running processor for workqueue been running.*Shown as second*                                                                                                                                                       |
| **datadog.operator.workqueue\_queue\_duration\_seconds.count**(count)           | Count of how long in seconds an item stays in workqueue before being requested*Shown as second*                                                                                                                                                       |
| **datadog.operator.workqueue\_queue\_duration\_seconds.sum**(count)             | Sum of how long in seconds an item stays in workqueue before being requested*Shown as second*                                                                                                                                                         |
| **datadog.operator.workqueue\_retries\_total**(count)                           | Total number of retries handled by workqueue                                                                                                                                                                                                          |
| **datadog.operator.workqueue\_unfinished\_work\_seconds**(gauge)                | How many seconds of work has been done that is in progress and hasn't been observed by work_duration. Large values indicate stuck threads. One can deduce the number of stuck threads by observing the rate at which this increases.*Shown as second* |
| **datadog.operator.workqueue\_work\_duration\_seconds.count**(count)            | Count of how long in seconds processing an item from workqueue takes*Shown as second*                                                                                                                                                                 |
| **datadog.operator.workqueue\_work\_duration\_seconds.sum**(count)              | Sum of how long in seconds processing an item from workqueue takes*Shown as second*                                                                                                                                                                   |

### Events{% #events %}

The Datadog Operator integration does not include any events.

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

See [service_checks.json](https://github.com/DataDog/integrations-core/blob/master/datadog_operator/assets/service_checks.json) for a list of service checks provided by this integration.

## Troubleshooting{% #troubleshooting %}

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