OpenTelemetry

HTTP engine

When sending tracing data, Artillery creates a trace per each scenario created, holding all requests that are executed as a part of that scenario. Each request is then broken down further into the following child spans (representing the request timings as they are recorded in the got response.timings.phases object):

• dns_lookup
• tcp_handshake
• tls_negotiation
• request
• first_byte
• download

The following attributes are set by default on all request spans:

• test_id: unique id for the test run Added inv2.0.6
• vu.uuid: unique id for the virtual user
• url.full: full URL of the request
• server.address: hostname
• server.port: port
• http.request.method: HTTP method e.g. GET
• http.response.status_code: HTTP status code e.g. 200
• response.time.ms: time-to-first-byte of the response in milliseconds

Playwright engine

A trace is created for each scenario/virtual user execution and it holds a span for each:

• test.step helper call: remains active for the duration of the test.step function.
• Page navigated: This span is active for the duration of time consumed on the given page.

Information added to spans:

• test_id: unique id for the test run attribute is set on all spans. Added inv2.0.6
• vu.uuid: unique id for the virtual user attribute is set on all spans.
• browser.memory_used_mb: represents usedJSHeapSize. This attribute is set on page spans when extendedMetrics setting is enabled in the Playwright engine config.
• dominteractive: time it takes for DOM to become interactive. This attribute is set on page spans when extendedMetrics setting is enabled in the Playwright engine config.
• Attributes set with attributes in the tracing config are added to all spans.
• Web Vitals (opens in a new tab) (when available) are recorded as events, as well as set as attributes on page spans. Events are named by the given Web Vital abbreviation (e.g.TTFB for Time To First Byte), and attribute names are in the following format:
  • web_vitals.<web_vital_metric_name>.value: the value of given web vital metric. This attribute is set on page spans, and only when available.
  • web_vitals.<web_vital_metric_name>.rating: the rating of given web vital metric. This attribute is set on page spans, and only when available.
• Errors are recorded as exceptions and as span status set to ERROR.

Look into your chosen observability platforms documentation for the following information:

1. Signal type supported - make sure ingesting the signal type that you want to send (traces and/or metrics) is supported.
2. Underlying transport protocol for OTLP supported (HTTP/JSON, HTTP/protobuf or gRPC) for each signal type (metrics/traces). You will need this information to understand if you need to override the reporters default exporter setting. Artillery defaults to OTLP HTTP/JSON but has exporters for all 3 OTLP options.
3. OTLP API endpoints to send data to. Keep in mind that the endpoints will be different for metrics and traces. If the same endpoint is provided for both signal types, you will need to append the /v1/metrics or /v1/traces to it.
4. Headers needed. Usually at least one header is needed as that is how authentication is provided. Header format (name and value) as well as information you need for authentication (e.g. API key which will be set in the header value) will be provided in your chosen observability platforms documentation
5. Any additional information that the platform might ask you to set (e.g. specific attributes).

With the configuration shown below the reporter will export traces with:

• Errors
• HTTP Status 400 or more
• TTFB over 500 miliseconds
• Total time of request over 2000 miliseconds

plugins:
  publish-metrics:
    - type: 'open-telemetry'
      serviceName: <your-service-name>
      traces:
        endpoint: '{{ $env.OTLP_TRACES_ENDPOINT }}'
        headers:
          <auth-header-name>: '{{ $env.API_KEY }}'
        smartSampling:
          thresholds:
            firstByte: 500
            total: 2000

Some additional configuration options can be set through environment variables:

  plugins:
    publish-metrics:
      - type: "open-telemetry"
        metrics: {}
        traces: {}

Datadog

Requirements

• Datadog API Key
• Datadog requires a Datadog Agent to ingest OTLP data. The Agent setup is different depending which platform you're using (check below).

Note: Lambda is not currently supported.

Configuration Template

plugins:
  publish-metrics:
    - type: 'open-telemetry'
      serviceName: 'my_service'
      metrics:
        attributes:
          environment: 'test'
          type: 'Load test'
      traces: {}

Fargate - additional setup

Artillery sets up the Datadog Agent for you as a sidecar container. For it to start, all you need to do is 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

Local runs - additional setup

You'll need to setup a Datadog Agent in your machine. You can follow this guide (opens in a new tab) to set it up using Docker.

Reference

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

Honeycomb

Requirements

• API key (opens in a new tab)
• OTLP Endpoints (already provided below)

Configuration Template

plugins:
  publish-metrics:
    - type: open-telemetry
      serviceName: <your_service_name>
      traces:
        endpoint: https://api.honeycomb.io/v1/traces
        headers:
          x-honeycomb-team: '{{ $env.HONEYCOMB_API_KEY }}'
      metrics:
        endpoint: https://api.honeycomb.io/v1/metrics
        headers:
          x-honeycomb-team: '{{ $env.HONEYCOMB_API_KEY }}'
          x-honeycomb-dataset: <your_dataset_name>

Reference

For additional information about OpenTelemetry data in Honeycomb consult Honeycomb's documentation (opens in a new tab).

New Relic

Requirements

• License Key (opens in a new tab)
• Region (EU or US)

Configuration Template

plugins:
  publish-metrics:
    - type: 'open-telemetry'
      serviceName: <your-service-name>
      metrics:
        endpoint: 'https://{{ $env.NEW_RELIC_OTLP_ENDPOINT }}/v1/metrics'
        headers:
          api-key: '{{ $env.NR_LICENSE_KEY }}'
      traces:
        endpoint: 'https://{{ $env.NEW_RELIC_OTLP_ENDPOINT }}/v1/traces'
        headers:
          api-key: '{{ $env.NEW_RELIC_LICENSE_KEY }}'

Endpoint

Reference

For more information, consult the New Relic documentation (opens in a new tab).

Dynatrace

Requirements

• API Access Token with correct scopes
• Endpoints
• Network requirements (opens in a new tab) where needed

Note: this guide is only for sending traces to ActiveGate (opens in a new tab). In order to send traces to OneAgent consult the Dynatrace documentation (opens in a new tab)

Configuration Template

plugins:
  publish-metrics:
    - type: 'open-telemetry'
      serviceName: <your-service-name>
      metrics:
        exporter: otlp-proto
        endpoint: '{{ $env.DYNATRACE_OTLP_ENDPOINT }}/v1/metrics'
        headers:
          Authorization: 'Api-Token {{ $env.API_ACCESS_TOKEN }}'
 
      traces:
        exporter: otlp-proto
        endpoint: '{{ $env.DYNATRACE_OTLP_ENDPOINT }}/v1/traces'
        headers:
          Authorization: 'Api-Token {{ $env.API_ACCESS_TOKEN }}'

Endpoints

API Access Token scopes

To obtain an access token, in the Dynatrace web UI, go to Access tokens. Use the following access scopes for the signals you are exporting:

Reference

For any aditional information on OpenTelemetry data in Dynatrace, consult the Dynatrace documentation (opens in a new tab).

Lightstep (ServiceNow Observability Cloud)

Requirements

• Access Token (opens in a new tab)
• Endpoints

Configuration Template

plugins:
  publish-metrics:
    - type: 'open-telemetry'
      serviceName: 'my_service'
      metrics:
        endpoint: '{{ $env.LIGHTSTEP_OTLP_METRICS_ENDPOINT }}'
        headers:
          Lightstep-Access-Token: '{{ $env.LIGHTSTEP_ACCESS_TOKEN }}'
      traces:
        endpoint: '{{ $env.LIGHTSTEP_OTLP_TRACES_ENDPOINT }}'
        headers:
          Lightstep-Access-Token: '{{ $env.LIGHTSTEP_ACCESS_TOKEN }}'

Endpoints

Choose the endpoint that matches the type of signal you wish to send and to your Lightstep/Service Now service type, and replace the placeholders with your data if needed (e.g. replace {microsatellite_ip} with your microsatellite_ip).

Reference

For additional information about sending OpenTelemetry data to Lightstep (ServiceNow Observability Cloud), check Lightstep documentation (opens in a new tab).

Grafana

Requirements

• Access Policy Token with correct scopes
• Account Information obtained in Cloud Portal (opens in a new tab) -> OpenTelemetry card -> Configure:
  • Instance ID (e.g. 130834)
  • OTLP Endpoint (e.g. https://otlp-gateway-prod-us-central-0.grafana.net/otlp)

Configuration Template

plugins:
  publish-metrics:
    - type: 'open-telemetry'
      serviceName: <your-service-name>
      metrics:
        exporter: otel-proto
        endpoint: '{{ $env.GRAFANA_OTLP_ENDPOINT }}'
        headers:
          Authorization: 'Basic: {{ $env.GRAFANA_AUTH_CODE }}'
      traces:
        exporter: otel-proto
        endpoint: '{{ $env.GRAFANA_OTLP_ENDPOINT }}'
        headers:
          Authorization: 'Basic: {{ $env.GRAFANA_AUTH_CODE }}'

Generating Auth Code

1. Create an Access Policy Token (opens in a new tab) with the metrics:write and/or traces:write scopes depending on the data you will be sending.
2. Make a base64 encoding of the <your-instance-id>:<your-token> string and store it as an environment variable (e.g. GRAFANA_AUTH_CODE).

Reference

For additional information about sending OpenTelemetry data to Grafana, check their documentation (opens in a new tab)

Chronosphere

https://chronosphere.io/ (opens in a new tab)

Requirements

• A Chronosphere account
• An API key of a Chronosphere service account (opens in a new tab)

Configuration Template

plugins:
  publish-metrics:
    - type: 'open-telemetry'
 
      # Replace COMPANY with the name of your company as it appears in the subdomain of the
      # Observability Platform URL
      metrics:
        exporter: 'otlp-http'
        endpoint: 'https://COMPANY.chronosphere.io/data/opentelemetry/v1/metrics'
        headers:
          API-Token: '{{ $env.CHRONOSPHERE_API_KEY }}'
      traces:
        exporter: 'otlp-http'
        endpoint: 'https://COMPANY.chronosphere.io/data/opentelemetry/v1/traces'
        headers:
          API-Token: '{{ $env.CHRONOSPHERE_API_KEY }}'

Please refer to the Chronosphere docs for more details on configuring OpenTelemetry data ingestion:

https://docs.chronosphere.io/ingest/metrics-traces/otel/otlp-endpoints (opens in a new tab)

Dash0

https://www.dash0.com (opens in a new tab)

Requirements

• A Dash0 account and an auth token (opens in a new tab)

Configuration Template

plugins:
  publish-metrics:
      - type: 'open-telemetry'
 
        metrics:
          exporter: 'otlp-http'
          endpoint: https://ingress.eu-west-1.aws.dash0.com/v1/metrics
          headers:
            Authorization: Bearer "{{ $env.DASH0_AUTH_TOKEN }}"
 
        traces:
          exporter: 'otlp-http'
          endpoint: https://ingress.eu-west-1.aws.dash0.com/v1/traces
          headers:
            Authorization: "Bearer {{ $env.DASH0_AUTH_TOKEN }}""

Note that you may need to adjust the endpoint URL to match the region where your Dash0 account is hosted.

Please refer to the Dash0 docs for details on where to find your endpoint URL:

https://www.dash0.com/documentation/dash0/get-started/sending-data-to-dash0 (opens in a new tab)