Header background

Dynatrace joins the OpenTelemetry project

At KubeCon Barcelona, the OpenCensus and OpenTracing projects announced that they’ve merged into a single new project called OpenTelemetry. Dynatrace has been working with the team behind both projects for some time already in the W3C Distributed Tracing working group. Dynatrace has now also officially joined the OpenTelemetry project

Why are we doing this?

Data analysis within large and highly dynamic microservices environments is the biggest challenge that Performance Monitoring vendors face today. While data collection itself is an integral part of APM, it’s ultimately only a means to an end. The real challenge is a robust and effective analysis of such data.

Dynatrace has been building automated application instrumentation—without the need to modify source code—for over 15 years already. Dynatrace provides the widest monitoring coverage of software frameworks that are used in modern enterprise applications. We invest heavily in ensuring that Dynatrace maintains the widest possible monitoring coverage of frameworks and platforms.

As we know how much work intelligent data analysis requires, we embrace the idea of OpenTelemetry building more observability into frameworks out-of-the-box. Once OpenTelemetry is more widely adopted as a standard, it will serve as an additional data source that further extends the breadth of Dynatrace monitoring.

The Dynatrace platform automatically integrates OpenTelemetry data, thereby providing the highest possible scalability, enterprise manageability, seamless processing of data, and, most importantly the best analytics through Davis® (our AI-driven analytics engine), and automation support available.

What Dynatrace will contribute

Initially, we’ll focus on the following key areas where we believe our experience in building enterprise-grade tracing will help OpenTelemetry evolve as quickly as possible:

  • Support for the merging of OpenTracing and OpenCensus for Node.js, Python, and Java.
  • Integration of Trace-Context—a uniform means of propagating transactional context across tiers—into OpenTelemetry
  • Driving the implementation of higher-level APIs—also called “typed spans”—to simplify the implementation of semantically strong tracing code
  • Adding capabilities for enterprise-supportability using runtime management of individual components and libraries

What are the benefits of the Dynatrace contribution?

With OpenTelemetry data being a first class data source in Dynatrace, companies can leverage their existing investments in custom tracing while gaining all the benefits of the Dynatrace platform. This means that Dynatrace customers will receive:

  • Automatic OneAgent monitoring with auto-discovery of processes exposing OpenTelemetry data including native apps.
  • Instrumentation exposed by frameworks using OpenTelemetry will be automatically added to Dynatrace PurePath data
  • OpenTelemetry data will be natively supported and used by the Dynatrace AI engine, Smartscape, Service flow, and more.

How Dynatrace OneAgent integrates OpenTelemetry

Dynatrace has long provided SDKs for custom instrumentation where automatic instrumentation isn’t possible or feasible, for example with native technologies like C/C++,  proprietary protocols and frameworks, or IoT environments. OpenTelemetry now provides a standardized way of adding instrumentation to such frameworks. We’re currently investigating how we can better adapt the Dynatrace OneAgent SDK to take full advantage of OpenTelemetry. Our contribution to typed spans is a first step in this direction.

Agents will continue to be the primary and best means of performance-data collection going forward. Agents are far easier to deploy than manual instrumentation to code. New agents can also be automatically deployed based on detected changes in your infrastructure and service landscape. The OpenTelemetry project has a SIG for Automatic Instrumentation, so clearly, the need for agents and automatic instrumentation is real.

At Dynatrace, we believe that combining own instrumentation code (in combination with OpenTelemetry data) with agent technology, provides the highest possible value for our customers:

    • Dynatrace OneAgent supports automatic instrumentation without any code change.
    • Dynatrace will keep providing framework instrumentation for all important frameworks beyond the scope of OpenTelemetry.
    • OpenTelemetry instrumentation will be automatically picked up by Dynatrace OneAgent.
    • Dynatrace OneAgent will provide code-level insights that are essential for production debugging and performance tuning.
    • The OneAgent auto-update feature allows for the shipping of updated instrumentation code within hours—even for older libraries—without requiring customers to update and redeploy their applications.
  • OpenTelemetry instrumentation often wraps framework interfaces to collect tracing data. This approach doesn’t always work. Dynatrace OneAgent can better handle these situations using byte code instrumentation or similar means.

What’s next?

If you’re a Dynatrace customer who is using OpenTracing or OpenCensus, we invite you to reach out to us to discuss the details of our OpenTelemetry strategy.

We’ll be releasing support for OpenTelemetry as the project matures and the related libraries are released. For details on the current roadmap for OpenTelemetry please see this blog post.