Datadog

This reporter supports sending metrics, events and traces to Datadog.

In order to enable the Datadog reporter set type to datadog as shown below:

plugins:
  publish-metrics:
    - type: datadog

Metrics

Metrics can be sent to an already running Datadog agent (opens in a new tab) or directly to Datadog API (opens in a new tab).

If Datadog agents have already been set up on your infrastructure, then publishing via the agent is probably preferable. Publishing via the HTTP API is useful when running in environments which do not have the agent (e.g. when running Artillery on AWS Lambda or AWS Fargate).

By default, all Artillery metrics will be sent to Datadog. Each Artillery metric will create a custom Datadog metric (opens in a new tab), which will have an associated charge.

You can configure a specific list of metrics to send with the includeOnly setting (see Configuration section below).

Configuration options

  config:
    plugins:
      publish-metrics:
        - type: datadog
          # DD_API_KEY is an environment variable containing the API key
          apiKey: "{{ $env.DD_API_KEY }}"
          prefix: "artillery.publish_metrics_plugin."
          tags:
            - "testId:{{ $testId }}"
            - "reporterType:datadog-api"

Events

The reporter supports sending a Datadog event on test start and test finish.

Configuration options

config:
  plugins:
    publish-metrics:
      - type: datadog
        event:
          title: "Plugin integration test"
          priority: normal
          tags:
            - 'testId:{{ $testId }}'

Traces

Powered by: OpenTelemetry reporter

Datadog tracing feature is available for both HTTP and Playwright engines, and the tracing data available is different depending on the engine used.

An additional plugins.publish-metrics.spans.exported metric will be recorded and will appear in your reports when tracing is enabled. It represents the number of spans exported to Datadog.

Configuration options

Datadog requires a running instance of the Datadog Agent (or the OTel Collector configured with the Datadog exporter) in order to ingest traces. When you run a test on AWS Fargate, Artillery will take care of this for you automatically, but for testing on your local machine you will need to run the agent yourself. Below you will find a quick quide for both AWS Fargate and local runs.

Note: AWS Lambda is not currently supported.

plugins:
  publish-metrics:
    - type: 'datadog'
      traces:
        sampleRate: 0.5
        replaceSpanNameRegex:
          - pattern: get_user_[a-zA-Z0-9]+
            as: get_user_id
        tags:
          - 'testType:LoadTest'
          - 'tool:Artillery'

AWS Fargate - additional setup

Artillery sets up the AWS Distro for OpenTelemetry (opens in a new tab) configured with the Datadog exporter as a sidecar container. For it to start, all you need to do is to make sure a DD_API_KEY is set in a .env file by using the --env-file flag. Example:

artillery run-fargate scenario.yaml --env-file .env

NOTE: If you're sending the metrics to Datadogs HTTP API and have therefore already provided the API key in the script with apiKey, you do not need to provide it through dotenv file.

Local runs - additional setup

You'll need to setup a Datadog Agent in your machine with the following environment variables:

To setup a Datadog agent using Docker:

1. Install Docker here (opens in a new tab)
2. Run the following Docker CLI command in a Terminal (Mac/Linux) or Command Prompt (Windows), making sure to replace DD_API_KEY and DD_HOSTNAME with the correct values:

docker run --rm \
	-e DD_API_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX \
	-e DD_HOSTNAME=ADD_A_UNIQUE_NAME_FOR_YOUR_MACHINE \
	-e DD_SITE="datadoghq.com" \
	-e DD_APM_TRACE_BUFFER=100 \
	-e DD_OTLP_CONFIG_RECEIVER_PROTOCOLS_HTTP_ENDPOINT=0.0.0.0:4318 \
	-p 4318:4318 \
	datadog/agent

1. Wait a few moments. You should start seeing logs while the agent starts up.
2. After that, you can run your Artillery script (example configuration below).

Demo

Here is a small demo (opens in a new tab) on seeing your Playwright engine traces on Datadog.

Debugging

Set DEBUG=plugin:publish-metrics:datadog-statsd when running your tests to print out helpful debugging messages when sending metrics to Datadog.

DEBUG=plugin:publish-metrics:datadog-statsd artillery run my-script.yaml

Examples

Datadog with an agent

config:
  plugins:
    publish-metrics:
      # apiKey not set, so the plugin will assume that the agent is running:
      - type: datadog
        prefix: 'artillery.publish_metrics_plugin.'
        tags:
          - 'reporterType:datadog-agent'
        event:
          priority: normal
          tags:
            - 'testId:{{ $testId }}'
        traces:
          useRequestNames: true
          tags:
            - 'testType:LoadTest'

Datadog with an API key

config:
  plugins:
    publish-metrics:
      - type: datadog
        # DD_API_KEY is an environment variable containing the API key
        apiKey: '{{ $env.DD_API_KEY }}'
        prefix: 'artillery.publish_metrics_plugin.'
        tags:
          - 'testId:{{ $testId }}'
          - 'reporterType:datadog-api'
        event:
          title: 'Plugin integration test'
          priority: normal
          tags:
            - 'testId:{{ $testId }}'
        traces:
          sampleRate: 0.5
          useRequestNames: true
          tags:
            - 'testType:LoadTest'