from app.core.monitoring.otel_logger import initialize_otel_logger

2. **Get logger and tracer in each module**:

```python
from app.core.monitoring.otel_logger import logger, get_tracer

3. **Use trace_span for operations**:

```python
from app.core.monitoring.otel_logger import trace_span, logger

logger = logger(__name__)

That's it! All logs automatically include trace context, and spans are created with attributes.

**Key Benefits**:
- ✅ Single entry point: `app/core/monitoring/otel_logger.py`
- ✅ No direct imports of structlog or opentelemetry needed
- ✅ Automatic trace context propagation
- ✅ Automatic exception handling in spans
- ✅ Works with async and sync functions

undefined

exporter = ConsoleLogExporter()
processor = SimpleLogRecordExporter(exporter)
logger_provider.add_log_record_processor(processor)
logs.set_logger_provider(logger_provider)

return logger_provider

**For production OTLP/Jaeger setup**, see [references/advanced-patterns.md](references/advanced-patterns.md#otelconfig-class)

undefined

# Configure structlog
structlog.configure(
    processors=[
        structlog.contextvars.merge_contextvars,
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.ExceptionRenderer(),
        structlog.processors.JSONRenderer(),
    ],
    logger_factory=structlog.logging.LoggerFactory(),
    cache_logger_on_first_use=True,
)

**For advanced structlog configuration**, see [references/advanced-patterns.md](references/advanced-patterns.md#structlog-configuration)

undefined

@staticmethod
def set_request_id(request_id: str) -> None:
    """Set request ID in context."""
    request_id_var.set(request_id)

@staticmethod
def get_tracer(name: str):
    """Get tracer instance."""
    return trace.get_tracer(name)

@staticmethod
def set_span_attribute(key: str, value: any) -> None:
    """Set attribute on current span."""
    span = trace.get_current_span()
    if span.is_recording():
        span.set_attribute(key, value)

**For complete ObservabilityContext class**, see [references/advanced-patterns.md](references/advanced-patterns.md#observability-context)

undefined

otel_enabled: bool = Field(default=True)
otel_exporter_type: str = Field(default="console")  # 'otlp', 'jaeger', or 'console'
otel_otlp_endpoint: str = Field(default="localhost:4317")
otel_jaeger_host: str = Field(default="localhost")
otel_jaeger_port: int = Field(default=6831)

Then use config in main:

```python

if config.otel_enabled:
    otel_config = OTELConfig(
        service_name="my-service",
        exporter_type=config.otel_exporter_type,
        otlp_endpoint=config.otel_otlp_endpoint,
    )
    otel_config.setup_logging()
    otel_config.setup_tracing()

logger = get_logger(__name__)
logger.info("service_started")

**For complete exporter configuration**, see [references/advanced-patterns.md](references/advanced-patterns.md#exporter-configuration)

undefined

def __init__(self, gateway, publisher) -> None:
    self.gateway = gateway
    self.publisher = publisher
    self.logger = get_logger(__name__)
    self.tracer = trace.get_tracer(__name__)

async def execute(self) -> int:
    """Execute with tracing."""
    with self.tracer.start_as_current_span("extract_orders") as span:
        self.logger.info("starting_extraction")

        try:
            orders = await self.gateway.fetch_all_orders()
            self.logger.info("orders_fetched", count=len(orders))

            for order in orders:
                await self.publisher.publish(order)

            span.set_attribute("orders_processed", len(orders))
            self.logger.info("extraction_completed", total=len(orders))
            return len(orders)

        except Exception as e:
            self.logger.error("extraction_failed", error=str(e))
            span.record_exception(e)
            raise

**For advanced instrumentation patterns**, see [examples/examples.md](examples/examples.md#fastapi-instrumentation)

undefined

logger.error(
    "unhandled_exception",
    error=str(exc),
    error_type=type(exc).__name__,
    request_id=request_id,
    path=request.url.path,
    method=request.method,
    exc_info=True,  # Include full stack trace
)

return JSONResponse(
    status_code=500,
    content={"detail": "Internal server error", "request_id": request_id},
)

**For complete error handling patterns**, see [examples/examples.md](examples/examples.md#error-handling)

from opentelemetry import trace
from app.shared.logging_setup import get_logger

logger = get_logger(__name__)
tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("process_payment"):
    logger.info("payment_started", customer_id="cust-123")
    logger.info("payment_completed", amount=99.99)
    # All logs have same trace_id and span_id

from app.shared.observability import ObservabilityContext

ObservabilityContext.set_request_id("req-12345")
ObservabilityContext.set_user_id("user-456")

logger.info("user_action", action="login")

**For complete pattern examples**, see [examples/examples.md](examples/examples.md)

import pytest
from opentelemetry import logs
from opentelemetry.sdk.logs import LoggerProvider

def test_logging_configuration():
    """Test OTEL logging provider setup."""
    logger_provider = LoggerProvider()
    assert logger_provider is not None
    logs.set_logger_provider(logger_provider)
    assert logs.get_logger_provider() == logger_provider

@pytest.fixture
def in_memory_log_exporter():
    """In-memory exporter for testing."""
    class InMemoryExporter:
        def __init__(self):
            self.records = []

        def emit(self, log_records):
            self.records.extend(log_records)

    return InMemoryExporter()

def test_trace_context_in_logs(in_memory_log_exporter):
    """Verify trace context is included in logs."""
    # Setup logger and tracer
    # Log within span
    # Verify trace context in exported logs
    pass