---
title: Argo Rollouts
description: Monitor the health and performance of Argo Rollouts
breadcrumbs: Docs > Integrations > Argo Rollouts
---

# Argo Rollouts
Supported OS Integration version3.4.1
## Overview{% #overview %}

This check monitors [Argo Rollouts](https://argoproj.github.io/rollouts/) through the Datadog Agent.

**Minimum Agent version:** 7.53.0

## Setup{% #setup %}

Follow the instructions below to install and configure this check for an Agent running in your Kubernetes environment. For more information about configuration in containerized environments, see the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations.md) for guidance.

### Installation{% #installation %}

Starting from Agent release 7.53.0, the Argo Rollouts check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. No additional installation is needed in your environment.

This check uses [OpenMetrics](https://docs.datadoghq.com/integrations/openmetrics.md) to collect metrics from the OpenMetrics endpoint that Argo Rollouts exposes, which requires Python 3.

### Configuration{% #configuration %}

The Argo Rollouts controller has Prometheus-formatted metrics readily available at `/metrics` on port `8090`. For the Agent to start collecting metrics, the Argo Rollouts pods need to be annotated. For more information about annotations, refer to the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations.md) for guidance. You can find additional configuration options by reviewing the [sample argo_rollouts.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/argo_rollouts/datadog_checks/argo_rollouts/data/conf.yaml.example).

**Note**: The listed metrics can only be collected if they are available. Some metrics are generated only when certain actions are performed. For example, the `argo_rollouts.info.replicas.updated` metric is exposed only after a replica is updated.

The only parameter required for configuring the Argo Rollouts check is:

- `openmetrics_endpoint`: This parameter should be set to the location where the Prometheus-formatted metrics are exposed. The default port is `8090`. In containerized environments, `%%host%%` should be used for [host autodetection](https://docs.datadoghq.com/agent/kubernetes/integrations.md).

```yaml
apiVersion: v1
kind: Pod
# (...)
metadata:
  name: '<POD_NAME>'
  annotations:
    ad.datadoghq.com/argo-rollouts.checks: |
      {
        "argo_rollouts": {
          "init_config": {},
          "instances": [
            {
              "openmetrics_endpoint": "http://%%host%%:8090/metrics"
            }
          ]
        }
      }
    # (...)
spec:
  containers:
    - name: 'argo-rollouts'
# (...)
```

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

*Available for Agent versions >6.0*

Argo Rollouts logs can be collected from the different Argo Rollouts 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": "argo_rollouts", "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 `argo_rollouts` under the Checks section.

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

### Metrics{% #metrics %}

|  |
|  |
| **argo\_rollouts.analysis.run.info**(gauge)                            | Information about analysis run                                                                                                                                                                                                                                   |
| **argo\_rollouts.analysis.run.metric.phase**(gauge)                    | Information on the duration of a specific metric in the Analysis Run                                                                                                                                                                                             |
| **argo\_rollouts.analysis.run.metric.type**(gauge)                     | Information on the type of a specific metric in the Analysis Runs                                                                                                                                                                                                |
| **argo\_rollouts.analysis.run.phase**(gauge)                           | Information on the state of the Analysis Run                                                                                                                                                                                                                     |
| **argo\_rollouts.analysis.run.reconcile.bucket**(count)                | The number of observations in the Analysis Run reconciliation performance histogram by upper_bound buckets                                                                                                                                                       |
| **argo\_rollouts.analysis.run.reconcile.count**(count)                 | The number of observations in the Analysis Run reconciliation performance histogram                                                                                                                                                                              |
| **argo\_rollouts.analysis.run.reconcile.error.count**(count)           | Error occurring during the analysis run                                                                                                                                                                                                                          |
| **argo\_rollouts.analysis.run.reconcile.sum**(count)                   | The duration sum of all observations in the Analysis Run reconciliation performance histogram                                                                                                                                                                    |
| **argo\_rollouts.controller.clientset.k8s.request.count**(count)       | The total number of Kubernetes requests executed during application reconciliation                                                                                                                                                                               |
| **argo\_rollouts.experiment.info**(gauge)                              | Information about Experiment                                                                                                                                                                                                                                     |
| **argo\_rollouts.experiment.phase**(gauge)                             | Information on the state of the experiment                                                                                                                                                                                                                       |
| **argo\_rollouts.experiment.reconcile.bucket**(count)                  | The number of observations in the Experiments reconciliation performance histogram by upper_bound buckets                                                                                                                                                        |
| **argo\_rollouts.experiment.reconcile.count**(count)                   | The number of observations in the Experiments reconciliation performance histogram                                                                                                                                                                               |
| **argo\_rollouts.experiment.reconcile.error.count**(count)             | Error occurring during the experiment                                                                                                                                                                                                                            |
| **argo\_rollouts.experiment.reconcile.sum**(count)                     | The duration sum of all observations in the Experiments reconciliation performance histogram                                                                                                                                                                     |
| **argo\_rollouts.go.gc.duration.seconds.count**(count)                 | The summary count of garbage collection cycles in the Argo Rollouts instance*Shown as second*                                                                                                                                                                    |
| **argo\_rollouts.go.gc.duration.seconds.quantile**(gauge)              | A summary of the pause duration of garbage collection cycles in the Argo Rollouts instance*Shown as second*                                                                                                                                                      |
| **argo\_rollouts.go.gc.duration.seconds.sum**(count)                   | The sum of the pause duration of garbage collection cycles in the Argo Rollouts instance*Shown as second*                                                                                                                                                        |
| **argo\_rollouts.go.goroutines**(gauge)                                | The number of goroutines that currently exist in the Argo Rollouts instance                                                                                                                                                                                      |
| **argo\_rollouts.go.info**(gauge)                                      | Metric containing the Go version as a tag                                                                                                                                                                                                                        |
| **argo\_rollouts.go.memstats.alloc\_bytes**(gauge)                     | The number of bytes allocated and still in use in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                      |
| **argo\_rollouts.go.memstats.alloc\_bytes.count**(count)               | The monotonic count of bytes allocated and still in use in the Argo Rollouts instance*Shown as byte*                                                                                                                                                             |
| **argo\_rollouts.go.memstats.buck\_hash.sys\_bytes**(gauge)            | The number of bytes used by the profiling bucket hash table in the Argo Rollouts instance*Shown as byte*                                                                                                                                                         |
| **argo\_rollouts.go.memstats.frees.count**(count)                      | The total number of frees in the Argo Rollouts instance                                                                                                                                                                                                          |
| **argo\_rollouts.go.memstats.gc.cpu\_fraction**(gauge)                 | The fraction of this program's available CPU time used by the GC since the program started in the Argo Rollouts instance*Shown as fraction*                                                                                                                      |
| **argo\_rollouts.go.memstats.gc.sys\_bytes**(gauge)                    | The number of bytes used for garbage collection system metadata in the Argo Rollouts instance*Shown as byte*                                                                                                                                                     |
| **argo\_rollouts.go.memstats.heap.alloc\_bytes**(gauge)                | The number of heap bytes allocated and still in use in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                 |
| **argo\_rollouts.go.memstats.heap.idle\_bytes**(gauge)                 | The number of heap bytes waiting to be used in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                         |
| **argo\_rollouts.go.memstats.heap.inuse\_bytes**(gauge)                | The number of heap bytes that are in use in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                            |
| **argo\_rollouts.go.memstats.heap.objects**(gauge)                     | The number of allocated objects in the Argo Rollouts instance*Shown as object*                                                                                                                                                                                   |
| **argo\_rollouts.go.memstats.heap.released\_bytes**(gauge)             | The number of heap bytes released to the OS in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                         |
| **argo\_rollouts.go.memstats.heap.sys\_bytes**(gauge)                  | The number of heap bytes obtained from system in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                       |
| **argo\_rollouts.go.memstats.lookups.count**(count)                    | The number of pointer lookups                                                                                                                                                                                                                                    |
| **argo\_rollouts.go.memstats.mallocs.count**(count)                    | The number of mallocs                                                                                                                                                                                                                                            |
| **argo\_rollouts.go.memstats.mcache.inuse\_bytes**(gauge)              | The number of bytes in use by mcache structures in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                     |
| **argo\_rollouts.go.memstats.mcache.sys\_bytes**(gauge)                | The number of bytes used for mcache structures obtained from system in the Argo Rollouts instance*Shown as byte*                                                                                                                                                 |
| **argo\_rollouts.go.memstats.mspan.inuse\_bytes**(gauge)               | The number of bytes in use by mspan structures in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                      |
| **argo\_rollouts.go.memstats.mspan.sys\_bytes**(gauge)                 | The number of bytes used for mspan structures obtained from system in the Argo Rollouts instance*Shown as byte*                                                                                                                                                  |
| **argo\_rollouts.go.memstats.next.gc\_bytes**(gauge)                   | The number of heap bytes when next garbage collection takes place in the Argo Rollouts instance*Shown as byte*                                                                                                                                                   |
| **argo\_rollouts.go.memstats.other.sys\_bytes**(gauge)                 | The number of bytes used for other system allocations in the Argo Rollouts instance*Shown as byte*                                                                                                                                                               |
| **argo\_rollouts.go.memstats.stack.inuse\_bytes**(gauge)               | The number of bytes in use by the stack allocator in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                   |
| **argo\_rollouts.go.memstats.stack.sys\_bytes**(gauge)                 | The number of bytes obtained from system for stack allocator in the Argo Rollouts instance*Shown as byte*                                                                                                                                                        |
| **argo\_rollouts.go.memstats.sys\_bytes**(gauge)                       | The number of bytes obtained from system in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                            |
| **argo\_rollouts.go.threads**(gauge)                                   | The number of OS threads created in the Argo Rollouts instance*Shown as thread*                                                                                                                                                                                  |
| **argo\_rollouts.notification.send.bucket**(count)                     | The number of observations in the Notification send performance histogram by upper_bound buckets                                                                                                                                                                 |
| **argo\_rollouts.notification.send.count**(count)                      | The number of observations in the Notification send performance histogram                                                                                                                                                                                        |
| **argo\_rollouts.notification.send.sum**(count)                        | The duration sum of all observations in the Notification send performance histogram                                                                                                                                                                              |
| **argo\_rollouts.process.cpu.seconds.count**(count)                    | The total user and system CPU time spent in seconds in the Argo Rollouts instance*Shown as second*                                                                                                                                                               |
| **argo\_rollouts.process.max\_fds**(gauge)                             | The maximum number of open file descriptors in the Argo Rollouts instance                                                                                                                                                                                        |
| **argo\_rollouts.process.open\_fds**(gauge)                            | The number of open file descriptors in the Argo Rollouts instance                                                                                                                                                                                                |
| **argo\_rollouts.process.resident\_memory.bytes**(gauge)               | The resident memory size in bytes in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                                   |
| **argo\_rollouts.process.start\_time.seconds**(gauge)                  | The start time of the process since unix epoch in seconds in the Argo Rollouts instance*Shown as second*                                                                                                                                                         |
| **argo\_rollouts.process.virtual\_memory.bytes**(gauge)                | The virtual memory size in bytes in the Argo Rollouts instance*Shown as byte*                                                                                                                                                                                    |
| **argo\_rollouts.process.virtual\_memory.max\_bytes**(gauge)           | The maximum amount of virtual memory available in bytes in the Argo Rollouts instance*Shown as byte*                                                                                                                                                             |
| **argo\_rollouts.rollout.events.count**(count)                         | The count of rollout events                                                                                                                                                                                                                                      |
| **argo\_rollouts.rollout.info**(gauge)                                 | Information about rollout                                                                                                                                                                                                                                        |
| **argo\_rollouts.rollout.info.replicas.available**(gauge)              | The number of available replicas per rollout                                                                                                                                                                                                                     |
| **argo\_rollouts.rollout.info.replicas.desired**(gauge)                | The number of desired replicas per rollout                                                                                                                                                                                                                       |
| **argo\_rollouts.rollout.info.replicas.unavailable**(gauge)            | The number of unavailable replicas per rollout                                                                                                                                                                                                                   |
| **argo\_rollouts.rollout.info.replicas.updated**(gauge)                | The number of updated replicas per rollout                                                                                                                                                                                                                       |
| **argo\_rollouts.rollout.phase**(gauge)                                | Information on the state of the rollout. This will be soon to be deprecated by Argo Rollouts, use `argo_rollouts.rollout.info` instead                                                                                                                           |
| **argo\_rollouts.rollout.reconcile.bucket**(count)                     | The number of observations in the Rollout reconciliation performance histogram by upper_bound buckets                                                                                                                                                            |
| **argo\_rollouts.rollout.reconcile.count**(count)                      | The number of observations in the Rollout reconciliation performance histogram                                                                                                                                                                                   |
| **argo\_rollouts.rollout.reconcile.error.count**(count)                | Error occurring during the rollout                                                                                                                                                                                                                               |
| **argo\_rollouts.rollout.reconcile.sum**(count)                        | The duration sum of all observations in the Rollout reconciliation performance histogram                                                                                                                                                                         |
| **argo\_rollouts.workqueue.adds.count**(count)                         | The total number of adds handled by workqueue                                                                                                                                                                                                                    |
| **argo\_rollouts.workqueue.depth**(gauge)                              | The current depth of the workqueue                                                                                                                                                                                                                               |
| **argo\_rollouts.workqueue.longest.running\_processor.seconds**(gauge) | The number of seconds the longest running worqueue processor has been running*Shown as second*                                                                                                                                                                   |
| **argo\_rollouts.workqueue.queue.duration.seconds.bucket**(count)      | The histogram bucket of how long in seconds an item stays in the workqueue before being requested*Shown as second*                                                                                                                                               |
| **argo\_rollouts.workqueue.queue.duration.seconds.count**(count)       | The total number of events in the workqueue duration histogram                                                                                                                                                                                                   |
| **argo\_rollouts.workqueue.queue.duration.seconds.sum**(count)         | The sum the of events counted in the workqueue duration histogram                                                                                                                                                                                                |
| **argo\_rollouts.workqueue.retries.count**(count)                      | The total number of retries handled by workqueue                                                                                                                                                                                                                 |
| **argo\_rollouts.workqueue.unfinished\_work.seconds**(gauge)           | The number of seconds of work that 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* |
| **argo\_rollouts.workqueue.work.duration.seconds.bucket**(count)       | The histogram bucket for time in seconds it takes for processing of an item in the workqueue*Shown as second*                                                                                                                                                    |
| **argo\_rollouts.workqueue.work.duration.seconds.count**(count)        | The total number of events in the workqueue item processing duration histogram                                                                                                                                                                                   |
| **argo\_rollouts.workqueue.work.duration.seconds.sum**(count)          | The sum of events in the workqueue item processing duration histogram                                                                                                                                                                                            |

### Events{% #events %}

The Argo Rollouts integration does not include any events.

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

**argo\_rollouts.openmetrics.health**

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

*Statuses: ok, critical*

## Troubleshooting{% #troubleshooting %}

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