The complete guide to OpenTelemetry in Python

1
from opentelemetry import trace
2
from opentelemetry.sdk.trace import TracerProvider
3
from opentelemetry.sdk.resources import Resource
4
5
provider = TracerProvider(resource=Resource.create(
6
    {
7
        "service.name": "my-service",
8
        "highlight.project_id": "<YOUR_PROJECT_ID>",
9
        "environment": "production",
10
    }
11
))
12
13
trace.set_tracer_provider(provider)
14
tracer = trace.get_tracer("my-service")

1
from opentelemetry.sdk.trace import TracerProvider
2
from opentelemetry.sdk.trace.export import BatchSpanProcessor
3
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
4
5
processor = BatchSpanProcessor(
6
    exporter=OTLPSpanExporter(endpoint="https://otel.highlight.io:4317"),
7
    max_queue_size=1000,
8
    max_export_batch_size=100,
9
    schedule_delay_millis=1000,
10
)

1
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
2
3
exporter = OTLPSpanExporter(endpoint="https://otel.highlight.io:4317", insecure=True, headers={ "foo": "bar" })

1
service_name = "my-service"
2
environment = "production"
3
otel_endpoint = "https://otel.highlight.io:4317"
4
5
# Set up the logger provider with the resource
6
logger_provider = LoggerProvider(resource=Resource.create(
7
    {
8
        "service.name": service_name,
9
        "highlight.project_id": "<YOUR_PROJECT_ID>",
10
        "environment": environment,
11
    }
12
))
13
set_logger_provider(logger_provider)
14
15
# Configure the OTLP log exporter
16
exporter = OTLPLogExporter(endpoint=otel_endpoint, insecure=True)
17
logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
18
19
# Set up the logger
20
logger = logging.getLogger(service_name)
21
logger.setLevel(logging.DEBUG)
22
23
# Add the OpenTelemetry logging handler
24
handler = LoggingHandler(level=logging.DEBUG, logger_provider=logger_provider)
25
logger.addHandler(handler)

1
import logging
2
from opentelemetry import trace
3
from opentelemetry._logs import set_logger_provider
4
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
5
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
6
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
7
from opentelemetry.sdk.resources import Resource
8
from opentelemetry.sdk.trace import TracerProvider
9
from opentelemetry.sdk.trace.export import BatchSpanProcessor
10
from opentelemetry.sdk.trace.export import ConsoleSpanExporter
11
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
12
import sys
13
14
# Define the service name and environment
15
service_name = "my-service"
16
environment = "production"
17
otel_endpoint = "https://otel.highlight.io:4317"
18
19
# Create a resource with service name and highlight project ID
20
provider = TracerProvider(resource=Resource.create(
21
    {
22
        "service.name": service_name,
23
        "highlight.project_id": "<YOUR_PROJECT_ID>",
24
        "environment": environment,
25
    }
26
))
27
processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=otel_endpoint, insecure=True))
28
provider.add_span_processor(processor)
29
trace.set_tracer_provider(provider)
30
tracer = trace.get_tracer(service_name)

1
    with tracer.start_as_current_span("example-span") as span:
2
	        logger.info('hello, world!')
3
	        span.set_attributes(
4
	            {
5
	                "category": "special",
6
	                "rows_affected": 123
7
	            }
8
	        )
9
	        logger.warning('whoa there', {'key': 'value'})`,

1
from opentelemetry import metrics
2
from opentelemetry.sdk.metrics import MeterProvider, set_meter_provider
3
from opentelemetry.sdk.metrics.export import ConsoleMetricsExporter
4
from opentelemetry.sdk.resources import Resource
5
6
# Set up the meter provider with the resource
7
meter_provider = MeterProvider(resource=Resource.create(
8
    {
9
        "service.name": service_name,
10
        "highlight.project_id": "<YOUR_PROJECT_ID>",
11
        "environment": environment,
12
    }
13
))
14
set_meter_provider(meter_provider)
15
meter = metrics.get_meter("my-service")
16
counter = meter.create_counter("my-counter")

1
counter.add(1)

1
from fastapi import Request, FastAPI
2
3
app = FastAPI()
4
5
@app.middleware("http")
6
async def trace_middleware(request, call_next):
7
    with tracer.start_as_current_span(f"{request.method} {request.url.path}"):
8
        response = await call_next(request)
9
        return response
10
11
@app.get("/")
12
def read_root():
13
    return {"message": "Hello, World!"}

1
import logging
2
import os
3
from dotenv import load_dotenv
4
from typing import Optional
5
6
from opentelemetry import metrics, trace
7
from opentelemetry.sdk.metrics.export import AggregationTemporality
8
from opentelemetry.sdk.metrics import Counter, Histogram, UpDownCounter
9
from opentelemetry._logs import set_logger_provider
10
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
11
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
12
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
13
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
14
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, ConsoleLogExporter
15
from opentelemetry.sdk.metrics import MeterProvider
16
from opentelemetry.sdk.metrics.export import ConsoleMetricExporter, PeriodicExportingMetricReader
17
from opentelemetry.sdk.resources import Resource
18
from opentelemetry.sdk.trace import TracerProvider
19
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
20
21
EXPORTER_OTLP_ENDPOINT = os.getenv("OTEL_ENDPOINT","https://otel.highlight.io:4317")
22
23
# read from .env
24
load_dotenv()
25
26
print("OTEL Endpoint is: ", EXPORTER_OTLP_ENDPOINT)
27
HIGHLIGHT_PROJECT_ID = os.getenv("HIGHLIGHT_PROJECT_ID", "EMPTY")
28
print("HIGHLIGHT_PROJECT_ID is: ", HIGHLIGHT_PROJECT_ID)
29
30
import sys
31
32
def create_logger(service_name: str, environment: Optional[str] = "production", local_debug: bool = False) -> logging.Logger:
33
    if environment is None:
34
        environment = "production"
35
    commit = os.getenv("RENDER_GIT_COMMIT", "unknown")
36
    resource = Resource.create(
37
        {
38
            "service.name": service_name,
39
            "highlight.project_id": HIGHLIGHT_PROJECT_ID,
40
            "environment": environment,
41
            "commit": commit
42
        }
43
    )
44
45
    logger_provider = LoggerProvider(resource=resource)
46
    set_logger_provider(logger_provider)
47
48
    exporter = OTLPLogExporter(endpoint=EXPORTER_OTLP_ENDPOINT, insecure=True) if not local_debug else ConsoleLogExporter()
49
50
    logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
51
52
    logger = logging.getLogger(service_name)
53
    logger.setLevel(logging.DEBUG)
54
55
    handler = LoggingHandler(level=logging.DEBUG, logger_provider=logger_provider)
56
    logger.addHandler(handler)
57
58
    # Add console handler for stdout
59
    console_handler = logging.StreamHandler(sys.stdout)
60
    console_handler.setLevel(logging.DEBUG)
61
    if commit:
62
        formatter = logging.Formatter('commit: ' + commit + ' - %(asctime)s - %(name)s - %(levelname)s - %(message)s')
63
    else:
64
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
65
    console_handler.setFormatter(formatter)
66
    logger.addHandler(console_handler)
67
68
    return logger
69
70
def create_tracer(
71
        service_name: str, 
72
        environment: Optional[str] = "production", 
73
        local_debug: bool = False
74
        ) -> trace.Tracer:
75
    if environment is None:
76
        environment = "production"
77
    commit = os.getenv("RENDER_GIT_COMMIT", "unknown")
78
    provider = TracerProvider(resource=Resource.create(
79
        {
80
            "service.name": service_name,
81
            "highlight.project_id": HIGHLIGHT_PROJECT_ID,
82
            "environment": environment,
83
            "commit": commit
84
        }
85
    ))
86
    processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=EXPORTER_OTLP_ENDPOINT, insecure=True)) if not local_debug else BatchSpanProcessor(ConsoleSpanExporter())
87
    provider.add_span_processor(processor)
88
    trace.set_tracer_provider(provider)
89
    tracer = trace.get_tracer(service_name)
90
91
    return tracer
92
93
def get_meter(service_name: str, environment: Optional[str] = "production", local_debug: bool = False) -> metrics.Meter:
94
    if environment is None:
95
        environment = "production"
96
    commit = os.getenv("RENDER_GIT_COMMIT", "unknown")
97
98
99
    preferred_temporality: dict[type, AggregationTemporality] = {
100
            Counter: AggregationTemporality.DELTA,
101
            UpDownCounter: AggregationTemporality.DELTA,
102
            Histogram: AggregationTemporality.DELTA,
103
    }
104
105
    readers = [PeriodicExportingMetricReader(exporter=OTLPMetricExporter(endpoint=EXPORTER_OTLP_ENDPOINT, insecure=True, preferred_temporality=preferred_temporality))]
106
    if local_debug:
107
        readers.append(PeriodicExportingMetricReader(exporter=ConsoleMetricExporter(
108
            preferred_temporality=preferred_temporality
109
        ), export_interval_millis=1000))
110
111
    provider = MeterProvider(resource=Resource.create(
112
        {
113
            "service.name": service_name,
114
            "highlight.project_id": HIGHLIGHT_PROJECT_ID,
115
            "environment": environment,
116
            "commit": commit
117
        }
118
    ), metric_readers=readers)
119
    metrics.set_meter_provider(provider)
120
    meter = metrics.get_meter(service_name)
121
    return meter

1
import os
2
from o11y import create_logger, create_tracer, get_meter
3
4
# Initialize observability tools
5
service_name = "flask-backend"
6
logger = create_logger(service_name, os.getenv("ENVIRONMENT"))
7
tracer = create_tracer(service_name, os.getenv("ENVIRONMENT"))
8
meter = get_meter(service_name, os.getenv("ENVIRONMENT"))
9
10
histogram = meter.create_histogram("request_duration_histogram")
11
gauge = meter.create_gauge("request_duration_gauge")
12
counter = meter.create_counter("request_count")
13
14
logger.info("Starting the application")