MyObservability

🟦 Step by Step Setup

🟩 Step 1: Import SDK and setup Exporter, Processors for Span/Metric

🟥 Import Exporters

Send telemetry to the OpenTelemetry Collector to make sure it’s exported correctly.

• ConsoleSpanExporter for printing in console
• OTLPSpanExporter / OTLPMetricExporter for OpenTelemetry Collector, Splunk, Dynatrace, Grafana etc which supports gRPC and HTTP/protobuf to receive telemetry data via the OTLP protocol.
• send your metric data to Prometheus, you can either enable Prometheus’ OTLP Receiver and use the OTLP exporter or you can use the Prometheus exporters.

🟥 Import Processors

The OpenTelemetry SDK provides a set of default span and log record processors, that allow you to either emit spans one-by-on (“simple”) or batched. Using batching is recommended, but if you do not want to batch your spans or log records, you can use a simple processor

Ex:

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor

from opentelemetry import metrics
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader

---

🟩 Step 2: Create Pipeline (Trace or Metrics) to configure Exporter, Processors

1. Main responsibility of the pipeline is to push traces/metrics to one (or more) Exporter(s) via processors. Create a Processor and passed the exporter to the constructor to connect both.

• Traces: A Pipeline function for SpanProcessor & SpanExporters
• Metrics: A Pipeline function for MetricReader & MetricExporter

Processor

Use one of the below method.

• BatchSpanProcessor processes spans in batches before they are exported. This is usually the right processor to use for an application.
• SimpleSpanProcessor processes spans as they are created. This means that if you create 5 spans, each will be processed and exported before the next span is created in code
  • ✅ Note: each time a call to create a span is made, it would be processed and sent over a network before your app’s execution could continue.

In most cases, stick with BatchSpanProcessor over SimpleSpanProcessor.

Exporter

(Metrics) OTLP Metrics Exporter is a Push Metric Exporter which sends metrics via the OpenTelemetry Protocol. (Traces) use either Synchronous (Blocks the program execution to forward spans as soon as they are generated) or Asynchronous (Maintains a buffer for completed spans and export at regular intervals) method to export traces.

Ex:

tracerProvider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="<traces-endpoint>/v1/traces"))
tracerProvider.add_span_processor(processor)
trace.set_tracer_provider(tracerProvider)

reader = PeriodicExportingMetricReader(
    OTLPMetricExporter(endpoint="<traces-endpoint>/v1/metrics")
)
meterProvider = MeterProvider(resource=resource, metric_readers=[reader])
metrics.set_meter_provider(meterProvider)

🟩 Step 3: Import required API, SDK & Providers

1. Import OTel API

   Ex:

    from opentelemetry import metrics as metric_api
    from opentelemetry import trace as trace_api
   

2. Import Providers

    from opentelemetry.sdk.trace import TracerProvider
    from opentelemetry.sdk.metrics import MeterProvider
   

3. (Metrics) Import Metric Instruments from metrics API.

   This is used to define telemetry data points

    from opentelemetry.metrics import Counter, Histogram, ObservableGauge
   

🟩 Step 4: Tracer (For Traces) / Meter (for Metrics)

• Traces: A function for TracingProvider to create and store configuration for Tracer.
• Metrics: A function for MetricProvider to create a meter.

1. (Traces) Configure Resources

    # Service name is required for most backends
    resource = Resource.create(attributes={
        SERVICE_NAME: "your-service-name"
    })
   

2. Create TraceProvider/MeterProvider to obtain Tracer/Meter.

    tracerProvider = TracerProvider(resource=resource)
    processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="<traces-endpoint>/v1/traces"))
    tracerProvider.add_span_processor(processor)
    trace.set_tracer_provider(tracerProvider)
   
    reader = PeriodicExportingMetricReader(
        OTLPMetricExporter(endpoint="<traces-endpoint>/v1/metrics")
    )
    meterProvider = MeterProvider(resource=resource, metric_readers=[reader])
    metrics.set_meter_provider(meterProvider)
   

🟩 Step 5: Create Tracer & Meter from providers

Create tracer from the global tracer/meter provider.

```python
# Creates a tracer from the global tracer provider
tracer = trace.get_tracer("my.tracer.name")
```

```python
# Creates a meter from the global meter provider
meter = metrics.get_meter("my.meter.name")
```

🟩 Step 6: Create spans & metrics

Generating trace and metrics are different from this step.

• Tracer generate spans but meter produce set of instruments which reports measurements.

Spans

• Create spans/ nested spans.
• Add attributes to the span (Use semantic attributes)
• Add events & exceptions.
• Ensure Context Propagation Across Threads / Services.
• Execute application.

Metrics

• Use the meter to create counter instrument to measure.

---

✅ Kubernetes

✅ Main Page: Click Here

---