Many teams have adopted OpenTelemetry for a good reason: no longer depending on a proprietary agent to instrument their services. The project has now graduated from the CNCF and has become the common framework for producing traces, metrics and logs. But once the SDKs are in place and the Collector is deployed, one question soon comes back: why is investigating still so laborious? That is the whole point of taking OpenTelemetry end-to-end, from the user’s click to the host.
The answer fits in one sentence: OpenTelemetry standardises the shape of signals, not the relationships between them. A trace knows which service it comes from; it does not know which host that service runs on, which user session triggered it, or which AI model it calls downstream. Without that context, the on-call engineer makes the connections by hand, across several tabs.
Dynatrace SaaS tackles the problem from the other end: it accepts OTel telemetry as is and automatically builds the topology that connects it. Let us look at what this brings in practice and which settings determine the result.
Four seams to stitch back together
In an architecture instrumented with OpenTelemetry, context breaks almost always happen in the same places.
Between the browser and the first service
Dynatrace frontend monitoring (web, mobile, cross-platform) connects to OTel-instrumented backends through standard W3C propagation, i.e. the traceparent and tracestate headers. No additional instrumentation is needed along the backend chain. You can then start from a session in User Events and Sessions (including its replay on Grail), open the associated trace in Distributed Tracing, or go the other way from a backend span to the user action that caused it. The condition, and it is often forgotten: the trace context must actually be propagated all the way to the service.
Between services
The cloud-native Service Map continuously discovers connections at runtime: upstream and downstream services, database queries, messaging flows, with health status overlaid. Service-to-database mapping is built from OTel data, with no manual entity modelling; it relies on dependencies actually observed rather than on tags.
Between the application and the infrastructure
For teams already running a Collector on their hosts, host and process metrics feed the Infrastructure & Operations app, with correlated logs and alert templates. Infrastructure entities join Smartscape, which makes it quick to tell an application problem from a platform problem. The documentation lists the supported Collector distributions; they must include the hostmetrics receiver and the resourcedetection processor.
Between classic services and AI
Community conventions for AI, such as OpenInference and OpenLLMetry, which belong to the OpenTelemetry ecosystem, allow Dynatrace to place models, agents and agent services in Smartscape, next to traditional services. Captured production telemetry can then serve as input to online evaluations of response quality, safety and performance, depending on the chosen configuration.
OneAgent or OpenTelemetry: no need to choose
Smartscape treats OneAgent and OpenTelemetry as equivalent sources: an OTel-instrumented service appears with the same depth as a service observed by OneAgent. That is a practical argument for hybrid environments, which are very common: one team keeps OneAgent on its legacy VMs, another instruments its microservices with OTel, and the topology stays unified.
A note on scope: the Service Map, the frontend-backend link and host monitoring through the Collector are offered to customers on the Dynatrace Platform Subscription (DPS).
In practice: OpenTelemetry end-to-end in Dynatrace
Step 1 — Check propagation on the frontend side
When the frontend calls an API on another domain, the browser only sends trace headers if the API explicitly allows them. Check your APIs’ CORS response:
Access-Control-Allow-Headers: traceparent, tracestate, content-type
Also check that your gateways and reverse proxies do not strip these headers. A session that leads to no backend trace almost always comes down to this.
Step 2 — Complete the host Collector
Here is a minimal configuration that adds host metrics and resource detection, then exports to the environment’s OTLP endpoint. Dynatrace expects metrics with delta temporality, hence the conversion processor:
receivers:
hostmetrics:
collection_interval: 60s
scrapers:
cpu: {}
memory: {}
disk: {}
filesystem: {}
network: {}
process: {}
processors:
resourcedetection:
detectors: [env, system]
cumulativetodelta: {}
batch: {}
exporters:
otlphttp:
endpoint: https://<environment-id>.live.dynatrace.com/api/v2/otlp
headers:
Authorization: "Api-Token ${env:DT_API_TOKEN}"
service:
pipelines:
metrics:
receivers: [hostmetrics]
processors: [resourcedetection, cumulativetodelta, batch]
exporters: [otlphttp]
The token must have the ingest scopes matching the signals sent. Adapt the detectors to your context (cloud, Kubernetes) using the Collector documentation.
Step 3 — Check that spans arrive in Grail
Before judging the topology, make sure spans arrive with the right resource attributes. In a Notebook (for a syntax refresher, see DQL fundamentals):
fetch spans, from: now()-30m
| summarize spans = count(), by: { service.name }
| sort spans desc
A missing service, or one saddled with a generic name, signals a service.name not set in the SDK or the instrumentation configuration.
Step 4 — Walk the full chain
Pick a real user journey, for example a slow product search. Start from the session, open the trace, identify the service and its database query in the Service Map, then move up to the host in Infrastructure & Operations. If a link is missing, you know exactly where to step in. The Dynatrace Playground lets you do this exercise on demo data before touching your own environment.
Best practices
- Follow the OpenTelemetry semantic conventions for resource attributes: entity construction relies on them.
- Test W3C propagation end to end, including CORS and proxies, before concluding that a frontend-backend link « does not work ».
- Keep a single, well-documented Collector pipeline per host type rather than diverging variants.
- In mixed environments, let OneAgent and OTel coexist: the topology reconciles them.
- For AI workloads, adopt a common convention (OpenInference or OpenLLMetry) from the start rather than home-grown attributes.
Frequently asked questions
Do you have to choose between OneAgent and OpenTelemetry?
No. Smartscape treats both as equivalent sources: an OTel-instrumented service appears with the same depth as a service observed by OneAgent, and the topology stays unified in a hybrid environment.
Why does a user session lead to no backend trace?
Almost always because the W3C context is not propagated: the API called on another domain does not allow the traceparent and tracestate headers in its CORS response, or a gateway strips them along the way.
Which Collector distribution should you use for host metrics?
One of the distributions listed in the Dynatrace documentation, as long as it includes the hostmetrics receiver and the resourcedetection processor. Add the conversion to delta temporality, which Dynatrace expects for metrics.
Conclusion
OpenTelemetry has settled the question of format; the value now lies in connecting the signals. By automatically building the topology from OTel telemetry, from the browser to the host and AI components, Dynatrace SaaS avoids the manual stitching that slows down every incident. The remaining work is mostly hygiene: propagate context, name resources correctly and equip the Collector with the right components.
Further reading: Connect OpenTelemetry signals end-to-end with Dynatrace (Dynatrace blog).
span.observer is an independent community blog, not affiliated with Dynatrace LLC. Dynatrace is a trademark of Dynatrace LLC. SaaS features evolve quickly: check their availability in your environment and in the official documentation.
Originally published on span.observer. French version: https://span.observer/fr/opentelemetry-bout-en-bout-dynatrace/.
Top comments (0)