Library of the Week — Logfire

Logfire — OpenTelemetry-native observability built for Python, with first-class LLM tracing support

GitHub · Language: Python · License: MIT

What it does

Logfire is Pydantic’s observability platform that wraps OpenTelemetry with an ergonomic Python API and automatic instrumentation for popular frameworks. For LLM developers specifically, it provides structured tracing of model calls, token usage, latency, and prompt/response content with almost no setup. If you’re already using Pydantic or FastAPI in your AI stack, it slots in near-invisibly.

Why it stands out

• Auto-instrumentation for LLM clients: one call to logfire.instrument_openai() or logfire.instrument_anthropic() wraps your existing client and captures every request, including model name, token counts, and full message payloads, as structured spans
• Built on real OpenTelemetry: unlike bespoke tracing SDKs, Logfire emits standard OTLP spans you can route to any backend — Grafana, Honeycomb, your own collector — so you’re not locked into Pydantic’s hosted dashboard
• Pydantic-aware structured logging: log calls accept Pydantic models directly and store them as typed, queryable fields rather than raw JSON strings, which makes filtering traces by specific prompt parameters practical
• Minimal API surface: logfire.span() as a context manager and logfire.info() cover 90% of cases; there’s no steep conceptual model to internalize before getting useful signal

Quick start

import logfire
import openai

logfire.configure()  # reads LOGFIRE_TOKEN from env
logfire.instrument_openai()  # patches the OpenAI client globally

client = openai.OpenAI()

with logfire.span("answer_user_query", query=user_query):
    response = client.chat.completions.create(
        model="gpt-5.4-nano",
        messages=[{"role": "user", "content": user_query}],
    )
    logfire.info("response received", tokens=response.usage.total_tokens)

Token usage, latency, and the full message payload appear as structured fields on the span automatically.

When to use it

• You want LLM call tracing without committing to a dedicated LLMOps platform — Logfire gives you the raw spans and you decide where they go
• Your stack already uses Pydantic models (FastAPI, Instructor, etc.) and you want observability that understands your data shapes natively
• You need production-grade OpenTelemetry compliance but don’t want to write the boilerplate instrumentation yourself

When to skip it

• If you need deep LLM-specific evaluation features — scoring, regression testing, dataset management — Logfire doesn’t do that; pair it with Braintrust or reach for a dedicated eval library
• Teams already running a mature OTel pipeline with vendor-specific SDKs may find Logfire redundant unless the Pydantic integration is a genuine draw

The verdict

Logfire is the observability choice that doesn’t make you choose between “good Python DX” and “real telemetry infrastructure.” For LLM developers who are tired of brittle callback-based tracing and want spans that actually behave like spans, it’s the most pragmatic on-ramp to production observability right now. The hosted dashboard is optional — the library earns its place even if you never use it.