opentelemetry.io

Implement OTel SDK context propagation across async task boundaries in Python with asyncio and contextvars

Configure the OTel Collector routing connector to split telemetry streams by attribute value into separate pipelines

Use the OTel Collector count connector to derive a request-count metric from log records without modifying the application

Configure the OTel Collector spanmetrics connector with explicit histogram bucket boundaries and dimension overrides

Apply OTTL expressions in the OTel Collector transform processor to rename metric data points and remove unwanted attributes

Configure OpenTelemetry resource detection processors in the Collector to automatically populate cloud and Kubernetes resource attributes

Emit and ingest the experimental OpenTelemetry profiling signal using the OTel Collector and Pyroscope exporter

Configure the OpenTelemetry Collector to export traces to multiple backends simultaneously using the fanout pattern with the forward connector

Configure cardinality control in an OTel Collector metrics pipeline using the metricstransform processor and the transform processor to aggregate away high-cardinality dimensions

Enable and configure OpenTelemetry Collector's zpages extension for live pipeline debugging and span inspection

Compute an availability SLI as a Prometheus recording rule ratio

Instrument a browser SPA with the OpenTelemetry JavaScript SDK for traces and web vitals

Generate RED metrics from trace spans using the OTel Collector spanmetrics connector

Compute latency percentile SLOs (p99) from Prometheus histogram metrics

Configure Elastic Heartbeat for uptime synthetics monitoring (HTTP and ICMP checks)

Capture and export browser errors and web vitals as OTel spans using the OTel JS SDK with custom instrumentation

Configure Prometheus recording rules to pre-aggregate SLO burn rate windows for efficient querying

Set up the OpenTelemetry eBPF collector to capture network-level telemetry

Attach experimental OTel profiling signal to an existing OTel pipeline

Capture Core Web Vitals (LCP, INP, CLS) and forward them as OTel metrics

Configure OTel Collector tail-based sampling with composite policies

Use the OTel Collector transform processor to modify telemetry with OTTL statements

Connect services using the OTel Collector routing connector to split telemetry by attribute

Generate span metrics from traces using the OTel Collector spanmetrics connector

Enable exemplars to link Prometheus metrics to OTel traces

Implement log-trace correlation by injecting trace_id into structured logs using the OTel logs bridge

Apply OpenTelemetry semantic conventions for GenAI and LLM spans

Configure OTel metrics SDK for delta vs cumulative temporality per exporter

Propagate distributed trace context using W3C TraceContext and Baggage headers

Configure OTel resource detection to automatically populate resource attributes

Use OTel span links to model batch processing and fan-in relationships

Manually create and nest spans with the OTel SDK to trace internal business logic beyond framework auto-instrumentation

Propagate W3C TraceContext and Baggage headers across HTTP service boundaries using OTel context propagation APIs

Attach OTel SDK baggage to carry tenant and request metadata across service calls without modifying span attributes

Configure the OTel Collector probabilistic sampler processor for head-based sampling to reduce trace volume uniformly

Auto-instrument a Java application with the OpenTelemetry Java agent and configure agent settings via system properties

Auto-instrument a Node.js application with the OTel Node.js SDK and @opentelemetry/auto-instrumentations-node

Record OTel metrics using a Counter, UpDownCounter, and Histogram with the OTel Metrics API and SDK

Configure an exponential histogram in the OTel SDK and Collector for high-resolution latency distribution without manual bucket tuning

Bridge existing log framework output (Java Logback / Python logging) into OTel Logs using the OTel Logs Bridge API

Correlate traces, metrics, and logs using OTel exemplars and trace context injection for a unified debugging workflow

Use OTel span links to connect causally related spans across asynchronous message queue boundaries

Deploy the OTel Collector as both a DaemonSet and a Deployment (gateway) on Kubernetes and understand the routing responsibilities of each tier

Apply OTel stable HTTP semantic conventions (semconv 1.x) to ensure consistent span attribute naming across services and backends

Fix the OpenTelemetry Collector health_check extension endpoint so Kubernetes liveness probes succeed

Choose between OTel Collector agent and gateway deployment patterns

Wire receivers, processors, and exporters into an OTel Collector pipeline

Tune memory_limiter and batch processor order and settings for stable throughput

Scale and operate an OTel Collector gateway tier for high availability

Monitor OTel Collector health using internal telemetry (service.telemetry)

Collect Kubernetes container logs with filelog receiver and k8sattributes processor

Link metric spikes to traces using OTel exemplars

Configure OTLP exporter sending_queue and retry_on_failure for resilient export

Debug an OTel Collector using zpages and pprof extensions

Instrument a browser application with the OpenTelemetry JavaScript SDK to emit traces for page loads and fetch requests

Scale OpenTelemetry Collector deployments using the loadbalancingexporter to route traces from gateway collectors to tail-sampling backends by trace ID

Tune the OpenTelemetry Collector memory_limiter and batch processor for stable high-throughput operation

Configure the OpenTelemetry Collector tail sampling processor with multiple composite policies for intelligent trace retention

Configure tail sampling in the OpenTelemetry Collector to keep only high-value traces

Choose and configure head sampling in the OpenTelemetry SDK to reduce trace volume at the source

Migrate OpenTelemetry instrumentation to stable semantic conventions (semconv 1.x) without breaking dashboards

Enable the spanmetrics connector in the OpenTelemetry Collector to generate RED metrics from trace spans

Propagate OpenTelemetry baggage across service boundaries to carry request-scoped metadata

Configure an OpenTelemetry Collector pipeline with receivers, processors, and exporters

Set up an OTLP exporter in an application SDK choosing between gRPC and HTTP transport