---
title: n8n
description: Monitor the health and performance of n8n.
breadcrumbs: Docs > Integrations > n8n
---

# n8n
Supported OS Integration version1.0.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 %}
   n8n dashboardn8n dashboardn8n dashboard
## Overview{% #overview %}

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

This integration collects n8n metrics including:

- Cache metrics: hit, miss, and update counts.
- Workflow metrics: Started, success, and failed counters. Audit workflow life cycle counters. In n8n 2.x, an execution-duration histogram.
- Node metrics: per-node counters (started and finished) emitted by worker processes in queue mode.
- Queue metrics: queue depth; enqueued, dequeued, completed, failed, and stalled counters; and scaling-mode worker gauges.
- HTTP metrics: request duration histograms tagged with status code.
- Process and Node.js runtime metrics.

## Setup{% #setup %}

Follow the instructions below to install and configure this check for an Agent running on a host. For containerized environments, see the [Autodiscovery integration templates](https://docs.datadoghq.com/containers/kubernetes/integrations.md) for guidance on applying these instructions.

### Installation{% #installation %}

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

### Configuration{% #configuration %}

#### Enable the n8n metrics endpoint{% #enable-the-n8n-metrics-endpoint %}

The `/metrics` endpoint is disabled by default and must be enabled in your n8n configuration.

**Note**: The `/metrics` endpoint is only available for self-hosted instances and is not available on n8n Cloud.

Set the following environment variables to enable metrics:

```bash
# Required: Enable the metrics endpoint
N8N_METRICS=true

# Optional: Include additional metric categories
N8N_METRICS_INCLUDE_DEFAULT_METRICS=true
N8N_METRICS_INCLUDE_CACHE_METRICS=true
N8N_METRICS_INCLUDE_MESSAGE_EVENT_BUS_METRICS=true
N8N_METRICS_INCLUDE_WORKFLOW_ID_LABEL=true
N8N_METRICS_INCLUDE_API_ENDPOINTS=true
N8N_METRICS_INCLUDE_QUEUE_METRICS=true

# Optional: n8n 2.x adds workflow_statistics gauges (workflows, users, executions, ...) - opt in
N8N_METRICS_INCLUDE_WORKFLOW_STATISTICS=true

# Optional: Customize the metric prefix (default is 'n8n_')
N8N_METRICS_PREFIX=n8n_
```

For more details, see the n8n documentation on [enabling Prometheus metrics](https://docs.n8n.io/hosting/configuration/configuration-examples/prometheus/).

If you change `N8N_METRICS_PREFIX` from its default of `n8n_`, you **must** also set `raw_metric_prefix` in the integration's `conf.yaml` to the same value. Otherwise the check does not recognize the exposed metric names and silently submits nothing:

```yaml
instances:
  - openmetrics_endpoint: http://localhost:5678/metrics
    raw_metric_prefix: my_custom_prefix_
```

#### Event-driven counters{% #event-driven-counters %}

Most n8n counters are registered dynamically the first time their underlying event fires. The integration ships mappings for around 70 of these event-bus counters, including:

- Workflow life cycle: `n8n.workflow.started.count`, `n8n.workflow.success.count`, `n8n.workflow.failed.count`, `n8n.workflow.cancelled.count`
- Audit (workflow, user, credentials, package, variable, execution data): `n8n.audit.workflow.executed.count`, `n8n.audit.user.login.success.count`, `n8n.audit.user.credentials.created.count`, and similar
- AI nodes: `n8n.ai.tool.called.count`, `n8n.ai.llm.generated.count`, `n8n.ai.vector.store.searched.count`, and similar
- Runner, queue, and node life cycle: `n8n.runner.task.requested.count`, `n8n.queue.job.completed.count`, `n8n.node.started.count`, `n8n.node.finished.count`

These counters do not appear on the `/metrics` endpoint until the corresponding event has occurred. A healthy idle deployment does not produce datapoints for them until that activity fires. The complete list is in [metadata.csv](https://github.com/DataDog/integrations-core/blob/master/n8n/metadata.csv).

If a future n8n release exposes a new event-driven counter that is not yet covered by this integration, add it to the `extra_metrics` option in your instance configuration:

```yaml
instances:
  - openmetrics_endpoint: http://n8n:5678/metrics
    extra_metrics:
      - some_new_n8n_event_total: some.new.n8n.event
```

The left-hand side is the Prometheus counter name as n8n exposes it (keep the `_total` suffix). The right-hand side is the dotted Datadog metric name to submit it as.

#### Queue mode and workers{% #queue-mode-and-workers %}

In queue mode, n8n runs separate worker processes that execute jobs picked up from a Redis-backed queue. Each worker exposes its own `/metrics` endpoint and emits a different subset of metrics than the main process. Worker-observed metrics include `n8n.queue.job.dequeued.count`, `n8n.queue.job.stalled.count`, `n8n.node.started.count`, `n8n.node.finished.count`, and `n8n.runner.task.requested.count`. Main-only metrics include `n8n.instance.role.leader` and the `n8n.scaling.mode.queue.jobs.*` family.

To expose worker metrics, set `QUEUE_HEALTH_CHECK_ACTIVE=true` and `QUEUE_HEALTH_CHECK_PORT=<port>` on each worker.

**Note**: In n8n 2.x, port `5679` is reserved for the task runner broker. Pick a different port (for example `5680`).

For full coverage in queue deployments, configure one Datadog instance per n8n process exposing `/metrics`, including main and worker processes:

```yaml
instances:
  - openmetrics_endpoint: http://n8n-main:5678/metrics
  - openmetrics_endpoint: http://n8n-worker:5680/metrics
```

#### Tag cardinality{% #tag-cardinality %}

When `N8N_METRICS_INCLUDE_WORKFLOW_ID_LABEL=true`, http and workflow execution histograms are tagged with `workflow_id` (and similar labels for nodes). On deployments with many distinct workflows or nodes, this can produce high-cardinality metrics. Drop the label through `exclude_labels` or omit `N8N_METRICS_INCLUDE_WORKFLOW_ID_LABEL` to keep tag cardinality bounded.

#### Configure the Datadog Agent{% #configure-the-datadog-agent %}

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

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

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

**Note**: Available for Agent versions 6.0 and later.

#### Enable n8n logging{% #enable-n8n-logging %}

Configure n8n application logs by setting the following environment variables:

```bash
# Set the log level (error, warn, info, debug)
N8N_LOG_LEVEL=info

# Output application logs to console or file
N8N_LOG_OUTPUT=console

# Use JSON formatting so Datadog can parse n8n application log attributes
N8N_LOG_FORMAT=json

# If using file output, specify the application log file location
N8N_LOG_FILE_LOCATION=/var/log/n8n/n8n.log
```

#### Structured event logs{% #structured-event-logs %}

n8n also writes structured event bus logs to `n8nEventLog*.log`. These logs contain workflow, node, queue, runner, and audit events and are separate from the application logs controlled by `N8N_LOG_OUTPUT` and `N8N_LOG_FILE_LOCATION`.

By default, event bus log files are written under the n8n user folder, for example:

- Host installations: `~/.n8n/n8nEventLog*.log`
- Official Docker image: `/home/node/.n8n/n8nEventLog*.log`

If you use a custom n8n user folder, collect the event bus logs from that folder instead. If you customize the event bus log file base name with `N8N_EVENTBUS_LOGWRITER_LOGBASENAME`, update the Datadog log path to match.

The event log includes the following event types:

| Event Type                    | Description                         |
| ----------------------------- | ----------------------------------- |
| `n8n.workflow.started`        | Workflow execution has begun        |
| `n8n.workflow.success`        | Workflow completed successfully     |
| `n8n.workflow.failed`         | Workflow execution failed           |
| `n8n.node.started`            | Individual node started execution   |
| `n8n.node.finished`           | Individual node completed execution |
| `n8n.audit.workflow.executed` | Audit trail for workflow execution  |

Each event contains rich metadata including `executionId`, `workflowId`, `workflowName`, `nodeType`, `nodeName`, and timestamps for correlation with metrics.

#### Configure the Datadog Agent to collect logs{% #configure-the-datadog-agent-to-collect-logs %}

1. Collecting logs is disabled by default in the Datadog Agent. Enable it in your `datadog.yaml` file:

   ```yaml
   logs_enabled: true
   ```

1. Add log collection entries to your `n8n.d/conf.yaml` file.

For a host-based n8n installation where the Agent can read local files, collect the application log file and the event bus log files:

   ```yaml
   logs:
     - type: file
       path: /var/log/n8n/*.log
       source: n8n
       service: <SERVICE>
     - type: file
       path: /home/n8n/.n8n/n8nEventLog*.log
       source: n8n
       service: <SERVICE>
   ```

Adjust `/home/n8n/.n8n/n8nEventLog*.log` to the n8n user folder on your host.

For a containerized n8n deployment, collect stdout and stderr from the n8n container for application logs, and make the n8n user folder available to the Agent for event bus file logs. For example, if the n8n data directory is mounted on the host at `/var/lib/n8n`, configure:

   ```yaml
   logs:
     - type: docker
       source: n8n
       service: <SERVICE>
     - type: file
       path: /var/lib/n8n/n8nEventLog*.log
       source: n8n
       service: <SERVICE>
   ```

If the Agent runs in a container, mount the n8n data volume or host directory into the Agent container and use the path as seen from inside the Agent container.

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

### Validation{% #validation %}

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

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

### Metrics{% #metrics %}

|  |
|  |
| **n8n.active.workflow.count**(gauge)                         | Total number of active workflows.                                                                                                                                                                                                   |
| **n8n.ai.document.processed.count**(count)                   | Total number of documents processed by AI nodes. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                       |
| **n8n.ai.embeddings.embedded.document.count**(count)         | Total number of documents embedded by AI embedding nodes. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                              |
| **n8n.ai.embeddings.embedded.query.count**(count)            | Total number of queries embedded by AI embedding nodes. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                |
| **n8n.ai.llm.error.count**(count)                            | Total number of LLM errors raised by AI nodes. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                         |
| **n8n.ai.llm.generated.count**(count)                        | Total number of successful LLM generations from AI nodes. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                              |
| **n8n.ai.memory.added.message.count**(count)                 | Total number of AI memory message writes. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                              |
| **n8n.ai.memory.get.messages.count**(count)                  | Total number of AI memory message reads. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                               |
| **n8n.ai.output.parser.parsed.count**(count)                 | Total number of AI output parser invocations. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                          |
| **n8n.ai.retriever.get.relevant.documents.count**(count)     | Total number of AI retriever relevant-document fetches. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                |
| **n8n.ai.text.splitter.split.count**(count)                  | Total number of AI text-splitter splits. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                               |
| **n8n.ai.tool.called.count**(count)                          | Total number of AI tool invocations. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                                   |
| **n8n.ai.vector.store.populated.count**(count)               | Total number of AI vector-store population events. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                     |
| **n8n.ai.vector.store.searched.count**(count)                | Total number of AI vector-store searches. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                              |
| **n8n.ai.vector.store.updated.count**(count)                 | Total number of AI vector-store update events. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                         |
| **n8n.audit.execution.data.reveal\_failure.count**(count)    | Total number of execution-data reveal failures audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                |
| **n8n.audit.execution.data.revealed.count**(count)           | Total number of execution-data reveal events audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                  |
| **n8n.audit.package.deleted.count**(count)                   | Total number of community package removals audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                    |
| **n8n.audit.package.installed.count**(count)                 | Total number of community package installations audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                               |
| **n8n.audit.package.updated.count**(count)                   | Total number of community package updates audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                     |
| **n8n.audit.user.api.created.count**(count)                  | Total number of API key creations audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                             |
| **n8n.audit.user.api.deleted.count**(count)                  | Total number of API key deletions audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                             |
| **n8n.audit.user.credentials.created.count**(count)          | Total number of credential creations audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                          |
| **n8n.audit.user.credentials.deleted.count**(count)          | Total number of credential deletions audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                          |
| **n8n.audit.user.credentials.shared.count**(count)           | Total number of credential share events audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                       |
| **n8n.audit.user.credentials.updated.count**(count)          | Total number of credential updates audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                            |
| **n8n.audit.user.deleted.count**(count)                      | Total number of user deletions audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                                |
| **n8n.audit.user.email.failed.count**(count)                 | Total number of user-facing email send failures audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                               |
| **n8n.audit.user.execution.deleted.count**(count)            | Total number of executions deleted by users audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                   |
| **n8n.audit.user.invitation.accepted.count**(count)          | Total number of user invitations accepted. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                             |
| **n8n.audit.user.invited.count**(count)                      | Total number of user invitations sent. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                                 |
| **n8n.audit.user.login.failed.count**(count)                 | Total number of failed user login attempts audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                    |
| **n8n.audit.user.login.success.count**(count)                | Total number of successful user logins audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                        |
| **n8n.audit.user.mfa.disabled.count**(count)                 | Total number of times a user disabled multi-factor authentication. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                     |
| **n8n.audit.user.mfa.enabled.count**(count)                  | Total number of times a user enabled multi-factor authentication. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                      |
| **n8n.audit.user.reinvited.count**(count)                    | Total number of user re-invitations sent. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                              |
| **n8n.audit.user.reset.count**(count)                        | Total number of completed password resets audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                     |
| **n8n.audit.user.reset.requested.count**(count)              | Total number of password reset requests audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                       |
| **n8n.audit.user.signedup.count**(count)                     | Total number of user sign-ups audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                                 |
| **n8n.audit.user.updated.count**(count)                      | Total number of user profile updates audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                          |
| **n8n.audit.variable.created.count**(count)                  | Total number of variable creations audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                            |
| **n8n.audit.variable.deleted.count**(count)                  | Total number of variable deletions audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                            |
| **n8n.audit.variable.updated.count**(count)                  | Total number of variable updates audited. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                              |
| **n8n.audit.workflow.activated.count**(count)                | Total number of audited workflow activations. Available in n8n 2.x and later.                                                                                                                                                       |
| **n8n.audit.workflow.archived.count**(count)                 | Total number of audited workflow archive events.                                                                                                                                                                                    |
| **n8n.audit.workflow.created.count**(count)                  | Total number of audited workflow creations.                                                                                                                                                                                         |
| **n8n.audit.workflow.deactivated.count**(count)              | Total number of audited workflow deactivations. Available in n8n 2.x and later.                                                                                                                                                     |
| **n8n.audit.workflow.deleted.count**(count)                  | Total number of audited workflow deletions.                                                                                                                                                                                         |
| **n8n.audit.workflow.executed.count**(count)                 | Total number of audited workflow executions. Available in n8n 2.x and later.                                                                                                                                                        |
| **n8n.audit.workflow.resumed.count**(count)                  | Total number of audited workflow resumptions. Available in n8n 2.x and later.                                                                                                                                                       |
| **n8n.audit.workflow.unarchived.count**(count)               | Total number of audited workflow unarchive events.                                                                                                                                                                                  |
| **n8n.audit.workflow.updated.count**(count)                  | Total number of audited workflow updates.                                                                                                                                                                                           |
| **n8n.audit.workflow.version.updated.count**(count)          | Total number of audited workflow version updates. Available in n8n 2.x and later.                                                                                                                                                   |
| **n8n.audit.workflow.waiting.count**(count)                  | Total number of audited workflow executions entering a waiting state. Available in n8n 2.x and later.                                                                                                                               |
| **n8n.cache.hits.count**(count)                              | Total number of cache hits.                                                                                                                                                                                                         |
| **n8n.cache.misses.count**(count)                            | Total number of cache misses.                                                                                                                                                                                                       |
| **n8n.cache.updates.count**(count)                           | Total number of cache updates.                                                                                                                                                                                                      |
| **n8n.credentials.total**(gauge)                             | Total number of credentials. Available in n8n 2.x and later when N8N_METRICS_INCLUDE_WORKFLOW_STATISTICS is enabled.                                                                                                                |
| **n8n.embed.login.failures.count**(count)                    | Total number of embed login failures broken down by reason. Available in n8n 2.x and later. Only emits samples after the first failure.                                                                                             |
| **n8n.embed.login.requests.count**(count)                    | Total number of embed login requests (tagged with `result:success`/`result:failure`). Available in n8n 2.x and later.                                                                                                               |
| **n8n.enabled.users**(gauge)                                 | Total number of enabled users. Available in n8n 2.x and later when N8N_METRICS_INCLUDE_WORKFLOW_STATISTICS is enabled.                                                                                                              |
| **n8n.execution.throttled.count**(count)                     | Total number of executions throttled because the production concurrency limit was reached. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                             |
| **n8n.expression.code.cache.eviction.count**(count)          | Total expression code cache evictions. Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.                                                                           |
| **n8n.expression.code.cache.hit.count**(count)               | Total expression code cache hits (compiled expression reused). Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.                                                   |
| **n8n.expression.code.cache.miss.count**(count)              | Total expression code cache misses (expression compiled for the first time). Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.                                     |
| **n8n.expression.code.cache.size**(gauge)                    | Current number of compiled expressions held in the expression code cache. Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.                                        |
| **n8n.expression.evaluation.duration.seconds.bucket**(count) | Histogram bucket for VM-isolated expression evaluation duration in seconds (tagged with `status` and `type`). Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.    |
| **n8n.expression.evaluation.duration.seconds.count**(count)  | Count of VM-isolated expression evaluations (tagged with `status` and `type`). Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.                                   |
| **n8n.expression.evaluation.duration.seconds.sum**(count)    | Sum of VM-isolated expression evaluation durations in seconds. Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.                                                   |
| **n8n.expression.pool.acquired.count**(count)                | Total VM bridges acquired from the expression pool for evaluation. Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.                                               |
| **n8n.expression.pool.replenish.failed.count**(count)        | Total times the expression pool failed to replenish a bridge after release/dispose. Should remain near zero. Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.     |
| **n8n.expression.pool.scaled.to.zero.count**(count)          | Total times the expression pool scaled to zero after `N8N_EXPRESSION_ENGINE_IDLE_TIMEOUT` seconds of inactivity. Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true. |
| **n8n.expression.pool.scaled.up.count**(count)               | Total times the expression pool scaled up from idle on a new acquire. Available in n8n 2.x and later when N8N_EXPRESSION_ENGINE=vm and N8N_EXPRESSION_ENGINE_OBSERVABILITY_ENABLED=true.                                            |
| **n8n.http.request.duration.seconds.bucket**(count)          | Histogram bucket for HTTP request duration in seconds labeled with status_code.                                                                                                                                                     |
| **n8n.http.request.duration.seconds.count**(count)           | The count of HTTP request duration samples.                                                                                                                                                                                         |
| **n8n.http.request.duration.seconds.sum**(count)             | The sum of HTTP request duration in seconds.                                                                                                                                                                                        |
| **n8n.instance.role.leader**(gauge)                          | Whether this main instance is the leader (1) or not (0).                                                                                                                                                                            |
| **n8n.last.activity**(gauge)                                 | Time elapsed since the last instance activity (backend request).*Shown as second*                                                                                                                                                   |
| **n8n.manual.executions**(gauge)                             | Total number of manual workflow executions. Available in n8n 2.x and later when N8N_METRICS_INCLUDE_WORKFLOW_STATISTICS is enabled.                                                                                                 |
| **n8n.node.finished.count**(count)                           | Total number of node executions that finished. Emitted by worker processes in queue mode (n8n.node.finished event).                                                                                                                 |
| **n8n.node.started.count**(count)                            | Total number of node executions that started. Emitted by worker processes in queue mode (n8n.node.started event).                                                                                                                   |
| **n8n.nodejs.active.handles**(gauge)                         | Number of active libuv handles grouped by handle type. Every handle type is C++ class name.                                                                                                                                         |
| **n8n.nodejs.active.handles.total**(gauge)                   | Total number of active handles.                                                                                                                                                                                                     |
| **n8n.nodejs.active.requests**(gauge)                        | Number of active libuv requests grouped by request type. Only emits samples for request types currently in flight at scrape time (from prom-client's default collector via process._getActiveRequests).                             |
| **n8n.nodejs.active.requests.total**(gauge)                  | Total number of active requests.                                                                                                                                                                                                    |
| **n8n.nodejs.active.resources**(gauge)                       | Number of active resources keeping the event loop alive grouped by async resource type.                                                                                                                                             |
| **n8n.nodejs.active.resources.total**(gauge)                 | Total number of active resources.                                                                                                                                                                                                   |
| **n8n.nodejs.eventloop.lag.max.seconds**(gauge)              | The maximum recorded event loop delay.                                                                                                                                                                                              |
| **n8n.nodejs.eventloop.lag.mean.seconds**(gauge)             | The mean of the recorded event loop delays.                                                                                                                                                                                         |
| **n8n.nodejs.eventloop.lag.min.seconds**(gauge)              | The minimum recorded event loop delay.                                                                                                                                                                                              |
| **n8n.nodejs.eventloop.lag.p50.seconds**(gauge)              | The 50th percentile of the recorded event loop delays.                                                                                                                                                                              |
| **n8n.nodejs.eventloop.lag.p90.seconds**(gauge)              | The 90th percentile of the recorded event loop delays.                                                                                                                                                                              |
| **n8n.nodejs.eventloop.lag.p99.seconds**(gauge)              | The 99th percentile of the recorded event loop delays.                                                                                                                                                                              |
| **n8n.nodejs.eventloop.lag.seconds**(gauge)                  | Lag of event loop in seconds.                                                                                                                                                                                                       |
| **n8n.nodejs.eventloop.lag.stddev.seconds**(gauge)           | The standard deviation of the recorded event loop delays.                                                                                                                                                                           |
| **n8n.nodejs.external.memory.bytes**(gauge)                  | Node.js external memory size in bytes.                                                                                                                                                                                              |
| **n8n.nodejs.gc.duration.seconds.bucket**(count)             | Histogram bucket for garbage collection duration by kind.                                                                                                                                                                           |
| **n8n.nodejs.gc.duration.seconds.count**(count)              | The count of garbage collection duration samples.                                                                                                                                                                                   |
| **n8n.nodejs.gc.duration.seconds.sum**(count)                | The sum of garbage collection duration in seconds.                                                                                                                                                                                  |
| **n8n.nodejs.heap.size.total.bytes**(gauge)                  | Process heap size from Node.js in bytes.                                                                                                                                                                                            |
| **n8n.nodejs.heap.size.used.bytes**(gauge)                   | Process heap size used from Node.js in bytes.                                                                                                                                                                                       |
| **n8n.nodejs.heap.space.size.available.bytes**(gauge)        | Process heap space size available from Node.js in bytes.                                                                                                                                                                            |
| **n8n.nodejs.heap.space.size.total.bytes**(gauge)            | Process heap space size total from Node.js in bytes.                                                                                                                                                                                |
| **n8n.nodejs.heap.space.size.used.bytes**(gauge)             | Process heap space size used from Node.js in bytes.                                                                                                                                                                                 |
| **n8n.process.cpu.seconds.count**(count)                     | Total user and system CPU time spent in seconds.                                                                                                                                                                                    |
| **n8n.process.cpu.system.seconds.count**(count)              | Total system CPU time spent in seconds.                                                                                                                                                                                             |
| **n8n.process.cpu.user.seconds.count**(count)                | Total user CPU time spent in seconds.                                                                                                                                                                                               |
| **n8n.process.heap.bytes**(gauge)                            | Process heap size in bytes.                                                                                                                                                                                                         |
| **n8n.process.max.fds**(gauge)                               | Maximum number of open file descriptors.                                                                                                                                                                                            |
| **n8n.process.open.fds**(gauge)                              | Number of open file descriptors.                                                                                                                                                                                                    |
| **n8n.process.pss.bytes**(gauge)                             | Proportional set size of the process in bytes. Available in n8n 2.x and later on Linux.                                                                                                                                             |
| **n8n.process.resident.memory.bytes**(gauge)                 | Resident memory size in bytes.                                                                                                                                                                                                      |
| **n8n.process.uptime.seconds**(gauge)                        | Process uptime in seconds.*Shown as second*                                                                                                                                                                                         |
| **n8n.process.virtual.memory.bytes**(gauge)                  | Virtual memory size in bytes.                                                                                                                                                                                                       |
| **n8n.production.executions**(gauge)                         | Total number of production workflow executions. Available in n8n 2.x and later when N8N_METRICS_INCLUDE_WORKFLOW_STATISTICS is enabled.                                                                                             |
| **n8n.production.root.executions**(gauge)                    | Total number of production root workflow executions (excludes sub-workflows). Available in n8n 2.x and later when N8N_METRICS_INCLUDE_WORKFLOW_STATISTICS is enabled.                                                               |
| **n8n.queue.job.completed.count**(count)                     | Number of jobs completed successfully (n8n.queue.job.completed event).                                                                                                                                                              |
| **n8n.queue.job.dequeued.count**(count)                      | Number of jobs dequeued by workers (n8n.queue.job.dequeued event). Emitted by worker processes in queue mode.                                                                                                                       |
| **n8n.queue.job.enqueued.count**(count)                      | Number of jobs added to the queue (n8n.queue.job.enqueued event).                                                                                                                                                                   |
| **n8n.queue.job.failed.count**(count)                        | Number of jobs that have failed (n8n.queue.job.failed event).                                                                                                                                                                       |
| **n8n.queue.job.stalled.count**(count)                       | Number of jobs that stalled (n8n.queue.job.stalled event).                                                                                                                                                                          |
| **n8n.readiness.check**(gauge)                               | Readiness check status (1 if ready with status code 200 otherwise 0) with status code tag.                                                                                                                                          |
| **n8n.runner.response.received.count**(count)                | Total number of task-runner responses received by worker processes. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                    |
| **n8n.runner.task.requested.count**(count)                   | Total number of runner tasks requested by worker processes.                                                                                                                                                                         |
| **n8n.scaling.mode.queue.jobs.active**(gauge)                | Current number of jobs being processed across all workers in scaling mode.                                                                                                                                                          |
| **n8n.scaling.mode.queue.jobs.completed.count**(count)       | Total number of jobs completed across all workers in scaling mode since instance start.                                                                                                                                             |
| **n8n.scaling.mode.queue.jobs.failed.count**(count)          | Total number of jobs failed across all workers in scaling mode since instance start.                                                                                                                                                |
| **n8n.scaling.mode.queue.jobs.waiting**(gauge)               | Current number of enqueued jobs waiting for pickup in scaling mode.                                                                                                                                                                 |
| **n8n.token.exchange.failures.count**(count)                 | Total number of token exchange failures broken down by reason. Available in n8n 2.x and later. Only emits samples after the first failure.                                                                                          |
| **n8n.token.exchange.identity.linked.count**(count)          | Total number of identities linked to existing users via token exchange. Available in n8n 2.x and later.                                                                                                                             |
| **n8n.token.exchange.jit.provisioning.count**(count)         | Total number of users JIT-provisioned via token exchange. Available in n8n 2.x and later.                                                                                                                                           |
| **n8n.token.exchange.requests.count**(count)                 | Total number of token exchange requests. Available in n8n 2.x and later.                                                                                                                                                            |
| **n8n.users.total**(gauge)                                   | Total number of users. Available in n8n 2.x and later when N8N_METRICS_INCLUDE_WORKFLOW_STATISTICS is enabled.                                                                                                                      |
| **n8n.workflow.cancelled.count**(count)                      | Total number of workflows cancelled mid-execution. Best-effort dynamic event-bus metric: only emitted when the n8n event fires.                                                                                                     |
| **n8n.workflow.execution.duration.seconds.bucket**(count)    | Histogram bucket for workflow execution duration in seconds. Available in n8n 2.x and later.                                                                                                                                        |
| **n8n.workflow.execution.duration.seconds.count**(count)     | The count of workflow execution duration samples. Available in n8n 2.x and later.                                                                                                                                                   |
| **n8n.workflow.execution.duration.seconds.sum**(count)       | The sum of workflow execution duration in seconds. Available in n8n 2.x and later.                                                                                                                                                  |
| **n8n.workflow.failed.count**(count)                         | Total number of workflows that failed (n8n.workflow.failed event).                                                                                                                                                                  |
| **n8n.workflow.started.count**(count)                        | Total number of workflows started (n8n.workflow.started event).                                                                                                                                                                     |
| **n8n.workflow.success.count**(count)                        | Total number of workflows completed successfully (n8n.workflow.success event).                                                                                                                                                      |
| **n8n.workflows.total**(gauge)                               | Total number of workflows. Available in n8n 2.x and later when N8N_METRICS_INCLUDE_WORKFLOW_STATISTICS is enabled.                                                                                                                  |

## Uninstallation{% #uninstallation %}

To uninstall this integration from your Agent, run the following command:

```bash
datadog-agent integration remove datadog-n8n
```

Alternatively, to disable the integration, rename the `n8n.d/conf.yaml` file to `n8n.d/conf.yaml.example`.

## Support{% #support %}

Need help? Contact [Datadog Support](https://app.datadoghq.com/help).
