--- title: Argo CD description: Monitor the health and performance of Argo CD breadcrumbs: Docs > Integrations > Argo CD --- > For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt). # Argo CD Supported OS Integration version4.8.0 {% callout %} # Important note for users on the following Datadog sites: us2.ddog-gov.com {% alert level="info" %} To find out if this integration is available in your organization, see your [Datadog Integrations](https://app.datadoghq.com/integrations) page or ask your organization administrator. To initiate an exception request to enable this integration for your organization, email [support@ddog-gov.com](mailto:support@ddog-gov.com). {% /alert %} {% /callout %} ## Overview{% #overview %} This check monitors [Argo CD](https://argo-cd.readthedocs.io/en/stable/) through the Datadog Agent. **Minimum Agent version:** 7.41.0 ## Setup{% #setup %} ### Installation{% #installation %} The Argo CD check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. No additional installation is needed on your server. **Note**: This check requires Agent v7.42.0+. ### Configuration{% #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](https://docs.datadoghq.com/integrations/openmetrics.md) for metric collection, which requires Python 3. #### Containerized{% #containerized %} ##### Metric collection{% #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](https://argo-cd.readthedocs.io/en/stable/operator-manual/installation/). Configure each of the three components with one of the Kubernetes Autodiscovery options below. Additional configuration options are available by reviewing the [sample argocd.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/argocd/datadog_checks/argocd/data/conf.yaml.example). 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](https://argo-cd.readthedocs.io/en/stable/operator-manual/metrics/#exposing-application-labels-as-prometheus-metrics) for instructions on how to enable it. Example configurations: {% tab title="Kubernetes annotations" %} **Application Controller**: ```yaml apiVersion: v1 kind: Pod # (...) metadata: 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**: ```yaml apiVersion: v1 kind: Pod # (...) metadata: 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**: ```yaml apiVersion: v1 kind: Pod # (...) metadata: 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' # (...) ``` {% /tab %} {% tab title="DatadogInstrumentation CRD" %} Create one resource per target workload. These resources mirror the annotation configurations: ```yaml apiVersion: datadoghq.com/v1alpha1 kind: DatadogInstrumentation metadata: name: argocd-application-controller-instrumentation namespace: spec: targetRef: apiVersion: apps/v1 kind: StatefulSet name: argocd-application-controller config: checks: - integration: argocd containerName: argocd-application-controller initConfig: {} instances: - app_controller_endpoint: "http://%%host%%:8082/metrics" --- apiVersion: datadoghq.com/v1alpha1 kind: DatadogInstrumentation metadata: name: argocd-server-instrumentation namespace: spec: targetRef: apiVersion: apps/v1 kind: Deployment name: argocd-server config: checks: - integration: argocd containerName: argocd-server initConfig: {} instances: - api_server_endpoint: "http://%%host%%:8083/metrics" --- apiVersion: datadoghq.com/v1alpha1 kind: DatadogInstrumentation metadata: name: argocd-repo-server-instrumentation namespace: spec: targetRef: apiVersion: apps/v1 kind: Deployment name: argocd-repo-server config: checks: - integration: argocd containerName: argocd-repo-server initConfig: {} instances: - repo_server_endpoint: "http://%%host%%:8084/metrics" ``` For setup details, see [Configure Autodiscovery with the DatadogInstrumentation CRD](https://docs.datadoghq.com/containers/guide/configure-autodiscovery-with-the-datadoginstrumentation-crd.md). {% /tab %} **Note**: For the full list of supported endpoints, see the [conf.yaml example file](https://github.com/DataDog/integrations-core/blob/master/argocd/datadog_checks/argocd/data/conf.yaml.example#L45-L72). ##### Troubleshooting{% #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](https://github.com/DataDog/integrations-core/blob/7.45.x/argocd/datadog_checks/argocd/data/conf.yaml.example#L164-L166) to something more unique, such as `argocd_app_name` if the host happens to already have a name tag. Below is an example configuration: {% tab title="Kubernetes annotations" %} **Application Controller**: ```yaml apiVersion: v1 kind: Pod # (...) metadata: 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' # (...) ``` {% /tab %} {% tab title="DatadogInstrumentation CRD" %} Target the Application Controller StatefulSet: ```yaml apiVersion: datadoghq.com/v1alpha1 kind: DatadogInstrumentation metadata: name: namespace: spec: targetRef: apiVersion: apps/v1 kind: StatefulSet name: argocd-application-controller config: checks: - integration: argocd containerName: argocd-application-controller initConfig: {} instances: - app_controller_endpoint: "http://%%host%%:8082/metrics" rename_labels: name: "argocd_app_name" ``` For setup details, see [Configure Autodiscovery with the DatadogInstrumentation CRD](https://docs.datadoghq.com/containers/guide/configure-autodiscovery-with-the-datadoginstrumentation-crd.md). {% /tab %} ##### Log collection{% #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](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 | | -------------- | --------------------------------------------------- | | `` | `{"source": "argocd", "service": ""}` | ### Entity collection{% #entity-collection %} Entity collection sends Argo CD Applications, Clusters, and Repositories to Datadog as resources, so that your Argo CD inventory is visible alongside the rest of your infrastructure. It is independent of metric and log collection, and it uses two complementary paths: | Path | Mechanism | Coverage | | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | | Agent collector | The Agent's `argocd` check polls the Argo CD API on a fixed interval. | Baseline inventory of Applications, Clusters, and Repositories. | | Notifications webhook | The Argo CD [notifications controller](https://argo-cd.readthedocs.io/en/stable/operator-manual/notifications/) posts Application changes to Datadog. | Application sync, health, and operation changes between polls. These are also submitted as Datadog events. | Configure both paths. The Agent collector establishes and refreshes the full inventory, and the webhook carries the Application changes that happen between polls. Clusters and Repositories are collected only by the Agent, because Argo CD stores them as Kubernetes Secrets rather than custom resources and offers no notification trigger for them. **Important**: Both paths identify an Application by the same key, built from the cluster name, the environment, the Application's namespace, and its name. The Agent derives the cluster name and environment from its own configuration, while the notifications controller reads them from its ConfigMap. If the two disagree, each path creates a separate resource for every Application, and neither path reports an error. Define both values once per cluster and reference them from both places. **Note**: Entity collection requires Agent v7.82.0 or later. #### Prerequisites{% #prerequisites %} - Network access from the Agent to the Argo CD API server, which is usually the `argocd-server` service. This is the REST API, and it is distinct from the Prometheus endpoints used for metric collection. - An Argo CD API token with read access to applications, clusters, and repositories. Add a dedicated local account to the `argocd-cm` ConfigMap, grant it read access in `argocd-rbac-cm`, then issue a token for it: ```yaml ## argocd-cm data: accounts.datadog: apiKey ``` ```yaml ## argocd-rbac-cm data: policy.csv: | p, role:datadog-readonly, applications, get, */*, allow p, role:datadog-readonly, clusters, get, *, allow p, role:datadog-readonly, repositories, get, *, allow g, datadog, role:datadog-readonly ``` ```shell argocd account generate-token --account datadog ``` Patch these ConfigMaps rather than applying a partial manifest over them. Argo CD's installation manifest owns both, and applying a partial file replaces their entire `data` map. For more details, see [Argo CD user management](https://argo-cd.readthedocs.io/en/stable/operator-manual/user-management/) and [Argo CD RBAC configuration](https://argo-cd.readthedocs.io/en/stable/operator-manual/rbac/). - The Argo CD notifications controller, which is bundled with Argo CD v2.6 and later. Earlier versions require the standalone `argocd-notifications` component. #### Configure the Agent collector{% #configure-the-agent-collector %} Add the following to the Argo CD instance in `conf.d/argocd.d/conf.yaml`, alongside the metric collection endpoints you already configured. When the check is configured through Kubernetes Autodiscovery annotations instead, add the same keys to the instance in that configuration. ```yaml init_config: instances: - ## Existing metric collection endpoints, unchanged. app_controller_endpoint: http://argocd-metrics:8082/metrics api_server_endpoint: http://argocd-server-metrics:8083/metrics ## Entity collection against the Argo CD REST API. collect_genresources: true genresources_endpoint: https://argocd-server.argocd.svc.cluster.local genresources_auth_token: ## Poll all three resource types every five minutes. genresources_application_full_scrape_interval_seconds: 300 genresources_application_poll_interval_seconds: 300 genresources_cluster_scrape_interval_seconds: 300 genresources_repository_scrape_interval_seconds: 300 genresources_ttl_seconds: 1800 ## The check need not run every 15 seconds when the shortest interval above is 300. min_collection_interval: 60 ``` The available options are: | Option | Default | Description | | ------------------------------------------------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `collect_genresources` | `false` | Enables entity collection. Required. | | `genresources_endpoint` | none | Base URL of the Argo CD REST API. Required. This is not a Prometheus metrics URL. | | `genresources_auth_token` | none | Bearer token used to authenticate against the Argo CD API. When unset, the collector uses the authentication configured on the instance. | | `genresources_application_full_scrape_interval_seconds` | `600` | Interval between full Application scrapes. Every Application is resubmitted, which refreshes its expiry. | | `genresources_application_poll_interval_seconds` | `120` | Interval between Application polls that submit only what changed. Set it to the full scrape interval to collect Applications on a single cadence. | | `genresources_cluster_scrape_interval_seconds` | `300` | Interval between full Cluster scrapes. | | `genresources_repository_scrape_interval_seconds` | `300` | Interval between full Repository scrapes. | | `genresources_ttl_seconds` | `1800` | How long a resource is retained after it was last observed. Keep it at or above the longest scrape interval; otherwise, resources expire before they are refreshed. The check logs a warning when this value is too low. | | `genresources_max_resources_per_cycle` | `10000` | Maximum number of items collected per resource type per cycle. Anything beyond the cap is dropped and a warning is logged. | | `collect_openmetrics` | `true` | Scrapes the Prometheus endpoints. Set it to `false` to run entity collection without metric collection, in which case the `*_endpoint` options are not required. At least one of `collect_openmetrics` and `collect_genresources` must be enabled. | Note the following: - Enable entity collection on one Argo CD instance only. Several Agents polling the same Argo CD API submit the same resources under the same key, which adds API load without adding data. - The key prefix comes from the Agent's own cluster name and `env` tag, not from this configuration. Set `DD_CLUSTER_NAME` and `DD_ENV` explicitly when the Agent cannot detect them, such as when it runs outside the cluster it monitors, and use the same values in the notifications ConfigMap below. - When the Argo CD API presents a certificate the Agent does not trust, point `tls_ca_cert` at the certificate authority. Setting `tls_verify` to `false` also works, but it disables verification for the whole instance. #### Configure the notifications webhook{% #configure-the-notifications-webhook %} The Argo CD notifications controller renders a template and posts it to a webhook URL whenever a trigger fires. Point it at Datadog to push Application changes as they happen. 1. Copy the generated webhook URL from the **Configure** tab on the [Argo CD integration tile](https://app.datadoghq.com/integrations/argocd). 1. Add the context, destination, payload template, and trigger to the `argocd-notifications-cm` ConfigMap in the `argocd` namespace: ```yaml apiVersion: v1 kind: ConfigMap metadata: name: argocd-notifications-cm namespace: argocd data: ## Values available to the template below. These must match the cluster name ## and environment the Datadog Agent reports for this cluster. context: | cluster_name: env: ## Destination. Paste the webhook URL generated above exactly as copied: it ## already carries the API key and the Argo CD integration selector. service.webhook.datadog: | url: headers: - name: Content-Type value: application/json ## Payload. The whole Application resource is sent, so every field Datadog ## reads is present without selecting fields here. template.dd-entity: | webhook: datadog: method: POST body: | {"dd":{"cluster_name":"{{ .context.cluster_name }}","env":"{{ .context.env }}"},"app":{{ toJson .app }}} ## When to send. The oncePer expression collapses repeats, so a stable ## Application is not notified again until its health, sync, or operation ## state changes. trigger.dd-on-change: | - when: app.status.health.status != '' or app.status.sync.status != '' oncePer: "app.status.health.status + '|' + app.status.sync.status + '|' + (app.status.operationState != nil ? app.status.operationState.phase : '')" send: [dd-entity] ``` The webhook URL contains your API key, so treat the ConfigMap accordingly. To keep the key out of it, remove the `dd-api-key` query parameter from the URL and send the key as a `DD-API-KEY` header sourced from a Secret instead. 1. Apply the ConfigMap and restart the notifications controller so that it reloads the configuration: ```shell kubectl apply -f argocd-notifications-cm.yaml kubectl rollout restart deploy/argocd-notifications-controller -n argocd ``` 1. Subscribe each Application you want to track: ```shell kubectl -n argocd annotate application \ notifications.argoproj.io/subscribe.dd-on-change.datadog="" ``` To subscribe every Application at once, add a default subscription to the same ConfigMap instead of annotating each one: ```yaml subscriptions: | - recipients: [datadog] triggers: [dd-on-change] ``` A default subscription tracks every Application on the cluster. On large clusters, start with per-Application annotations, or add a `selector` to the default subscription, to keep event volume under control. **Note**: Argo CD records the notifications it has already sent in each Application's `notified.notifications.argoproj.io` annotation and never removes entries. An Application therefore stops notifying after it has sent one notification for every combination its `oncePer` expression can produce, and the controller logs `already sent` in place of `TRIGGERED`. This deduplication is what keeps the webhook from firing on every reconcile, and the Agent collector's periodic scrape keeps the resource current regardless. #### Validate entity collection{% #validate-entity-collection %} 1. Confirm that the Agent reaches the Argo CD API. The check submits `argocd.genresources.api.up` with a value of `1` for each `resource_type` tag (`argocd_application`, `argocd_cluster`, and `argocd_repository`) when a scrape succeeds, and `0` when it fails. 1. Confirm that the notifications controller is sending notifications: ```shell kubectl logs -n argocd deploy/argocd-notifications-controller --tail=40 | grep -i trigger ``` A line containing `TRIGGERED` means the trigger fired and the notification was sent. 1. Search the Datadog [Event Explorer](https://docs.datadoghq.com/service_management/events/explorer.md) for `@evt.integration_id:argocd` to confirm that the webhook notifications arrived. A `202` response from Datadog means the notification was accepted rather than searchable, so allow a short delay before searching. 1. Confirm that each Application appears once in Datadog. Two resources for the same Application mean the cluster name or the environment differs between the Agent configuration and the notifications ConfigMap. ### Validation{% #validation %} [Run the Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands.md#agent-status-and-information) and look for `argocd` under the Checks section. ## Data Collected{% #data-collected %} ### Metrics{% #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.login.request.count**(count) | Total number of login requests*Shown as request* | | **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.proxy_extension.request.count**(count) | Total number of proxy extension requests*Shown as request* | | **argocd.api_server.proxy_extension.request.duration.seconds.bucket**(count) | Proxy extension request duration histogram buckets*Shown as second* | | **argocd.api_server.proxy_extension.request.duration.seconds.count**(count) | The count aggregation of the proxy extension request duration histogram | | **argocd.api_server.proxy_extension.request.duration.seconds.sum**(count) | The sum aggregation of the proxy extension request duration histogram*Shown as second* | | **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.condition**(gauge) | Report Applications conditions currently present in status | | **argocd.app_controller.app.info**(gauge) | Information about Applications. It contains tags such as sync_status and health_status 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.orphaned_resources.count**(gauge) | Number of orphaned resources per application | | **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.app.sync.duration.seconds.count**(count) | Application sync performance in seconds*Shown as second* | | **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.client_cert_rotation.age.seconds**(gauge) | Age of kubectl client certificate rotation*Shown as second* | | **argocd.app_controller.kubectl.dns_resolution.duration.seconds.bucket**(count) | Latency of kubectl DNS resolution histogram buckets*Shown as second* | | **argocd.app_controller.kubectl.dns_resolution.duration.seconds.count**(count) | The count aggregation of the kubectl DNS resolution histogram | | **argocd.app_controller.kubectl.dns_resolution.duration.seconds.sum**(count) | The sum aggregation of the kubectl DNS resolution histogram*Shown as second* | | **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.kubectl.exec_plugin.call.count**(count) | Total number of kubectl exec plugin calls | | **argocd.app_controller.kubectl.rate_limiter.duration.seconds.bucket**(count) | Latency of kubectl rate limiter histogram buckets*Shown as second* | | **argocd.app_controller.kubectl.rate_limiter.duration.seconds.count**(count) | The count aggregation of the kubectl rate limiter histogram | | **argocd.app_controller.kubectl.rate_limiter.duration.seconds.sum**(count) | The sum aggregation of the kubectl rate limiter histogram*Shown as second* | | **argocd.app_controller.kubectl.request.duration.seconds.bucket**(count) | Latency of kubectl requests histogram buckets*Shown as second* | | **argocd.app_controller.kubectl.request.duration.seconds.count**(count) | The count aggregation of the kubectl request duration histogram | | **argocd.app_controller.kubectl.request.duration.seconds.sum**(count) | The sum aggregation of the kubectl request duration histogram*Shown as second* | | **argocd.app_controller.kubectl.request.retries.count**(count) | Total number of kubectl request retries | | **argocd.app_controller.kubectl.request.size.bytes.bucket**(count) | Size of kubectl requests histogram buckets*Shown as byte* | | **argocd.app_controller.kubectl.request.size.bytes.count**(count) | The count aggregation of the kubectl request size histogram | | **argocd.app_controller.kubectl.request.size.bytes.sum**(count) | The sum aggregation of the kubectl request size histogram*Shown as byte* | | **argocd.app_controller.kubectl.requests.count**(count) | Total number of kubectl requests*Shown as request* | | **argocd.app_controller.kubectl.response.size.bytes.bucket**(count) | Size of kubectl responses histogram buckets*Shown as byte* | | **argocd.app_controller.kubectl.response.size.bytes.count**(count) | The count aggregation of the kubectl response size histogram | | **argocd.app_controller.kubectl.response.size.bytes.sum**(count) | The sum aggregation of the kubectl response size histogram*Shown as byte* | | **argocd.app_controller.kubectl.transport.cache_entries**(gauge) | Number of kubectl transport cache entries | | **argocd.app_controller.kubectl.transport.create_calls.count**(count) | Total number of kubectl transport create calls | | **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.resource_events.processed_in_batch**(gauge) | Number of resource events processed in batch | | **argocd.app_controller.resource_events.processing.bucket**(count) | Time to process resource events in batch histogram buckets*Shown as second* | | **argocd.app_controller.resource_events.processing.count**(count) | The count aggregation of the resource events processing histogram | | **argocd.app_controller.resource_events.processing.sum**(count) | The sum aggregation of the resource events processing 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 Resource_update_status 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.github_api.rate_limit.limit**(gauge) | GitHub API maximum requests per hour | | **argocd.appset_controller.github_api.rate_limit.remaining**(gauge) | GitHub API requests remaining in rate limit window | | **argocd.appset_controller.github_api.rate_limit.reset.seconds**(gauge) | GitHub API time until rate limit window resets*Shown as second* | | **argocd.appset_controller.github_api.rate_limit.used**(gauge) | GitHub API requests used in current rate limit window | | **argocd.appset_controller.github_api.request.duration.seconds.bucket**(count) | GitHub API request duration histogram buckets*Shown as second* | | **argocd.appset_controller.github_api.request.duration.seconds.count**(count) | The count aggregation of the GitHub API request duration histogram | | **argocd.appset_controller.github_api.request.duration.seconds.sum**(count) | The sum aggregation of the GitHub API request duration histogram*Shown as second* | | **argocd.appset_controller.github_api.requests.count**(count) | Total number of GitHub API requests*Shown as request* | | **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.commit_server.commit.pending.request.total**(gauge) | The number of pending requests requiring commit lock*Shown as request* | | **argocd.commit_server.commit.request.count**(count) | The number of commit requests performed by commit server*Shown as request* | | **argocd.commit_server.commit.request.duration.seconds.bucket**(count) | The commit requests duration histogram buckets | | **argocd.commit_server.commit.request.duration.seconds.count**(count) | The count aggregation of the commit requests duration histogram | | **argocd.commit_server.commit.request.duration.seconds.sum**(count) | The sum aggregation of the commit requests duration histogram*Shown as second* | | **argocd.commit_server.git.request.count**(count) | The number of git requests performed by commit server*Shown as request* | | **argocd.commit_server.git.request.duration.seconds.bucket**(count) | The git requests duration histogram buckets | | **argocd.commit_server.git.request.duration.seconds.count**(count) | The count aggregation of the git requests duration histogram | | **argocd.commit_server.git.request.duration.seconds.sum**(count) | The sum aggregation of the git requests duration histogram*Shown as second* | | **argocd.commit_server.go.gc.duration.seconds.count**(count) | The summary count of garbage collection cycles in the commit server | | **argocd.commit_server.go.gc.duration.seconds.quantile**(gauge) | A summary of the pause duration of garbage collection cycles in the commit server | | **argocd.commit_server.go.gc.duration.seconds.sum**(count) | The sum of the pause duration of garbage collection cycles in the commit server*Shown as second* | | **argocd.commit_server.go.goroutines**(gauge) | The number of goroutines that currently exist in the commit server | | **argocd.commit_server.go.memstats.alloc_bytes**(gauge) | The number of bytes allocated and still in use in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.buck_hash.sys_bytes**(gauge) | The number of bytes used by the profiling bucket hash table in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.frees.count**(count) | The total number of frees in the commit server | | **argocd.commit_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 commit server*Shown as fraction* | | **argocd.commit_server.go.memstats.gc.sys_bytes**(gauge) | The number of bytes used for garbage collection system metadata in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.heap.alloc_bytes**(gauge) | The number of heap bytes allocated and still in use in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.heap.idle_bytes**(gauge) | The number of heap bytes waiting to be used in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.heap.inuse_bytes**(gauge) | The number of heap bytes that are in use in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.heap.objects**(gauge) | The number of allocated objects in the commit server*Shown as object* | | **argocd.commit_server.go.memstats.heap.released_bytes**(gauge) | The number of heap bytes released to OS in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.heap.sys_bytes**(gauge) | The number of heap bytes obtained from system in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.last_gc_time.seconds**(gauge) | The number of seconds since Unix epoch of last garbage collection in the commit server*Shown as second* | | **argocd.commit_server.go.memstats.lookups.count**(count) | The total number of pointer lookups in the commit server | | **argocd.commit_server.go.memstats.mallocs.count**(count) | The total number of mallocs in the commit server | | **argocd.commit_server.go.memstats.mcache.inuse_bytes**(gauge) | The number of bytes in use by mcache structures in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.mcache.sys_bytes**(gauge) | The number of bytes used for mcache structures obtained from system in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.mspan.inuse_bytes**(gauge) | The number of bytes in use by mspan structures in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.mspan.sys_bytes**(gauge) | The number of bytes used for mspan structures obtained from system in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.next.gc_bytes**(gauge) | The number of heap bytes when next garbage collection takes place in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.other.sys_bytes**(gauge) | The number of bytes used for other system allocations in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.stack.inuse_bytes**(gauge) | The number of bytes in use by the stack allocator in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.stack.sys_bytes**(gauge) | The number of bytes obtained from system for stack allocator in the commit server*Shown as byte* | | **argocd.commit_server.go.memstats.sys_bytes**(gauge) | The number of bytes obtained from system in the commit server*Shown as byte* | | **argocd.commit_server.go.threads**(gauge) | The number of OS threads created in the commit server*Shown as thread* | | **argocd.commit_server.process.cpu.seconds.count**(count) | The total user and system CPU time spent in seconds in the commit server*Shown as second* | | **argocd.commit_server.process.max_fds**(gauge) | The maximum number of open file descriptors in the commit server | | **argocd.commit_server.process.open_fds**(gauge) | The number of open file descriptors in the commit server | | **argocd.commit_server.process.resident_memory.bytes**(gauge) | The resident memory size in bytes in the commit server*Shown as byte* | | **argocd.commit_server.process.start_time.seconds**(gauge) | The start time of the process since unix epoch in seconds in the commit server*Shown as second* | | **argocd.commit_server.process.virtual_memory.bytes**(gauge) | The virtual memory size in bytes in the commit server*Shown as byte* | | **argocd.commit_server.process.virtual_memory.max_bytes**(gauge) | The maximum amount of virtual memory available in bytes in the commit server*Shown as byte* | | **argocd.commit_server.userinfo.request.duration.seconds.bucket**(count) | The userinfo requests duration histogram buckets | | **argocd.commit_server.userinfo.request.duration.seconds.count**(count) | The count aggregation of the userinfo requests duration histogram | | **argocd.commit_server.userinfo.request.duration.seconds.sum**(count) | The sum aggregation of the userinfo requests duration histogram*Shown as second* | | **argocd.genresources.api.up**(gauge) | Reachability of the Argo CD REST API used by the generic resources collector. Emits 1 per resource_type tag on success and 0 on failure; each resource_type reports on its own scrape interval rather than the check's collection interval. | | **argocd.genresources.stream.events_received**(count) | Number of application watch events received from the Argo CD stream. | | **argocd.genresources.stream.reconnects**(count) | Number of times the application watch stream reconnected after a disconnect (clean or error). | | **argocd.genresources.stream.up**(gauge) | Whether the Argo CD application watch stream is currently connected (1) or not (0). | | **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.fetch.fail.count**(count) | Total number of git fetch request failures | | **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.oci.digest_metadata.fail.count**(count) | Total number of OCI digest metadata failures | | **argocd.repo_server.oci.extract.fail.count**(count) | Total number of OCI extract request failures | | **argocd.repo_server.oci.get_tags.fail.count**(count) | Total number of OCI get tags request failures | | **argocd.repo_server.oci.request.count**(count) | Total number of OCI requests performed*Shown as request* | | **argocd.repo_server.oci.request.duration.seconds.bucket**(count) | OCI request duration histogram buckets*Shown as second* | | **argocd.repo_server.oci.request.duration.seconds.count**(count) | The count aggregation of the OCI request duration histogram | | **argocd.repo_server.oci.request.duration.seconds.sum**(count) | The sum aggregation of the OCI request duration histogram*Shown as second* | | **argocd.repo_server.oci.resolve_revision.fail.count**(count) | Total number of OCI resolve revision failures | | **argocd.repo_server.oci.test_repo.fail.count**(count) | Total number of OCI test repo request failures | | **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{% #events %} The Argo CD integration submits Application sync and health status events to Datadog when the Argo CD [notifications controller](https://argo-cd.readthedocs.io/en/stable/operator-manual/notifications/) is configured to forward them through the webhook described in the Entity collection section. ### Service Checks{% #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 Notifications Controller OpenMetrics endpoint, otherwise returns `OK`. *Statuses: ok, critical* ## Troubleshooting{% #troubleshooting-1 %} Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).