Explainer

What is OpenTelemetry? A plain-English guide

A plain guide to OpenTelemetry: what it standardizes, how the Collector and OTLP fit together, what it costs to run, and how to start with one service.

By the Cloudverg engineering team · · 5 min read

What it is

OpenTelemetry is an open source project that gives you one standard way to produce, collect and export telemetry from software. Telemetry means traces, metrics and logs. A trace follows one request across services. A metric is a number over time, like request count or queue depth. A log is a timestamped record of an event. OpenTelemetry defines the data model, the APIs that code calls, the SDKs that implement those APIs, and a wire protocol called OTLP.

Before OpenTelemetry, most teams wired each signal to a vendor agent or a homegrown library. Moving to another backend meant re-instrumenting. OpenTelemetry separates instrumentation from the backend. You add the SDK once, point it at an OTLP endpoint, and change the endpoint when your monitoring choice changes. It is not a monitoring product. It does not store data, draw dashboards or page anyone. It is the plumbing that feeds those systems.

The project is developed in public and backed by a broad set of cloud providers, vendors and end users. That matters at buying time: ask whether a product accepts OTLP natively and follows the semantic conventions, instead of asking whether it has a proprietary agent.

How it works

Inside the application, the OpenTelemetry API creates spans, counters, histograms and log records. The SDK decides how to sample, batch and export them. Auto-instrumentation packages cover common frameworks: HTTP servers, gRPC, database drivers, message queues. Java, .NET, Python, Node.js and Go have agents or packages that attach at startup. Manual spans fill gaps around business steps, like price calculation or payment authorization.

Context propagation makes traces useful. When service A calls service B, the trace ID and parent span ID travel in headers. OpenTelemetry uses W3C Trace Context by default, plus baggage for small key value pairs. If a proxy, queue or background job drops those headers, the trace breaks into separate pieces. Check propagation at every hop.

The Collector is a separate process that receives, processes and exports telemetry. A config has receivers, processors and exporters. Receivers accept OTLP, Prometheus metrics, Jaeger traces or host metrics. Processors add resource attributes, batch data, cap memory, redact fields, sample traces or drop noisy metrics. Exporters send data to your backend or another Collector. Run it as an agent on each node, as a gateway, or both.

Resource attributes identify the source: service.name, service.version, deployment.environment, host.name, cloud region. Set them consistently because every dashboard, alert and query depends on them. Semantic conventions define common names for HTTP, database and messaging spans. Follow them and standard dashboards work with less custom mapping.

Why it matters for a business

For a business, the main value is choice. Telemetry is a long lived asset. If instrumentation is tied to one vendor, switching costs rise each year. With OpenTelemetry, instrumentation stays in your codebase and the backend becomes a routing decision. You can move a service to a cheaper store, or run different backends for different teams, without asking engineers to rewrite instrumentation.

It also gives finance and operations a control point. Telemetry volume drives observability bills. The Collector can sample, filter and aggregate before data leaves your network. You can drop debug logs from a noisy service, keep all errors, and reduce routine success traces. That is a policy you can see and review, not a hidden SDK setting.

Teams get a shared language. A trace from the web tier to the database uses the same service.name and span names in Java or TypeScript. A new engineer can follow one request instead of learning a different agent per service. Security teams can enforce redaction in one Collector config. The trade off is ownership: someone must run the pipeline, upgrade SDKs and watch data quality.

Common mistakes

The first mistake is treating OpenTelemetry as a drop-in replacement for an APM tool. It produces data. It does not give you alert rules, dashboards, SLO reports or an on call rotation. You still need a backend and a monitoring practice. Choose the backend for query, retention and alerting, then use OpenTelemetry to feed it.

The second is instrumenting everything at once. Auto instrumentation can produce more spans than the team can use. Start with one user facing flow and a few questions: where does latency come from, which dependency fails first, which customer segment sees errors. Add spans that answer those questions. Leave the rest for later.

Other common problems: missing service.name, so data lands in an unknown bucket. High cardinality metric labels, such as user ID or request ID, that raise cost. Sampling only at the SDK, which misses errors that tail sampling would keep. A single Collector with no memory limit or replicas, which becomes an outage. No owner for the pipeline. Sending every log line when a logs bridge with trace IDs would be enough.

How to get started

Pick one service that matters and has a clear owner. Write down three questions the team wants to answer, for example: which endpoint is slow, which database query fails during checkout, and how long the payment provider takes. That list keeps the work bounded.

Deploy the Collector close to the application first, as a sidecar or node agent, and send data over OTLP. Set OTEL_SERVICE_NAME and OTEL_RESOURCE_ATTRIBUTES in the deployment manifest so every signal has the same identity. Turn on auto instrumentation for the runtime. Add manual spans around the business steps from your list. Send the data to your existing backend if it accepts OTLP, or to a small staging backend.

Once traces look right, add metrics and logs for the same service. Configure the batch processor, the memory limiter and a sampling policy. Set a retention rule per signal. Compare the new data with what your current tool shows before you retire anything. Then write a short standard: naming, resource attributes, sampling defaults, and where the Collector config lives. Expand one service at a time.

If you need the surrounding delivery plumbing, Cloudverg's Delivery platform setup, at $14,500/month, includes monitoring, alerting and dashboards for the services in scope. It is one option. You can also assign an internal platform team, hire a contractor, or use a managed observability service. Own the instrumentation and the Collector config, not just the dashboard.

Frequently asked questions

Is OpenTelemetry a monitoring tool?

No. It is a set of APIs, SDKs and a Collector that produce and move telemetry. You still need a backend to store, query and alert on the data, and a team to act on it.

Do we need the OpenTelemetry Collector?

Not strictly. An SDK can export directly to a backend. Most teams add the Collector because it centralizes credentials, filters noisy data, adds resource attributes and lets you change backends without redeploying applications.

What is OTLP?

OTLP is the OpenTelemetry Protocol. It defines how telemetry is encoded and sent between SDKs, Collectors and backends. If a tool accepts OTLP, you can usually point your Collector at it without custom code.

Monthly plan

Want help with this? Delivery platform setup

$14,500/month

4 weeks · Starts within 10 business days

Four weeks to give your engineers a delivery platform: pipelines, environments, secrets, monitoring and rollback they can trust.

Renews monthly. Cancel any time.
What is included

Related guides

More devops and platforms guides   Engineering systems

Smallest way to start

Get a senior architect on your problem this week

Ninety minutes a month on the cloud, AI or security question that is blocking you, a pre-read of your material and a written summary within two business days.

$450/month

Renews monthly. Cancel any time.