Technology
OTLP Endpoint
Send traces, metrics, logs, and profiles to Dash0 from any OTLP exporter, over gRPC or HTTP.
Overview
OTLP Endpoint
The OpenTelemetry Protocol (OTLP) is the protocol OpenTelemetry SDKs, Collectors, and profilers use to export telemetry. Dash0 ingests OTLP natively, so any tool with an OTLP exporter can send data to Dash0 without a vendor-specific plugin.
Your organization's ingestion endpoint accepts all four OpenTelemetry signals over both OTLP transports:
- Traces: OTLP/gRPC, or OTLP/HTTP at
/v1/traces - Metrics: OTLP/gRPC, or OTLP/HTTP at
/v1/metrics - Logs: OTLP/gRPC, or OTLP/HTTP at
/v1/logs - Profiles: OTLP/gRPC, or OTLP/HTTP at
/v1development/profiles
Use this integration when Dash0 has no dedicated integration for your language, tool, or vendor, or when you need the raw connection details for an OTLP exporter.
On Kubernetes, the Dash0 Kubernetes Operator configures OTLP export for your workloads and collectors. Use it instead of configuring each exporter by hand.
Use Cases
- Connect any OpenTelemetry SDK to Dash0, including SDKs for languages without a dedicated integration.
- Point an existing OpenTelemetry Collector, or any other agent with OTLP output, at Dash0.
- Send profiles from eBPF or runtime profilers that export OpenTelemetry profiles.
- Use OTLP/HTTP on port 443 where firewalls or proxies block gRPC.
Setup
Overview
Every OTLP exporter needs three settings to send data to Dash0:
- Endpoint: The OTLP/gRPC or OTLP/HTTP address of your organization's ingestion endpoint.
- Authorization header: An auth token, sent as
Authorization: Bearer <token>. - Dataset header (optional): The
Dash0-Datasetheader selects the dataset. Without it, Dash0 writes to the token's default ingestion dataset.
The values on this page are filled in for your organization.
Prerequisites
- A Dash0 auth token (create one here). If you restrict the token's signal types, include every signal you plan to send.
- Write permission for the target dataset. See the dataset documentation.
- Outbound access to port
{{endpoint_otlp_grpc_port}}for OTLP/gRPC, or port{{endpoint_otlp_http_port}}for OTLP/HTTP.
Endpoints
| Transport | Endpoint |
|---|---|
| OTLP/gRPC | {{endpoint_otlp_grpc}} |
| OTLP/HTTP (base) | {{endpoint_otlp_http}} |
| OTLP/HTTP traces | {{endpoint_otlp_http}}/v1/traces |
| OTLP/HTTP metrics | {{endpoint_otlp_http}}/v1/metrics |
| OTLP/HTTP logs | {{endpoint_otlp_http}}/v1/logs |
| OTLP/HTTP profiles | {{endpoint_otlp_http}}/v1development/profiles |
Both transports use TLS. OTLP/HTTP accepts Protobuf (the default) and JSON for every signal.
Which transport to choose:
- OTLP/HTTP (
http/protobuf) is the default in the OpenTelemetry specification and works through most proxies and firewalls, because it uses port{{endpoint_otlp_http_port}}. - OTLP/gRPC suits exporters that only support gRPC, or environments that already allow outbound gRPC.
OpenTelemetry SDKs
OpenTelemetry SDKs read their exporter configuration from standard environment variables. Set the protocol and the endpoint together; an SDK that uses the wrong protocol for an endpoint cannot connect.
OTLP/HTTP
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_EXPORTER_OTLP_ENDPOINT="{{endpoint_otlp_http}}"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer {{token}},Dash0-Dataset={{dataset}}"
export OTEL_SERVICE_NAME="my-service"With OTEL_EXPORTER_OTLP_ENDPOINT, the SDK appends /v1/traces, /v1/metrics, and /v1/logs itself. Set the base URL
only, without a path.
OTLP/gRPC
export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_EXPORTER_OTLP_ENDPOINT="{{endpoint_otlp_grpc_protocol}}://{{endpoint_otlp_grpc_hostname}}:{{endpoint_otlp_grpc_port}}"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer {{token}},Dash0-Dataset={{dataset}}"
export OTEL_SERVICE_NAME="my-service"Keep the https:// scheme in the gRPC endpoint. Some SDKs use it to decide whether to enable TLS.
Some SDKs, such as Go, ignore OTEL_EXPORTER_OTLP_PROTOCOL and select the transport by the exporter package you
initialize in code. Use the gRPC exporter packages with the gRPC endpoint, and the HTTP exporter packages with the HTTP
endpoint.
Per-signal endpoints
To send only some signals to Dash0, or to route signals to different endpoints, use the per-signal variables instead
of OTEL_EXPORTER_OTLP_ENDPOINT. For OTLP/HTTP, a per-signal endpoint is used as-is, so it must include the full path:
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="{{endpoint_otlp_http}}/v1/traces"
export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT="{{endpoint_otlp_http}}/v1/metrics"
export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT="{{endpoint_otlp_http}}/v1/logs"To turn off a signal, set its exporter to none, for example OTEL_LOGS_EXPORTER="none".
Profiles
OpenTelemetry profiles are an alpha signal, and the SDK environment variables above do not cover them yet. Configure profilers that export OTLP profiles with the same endpoint and headers, following the profiler's documentation:
- OTLP/gRPC:
{{endpoint_otlp_grpc}} - OTLP/HTTP:
{{endpoint_otlp_http}}/v1development/profiles
If a profiler cannot set the authorization header, send its profiles to an OpenTelemetry Collector and let the Collector export them to Dash0, as shown below.
OpenTelemetry Collector
The Collector exports to Dash0 with the otlp_grpc or otlp_http exporter. Pick one; both support all four signals.
Collector releases before v0.144.0 name these exporters otlp and otlphttp.
Store the auth token in an environment variable, for example DASH0_AUTH_TOKEN, rather than in the configuration file.
OTLP/gRPC exporter
exporters:
otlp_grpc/dash0:
endpoint: { { endpoint_otlp_grpc } }
headers:
Authorization: Bearer ${env:DASH0_AUTH_TOKEN}
Dash0-Dataset: { { dataset } }OTLP/HTTP exporter
exporters:
otlp_http/dash0:
endpoint: { { endpoint_otlp_http } }
headers:
Authorization: Bearer ${env:DASH0_AUTH_TOKEN}
Dash0-Dataset: { { dataset } }The exporter appends the signal path to endpoint itself. It sends Protobuf by default; set encoding: json to send
JSON instead.
Pipelines for all four signals
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
exporters:
otlp_grpc/dash0:
endpoint: { { endpoint_otlp_grpc } }
headers:
Authorization: Bearer ${env:DASH0_AUTH_TOKEN}
Dash0-Dataset: { { dataset } }
service:
pipelines:
traces:
receivers: [otlp]
exporters: [otlp_grpc/dash0]
metrics:
receivers: [otlp]
exporters: [otlp_grpc/dash0]
logs:
receivers: [otlp]
exporters: [otlp_grpc/dash0]
profiles:
receivers: [otlp]
exporters: [otlp_grpc/dash0]To use OTLP/HTTP, replace otlp_grpc/dash0 with the otlp_http/dash0 exporter from the previous section.
The profiles pipeline is alpha. Start the Collector with the profiles feature gate, otherwise it rejects the
configuration:
otelcol-contrib --config config.yaml --feature-gates=service.profilesSupportRemove the profiles pipeline if you do not collect profiles.
Verification
Send a test log record over OTLP/HTTP with JSON encoding:
curl -i "{{endpoint_otlp_http}}/v1/logs" \
-H "Authorization: Bearer {{token}}" \
-H "Dash0-Dataset: {{dataset}}" \
-H "Content-Type: application/json" \
-d '{"resourceLogs":[{"resource":{"attributes":[{"key":"service.name","value":{"stringValue":"otlp-connectivity-test"}}]},"scopeLogs":[{"logRecords":[{"severityText":"INFO","body":{"stringValue":"Hello from OTLP/HTTP"}}]}]}]}'A 200 response with the body {"partialSuccess":{}} means Dash0 accepted the record. Open
Logs in Dash0, select the dataset, and filter by service.name =
otlp-connectivity-test.
For your own telemetry, check:
- Traces: Tracing shows spans for your
service.name. - Metrics: Metrics lists your metric names.
- Logs: Logs shows your log records.
- Profiles: Profiling under Telemetry shows profiles for your profile types.
If nothing arrives, see the Troubleshooting guide.