What is OpenTelemetry?

The OpenTelemetry project makes robust, portable telemetry a built-in feature of cloud-native software.

High-velocity development and reliable, proactive operations require an effective observability strategy. Rich telemetry is the foundation of cloud-native observability.

OTel Diagram

By connecting best-in-class observability tools to OpenTelemetry, dev and ops gain insights into the reliability and behavior of their applications while maintaining high performance and vendor neutrality in their instrumentation.

What is Observability and how is it related?

In software, observability generally refers to the ability to understand an application’s behavior and performance based only on its telemetry. Put more simply, observability is what allows you to understand what’s happening in production without changing your code.

In distributed systems, this telemetry can be divided into three overarching flavors:

  • (Distributed) Traces: detailed records of the paths that distinct requests take as they propagate across an entire system (including across service boundaries)
  • Metrics: aggregate statistics (mostly counters and gauges) about processes and infrastructure, typically with key:value tags attached to disaggregate patterns
  • Logs: timestamped messages – sometimes structured – emitted by services or other components (though, unlike traces, not necessarily associated with any particular user request or transaction)

Observability is not the same thing as finding a tracing tool, a metrics tool, and a logging tool: it’s about solving problems by putting that telemetry data to work. In this way, you can think of OpenTelemetry as the first step in any observability strategy since high-quality, vendor-neutral data is a great starting point.

Using OpenTelemetry

While the exact details differ between implementations, the general process of integrating with OpenTelemetry is consistent:

  1. First, get your process and core libraries instrumented. Auto-instrumentation is a great first step
  2. Validate your instrumentation by sending it to an observability tool like Lightstep
  3. Learn how to troubleshoot instrumentation issues
  4. With a good understanding of your telemetry, enrich your data with custom attributes and events
  5. Explore advanced topics and best practices to improve collection and analysis

Steps 4 and 5 are ongoing, and should be revisited regularly so you can ensure your telemetry evolves alongside your observability and business needs.

Using these Docs

The aim of these docs is to help developers familiarize themselves with the OpenTelemetry lexicon and architecture, as well as troubleshoot and improve instrumentation implementations.

In the About section, you can find higher-level overview information on tracing, spans, metrics and OpenTelemetry’s Collector/Exporter model.

If you are looking to get started with OpenTelemetry in your application, there is currently detailed documentation for Java, Python, Node.js, and Go. These articles will walk you through installation, data confirmation, and common troubleshooting scenarios, as well as detailed tracing information.

For further assistance, turn to the articles in the Core Concepts and Best Practices sections in the navigation.

If you run into trouble or wish to report an issue with the docs, please contact us.

OpenTelemetry and Lightstep

OpenTelemetry is a Cloud Native Computing Foundation sandbox project and was founded in 2019. OpenTelemetry brings together experts from open source projects, vendors, and the observability community to make it easy to get telemetry out of cloud native applications – and into tools that can analyze that telemetry, like Lightstep.

Lightstep is a founding contributor to OpenTelemetry and continues to participate in its specification process as well as core contributions to its Javascript, Java, Ruby, .Net, Go, and Python implementations.