Argo CD

Supported OS Linux Windows Mac OS

Integration version3.2.0

Overview

This check monitors Argo CD through the Datadog Agent.

Setup

Installation

The Argo CD check is included in the Datadog Agent package. No additional installation is needed on your server.

Note: This check requires Agent v7.42.0+.

Configuration

Argo CD exposes Prometheus-formatted metrics on three of their components:

  • Application Controller
  • API Server
  • Repo Server

The Datadog Agent can collect the exposed metrics using this integration. Follow the instructions below to configure data collection from any or all of the components.

Note: This check uses OpenMetrics for metric collection, which requires Python 3.

Containerized

Metric collection

Ensure that the Prometheus-formatted metrics are exposed in your Argo CD cluster. This is enabled by default if using Argo CD’s default manifests. For the Agent to gather all metrics, each of the three aforementioned components needs to be annotated. For more information about annotations, see the Autodiscovery Integration Templates for guidance. Additional configuration options are available by reviewing the sample argocd.d/conf.yaml.

There are use cases where Argo CD Applications contain labels that need to be exposed as Prometheus metrics. These labels are available using the argocd_app_labels metric, which is disabled on the Application Controller by default. Refer to the ArgoCD Documentation for instructions on how to enable it.

Example configurations:

Application Controller:

apiVersion: v1
kind: Pod
# (...)
metadata:
  name: '<POD_NAME>'
  annotations:
    ad.datadoghq.com/argocd-application-controller.checks: |
      {
        "argocd": {
          "init_config": {},
          "instances": [
            {
              "app_controller_endpoint": "http://%%host%%:8082/metrics"
            }
          ]
        }
      }      
    # (...)
spec:
  containers:
    - name: 'argocd-application-controller'
# (...)

API Server:

apiVersion: v1
kind: Pod
# (...)
metadata:
  name: '<POD_NAME>'
  annotations:
    ad.datadoghq.com/argocd-server.checks: |
      {
        "argocd": {
          "init_config": {},
          "instances": [
            {
              "api_server_endpoint": "http://%%host%%:8083/metrics"
            }
          ]
        }
      }      
    # (...)
spec:
  containers:
    - name: 'argocd-server'
# (...)

Repo Server:

apiVersion: v1
kind: Pod
# (...)
metadata:
  name: '<POD_NAME>'
  annotations:
    ad.datadoghq.com/argocd-repo-server.checks: |
      {
        "argocd": {
          "init_config": {},
          "instances": [
            {
              "repo_server_endpoint": "http://%%host%%:8084/metrics"
            }
          ]
        }
      }      
    # (...)
spec:
  containers:
    - name: 'argocd-repo-server'
# (...)

Note: For the full list of supported endpoints, see the conf.yaml example file.

Troubleshooting

Clashing Tag Names: The Argo CD integration attaches a name tag derived from the application name OpenMetrics label when available. This could sometimes lead to querying issues if a name tag is already attached to a host, as seen in the example name: host_a, app_a. To prevent any unwanted behavior when querying, it is advisable to remap the name label to something more unique, such as argocd_app_name if the host happens to already have a name tag. Below is an example configuration:

Application Controller:

apiVersion: v1
kind: Pod
# (...)
metadata:
  name: '<POD_NAME>'
  annotations:
    ad.datadoghq.com/argocd-application-controller.checks: |
      {
        "argocd": {
          "init_config": {},
          "instances": [
            {
              "app_controller_endpoint": "http://%%host%%:8082/metrics",
              "rename_labels": {
                "name": "argocd_app_name"
              }
            }
          ]
        }
      }      
    # (...)
spec:
  containers:
    - name: 'argocd-application-controller'
# (...)
Log collection

Available for Agent versions >6.0

Argo CD logs can be collected from the different Argo CD pods through Kubernetes. Collecting logs is disabled by default in the Datadog Agent. To enable it, see Kubernetes Log Collection.

See the Autodiscovery Integration Templates for guidance on applying the parameters below.

ParameterValue
<LOG_CONFIG>{"source": "argocd", "service": "<SERVICE_NAME>"}

Validation

Run the Agent’s status subcommand and look for argocd under the Checks section.

Data Collected

Metrics

argocd.api_server.go.gc.duration.seconds.count
(count)
The summary count of garbage collection cycles in the API Server
Shown as second
argocd.api_server.go.gc.duration.seconds.quantile
(gauge)
A summary of the pause duration of garbage collection cycles in the API Server
Shown as second
argocd.api_server.go.gc.duration.seconds.sum
(count)
The sum of the pause duration of garbage collection cycles in the API Server
Shown as second
argocd.api_server.go.goroutines
(gauge)
The number of goroutines that currently exist in the API Server
argocd.api_server.go.memstats.alloc_bytes
(gauge)
The number of bytes allocated and still in use in the API Server
Shown as byte
argocd.api_server.go.memstats.buck_hash.sys_bytes
(gauge)
The number of bytes used by the profiling bucket hash table in the API Server
Shown as byte
argocd.api_server.go.memstats.frees.count
(count)
The total number of frees in the API Server
argocd.api_server.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 API Server
Shown as fraction
argocd.api_server.go.memstats.gc.sys_bytes
(gauge)
The number of bytes used for garbage collection system metadata in the API Server
Shown as byte
argocd.api_server.go.memstats.heap.alloc_bytes
(gauge)
The number of heap bytes allocated and still in use in the API Server
Shown as byte
argocd.api_server.go.memstats.heap.idle_bytes
(gauge)
The number of heap bytes waiting to be used in the API Server
Shown as byte
argocd.api_server.go.memstats.heap.inuse_bytes
(gauge)
The number of heap bytes that are in use in the API Server
Shown as byte
argocd.api_server.go.memstats.heap.objects
(gauge)
The number of allocated objects in the API Server
Shown as object
argocd.api_server.go.memstats.heap.released_bytes
(gauge)
The number of heap bytes released to OS in the API Server
Shown as byte
argocd.api_server.go.memstats.heap.sys_bytes
(gauge)
The number of heap bytes obtained from system in the API Server
Shown as byte
argocd.api_server.go.memstats.last_gc_time.seconds
(gauge)
The number of seconds since Unix epoch of last garbage collection in the API Server
Shown as second
argocd.api_server.go.memstats.lookups.count
(count)
The total number of pointer lookups in the API Server
argocd.api_server.go.memstats.mallocs.count
(count)
The total number of mallocs in the API Server
argocd.api_server.go.memstats.mcache.inuse_bytes
(gauge)
The number of bytes in use by mcache structures in the API Server
Shown as byte
argocd.api_server.go.memstats.mcache.sys_bytes
(gauge)
The number of bytes used for mcache structures obtained from system in the API Server
Shown as byte
argocd.api_server.go.memstats.mspan.inuse_bytes
(gauge)
The number of bytes in use by mspan structures in the API Server
Shown as byte
argocd.api_server.go.memstats.mspan.sys_bytes
(gauge)
The number of bytes used for mspan structures obtained from system in the API Server
Shown as byte
argocd.api_server.go.memstats.next.gc_bytes
(gauge)
The number of heap bytes when next garbage collection takes place in the API Server
Shown as byte
argocd.api_server.go.memstats.other.sys_bytes
(gauge)
The number of bytes used for other system allocations in the API Server
Shown as byte
argocd.api_server.go.memstats.stack.inuse_bytes
(gauge)
The number of bytes in use by the stack allocator in the API Server
Shown as byte
argocd.api_server.go.memstats.stack.sys_bytes
(gauge)
The number of bytes obtained from system for stack allocator in the API Server
Shown as byte
argocd.api_server.go.memstats.sys_bytes
(gauge)
The number of bytes obtained from system in the API Server
Shown as byte
argocd.api_server.go.threads
(gauge)
The number of OS threads created in the API Server
Shown as thread
argocd.api_server.grpc.server.handled.count
(count)
The total number of RPCs completed on the server regardless of success or failure
argocd.api_server.grpc.server.msg.received.count
(count)
The total number of RPC stream messages received on the server
Shown as message
argocd.api_server.grpc.server.msg.sent.count
(count)
The total number of gRPC stream messages sent by the server
Shown as message
argocd.api_server.grpc.server.started.count
(count)
The total number of RPCs started on the server
argocd.api_server.process.cpu.seconds.count
(count)
The total user and system CPU time spent in seconds in the API Server
Shown as second
argocd.api_server.process.max_fds
(gauge)
The maximum number of open file descriptors in the API Server
argocd.api_server.process.open_fds
(gauge)
The number of open file descriptors in the API Server
argocd.api_server.process.resident_memory.bytes
(gauge)
The resident memory size in bytes in the API Server
Shown as byte
argocd.api_server.process.start_time.seconds
(gauge)
The start time of the process since unix epoch in seconds in the API Server
Shown as second
argocd.api_server.process.virtual_memory.bytes
(gauge)
The virtual memory size in bytes in the API Server
Shown as byte
argocd.api_server.process.virtual_memory.max_bytes
(gauge)
The maximum amount of virtual memory available in bytes in the API Server
Shown as byte
argocd.api_server.redis.request.count
(count)
The number of kubernetes requests executed during application reconciliation in the API Server
Shown as request
argocd.api_server.redis.request.duration.bucket
(count)
The Redis requests duration histogram buckets
Shown as request
argocd.api_server.redis.request.duration.count
(count)
The count aggregation of the Redis requests duration histogram
Shown as request
argocd.api_server.redis.request.duration.sum
(count)
The sum aggregation of the Redis requests duration histogram
Shown as request
argocd.app_controller.app.info
(gauge)
Information about Applications. It contains tags such as syncstatus and healthstatus that reflect the application state in Argo CD. The metric value is constant
argocd.app_controller.app.k8s.request.count
(count)
The number of kubernetes requests executed during application reconciliation
Shown as request
argocd.app_controller.app.labels
(gauge)
Argo Application labels converted to Prometheus labels. The metric value is constant. Disabled by default, see integration documentation for how to enable.
argocd.app_controller.app.reconcile.bucket
(count)
Application reconciliation performance histogram buckets
argocd.app_controller.app.reconcile.count
(count)
The count aggregation of the application reconciliation performance histogram
argocd.app_controller.app.reconcile.sum
(count)
The sum aggregation of the application reconciliation performance histogram
argocd.app_controller.app.sync.count
(count)
The total number of application syncs
argocd.app_controller.cluster.api.resource_objects
(gauge)
The number of Kubernetes resource objects in the cache
Shown as object
argocd.app_controller.cluster.api.resources
(gauge)
The number of monitored kubernetes API resources.
Shown as resource
argocd.app_controller.cluster.cache.age.seconds
(gauge)
The age of the cluster cache in seconds
Shown as second
argocd.app_controller.cluster.events.count
(count)
The number of processed Kubernetes resource events
Shown as event
argocd.app_controller.cluster.info
(gauge)
Information about cluster.
argocd.app_controller.go.gc.duration.seconds.count
(count)
The summary count of garbage collection cycles in the Repo Server Application Controller
Shown as second
argocd.app_controller.go.gc.duration.seconds.quantile
(gauge)
A summary of the pause duration of garbage collection cycles in the Application Controller
Shown as second
argocd.app_controller.go.gc.duration.seconds.sum
(count)
The sum of the pause duration of garbage collection cycles in the Application Controller
Shown as second
argocd.app_controller.go.goroutines
(gauge)
The number of goroutines that currently exist in the Application Controller
argocd.app_controller.go.memstats.alloc_bytes
(gauge)
The number of bytes allocated and still in use in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.buck_hash.sys_bytes
(gauge)
The number of bytes used by the profiling bucket hash table in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.frees.count
(count)
The notal number of frees in the Application Controller
argocd.app_controller.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 Application Controller
Shown as fraction
argocd.app_controller.go.memstats.gc.sys_bytes
(gauge)
The number of bytes used for garbage collection system metadata in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.heap.alloc_bytes
(gauge)
The number of heap bytes allocated and still in use in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.heap.idle_bytes
(gauge)
The number of heap bytes waiting to be used in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.heap.inuse_bytes
(gauge)
The number of heap bytes that are in use in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.heap.objects
(gauge)
The number of allocated objects in the Application Controller
Shown as object
argocd.app_controller.go.memstats.heap.released_bytes
(gauge)
The number of heap bytes released to OS in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.heap.sys_bytes
(gauge)
The number of heap bytes obtained from system in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.last_gc_time.seconds
(gauge)
The number of seconds since Unix epoch of last garbage collection in the Application Controller
Shown as second
argocd.app_controller.go.memstats.lookups.count
(count)
The total number of pointer lookups in the Application Controller
argocd.app_controller.go.memstats.mallocs.count
(count)
The total number of mallocs in the Application Controller
argocd.app_controller.go.memstats.mcache.inuse_bytes
(gauge)
The number of bytes in use by mcache structures in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.mcache.sys_bytes
(gauge)
The number of bytes used for mcache structures obtained from system in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.mspan.inuse_bytes
(gauge)
The number of bytes in use by mspan structures in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.mspan.sys_bytes
(gauge)
The number of bytes used for mspan structures obtained from system in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.next.gc_bytes
(gauge)
The number of heap bytes when next garbage collection takes place in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.other.sys_bytes
(gauge)
The number of bytes used for other system allocations in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.stack.inuse_bytes
(gauge)
The number of bytes in use by the stack allocator in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.stack.sys_bytes
(gauge)
The number of bytes obtained from system for stack allocator in the Application Controller
Shown as byte
argocd.app_controller.go.memstats.sys_bytes
(gauge)
The number of bytes obtained from system in the Application Controller
Shown as byte
argocd.app_controller.go.threads
(gauge)
The number of OS threads created in the Application Controller
Shown as thread
argocd.app_controller.kubectl.exec.count
(count)
The total number of kubectl executions
Shown as execution
argocd.app_controller.kubectl.exec.pending
(gauge)
The number of pending kubectl executions
Shown as execution
argocd.app_controller.process.cpu.seconds.count
(count)
The total user and system CPU time spent in seconds in the Application Controller
Shown as second
argocd.app_controller.process.max_fds
(gauge)
The maximum number of open file descriptors in the Application Controller
argocd.app_controller.process.open_fds
(gauge)
The number of open file descriptors in the Application Controller
argocd.app_controller.process.resident_memory.bytes
(gauge)
The resident memory size in bytes in the Application Controller
Shown as byte
argocd.app_controller.process.start_time.seconds
(gauge)
The start time of the process since unix epoch in seconds in the Application Controller
Shown as second
argocd.app_controller.process.virtual_memory.bytes
(gauge)
The virtual memory size in bytes in the Application Controller
Shown as byte
argocd.app_controller.process.virtual_memory.max_bytes
(gauge)
The maximum amount of virtual memory available in bytes in the Application Controller
Shown as byte
argocd.app_controller.redis.request.count
(count)
The number of kubernetes requests executed during application reconciliation in the Application Controller
Shown as request
argocd.app_controller.redis.request.duration.bucket
(count)
The Redis requests duration histogram buckets
Shown as second
argocd.app_controller.redis.request.duration.count
(count)
The count aggregation of the Redis requests duration histogram
Shown as second
argocd.app_controller.redis.request.duration.sum
(count)
The sum aggregation of the Redis requests duration histogram
Shown as second
argocd.app_controller.workqueue.adds.count
(count)
The total number of adds handled by workqueue
argocd.app_controller.workqueue.depth
(gauge)
The current depth of the workqueue
argocd.app_controller.workqueue.longest.running_processor.seconds
(gauge)
The number of seconds the longest running worqueue processor has been running
Shown as second
argocd.app_controller.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
argocd.app_controller.workqueue.queue.duration.seconds.count
(count)
The total number of events in the workqueue duration histogram
argocd.app_controller.workqueue.queue.duration.seconds.sum
(count)
The sum the of events counted in the workqueue duration histogram
argocd.app_controller.workqueue.retries.count
(count)
The total number of retries handled by workqueue
argocd.app_controller.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
argocd.app_controller.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
argocd.app_controller.workqueue.work.duration.seconds.count
(count)
The total number of events in the workqueue item processing duration histogram
argocd.app_controller.workqueue.work.duration.seconds.sum
(count)
The sum of events in the workqueue item processing duration histogram
argocd.appset_controller.active.workers
(gauge)
Number of currently used workers per controller
argocd.appset_controller.appset.info
(gauge)
Information about Application Sets. It contains labels for the name and namespace of an application set as well as Resourceupdatestatus that reflects the ResourcesUpToDate property
argocd.appset_controller.appset.labels
(gauge)
Applicationset labels translated to Prometheus labels. Disabled by default
argocd.appset_controller.appset.owned.applications
(gauge)
Number of applications owned by the applicationset. It contains labels for the name and namespace of an applicationset.
argocd.appset_controller.appset.reconcile.bucket
(count)
Application reconciliation performance observation counts by histogram buckets. It contains labels for the name and namespace of an applicationset
argocd.appset_controller.appset.reconcile.count
(count)
Application reconciliation performance observation counts total. It contains labels for the name and namespace of an applicationset
argocd.appset_controller.appset.reconcile.sum
(count)
Application reconciliation performance in seconds total. It contains labels for the name and namespace of an applicationset
argocd.appset_controller.go.gc.duration.seconds.count
(count)
The summary count of garbage collection cycles in the ApplicationSet controller
Shown as second
argocd.appset_controller.go.gc.duration.seconds.quantile
(gauge)
A summary of the pause duration of garbage collection cycles in the ApplicationSet controller
Shown as second
argocd.appset_controller.go.gc.duration.seconds.sum
(count)
The sum of the pause duration of garbage collection cycles in the ApplicationSet controller
Shown as second
argocd.appset_controller.go.goroutines
(gauge)
The number of goroutines that currently exist in the ApplicationSet controller
argocd.appset_controller.go.memstats.alloc_bytes
(gauge)
The number of bytes allocated and still in use in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.buck_hash.sys_bytes
(gauge)
The number of bytes used by the profiling bucket hash table in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.frees.count
(count)
The total number of frees in the ApplicationSet controller
argocd.appset_controller.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 ApplicationSet controller
Shown as fraction
argocd.appset_controller.go.memstats.gc.sys_bytes
(gauge)
The number of bytes used for garbage collection system metadata in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.heap.alloc_bytes
(gauge)
The number of heap bytes allocated and still in use in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.heap.idle_bytes
(gauge)
The number of heap bytes waiting to be used in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.heap.inuse_bytes
(gauge)
The number of heap bytes that are in use in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.heap.objects
(gauge)
The number of allocated objects in the ApplicationSet controller
Shown as object
argocd.appset_controller.go.memstats.heap.released_bytes
(gauge)
The number of heap bytes released to OS in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.heap.sys_bytes
(gauge)
The number of heap bytes obtained from system in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.last_gc_time.seconds
(gauge)
The number of seconds since Unix epoch of last garbage collection in the ApplicationSet controller
Shown as second
argocd.appset_controller.go.memstats.lookups.count
(count)
The total number of pointer lookups in the ApplicationSet controller
argocd.appset_controller.go.memstats.mallocs.count
(count)
The total number of mallocs in the ApplicationSet controller
argocd.appset_controller.go.memstats.mcache.inuse_bytes
(gauge)
The number of bytes in use by mcache structures in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.mcache.sys_bytes
(gauge)
The number of bytes used for mcache structures obtained from system in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.mspan.inuse_bytes
(gauge)
The number of bytes in use by mspan structures in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.mspan.sys_bytes
(gauge)
The number of bytes used for mspan structures obtained from system in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.next.gc_bytes
(gauge)
The number of heap bytes when next garbage collection takes place in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.other.sys_bytes
(gauge)
The number of bytes used for other system allocations in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.stack.inuse_bytes
(gauge)
The number of bytes in use by the stack allocator in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.stack.sys_bytes
(gauge)
The number of bytes obtained from system for stack allocator in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.memstats.sys_bytes
(gauge)
The number of bytes obtained from system in the ApplicationSet controller
Shown as byte
argocd.appset_controller.go.threads
(gauge)
The number of OS threads created in the ApplicationSet controller
Shown as thread
argocd.appset_controller.max.concurrent.reconciles
(gauge)
Maximum number of concurrent reconciles per controller
argocd.appset_controller.process.cpu.seconds.count
(count)
The total user and system CPU time spent in seconds in the ApplicationSet controller
Shown as second
argocd.appset_controller.process.max_fds
(gauge)
The maximum number of open file descriptors in the ApplicationSet controller
argocd.appset_controller.process.open_fds
(gauge)
The number of open file descriptors in the ApplicationSet controller
argocd.appset_controller.process.resident_memory.bytes
(gauge)
The resident memory size in bytes in the ApplicationSet controller
Shown as byte
argocd.appset_controller.process.start_time.seconds
(gauge)
The start time of the process since unix epoch in seconds in the ApplicationSet controller
Shown as second
argocd.appset_controller.process.virtual_memory.bytes
(gauge)
The virtual memory size in bytes in the ApplicationSet controller
Shown as byte
argocd.appset_controller.process.virtual_memory.max_bytes
(gauge)
The maximum amount of virtual memory available in bytes in the ApplicationSet controller
Shown as byte
argocd.appset_controller.reconcile.errors.count
(count)
The count of reconciliation errors per controller
argocd.appset_controller.reconcile.time_seconds.bucket
(count)
The histogram bucket for length of time per reconciliation per controller
argocd.appset_controller.reconcile.time_seconds.count
(count)
The count aggregation of length of time per reconciliation per controller
argocd.appset_controller.reconcile.time_seconds.sum
(count)
The sum aggregation of length of time per reconciliation per controller
argocd.appset_controller.runtime.reconcile.count
(count)
The count of reconciliations per controller
argocd.notifications_controller.go.gc.duration.seconds.count
(count)
The summary count of garbage collection cycles in the API Server
Shown as second
argocd.notifications_controller.go.gc.duration.seconds.quantile
(gauge)
A summary of the pause duration of garbage collection cycles in the API Server
Shown as second
argocd.notifications_controller.go.gc.duration.seconds.sum
(count)
The sum of the pause duration of garbage collection cycles in the API Server
Shown as second
argocd.notifications_controller.go.goroutines
(gauge)
The number of goroutines that currently exist in the API Server
argocd.notifications_controller.go.memstats.alloc_bytes
(gauge)
The number of bytes allocated and still in use in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.buck_hash.sys_bytes
(gauge)
The number of bytes used by the profiling bucket hash table in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.frees.count
(count)
The total number of frees in the API Server
argocd.notifications_controller.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 API Server
Shown as fraction
argocd.notifications_controller.go.memstats.gc.sys_bytes
(gauge)
The number of bytes used for garbage collection system metadata in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.heap.alloc_bytes
(gauge)
The number of heap bytes allocated and still in use in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.heap.idle_bytes
(gauge)
The number of heap bytes waiting to be used in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.heap.inuse_bytes
(gauge)
The number of heap bytes that are in use in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.heap.objects
(gauge)
The number of allocated objects in the API Server
Shown as object
argocd.notifications_controller.go.memstats.heap.released_bytes
(gauge)
The number of heap bytes released to OS in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.heap.sys_bytes
(gauge)
The number of heap bytes obtained from system in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.last_gc_time.seconds
(gauge)
The number of seconds since Unix epoch of last garbage collection in the API Server
Shown as second
argocd.notifications_controller.go.memstats.lookups.count
(count)
The total number of pointer lookups in the API Server
argocd.notifications_controller.go.memstats.mallocs.count
(count)
The total number of mallocs in the API Server
argocd.notifications_controller.go.memstats.mcache.inuse_bytes
(gauge)
The number of bytes in use by mcache structures in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.mcache.sys_bytes
(gauge)
The number of bytes used for mcache structures obtained from system in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.mspan.inuse_bytes
(gauge)
The number of bytes in use by mspan structures in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.mspan.sys_bytes
(gauge)
The number of bytes used for mspan structures obtained from system in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.next.gc_bytes
(gauge)
The number of heap bytes when next garbage collection takes place in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.other.sys_bytes
(gauge)
The number of bytes used for other system allocations in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.stack.inuse_bytes
(gauge)
The number of bytes in use by the stack allocator in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.stack.sys_bytes
(gauge)
The number of bytes obtained from system for stack allocator in the API Server
Shown as byte
argocd.notifications_controller.go.memstats.sys_bytes
(gauge)
The number of bytes obtained from system in the API Server
Shown as byte
argocd.notifications_controller.go.threads
(gauge)
The number of OS threads created in the API Server
Shown as thread
argocd.notifications_controller.notifications.deliveries.count
(count)
The total number of delivered notifications
argocd.notifications_controller.notifications.trigger_eval.count
(count)
The total number of triggered notifications
argocd.notifications_controller.process.cpu.seconds.count
(count)
The total user and system CPU time spent in seconds in the API Server
Shown as second
argocd.notifications_controller.process.max_fds
(gauge)
The maximum number of open file descriptors in the API Server
argocd.notifications_controller.process.open_fds
(gauge)
The number of open file descriptors in the API Server
argocd.notifications_controller.process.resident_memory.bytes
(gauge)
The resident memory size in bytes in the API Server
Shown as byte
argocd.notifications_controller.process.start_time.seconds
(gauge)
The start time of the process since unix epoch in seconds in the API Server
Shown as second
argocd.notifications_controller.process.virtual_memory.bytes
(gauge)
The virtual memory size in bytes in the API Server
Shown as byte
argocd.notifications_controller.process.virtual_memory.max_bytes
(gauge)
The maximum amount of virtual memory available in bytes in the API Server
Shown as byte
argocd.repo_server.git.request.count
(count)
The total number of Git Requests performed by the Repo Server
Shown as request
argocd.repo_server.git.request.duration.seconds.bucket
(count)
The histogram bucket for duration of Git Requests in seconds
Shown as second
argocd.repo_server.git.request.duration.seconds.count
(count)
The count aggregation of the Git Request duration histogram
argocd.repo_server.git.request.duration.seconds.sum
(count)
The sum aggregation of the Git Request duration histogram
argocd.repo_server.go.gc.duration.seconds.count
(count)
The summary count of garbage collection cycles in the Repo Server
Shown as second
argocd.repo_server.go.gc.duration.seconds.quantile
(gauge)
A summary of the pause duration of garbage collection cycles in the Repo Server
Shown as second
argocd.repo_server.go.gc.duration.seconds.sum
(count)
The sum of the pause duration of garbage collection cycles in the Repo Server
Shown as second
argocd.repo_server.go.goroutines
(gauge)
The number of goroutines that currently exist in the Repo Server
argocd.repo_server.go.memstats.alloc_bytes
(gauge)
The number of bytes allocated and still in use in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.buck_hash.sys_bytes
(gauge)
The number of bytes used by the profiling bucket hash table in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.frees.count
(count)
The total number of frees in the Repo Server
argocd.repo_server.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 Repo Server
Shown as fraction
argocd.repo_server.go.memstats.gc.sys_bytes
(gauge)
The number of bytes used for garbage collection system metadata in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.heap.alloc_bytes
(gauge)
The number of heap bytes allocated and still in use in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.heap.idle_bytes
(gauge)
The number of heap bytes waiting to be used in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.heap.inuse_bytes
(gauge)
The number of heap bytes that are in use in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.heap.objects
(gauge)
The number of allocated objects in the Repo Server
Shown as object
argocd.repo_server.go.memstats.heap.released_bytes
(gauge)
The number of heap bytes released to OS in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.heap.sys_bytes
(gauge)
The number of heap bytes obtained from system in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.last_gc_time.seconds
(gauge)
The number of seconds since Unix epoch of last garbage collection in the Repo Server
Shown as second
argocd.repo_server.go.memstats.lookups.count
(count)
The total number of pointer lookups in the Repo Server
argocd.repo_server.go.memstats.mallocs.count
(count)
The total number of mallocs in the Repo Server
argocd.repo_server.go.memstats.mcache.inuse_bytes
(gauge)
The number of bytes in use by mcache structures in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.mcache.sys_bytes
(gauge)
The number of bytes used for mcache structures obtained from system in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.mspan.inuse_bytes
(gauge)
The number of bytes in use by mspan structures in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.mspan.sys_bytes
(gauge)
The number of bytes used for mspan structures obtained from system in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.next.gc_bytes
(gauge)
The number of heap bytes when next garbage collection takes place in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.other.sys_bytes
(gauge)
The number of bytes used for other system allocations in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.stack.inuse_bytes
(gauge)
The number of bytes in use by the stack allocator in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.stack.sys_bytes
(gauge)
The number of bytes obtained from system for stack allocator in the Repo Server
Shown as byte
argocd.repo_server.go.memstats.sys_bytes
(gauge)
The number of bytes obtained from system in the Repo Server
Shown as byte
argocd.repo_server.go.threads
(gauge)
The number of OS threads created in the Repo Server
Shown as thread
argocd.repo_server.process.cpu.seconds.count
(count)
The total user and system CPU time spent in seconds in the Repo Server
Shown as second
argocd.repo_server.process.max_fds
(gauge)
The maximum number of open file descriptors in the Repo Server
argocd.repo_server.process.open_fds
(gauge)
The number of open file descriptors in the Repo Server
argocd.repo_server.process.resident_memory.bytes
(gauge)
The resident memory size in bytes in the Repo Server
Shown as byte
argocd.repo_server.process.start_time.seconds
(gauge)
The start time of the process since unix epoch in seconds in the Repo Server
Shown as second
argocd.repo_server.process.virtual_memory.bytes
(gauge)
The virtual memory size in bytes in the Repo Server
Shown as byte
argocd.repo_server.process.virtual_memory.max_bytes
(gauge)
The maximum amount of virtual memory available in bytes in the Repo Server
Shown as byte
argocd.repo_server.redis.request.count
(count)
The number of kubernetes requests executed during application reconciliation in the Repo Server
Shown as request
argocd.repo_server.redis.request.duration.seconds.bucket
(count)
The Redis requests duration histogram buckets
Shown as second
argocd.repo_server.redis.request.duration.seconds.count
(count)
The count aggregation of the Redis requests duration histogram
Shown as second
argocd.repo_server.redis.request.duration.seconds.sum
(count)
The sum aggregation of the Redis requests duration histogram
Shown as second
argocd.repo_server.repo.pending.request.total
(gauge)
The number of pending requests requiring repository lock
Shown as request

Events

The Argo CD integration does not include any events.

Service Checks

argocd.api_server.openmetrics.health
Returns CRITICAL if the Agent is unable to connect to the API Server OpenMetrics endpoint, otherwise returns OK.
Statuses: ok, critical

argocd.app_controller.openmetrics.health
Returns CRITICAL if the Agent is unable to connect to the Application Controller OpenMetrics endpoint, otherwise returns OK.
Statuses: ok, critical

argocd.appset_controller.openmetrics.health
Returns CRITICAL if not connected to the cluster, otherwise returns OK.
Statuses: ok, critical

argocd.repo_server.openmetrics.health
Returns CRITICAL if the Agent is unable to connect to the Repo Server OpenMetrics endpoint, otherwise returns OK.
Statuses: ok, critical

argocd.app_controller.cluster.connection.status
Returns CRITICAL if not connected to the cluster, otherwise returns OK.
Statuses: ok, critical

argocd.notifications_controller.openmetrics.health
Returns CRITICAL if the Agent is unable to connect to the Repo Server OpenMetrics endpoint, otherwise returns OK.
Statuses: ok, critical

Troubleshooting

Need help? Contact Datadog support.

Further Reading

Additional helpful documentation, links, and articles: