FastAPI Observability from the team behind Pydantic. One line instruments every route, and each request shows its dependencies, database queries, and Pydantic validation in one connected trace. Query everything in plain SQL. Standard OpenTelemetry, no lock-in.
This prompt was copied from the Pydantic Logfire website. Fetch https://raw.githubusercontent.com/pydantic/logfire/refs/heads/main/logfire/.agents/skills/logfire-setup/SKILL.md -- using `curl` if what comes back reads like a summary rather than the raw file -- and follow it end to end to connect this repository to Logfire. Authenticate first, confirmed via `whoami`, before opening or running any application file -- then get real telemetry flowing.
pip install 'logfire[fastapi]'
logfire auth # or set LOGFIRE_TOKEN in productionimport logfire
from fastapi import FastAPI
logfire.configure()
app = FastAPI()
logfire.instrument_fastapi(app)Full details are in the FastAPI setup guide.
Every request becomes a trace, the full timeline of one request, built from nested spans, each a timed unit of work, from the route down to each query, validation, and outbound call, with timing and errors attached.
Start free with 10 million spans, logs, and metrics each month. No credit card required.
The route span is the start. Add the libraries the endpoint uses, one line each: logfire.instrument_sqlalchemy(engine=engine), logfire.instrument_asyncpg(), logfire.instrument_httpx(), logfire.instrument_redis(). A request to POST /orders then shows the incoming call, the Pydantic validation, each database query with its timing, and the outbound call to your payments provider. When something is slow, you can see which part.
FastAPI request bodies are Pydantic models, and instrument_fastapi already captures the validated arguments and validation errors: a malformed request shows the model, the input, and the exact field that failed, turning a vague wave of 422s into a specific, fixable cause. For models you validate outside the endpoint signature, add logfire.instrument_pydantic() to trace those too. Captured arguments can include request data, so note that Logfire scrubs common sensitive fields by default and the scrubbing rules are configurable.
For the business logic inside a handler, open a span where the real work begins with logfire.span("create_order", customer=order.customer_id). It becomes the parent of the auto-instrumented queries and HTTP calls it triggers, with customer_id captured as a queryable attribute.
Query request spans, validation errors, database calls, metrics, and structured logs in one Logfire project. Filter by route or your own attributes, then save the same SQL as a dashboard or alert when the question recurs.
Logfire is OpenTelemetry underneath. Your FastAPI instrumentation is portable: send the same data to another OTel backend or self-host, and nothing in your app changes. You instrument once against the open standard and keep your options open.
If you can ask it, SQL can find out
select
attributes->>'http.route' as route,
count(*) as requests,
avg(duration) as avg_seconds
from records
where http_response_status_code >= 500
group by route
order by requests desc;We are finding and fixing issues in five minutes instead of an hour, which is obviously increasing uptime for our clients.
Install Pydantic Logfire, call logfire.configure(), then logfire.instrument_fastapi(app). That one line captures every route, request, response, and exception. Add instrument_sqlalchemy(engine=engine), instrument_httpx(), and similar to trace the database and outbound calls each request makes. Logfire is OpenTelemetry-native, so standard OTel tooling works too.
Yes. FastAPI validates requests with Pydantic, and because Logfire is built by the Pydantic team, calling logfire.instrument_pydantic() surfaces validation as spans. A failed request shows the model, the input, and the exact field that did not match, so a wave of 422s becomes a specific, fixable cause.
Set the standard OpenTelemetry variable OTEL_PYTHON_FASTAPI_EXCLUDED_URLS to comma-separated regexes, for example '/health$,/metrics$'.
Auto-instrumentation is built for production. Telemetry is batched and exported asynchronously, and traces can be sampled to control volume, so the runtime cost is small relative to the visibility gained into slow endpoints and failing calls.
Get started with 10 million free spans, logs, and metrics per month. No credit card required.