Dash0 Logo
Infrastructure MonitoringLog ManagementApplication Performance ManagementDistributed TracingKubernetes MonitoringWebsite MonitoringDashboardsAlertingService MapIntegrationsTransparent CostObservability as Code
PricingDocs
GuidesBlogKnowledgeComparisonsPodcastIntegrationsChangelog
Contact usMeet our TeamCareersSecurity
  • Book A Demo
  • Sign In
  • Start Free Trial
Book a demoSign in
Start Free Trial

Resources

  • Pricing
  • Blog
  • Guides
  • Knowledge
  • Comparisons
  • Integrations
  • Documentation
  • Glossary
  • OTelBin.io
  • Sitemap

Company

  • Our Team
  • Careers
  • Trust Center
  • Security

Compare

  • Datadog
  • Grafana
  • Dynatrace
  • New Relic
  • Elastic
  • Honeycomb
  • Sentry

Contact

  • Contact us
  • GitHub
  • LinkedIn
  • X
  • YouTube
  • Dash0 Newsletter
  • Terms and Conditions
  • Privacy Policy
  • Data Processing Agreement
  • Vulnerability Disclosure

©2025 Dash0 Inc.

Hub/Dapr

Technology

Dapr

Monitor and observe your Dapr applications with distributed tracing, metrics, and logs using OpenTelemetry integration.

Overview

Overview

Dapr (Distributed Application Runtime) is a portable, event-driven runtime that makes it easy for developers to build resilient microservice applications. With Dash0, you can gain comprehensive observability into your Dapr applications through distributed tracing, metrics, and logs.

Use Cases

  • Monitor Dapr runtime performance and health
  • Track distributed traces across microservices
  • Observe service-to-service communication patterns
  • Monitor pub/sub message flows and state management operations
  • Analyze HTTP and gRPC API performance
  • Track actor invocations and state changes
  • Monitor bindings and secrets usage

Prerequisites

  • Dapr runtime installed on Kubernetes
  • OpenTelemetry Collector configured in your cluster
In this section
    TechnologyOverviewUse CasesPrerequisitesSetupConfigure the OpenTelemetry CollectorStep 1: Create a namespace for the CollectorStep 2: Create a Secret with your Dash0 Auth Token and EndpointStep 3: Add the OpenTelemetry Helm repoStep 4: Create `values.yaml` for the CollectorStep 5: Install/upgrade the Collector with HelmConfigure Dapr to send telemetry to the CollectorStep 1: Create a configurationStep 2: Annotate your application(s)Verify the setupViewing tracesCleanupRelated Links

Setup

Setup

Dapr captures metrics, traces, and logs that can be sent directly to Dash0 through the OpenTelemetry Collector. This guide shows you how to configure Dapr tracing with the OpenTelemetry Collector and Dash0.

By using the OpenTelemetry Collector with the OTLP exporter to send data to Dash0, you can configure Dapr to create traces for each application in your Kubernetes cluster and collect them in Dash0 for analysis and monitoring.

Configure the OpenTelemetry Collector

This example shows a simple OpenTelemetry Collector configuration that will receive telemetry from Dapr and forward it to Dash0.

For production environments, consider using one of these more robust deployment methods:

  • Dash0 operator for Kubernetes (recommended)
  • OpenTelemetry Operator for Kubernetes
  • Helm Chart for The OpenTelemetry Collector

    The key requirement is that your collector accepts OTLP/gRPC on port 4317.

Step 1: Create a namespace for the Collector

Step 2: Create a Secret with your Dash0 Auth Token and Endpoint

Step 3: Add the OpenTelemetry Helm repo

Step 4: Create values.yaml for the Collector

This configuration:

  • Reads token + endpoint from the Secret via env vars
  • Enables OTLP receivers (gRPC + HTTP)
  • Sends traces, metrics, and logs to Dash0 via OTLP/gRPC with Bearer auth

Step 5: Install/upgrade the Collector with Helm

Configure Dapr to send telemetry to the Collector

Step 1: Create a configuration

Create dapr-config.yaml:

Note: If you used a different collector deployment method, update the endpointAddress to match your collector's service name and namespace.

Apply it:

Step 2: Annotate your application(s)

In each Deployment/Pod you want traced by Dapr, add:

Verify the setup

  1. Check that the OpenTelemetry Collector is running:
  1. Check the collector logs to ensure it's receiving and forwarding telemetry:
  1. Deploy a sample application with Dapr tracing enabled and generate some traffic to verify traces are being sent to Dash0. You can use the Dapr Kubernetes quickstart tutorial for testing.

Viewing traces

Once your setup is complete and telemetry data is flowing, you can view traces in Dash0:

  1. Navigate to your Dash0 account
  2. Go to the Traces section
  3. You should see distributed traces from your Dapr applications
  4. Use filters to narrow down traces by service name, operation, or time range

Cleanup

Related Links

  • Dapr Kubernetes quickstart tutorial
  • Dapr observability quickstart
  • Dash0 documentation
  • OpenTelemetry Collector documentation