Open Telemetry Collector

• 1: Using OpenTelemetry Collector to collect traces
• 2: Using Dynatrace OpenTelemetry Collector to collect traces to send to Dynatrace
• 3: Using OpenTelemetry Collector to collect traces to send to App Insights
• 4: Using OpenTelemetry Collector to collect traces to send to Jaeger

1 - Using OpenTelemetry Collector to collect traces

Dapr directly writes traces using the OpenTelemetry (OTLP) protocol as the recommended method. For observability tools that support the OTLP directly, it is recommended to use the OpenTelemetry Collector, as it allows your application to quickly offload data and includes features, such as retries, batching, and encryption. For more information, read the Open Telemetry Collector documentation.

Dapr can also write traces using the Zipkin protocol. Prior to supporting the OTLP protocol, the Zipkin protocol was used with the OpenTelemetry Collector to send traces to observability tools such as AWS X-Ray, Google Cloud Operations Suite, and Azure Monitor. Both protocol approaches are valid, however the OpenTelemetry protocol is the recommended choice.

Prerequisites

• Install Dapr on Kubernetes
• Verify your trace backends are already set up to receive traces
• Review your OTEL Collector exporter’s required parameters:
  • opentelemetry-collector-contrib/exporter
  • opentelemetry-collector/exporter

Set up OTEL Collector to push to your trace backend

1. Check out the open-telemetry-collector-generic.yaml.

2. Replace the <your-exporter-here> section with the correct settings for your trace exporter.

   • Refer to the OTEL Collector links in the prerequisites section to determine the correct settings.

3. Apply the configuration with:

   kubectl apply -f open-telemetry-collector-generic.yaml
   

Set up Dapr to send traces to OTEL Collector

Set up a Dapr configuration file to turn on tracing and deploy a tracing exporter component that uses the OpenTelemetry Collector.

1. Use this collector-config.yaml file to create your own configuration.

2. Apply the configuration with:

   kubectl apply -f collector-config.yaml
   

Deploy your app with tracing

Apply the appconfig configuration by adding a dapr.io/config annotation to the container that you want to participate in the distributed tracing, as shown in the following example:

apiVersion: apps/v1
kind: Deployment
metadata:
  ...
spec:
  ...
  template:
    metadata:
      ...
      annotations:
        dapr.io/enabled: "true"
        dapr.io/app-id: "MyApp"
        dapr.io/app-port: "8080"
        dapr.io/config: "appconfig"

You can register multiple tracing exporters at the same time, and the tracing logs are forwarded to all registered exporters.

That’s it! There’s no need to include any SDKs or instrument your application code. Dapr automatically handles the distributed tracing for you.

View traces

Deploy and run some applications. Wait for the trace to propagate to your tracing backend and view them there.

Related links

• Try out the observability quickstart
• Learn how to set tracing configuration options

2 - Using Dynatrace OpenTelemetry Collector to collect traces to send to Dynatrace

Dapr integrates with the Dynatrace Collector using the OpenTelemetry protocol (OTLP). This guide walks through an example using Dapr to push traces to Dynatrace, using the Dynatrace version of the OpenTelemetry Collector.

Prerequisites

• Install Dapr on Kubernetes
• Access to a Dynatrace tenant and an API token with openTelemetryTrace.ingest, metrics.ingest, and logs.ingest scopes
• Helm

Set up Dynatrace OpenTelemetry Collector to push to your Dynatrace instance

To push traces to your Dynatrace instance, install the Dynatrace OpenTelemetry Collector on your Kubernetes cluster.

1. Create a Kubernetes secret with your Dynatrace credentials:

   kubectl create secret generic dynatrace-otelcol-dt-api-credentials \
     --from-literal=DT_ENDPOINT=https://YOUR_TENANT.live.dynatrace.com/api/v2/otlp \
     --from-literal=DT_API_TOKEN=dt0s01.YOUR_TOKEN_HERE
   

   Replace YOUR_TENANT with your Dynatrace tenant ID and YOUR_TOKEN_HERE with your Dynatrace API token.

2. Use the Dynatrace OpenTelemetry Collector distribution for better defaults and support than the open source version. Download and inspect the collector-helm-values.yaml file. This is based on the k8s enrichment demo and includes Kubernetes metadata enrichment for proper pod/namespace/cluster context.

3. Deploy the Dynatrace Collector with Helm.

   helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
   helm repo update
   helm upgrade -i dynatrace-collector open-telemetry/opentelemetry-collector -f collector-helm-values.yaml
   

Set up Dapr to send traces to the Dynatrace Collector

Create a Dapr configuration file to enable tracing and send traces to the OpenTelemetry Collector via OTLP.

1. Update the following file to ensure the endpointAddress points to your Dynatrace OpenTelemetry Collector service in your Kubernetes cluster. If deployed in the default namespace, it’s typically dynatrace-collector.default.svc.cluster.local.

   Important: Ensure the endpointAddress does NOT include the http:// prefix to avoid URL encoding issues:

    apiVersion: dapr.io/v1alpha1
    kind: Configuration
    metadata:
      name: tracing
    spec:
      tracing:
        samplingRate: "1"
        otel:
          endpointAddress: "dynatrace-collector.default.svc.cluster.local:4318" # Update with your collector's service address
   

2. Apply the configuration with:

   kubectl apply -f collector-config-otel.yaml
   

Deploy your app with tracing

Apply the tracing configuration by adding a dapr.io/config annotation to the Dapr applications that you want to include in distributed tracing, as shown in the following example:

apiVersion: apps/v1
kind: Deployment
metadata:
  ...
spec:
  ...
  template:
    metadata:
      ...
      annotations:
        dapr.io/enabled: "true"
        dapr.io/app-id: "MyApp"
        dapr.io/app-port: "8080"
        dapr.io/config: "tracing"

You can register multiple tracing exporters at the same time, and the tracing logs are forwarded to all registered exporters.

That’s it! There’s no need to include any SDKs or instrument your application code. Dapr automatically handles the distributed tracing for you.

View traces

Deploy and run some applications. After a few minutes, you should see traces appearing in your Dynatrace tenant:

1. Navigate to Search > Distributed tracing in your Dynatrace UI.
2. Filter by service names to see your Dapr applications and their associated tracing spans.

metadata:
  annotations:
    dapr.io/enabled: "true"
    dapr.io/app-id: "MyApp"
    dapr.io/app-port: "8080"
    dapr.io/config: "tracing"
    container.inject.dynatrace.com/daprd: "false" # Exclude dapr sidecar from being auto-monitored by OneAgent

Related links

• Try out the observability quickstart
• Learn how to set tracing configuration options
• Dynatrace OpenTelemetry documentation
• Enrich OTLP telemetry data with Kubernetes metadata

3 - Using OpenTelemetry Collector to collect traces to send to App Insights

Dapr integrates with OpenTelemetry (OTEL) Collector using the OpenTelemetry protocol (OTLP). This guide walks through an example using Dapr to push traces to Azure Application Insights, using the OpenTelemetry Collector.

Prerequisites

• Install Dapr on Kubernetes
• Create an Application Insights resource and make note of your Application Insights connection string.

Set up OTEL Collector to push to your App Insights instance

To push traces to your Application Insights instance, install the OpenTelemetry Collector on your Kubernetes cluster.

1. Download and inspect the open-telemetry-collector-appinsights.yaml file.

2. Replace the <CONNECTION_STRING> placeholder with your App Insights connection string.

3. Deploy the OpenTelemetry Collector into the same namespace where your Dapr-enabled applications are running:

   kubectl apply -f open-telemetry-collector-appinsights.yaml
   

Set up Dapr to send traces to the OpenTelemetry Collector

Create a Dapr configuration file to enable tracing and send traces to the OpenTelemetry Collector via OTLP.

1. Download and inspect the collector-config-otel.yaml. Update the namespace and otel.endpointAddress values to align with the namespace where your Dapr-enabled applications and OpenTelemetry Collector are deployed.

2. Apply the configuration with:

   kubectl apply -f collector-config-otel.yaml
   

Deploy your app with tracing

Apply the tracing configuration by adding a dapr.io/config annotation to the Dapr applications that you want to include in distributed tracing, as shown in the following example:

apiVersion: apps/v1
kind: Deployment
metadata:
  ...
spec:
  ...
  template:
    metadata:
      ...
      annotations:
        dapr.io/enabled: "true"
        dapr.io/app-id: "MyApp"
        dapr.io/app-port: "8080"
        dapr.io/config: "tracing"

You can register multiple tracing exporters at the same time, and the tracing logs are forwarded to all registered exporters.

That’s it! There’s no need to include any SDKs or instrument your application code. Dapr automatically handles the distributed tracing for you.

View traces

Deploy and run some applications. After a few minutes, you should see tracing logs appearing in your App Insights resource. You can also use the Application Map to examine the topology of your services, as shown below:

Related links

• Try out the observability quickstart
• Learn how to set tracing configuration options

4 - Using OpenTelemetry Collector to collect traces to send to Jaeger

While Dapr supports writing traces using OpenTelemetry (OTLP) and Zipkin protocols, Zipkin support for Jaeger has been deprecated in favor of OTLP. Although Jaeger supports OTLP directly, the recommended approach for production is to use the OpenTelemetry Collector to collect traces from Dapr and send them to Jaeger, allowing your application to quickly offload data and take advantage of features like retries, batching, and encryption. For more information, read the Open Telemetry Collector documentation.

• Self-hosted
• Kubernetes

docker run -d --name jaeger \
  -p 4317:4317  \
  -p 16686:16686 \
  jaegertracing/all-in-one:1.49

apiVersion: dapr.io/v1alpha1
kind: Configuration
metadata:
  name: tracing
  namespace: default
spec:
  tracing:
    samplingRate: "1"
    stdout: true
    otel:
      endpointAddress: "localhost:4317"
      isSecure: false
      protocol: grpc 

dapr run --app-id myapp --app-port 3000 node app.js --config config.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  ...
spec:
  ...
  template:
    metadata:
      ...
      annotations:
        dapr.io/enabled: "true"
        dapr.io/app-id: "MyApp"
        dapr.io/app-port: "8080"
        dapr.io/config: "tracing"

kubectl port-forward svc/jaeger-query 16686 -n observability

References

• Jaeger Getting Started
• Jaeger Kubernetes Operator
• OpenTelemetry Collector Exporters