THE LINUX FOUNDATION PROJECTS

OpenTelemetry (OTel) in OpenSearch

Fully open observability from instrumentation to insight

OpenSearch ingests OpenTelemetry natively and stays Apache 2.0 from collection through storage to query. Keep your standard OTLP instrumentation and OTel SDKs. No proprietary agent, no re-instrumenting.

DescribeArchitecture diagram showing telemetry flow: Apps and AI agents are instrumented with OTel SDKs, which send traces, logs, and metrics via OTLP (gRPC :4317 / HTTP :4318) to an OTel Collector. The Collector forwards traces and logs to OpenSearch Data Prepper, which sends them to OpenSearch for visualization in Dashboards, and sends metrics directly to Prometheus. OpenSearch Data Prepper also derives RED metrics that flow to Prometheus.

OpenSearch Observability → OpenTelemetry

At a Glance
  • Apache 2.0, end-to-end
  • CNCF-graduated standard
  • No vendor lock-in

Observability data takes many forms: logs, metrics, traces, and now spans from AI agents. Each has traditionally meant a separate collector, a separate store, and a separate query language. The complexity is structural, and so is the cost.

01

What OTel is and why it matters

OpenTelemetry is a CNCF-backed, vendor-neutral standard for generating, collecting, and exporting traces, metrics, and logs. Instrument once and retain the flexibility to switch or evolve your backend without re-instrumenting your code.

One standard across your polyglot stack

Python JavaScript Go Java .NET Ruby PHP Rust C++ Erlang Swift

02

Why OpenSearch builds on OTel

Industry standard

Maintained by the CNCF with contributions from Google, Microsoft, Amazon, and hundreds of organizations.

Portable by default

Own your observability data outright. Export to any backend, store locally, or change providers without losing history and without rewriting instrumentation.

Language agnostic

One instrumentation model across Python, Java, Go, .NET, JavaScript, Rust, C++, Ruby, PHP, and more.

Future-proof

Built on open standards that evolve. As new telemetry types emerge, like the GenAI conventions now used for agent traces, your instrumentation stays relevant.

03

OpenSearch is OpenTelemetry native

OpenSearch ingests OTLP data via the OTel Collector on standard ports, 4317 for gRPC and 4318 for HTTP. Instrumentation uses standard OTel SDKs. There are no proprietary OpenSearch libraries required.

From the Collector, the pipeline forks by signal: metrics route to Prometheus for time-series storage, while traces and logs route to OpenSearch Data Prepper, which enriches them before writing them to OpenSearch. That enrichment step builds the service map, derives RED metrics from span data and writes them to Prometheus, and preserves the trace IDs that link logs to the requests that produced them. In Dashboards, a trace’s related logs are one tab away.

The Observability Stack ships this path preconfigured, by installer, Docker Compose, or Helm.

Split-screen loading view of an 'otel-collector.yaml' configuration file. The left panel shows an empty code editor with only a comment header, '# OpenTelemetry Collector Configuration,' and line numbers 1–22 reserved for content yet to appear. The right panel shows two gray placeholder bars indicating a trace result panel that hasn't loaded yet.

Depicts OpenSearch Dashboards 3.8

What the pipeline produces is covered in greater depth on the following pages: service maps and trace waterfalls in Application Performance Monitoring, PPL and log correlation in Log Analytics, PromQL and dashboards in Metrics and Prometheus.

04

AI agent observability in OpenSearch

Describe the image here

Depicts OpenSearch Dashboards 3.8

Instead of relying on proprietary schemas like most agent observability tools, OpenSearch has adopted the OpenTelemetry GenAI semantic conventions. This allows agent invocations, tool calls, and LLM interactions to be described with attributes anyone can read and any OTel-compatible backend can consume.

If your agents are already instrumented with something else, the stack converts on the way in. The Collector configuration shipped with the Observability Stack enables the upstream OpenTelemetry GenAI normalizer, which maps OpenInference and OpenLLMetry attributes into GenAI semantic conventions before AI agent traces are stored.

In production, agent telemetry lands alongside your service traces and is explored in OpenSearch Dashboards, where an invocation renders as a timeline and as a directed graph. Agent Health is the local companion to that, an npx tool for inspecting traces, running benchmarks, and scoring outputs before anything ships.

Agent observability in OpenSearch Dashboards
Timeline and graph views for agent traces. Agent Health adds local benchmarking and evaluation.

Instrumented where agent teams already work
OpenAI · Anthropic · LangChain · LlamaIndex · Cohere · Mistral · Groq · Ollama · Google · Amazon Bedrock · Strands Agents SDK

05

The benefit of end-to-end Apache 2.0

By combining Apache 2.0 projects, OpenTelemetry and OpenSearch remove licensing barriers for everything on your observability pathway. The Collector configuration, the ingestion layer, the storage layer, and the query and visualization layer are all open. No proprietary tiers, no features gated behind a license, and no vendor lock-in.

Apache 2.0, end to end

The license that matters governs the system storing your telemetry, not just your instrumentation.

Self-hosted by default

One command, your infrastructure, the complete stack. No managed tier required.

Open standards for agents

GenAI semantic conventions in, competing schemas normalized on ingest.

06

Go deeper

Observability Stack

The OTel-native stack

Deployable in one command, with the Collector and Data Prepper preconfigured.

Learn more
Observability Stack Documentation

Agent Health

Agent observability built on OTel GenAI semantic conventions.

Learn more
Observability Stack Documentation

Application Performance Monitoring

OTel distributed tracing and service maps in OpenSearch.

Learn more