Ruby Observability from the team behind Pydantic: trace Rails and Ruby apps, capture requests, queries and outbound calls, and query everything in plain SQL. Standard OpenTelemetry, no lock-in.
This prompt was copied from the Pydantic Logfire website. Follow https://pydantic.dev/.well-known/agent-skills/logfire-setup/SKILL.md 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.
gem install opentelemetry-sdk opentelemetry-exporter-otlp opentelemetry-instrumentation-allexport OTEL_EXPORTER_OTLP_ENDPOINT='https://logfire-us.pydantic.dev'
export OTEL_EXPORTER_OTLP_HEADERS='Authorization=your-write-token'require 'opentelemetry/sdk'
require 'opentelemetry/exporter/otlp'
require 'opentelemetry/instrumentation/all'
OpenTelemetry::SDK.configure do |c|
c.service_name = 'hello-ruby'
# Without use_all you get only the spans you write yourself.
c.use_all
end
tracer = OpenTelemetry.tracer_provider.tracer('hello-ruby')
tracer.in_span('Hello World') do |span|
# your work here
end
# No at_exit hook in the Ruby SDK: flush before the process exits.
OpenTelemetry.tracer_provider.shutdownFull details are in the Ruby setup guide.
Trusted by teams building production software and AI
What lands in Logfire:
in_span blocks, nested as they ranActiveRecord/PG query, timedNet::HTTP callStart free with 10 million spans, logs, and metrics each month. No credit card required.
The OpenTelemetry Ruby contrib gems cover Rails and Rack, along with common database and HTTP libraries such as ActiveRecord, Sidekiq, Net::HTTP, Faraday, Redis, and PostgreSQL. Incoming requests become traces without instrumenting each call site, and your own spans nest inside them.
tracer.in_span('...') do |span| closes the span even if the block raises, so an exception is recorded on the span rather than the span being lost. The failure case is the one you most want telemetry for, so the safe form is also the idiomatic one.
Configuration is OTEL_ environment variables against the standard OpenTelemetry Ruby SDK. Your Gemfile contains OpenTelemetry gems and nothing of ours, so repointing at a different backend is a config change rather than a migration.
Logfire ingests traces, metrics, and logs in one project, and the setup above sends traces with the stable OpenTelemetry Ruby SDK. Ruby's metrics and logs SDKs are still pre-1.0 (opentelemetry-metrics-sdk and opentelemetry-logs-sdk), and the OTLP logs exporter still ships as experimental, so treat those as available but early rather than a finished path. Traces are the part that is production-ready today, and everything you send is queryable with the same SQL.
Use PostgreSQL-compatible SQL to compare Rails routes, Sidekiq jobs, database spans, and any attributes your instrumentation records. Save the result as a dashboard or alert without translating the question into a vendor-specific language.
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 duration > 1
group by route
order by avg_seconds desc;You can tell that Pydantic Logfire was built by people who use it.
No. Ruby uses the standard OpenTelemetry Ruby SDK, and Logfire is the OTLP backend it exports to, so nothing proprietary enters your Gemfile. First-party Logfire SDKs exist for Python, TypeScript, and Rust.
Yes. The OpenTelemetry Ruby contrib instrumentation gems cover Rails and Rack, so incoming requests become spans automatically, with ActiveRecord queries and outbound HTTP calls attached as child spans. Your own in_span blocks then nest inside the request span.
Check that both gems are installed, opentelemetry-sdk and opentelemetry-exporter-otlp, that the endpoint matches your project's data region, and that the Authorization header carries a valid write token. Short-lived scripts also need the exporter to flush before the process exits.
The block form closes the span even when the block raises, so an exception is recorded on the span instead of the span being lost entirely. That is exactly the case you most want telemetry for, so the block form is the safer default.
No. Configuration is standard OTEL_ environment variables against the standard SDK, and your code references OpenTelemetry types only. Repoint the endpoint at another OpenTelemetry-compatible backend, or at your own collector, whenever you want.
Get started with 10 million free spans, logs, and metrics per month. No credit card required.