Testing
OpenTelemetry semantic conventions define standard names and attributes for common operations — HTTP requests, database calls, messaging systems, and more. When your instrumentation follows them, your observability data works correctly with standard dashboards, automatic anomaly detection, and cross-service correlation. When you deviate from semantic conventions — even slightly — things break in
Testing
When you add OpenTelemetry instrumentation to your codebase, you're writing code that needs to be tested like any other code. A function that creates a span, records attributes, and handles errors can have bugs. Without tests, you discover them in production when your traces are missing or incorrect.
Testing
Sampling is one of the most consequential decisions in an observability setup — and one of the least tested. When sampling is misconfigured, you lose exactly the traces you most need: errors, slow requests, and anomalies. Or you over-sample and blow your observability budget. Testing your sampling strategy should be
Testing
Your OTEL metrics instrumentation is only as good as your confidence that it measures what it claims to measure. A checkout success counter that double-counts, a latency histogram with wrong boundaries, or an alert rule that fires too late (or never) — these are observability bugs that cause real production
Testing
Most teams think of OpenTelemetry as a production concern — you instrument your app, deploy it, and then your observability stack tells you what's happening. CI/CD is where you validate code; OTEL is where you debug production. These two worlds don't meet. This is a missed
Testing
Custom OpenTelemetry instrumentation is code like any other code — it can be wrong, and wrong instrumentation is worse than no instrumentation. If your span names are wrong, your dashboards show garbage. If context propagation is broken, your distributed traces have gaps. If attributes are missing, your SLOs can't
Testing
Browser instrumentation is the hardest part of OpenTelemetry to test. Unlike server-side code, where you can inject an in-memory exporter directly, browser code runs in a JavaScript runtime that has no concept of "injectable test components" at the module level. You need strategies for both unit-
Testing
Your OpenTelemetry Collector configuration is infrastructure code. It determines which telemetry reaches which backend, which attributes get stripped or transformed, and what sampling decisions are made. A misconfigured collector silently drops spans, misroutes metrics, or leaks PII in attributes that should have been filtered. The collector should be tested before
Testing
When a microservices integration test fails with a vague 500 error, you have a problem: the error came from somewhere in a chain of four services, passed through an API gateway, and touched a database and a message queue. The stack trace in your test output tells you where the
Testing
OpenTelemetry Collector sits at the heart of modern observability pipelines. It receives telemetry from your services, processes it, and exports it to your backends. When that pipeline misbehaves—dropping spans, garbling attributes, or misrouting logs—debugging it is painful. The solution is testing it properly before it ever touches production.
Testing
Tracing tells you what happened — testing tells you whether it should have happened. OpenTelemetry brings them together: instrument once, verify always. What OpenTelemetry Adds to Testing Classic unit and integration tests check return values. They miss latency, span counts, attribute correctness, and propagation across services. OpenTelemetry testing fills that gap
Testing
Playwright tests verify what the user sees. OpenTelemetry traces verify what the backend did to produce it. Together, they give you the most complete picture of correctness available: from browser click to database write. The Architecture Playwright test → browser action (click, form fill) → HTTP request to your API → [service A