# Telemetry

> Telemetry is an agent-native structured event analytics product. Applications send purpose-built JSON events, query typed tables with DataFusion SQL, and turn reviewed results into dashboards and alerts.

Canonical site: https://telemetry.sh
This index was generated for docs.telemetry.sh. Prefer canonical telemetry.sh URLs when citing public content.

## Start here

- [Product overview](https://telemetry.sh/product)
- [Structured log management](https://telemetry.sh/structured-log-management)
- [Documentation](https://telemetry.sh/docs)
- [SQL recipe library](https://telemetry.sh/sql)
- [Interactive SaaS SQL Lab](https://telemetry.sh/sql/lab)
- [Event schema catalog](https://telemetry.sh/event-schemas)
- [Evidence and benchmark protocol](https://telemetry.sh/benchmarks)
- [Integrations](https://telemetry.sh/integrations)
- [Templates](https://telemetry.sh/templates)
- [skill.md guide](https://telemetry.sh/skill)
- [Raw skill.md](https://telemetry.sh/skill.md)
- [Comparisons](https://telemetry.sh/compare)
- [Security](https://telemetry.sh/security)
- [Editorial standards](https://telemetry.sh/about/editorial)

## Important product boundaries

- Telemetry accepts purpose-built structured application events; it is not presented as a distributed tracing, host-metrics, session-replay, or unrestricted log-search replacement.
- The OpenTelemetry integration correlates outcome events with approved trace identifiers. Telemetry does not currently expose an OTLP ingestion endpoint.
- SDK and API keys belong in trusted server code. Browser collection should use an application-owned, allowlisted server proxy.
- Comparison pages identify capabilities that require retaining the incumbent or another specialist.
- Customer outcome claims are published only with measured, reviewed, and approved context.

## Documentation

Each documentation URL below has a raw Markdown representation at the same URL with `.md` appended.

- [Quick Start](https://telemetry.sh/docs/getting-started/quick-start.md): Send a structured event, inspect its table, query it with SQL, and turn the result into a dashboard or alert.
- [Send Your First Structured Event](https://telemetry.sh/docs/getting-started/send-your-first-event.md): Create a write-scoped API key, send one synthetic structured event, and choose an event name and fields that remain useful in production.
- [Verify Event Ingestion and Schema](https://telemetry.sh/docs/getting-started/verify-event-ingestion.md): Confirm that a test event reached the expected table with the intended types, timestamp, identifiers, and privacy boundary before expanding instrumentation.
- [Write Your First Telemetry SQL Query](https://telemetry.sh/docs/getting-started/write-your-first-query.md): Query a verified structured-event table, calculate volume and error rate, inspect raw rows, and validate the result against a known synthetic fixture.
- [Create Your First Dashboard and Alert](https://telemetry.sh/docs/getting-started/create-your-first-dashboard-and-alert.md): Promote a validated query into a focused dashboard widget and a threshold alert with an explicit owner, time window, and response action.
- [Production Instrumentation Checklist](https://telemetry.sh/docs/getting-started/production-instrumentation-checklist.md): Review event ownership, schema stability, sensitive-data boundaries, credentials, failure behavior, retention, queries, dashboards, and alerts before production rollout.
- [JavaScript and TypeScript SDK](https://telemetry.sh/docs/sdks/javascript.md): Install the Telemetry JavaScript SDK, send structured events, run typed SQL queries, verify delivery, and handle production failure modes.
- [Python SDK](https://telemetry.sh/docs/sdks/python.md): Use the synchronous and asynchronous Telemetry Python clients to send events, query data, batch rows, and handle production delivery safely.
- [Rust SDK](https://telemetry.sh/docs/sdks/rust.md): Initialize the blocking Telemetry Rust client, send structured JSON events, query SQL, and design safe production delivery behavior.
- [Go SDK](https://telemetry.sh/docs/sdks/go.md): Initialize the Telemetry Go client, send structured events, query SQL, verify delivery, and design safe production timeouts and retries.
- [Ruby HTTP Integration](https://telemetry.sh/docs/sdks/ruby.md): Send structured events, run SQL, configure Net::HTTP timeouts, verify schemas, and handle Telemetry API failures safely from Ruby.
- [PHP HTTP Integration](https://telemetry.sh/docs/sdks/php.md): Send structured events, run SQL, configure cURL timeouts, verify schemas, and handle Telemetry API failures safely from PHP.
- [cURL and HTTP API Examples](https://telemetry.sh/docs/sdks/curl.md): Send events, inspect schemas, run SQL, export Parquet, and handle Telemetry HTTP failures safely with cURL.
- [Java HTTP Integration](https://telemetry.sh/docs/sdks/java.md): Send structured Telemetry events and SQL queries from Java with a shared HttpClient, bounded timeouts, safe JSON, and explicit failure handling.
- [.NET HTTP Integration](https://telemetry.sh/docs/sdks/dotnet.md): Send structured Telemetry events and SQL queries from .NET with IHttpClientFactory, bounded timeouts, typed payloads, and explicit failure handling.
- [Log](https://telemetry.sh/docs/api-reference/log.md): Ingest structured JSON events into Telemetry via the HTTP API.
- [Query](https://telemetry.sh/docs/api-reference/query.md): Run SQL queries and async exports against your Telemetry data.
- [Dashboard](https://telemetry.sh/docs/api-reference/dashboard.md): List, create, update, and delete Telemetry dashboards with the HTTP API.
- [Tables](https://telemetry.sh/docs/api-reference/tables.md): Inspect Telemetry tables and configure retention and partition columns through the HTTP API.
- [Delete](https://telemetry.sh/docs/api-reference/delete.md): Delete rows or whole tables through Telemetry's legacy delete endpoint.
- [Telemetry architecture](https://telemetry.sh/docs/discussion-topics/telemetry-architecture.md): See how Telemetry validates and buffers events, stores Parquet in S3, and combines fresh and historical data for SQL queries.
- [Creating Dashboards](https://telemetry.sh/docs/discussion-topics/creating-dashboards.md): Build focused Telemetry dashboards from Explore and SQL query results, then arrange widgets for fast operational decisions.
- [Schema Evolution](https://telemetry.sh/docs/discussion-topics/schema-evolution.md): Learn how Telemetry adapts as event fields are added or change type, and how to evolve schemas without breaking analysis.
- [Choosing Partition Columns](https://telemetry.sh/docs/discussion-topics/partition-columns.md): Use partition columns to make selective Telemetry queries scan less data.
- [Querying Nested JSON](https://telemetry.sh/docs/discussion-topics/querying-nested-json.md): Query top-level and nested JSON fields in Telemetry using stable dotted column names.
- [Working with Timestamps](https://telemetry.sh/docs/discussion-topics/working-with-timestamps.md): Store timestamps consistently and use SQL to extract, bucket, compare, and measure time intervals.
- [CamelCase vs snake_case](https://telemetry.sh/docs/discussion-topics/camelcase-vs-snake_case.md): Understand why snake_case produces simpler, more portable SQL column names for Telemetry event data.
- [Structured Events vs Text Logs](https://telemetry.sh/docs/discussion-topics/structured-events-vs-logs.md): Compare structured events and text logs, including when to use each, how they differ in SQL, and how to avoid duplicating telemetry.
- [Logs, Metrics, Traces, and Structured Events](https://telemetry.sh/docs/discussion-topics/logs-metrics-traces.md): Choose the right observability signal for debugging, trends, request paths, and business workflows without collecting redundant data.
- [Designing an Event Schema](https://telemetry.sh/docs/discussion-topics/designing-event-schema.md): Create stable event names and typed fields for reliable SQL, dashboards, alerts, and schema evolution.
- [High-Cardinality Fields](https://telemetry.sh/docs/discussion-topics/high-cardinality-fields.md): Use user IDs, request IDs, URLs, and other high-cardinality event fields deliberately in SQL, dashboards, and partitions.
- [Correlation IDs for Structured Events](https://telemetry.sh/docs/discussion-topics/correlation-ids.md): Connect requests, jobs, webhooks, and traces with safe correlation identifiers while avoiding sensitive data and unstable joins.
- [Redacting Sensitive Data from Events](https://telemetry.sh/docs/discussion-topics/redacting-sensitive-data.md): Prevent secrets, personal data, and raw customer content from entering structured events with allowlists and boundary-level controls.
- [DataFusion SQL Reference for Telemetry](https://telemetry.sh/docs/discussion-topics/datafusion-sql-reference.md): Write practical DataFusion SQL for Telemetry event tables using time filters, conditional aggregates, percentiles, windows, joins, and safe ratios.
- [Event Delivery, Idempotency, and Duplicate Handling](https://telemetry.sh/docs/discussion-topics/event-delivery-idempotency.md): Design structured-event producers for retries, duplicate delivery, stable event identity, and measurable ingestion failures.
- [Batching, Backpressure, and Graceful Shutdown](https://telemetry.sh/docs/discussion-topics/batching-backpressure-and-shutdown.md): Choose safe batch sizes, bound telemetry queues, handle overload, and flush or persist pending events during application shutdown.
- [Event Sampling Strategies for Structured Telemetry](https://telemetry.sh/docs/discussion-topics/event-sampling-strategies.md): Reduce telemetry volume without invalidating rates, percentiles, incident investigations, or customer-impact analysis.
- [Multi-Tenant Identity Modeling for Event Analytics](https://telemetry.sh/docs/discussion-topics/multi-tenant-identity-modeling.md): Model accounts, users, sessions, anonymous visitors, and tenant boundaries without mixing identity semantics or exposing personal data.
- [Structured Logging Guide](https://telemetry.sh/docs/guides/structured-logging.md): Design structured application events that are safe to collect, easy to query with SQL, and useful for dashboards, debugging, and product decisions.
- [Application Telemetry: A Practical Guide](https://telemetry.sh/docs/guides/application-telemetry.md): Design application telemetry that connects structured events, logs, metrics, and traces to reliable SQL, dashboards, and alerts.
- [OpenAI API Cost Tracking by Model and Feature](https://telemetry.sh/docs/guides/tracking-openai-costs.md): Track OpenAI API costs by model, feature, team, and outcome. Copy a production-ready event shape and SQL query, then reconcile estimates to your invoice.
- [Evaluate AI Agents with Structured Events and SQL](https://telemetry.sh/docs/guides/ai-agent-evaluation-with-sql.md): Design AI agent evaluation events, join quality with cost and reliability, and compare releases with reviewable SQL and explicit denominators.
- [AI Agent Security Monitoring with Structured Events](https://telemetry.sh/docs/guides/ai-agent-security-monitoring.md): Monitor agent tool authorization, policy denials, human approvals, and terminal outcomes with bounded events and reviewable SQL.
- [Connect OpenTelemetry GenAI Traces to Outcome Events](https://telemetry.sh/docs/guides/opentelemetry-genai-outcome-events.md): Correlate OpenTelemetry generative AI traces with compact Telemetry outcome events without copying prompts, tool payloads, or full spans.
- [Revenue A/B Tests](https://telemetry.sh/docs/guides/revenue-a-b-tests.md): Compare revenue per exposed visitor across experiment variants and quantify lift without being misled by unequal traffic.
- [Monitoring Website Uptime](https://telemetry.sh/docs/guides/monitoring-website-uptime.md): Log scheduled heartbeat checks to measure uptime, investigate incidents, and alert on repeated failures.
- [Alerts](https://telemetry.sh/docs/discussion-topics/alerts.md): Create understandable threshold alerts from single-series time charts in Explore and query results.
- [Queue Worker Observability](https://telemetry.sh/docs/guides/queue-worker-observability.md): Monitor queue depth and tail latency together to detect backlogs, stuck workers, and user-visible processing delays.
- [Visualizing Distributions](https://telemetry.sh/docs/guides/visualizing-distributions.md): Use percentiles to reveal typical values, long tails, and high-value customer segments that a single average can hide.
- [Measuring Conversion Rates with SQL](https://telemetry.sh/docs/guides/measuring-conversion-rates.md): Instrument funnel milestones and calculate user-level conversion rates so you can locate drop-off without double-counting repeated events.
- [Analyzing Webserver Errors](https://telemetry.sh/docs/guides/analyzing-webserver-errors.md): Capture status, route, release, and request context so error spikes lead to a specific regression instead of a generic count.
- [Profiling Code Execution](https://telemetry.sh/docs/guides/profiling-code-execution.md): Log step durations and execution context to find bottlenecks, compare runs, and prioritize performance work.
- [API Keys and Authentication](https://telemetry.sh/docs/getting-started/api-keys-and-authentication.md): Create, scope, store, rotate, and revoke Telemetry API keys without exposing ingestion or query access to untrusted clients.
- [Rate Limits and API Errors](https://telemetry.sh/docs/api-reference/rate-limits-and-errors.md): Handle Telemetry HTTP errors, throttling, retries, idempotency, and partial failures safely in ingestion and query clients.
- [OpenAPI Specification](https://telemetry.sh/docs/api-reference/openapi.md): Download and validate Telemetry's OpenAPI 3.1 specification for event ingestion, SQL queries, tables, dashboards, and deletion.
- [Event Data Types and Nullability](https://telemetry.sh/docs/discussion-topics/data-types-and-nullability.md): Choose stable string, numeric, boolean, timestamp, and nested event fields so schemas evolve without breaking SQL.
- [Data Retention and Deletion](https://telemetry.sh/docs/discussion-topics/data-retention-and-deletion.md): Plan table retention, selective deletion, whole-table removal, and verification for structured event data.
- [Canonical Wide Events](https://telemetry.sh/docs/discussion-topics/canonical-wide-events.md): Design canonical wide events that capture one completed unit of work with the context needed for SQL, debugging, dashboards, and agent analysis.
- [SQL Conditional Aggregation](https://telemetry.sh/docs/discussion-topics/sql-conditional-aggregation.md): Use CASE expressions with COUNT, SUM, and AVG to calculate rates, segments, and operational outcomes from structured event data.
- [SQL Time Bucketing for Event Data](https://telemetry.sh/docs/discussion-topics/sql-time-bucketing.md): Group structured events into complete UTC intervals with date_trunc or date_bin, then compare rates and volume without partial-bucket mistakes.
- [SQL Percentiles for Latency and Distributions](https://telemetry.sh/docs/discussion-topics/sql-percentiles.md): Calculate approximate p50, p95, and p99 values in DataFusion SQL and interpret tail latency without hiding volume or distribution shape.
- [SQL Window Functions for Event Analysis](https://telemetry.sh/docs/discussion-topics/sql-window-functions.md): Use LAG, ROW_NUMBER, and framed aggregates to compare periods, deduplicate events, and calculate rolling baselines without losing row detail.
- [SQL Deduplication for Structured Events](https://telemetry.sh/docs/discussion-topics/sql-deduplication.md): Define event identity and use ROW_NUMBER to remove duplicate deliveries without accidentally collapsing valid retries or repeated user actions.
- [SQL Funnel Analysis](https://telemetry.sh/docs/discussion-topics/sql-funnel-analysis.md): Build account-level product funnels with conditional milestones, explicit ordering, a cohort window, and conversion denominators that remain reviewable.
- [SQL Cohort Retention Analysis](https://telemetry.sh/docs/discussion-topics/sql-cohort-retention.md): Measure whether users or accounts return after a starting milestone while keeping cohort dates, activity windows, identities, and incomplete periods explicit.
- [Exporting Query Results](https://telemetry.sh/docs/guides/exporting-query-results.md): Choose synchronous JSON or asynchronous JSON and Parquet exports, poll safely, and preserve query context for downstream reporting.
- [Alert Delivery and Troubleshooting](https://telemetry.sh/docs/guides/alert-delivery-troubleshooting.md): Verify Telemetry alert queries, time buckets, thresholds, recipients, evaluation history, and email delivery without creating noisy pages.
- [Troubleshooting Event Ingestion](https://telemetry.sh/docs/guides/troubleshooting-event-ingestion.md): Diagnose missing or rejected Telemetry events by checking HTTP responses, API-key scope, payload shape, table normalization, timestamps, schemas, retries, and freshness.
- [Troubleshooting SQL Queries](https://telemetry.sh/docs/guides/troubleshooting-sql-queries.md): Debug Telemetry SQL systematically by checking the API response, table schema, DataFusion syntax, field types, time windows, joins, rates, and async export status.
- [Incident Response with SQL](https://telemetry.sh/docs/guides/incident-response-with-sql.md): Use a repeatable SQL workflow to scope an incident, identify affected routes and releases, build a timeline, and verify recovery from structured events.
- [Database Reliability Monitoring with SQL](https://telemetry.sh/docs/guides/database-reliability-with-sql.md): Instrument safe application-level database events and use SQL to investigate slow query fingerprints, pool contention, rollbacks, locks, replication lag, and migrations.
- [Migrate from Ad Hoc Logs to Structured Events and SQL](https://telemetry.sh/docs/guides/migrate-logs-to-structured-events.md): Move a production workflow from free-form log search to bounded structured events, tested SQL, dashboards, and alerts without requiring a risky all-at-once cutover.
- [Frontend Reliability Monitoring with SQL](https://telemetry.sh/docs/guides/frontend-reliability-with-sql.md): Instrument typed browser performance events and use SQL to compare Core Web Vitals by route and release without collecting raw page content.
- [Browser Telemetry Proxy and Core Web Vitals](https://telemetry.sh/docs/guides/browser-telemetry-proxy-web-vitals.md): Collect privacy-conscious browser events and Core Web Vitals through a rate-limited server proxy without exposing a Telemetry API key.
- [Event Tracking Plan and Governance](https://telemetry.sh/docs/guides/event-tracking-plan.md): Create an event tracking plan with explicit grain, ownership, fields, privacy, validation, retention, and downstream SQL dependencies.
- [Test Telemetry Instrumentation in CI](https://telemetry.sh/docs/guides/test-telemetry-instrumentation-in-ci.md): Test structured-event contracts, privacy boundaries, delivery failures, and SQL results in CI without sending production data or depending on a live API.
- [Use Telemetry with OpenTelemetry](https://telemetry.sh/docs/guides/telemetry-with-opentelemetry.md): Use Telemetry outcome events beside OpenTelemetry traces, metrics, and logs with safe correlation IDs and explicit signal boundaries.
- [Kubernetes Reliability Monitoring with SQL](https://telemetry.sh/docs/guides/kubernetes-reliability-with-sql.md): Use structured Kubernetes workload events and SQL to investigate container restarts, readiness loss, rollout changes, and application impact.
- [Security Audit Analytics with SQL](https://telemetry.sh/docs/guides/security-audit-analytics-with-sql.md): Design bounded privileged-action events and use SQL to review denials, failures, and human-review queues without exposing secrets.
- [Product Journey Analysis with SQL](https://telemetry.sh/docs/guides/product-journey-analysis-with-sql.md): Model ordered product milestones and use SQL to measure session journey completion and step-to-step drop-off with explicit counting rules.
- [Telemetry Cost and Volume Management](https://telemetry.sh/docs/guides/telemetry-cost-management.md): Measure event count, payload bytes, rejection rate, retention, and cardinality before changing a telemetry collection contract.
- [Customer Impact Analysis with SQL](https://telemetry.sh/docs/guides/customer-impact-analysis-with-sql.md): Connect incidents to privacy-safe account impact events and use SQL to count affected accounts, affected share, and impact duration by plan.
- [RAG Evaluation with SQL](https://telemetry.sh/docs/guides/rag-evaluation-with-sql.md): Version RAG evaluation events and use SQL to compare retrieval relevance, grounded answers, latency, and cost across pipeline releases.
- [Feature Rollout Analysis with SQL](https://telemetry.sh/docs/guides/feature-rollout-analysis-with-sql.md): Compare control and rollout cohorts with SQL using stable feature assignment, release context, request volume, errors, and latency.
- [SQL for Observability and Event Analytics](https://telemetry.sh/docs/guides/sql-observability-event-analytics.md): Learn how structured events become SQL-ready observability data, which event contracts work, how to query them, and where SQL should complement logs, metrics, and traces.
- [Send Scheduled SQL Reports to Slack](https://telemetry.sh/docs/guides/send-sql-reports-to-slack.md): Run a Telemetry SQL query on a schedule, format the result as a concise Slack message, protect webhook credentials, and make delivery failures observable.
- [Migrate LogQL, KQL, and SPL Queries to SQL](https://telemetry.sh/docs/guides/migrate-logql-kql-spl-to-sql.md): Translate common LogQL, Kusto Query Language, and Splunk SPL analysis patterns into reviewable SQL without assuming the languages or data models are identical.
- [End-to-End SaaS Observability Demo](https://telemetry.sh/docs/guides/end-to-end-saas-observability-demo.md): Run a small Node.js SaaS workflow that emits structured events, query the resulting table with SQL, and turn one event contract into reliability, product, and cost views.
- [Benchmark Telemetry Ingestion and Query Performance](https://telemetry.sh/docs/guides/benchmark-ingestion-and-query-performance.md): Run a reproducible, bounded Telemetry API benchmark, separate client timing from service behavior, publish the test conditions, and avoid unsupported performance claims.
- [SLI, SLO, and Error Budget Monitoring with SQL](https://telemetry.sh/docs/guides/sli-slo-error-budget-monitoring-with-sql.md): Define request-based service indicators, calculate SLO compliance and error-budget burn, and build reviewable reliability alerts with SQL.
- [Teams, Workspaces, Members, and Roles](https://telemetry.sh/docs/getting-started/teams-workspaces-and-members.md): Organize analysis into team workspaces, invite members, understand admin and member roles, and review access before sharing data.
- [Usage, Billing, and Plan Limits](https://telemetry.sh/docs/getting-started/usage-billing-and-plan-limits.md): Review storage and query-duration usage, understand free-plan enforcement, compare current pricing, and plan upgrades safely.
- [Explore Structured Events Without Starting from SQL](https://telemetry.sh/docs/guides/explore-structured-events.md): Inspect event samples, apply typed filters, aggregate fields, build charts, and promote a reviewed Explore result into a dashboard or alert.
- [AI-Assisted SQL: Generate, Review, and Validate Queries](https://telemetry.sh/docs/guides/ai-assisted-sql.md): Turn a focused event question into editable DataFusion SQL, then review schema assumptions, counting logic, privacy boundaries, and result validity.
- [Saved Queries, History, Favorites, and Collaboration](https://telemetry.sh/docs/guides/saved-queries-and-collaboration.md): Organize reviewed SQL in team workspaces, preserve query history, use personal favorites, and promote stable results into shared dashboards and alerts.
- [Secure Mobile Telemetry Proxy](https://telemetry.sh/docs/guides/mobile-app-telemetry-proxy.md): Route React Native, Swift, Kotlin, and Flutter events through an authenticated server proxy that keeps ingestion keys out of app binaries.
- [How Telemetry Evaluates SQL Alerts](https://telemetry.sh/docs/guides/how-telemetry-evaluates-sql-alerts.md): See how Telemetry evaluates saved SQL, selects points, aggregates values, records state transitions, and attempts email delivery.

## SQL recipes

- [Calculate API Error Rate by Route](https://telemetry.sh/sql/api-error-rate-by-route): Use SQL to rank API routes by 5xx error rate while protecting the result from low-volume noise.
- [Calculate p50, p95, and p99 API Latency](https://telemetry.sh/sql/api-latency-percentiles): Compare median and tail latency by endpoint with DataFusion-compatible percentile SQL.
- [Measure Background Job Retry and Failure Rate](https://telemetry.sh/sql/background-job-retry-rate): Find unreliable jobs by comparing successful runs, retries, failures, and tail duration.
- [Find Stalled Background Jobs With SQL](https://telemetry.sh/sql/find-stalled-background-jobs): Join job start and finish events to identify work that exceeded its expected completion window.
- [Measure Webhook Retry Recovery](https://telemetry.sh/sql/webhook-retry-recovery): Separate permanent webhook failures from deliveries that recovered on a later attempt.
- [Calculate LLM Cost by Feature and Model](https://telemetry.sh/sql/llm-cost-by-feature): Attribute model spend, tokens, request volume, and cost per request to product features.
- [Measure Accepted AI Outputs per Dollar](https://telemetry.sh/sql/accepted-ai-output-per-dollar): Connect model spend to accepted, saved, or otherwise useful product outcomes.
- [Build a Signup-to-Activation Funnel in SQL](https://telemetry.sh/sql/signup-activation-funnel): Calculate unique-user conversion through signup, onboarding, integration, and first-value milestones.
- [Calculate Weekly Cohort Retention](https://telemetry.sh/sql/weekly-cohort-retention): Group users by first activity week and measure the percentage returning in later weeks.
- [Find Features Used Before Upgrade](https://telemetry.sh/sql/feature-adoption-before-upgrade): Join feature events to upgrade events and rank behaviors that occur before paid conversion.
- [Detect Missing Service Heartbeats](https://telemetry.sh/sql/missing-heartbeats): Find services, workers, or scheduled tasks that stopped reporting before a failure event appeared.
- [Query Nested AI Tool-Call Events](https://telemetry.sh/sql/query-nested-tool-events): Filter dotted nested fields and rank failing tools without flattening the original event payload.
- [Calculate API Error-Budget Burn Rate](https://telemetry.sh/sql/api-error-budget-burn-rate): Turn hourly request failures into an SLO burn-rate series that shows how quickly the allowed error budget is being consumed.
- [Compare API Reliability by Release](https://telemetry.sh/sql/api-reliability-by-release): Compare traffic, 5xx rate, and p95 latency across application releases without attributing every post-deploy change to the deploy.
- [Rank Error Fingerprints by Customer Impact](https://telemetry.sh/sql/top-error-fingerprints): Rank normalized application errors by occurrences and affected accounts instead of letting one retry loop dominate the incident view.
- [Measure Queue Wait Time by Job](https://telemetry.sh/sql/queue-wait-time-by-job): Separate time spent waiting in a queue from execution duration and compare p50 and p95 delay by job name.
- [Measure Webhook Latency and Duplicate Rate](https://telemetry.sh/sql/webhook-latency-and-duplicates): Compare processing latency, duplicate deliveries, and failures by webhook provider and event type.
- [Measure LLM Cache Savings and Retry Cost](https://telemetry.sh/sql/llm-cache-and-retry-cost): Compare cached requests, retry volume, and estimated spend by model to find avoidable AI cost.
- [Calculate DAU, WAU, and Product Stickiness](https://telemetry.sh/sql/active-user-stickiness): Measure daily and weekly active users together and calculate DAU-to-WAU stickiness from a consistent activity definition.
- [Compare Funnel Conversion by Acquisition Source](https://telemetry.sh/sql/funnel-conversion-by-source): Measure signup-to-activation conversion by acquisition source while deduplicating repeated milestone events.
- [Measure Time to Activation](https://telemetry.sh/sql/time-to-activation-distribution): Calculate the distribution of elapsed time between signup and a user’s first meaningful product action.
- [Measure Churn and Reactivation by Cohort](https://telemetry.sh/sql/churn-and-reactivation): Classify accounts as retained, churned, or reactivated from recurring meaningful product activity.
- [Detect Error-Rate Spikes With a Rolling Baseline](https://telemetry.sh/sql/rolling-error-rate-anomaly): Compare each hourly API error rate with a rolling seven-bucket average instead of relying on one permanent threshold.
- [Measure Event Ingestion Freshness](https://telemetry.sh/sql/event-ingestion-freshness): Find event sources that stopped delivering data or are arriving substantially later than they occurred.
- [Find Duplicate Event IDs](https://telemetry.sh/sql/duplicate-event-ids): Identify event identifiers delivered more than once and measure whether duplicate handling is working.
- [Measure Required-Field Null Rate](https://telemetry.sh/sql/required-field-null-rate): Find event contracts where a required account, status, or correlation field is disappearing.
- [Calculate Trial-to-Paid Conversion](https://telemetry.sh/sql/trial-to-paid-conversion): Measure how many trial accounts become paid customers within a fixed conversion window.
- [Measure Payment-Failure Recovery](https://telemetry.sh/sql/payment-failure-recovery): Calculate how often failed invoices are recovered by a later successful payment attempt.
- [Calculate Monthly Recurring Revenue Movement](https://telemetry.sh/sql/monthly-recurring-revenue-movement): Separate new, expansion, contraction, churn, and reactivation MRR from billing lifecycle events.
- [Measure LLM Time to First Token](https://telemetry.sh/sql/llm-time-to-first-token): Compare streaming responsiveness and total generation latency by model and feature.
- [Detect Repeating AI Agent Tool Loops](https://telemetry.sh/sql/agent-tool-loop-detection): Find agent runs that repeatedly call a small set of tools without reaching a successful outcome.
- [Calculate API Timeout Rate by Route](https://telemetry.sh/sql/api-timeout-rate-by-route): Rank routes by timeout rate while preserving request volume and configured timeout boundaries.
- [Compare Dependency p95 Latency](https://telemetry.sh/sql/dependency-p95-latency): Find databases, APIs, caches, and queues contributing the most tail latency to requests.
- [Measure API Availability Against an SLO](https://telemetry.sh/sql/slo-availability-compliance): Calculate daily availability and show whether a service met its explicit objective.
- [Measure Dead-Letter Queue Growth](https://telemetry.sh/sql/dead-letter-queue-growth): Compare dead-letter creation and resolution to find queues accumulating unrecoverable work.
- [Compare Experiment Conversion and Revenue Lift](https://telemetry.sh/sql/experiment-revenue-lift): Measure conversion, revenue per participant, and relative lift by experiment variant without double-counting repeated events.
- [Calculate Net and Gross Revenue Retention](https://telemetry.sh/sql/net-gross-revenue-retention): Calculate NRR and GRR from account-level monthly recurring-revenue snapshots while keeping expansion out of gross retention.
- [Measure Late-Arriving Events](https://telemetry.sh/sql/late-arriving-events): Measure event delivery delay by source and identify producers that send stale or out-of-order data.
- [Track Event Schema-Version Adoption](https://telemetry.sh/sql/schema-version-adoption): Measure schema-version rollout by producer and find old event contracts that remain active after a deployment.
- [Detect Missed Cron Schedules](https://telemetry.sh/sql/missed-cron-schedules): Compare consecutive cron-run events with each schedule interval to find late or missing executions.
- [Detect Background-Job Retry Storms](https://telemetry.sh/sql/background-job-retry-storm): Find time buckets where repeated job attempts create disproportionate queue work and failures.
- [Measure Webhook End-to-End Completion](https://telemetry.sh/sql/webhook-end-to-end-completion): Follow each webhook from receipt through downstream completion and measure the share that finishes within an operating target.
- [Find Host and Container Resource Saturation](https://telemetry.sh/sql/infrastructure-resource-saturation): Rank infrastructure sources by sustained CPU, memory, and disk utilization while preserving sample volume.
- [Calculate Usage Quota Burn by Account](https://telemetry.sh/sql/usage-quota-burn-by-account): Measure billable units against each account's included monthly quota and rank accounts approaching an overage.
- [Analyze Authentication Failure Rate](https://telemetry.sh/sql/authentication-failure-rate): Measure authentication failures by method and reason while keeping traffic volume and affected identities visible.
- [Measure AI Agent Task Success and Human Handoff](https://telemetry.sh/sql/ai-agent-task-success-and-handoff): Compare agent task success, reviewer acceptance, cost, latency, and human-handoff rate by workflow and model.
- [Find Slow Database Queries by Fingerprint](https://telemetry.sh/sql/slow-database-queries-by-fingerprint): Rank normalized database operations by slow-query rate, average duration, and worst observed duration without storing raw SQL or parameters.
- [Measure Database Connection-Pool Saturation](https://telemetry.sh/sql/database-connection-pool-saturation): Measure average pool utilization, queued acquisition waits, timeouts, and idle capacity by application service.
- [Calculate Database Transaction Rollback Rate](https://telemetry.sh/sql/database-transaction-rollback-rate): Compare committed and rolled-back transactions by service while preserving error categories, duration, and affected accounts.
- [Find Database Lock Waits and Deadlocks](https://telemetry.sh/sql/database-lock-waits-and-deadlocks): Rank blocked database operation fingerprints by incident count, wait duration, unresolved locks, and detected deadlocks.
- [Measure Database Replication and CDC Lag](https://telemetry.sh/sql/database-replication-and-cdc-lag): Compare replica and change-data-capture consumers by average lag, worst lag, bytes behind, and stale-sample rate.
- [Track Database Migration Failures by Release](https://telemetry.sh/sql/database-migration-failures-by-release): Compare database migration success, failure, rollback, and duration by application release before completing a rollout.
- [Calculate API Request Throughput by Route](https://telemetry.sh/sql/api-request-throughput): Calculate observed requests per minute by stable API route and keep error volume beside throughput.
- [Measure API 429 Rate-Limit Recovery](https://telemetry.sh/sql/api-rate-limit-recovery): Measure how often rate-limited requests recover on a later attempt without treating every retry as a new request.
- [Find Cache Misses and Stampede Risk](https://telemetry.sh/sql/cache-hit-rate-and-stampede-risk): Compare hit rate, backend cost, and concurrent misses by bounded cache-key pattern.
- [Detect N+1 Database Query Patterns](https://telemetry.sh/sql/n-plus-one-database-queries): Detect database fingerprints repeated many times inside one application request.
- [Calculate Incident Detection and Recovery Time](https://telemetry.sh/sql/incident-detection-and-recovery-time): Calculate time to detect and time to recover from structured incident lifecycle events.
- [Find AI Quality Regressions by Prompt Version](https://telemetry.sh/sql/ai-quality-regression-by-prompt-version): Compare evaluated quality, acceptance, handoff, and cost by prompt version.
- [Reconstruct a Correlated Workflow Timeline](https://telemetry.sh/sql/workflow-correlation-timeline): Reconstruct ordered cross-service workflow steps and elapsed time from a shared workflow identifier.
- [Audit AI Agent Tool Authorization Decisions](https://telemetry.sh/sql/ai-agent-tool-authorization-decisions): Review allowed, denied, and approval-required agent tool decisions by risk class without collecting prompts, tool arguments, results, or credentials.
- [Audit Privileged Actions with SQL](https://telemetry.sh/sql/privileged-action-audit-trail): Summarize sensitive administrative actions, denied attempts, and review-required outcomes without collecting raw secrets or resource contents.
- [Compare Core Web Vitals by Route and Release](https://telemetry.sh/sql/core-web-vitals-by-route-release): Compare LCP, INP, and CLS samples by stable route and release while keeping the percentage of passing samples visible.
- [Find Kubernetes Restarts by Workload](https://telemetry.sh/sql/kubernetes-restart-rate-by-workload): Rank Kubernetes workloads by container restart events, readiness failures, and observed cumulative restart count.
- [Measure Product Journey Drop-Off by Session](https://telemetry.sh/sql/product-session-journey-dropoff): Measure how many sessions reach each ordered product milestone and calculate both journey completion and step-to-step conversion.
- [Compare Feature Rollout Error Rate](https://telemetry.sh/sql/feature-rollout-error-rate): Compare request errors and average latency between feature-flag rollout and control cohorts for one release.
- [Measure Telemetry Volume by Event Name](https://telemetry.sh/sql/telemetry-volume-by-event-name): Rank event types by payload bytes, average event size, and rejection rate before changing retention or collection policy.
- [Measure Incident Customer Impact by Plan](https://telemetry.sh/sql/incident-customer-impact-by-plan): Count affected accounts and average impact duration by plan without exposing customer names or raw request data.
- [Evaluate RAG Retrieval Quality by Version](https://telemetry.sh/sql/rag-retrieval-quality-by-version): Compare relevant-document retrieval, grounded answers, retrieval latency, and evaluation cost across RAG pipeline versions.
- [Rank JavaScript Errors by Route and Release](https://telemetry.sh/sql/javascript-errors-by-route-release): Find frontend releases and routes with the most repeated JavaScript failures and affected sessions.
- [Measure SPA Navigation Latency by Route](https://telemetry.sh/sql/spa-navigation-latency-by-route): Compare typical and tail client-side navigation time by destination route and frontend release.
- [Calculate Browser Long-Task Rate by Route](https://telemetry.sh/sql/browser-long-task-rate): Measure main-thread blocking events and their total blocked time by route and frontend release.
- [Find Slow Frontend Resources by Host](https://telemetry.sh/sql/slow-frontend-resources-by-host): Rank scripts, stylesheets, images, and API resources by tail duration, failures, and transferred bytes.
- [Detect Suspicious Authentication Bursts](https://telemetry.sh/sql/suspicious-authentication-bursts): Find short authentication windows with repeated failures across many identities or coarse network sources.
- [Analyze Access-Policy Denials](https://telemetry.sh/sql/access-policy-denials): Rank denied actions by policy, resource class, actor role, and affected identities.
- [Audit API-Key Lifecycle Events](https://telemetry.sh/sql/api-key-lifecycle-audit): Review creation, use, rotation, and revocation events without logging API-key material.
- [Review Sensitive Data Exports with SQL](https://telemetry.sh/sql/sensitive-data-export-review): Summarize export volume, denied attempts, data classifications, and review status without storing exported contents.
- [Rank Database Queries by Total Time Impact](https://telemetry.sh/sql/database-query-time-impact): Combine call volume and latency to find database fingerprints consuming the most application time.
- [Measure Long-Running Database Transactions](https://telemetry.sh/sql/long-running-database-transactions): Find application transaction classes with long tails, rollbacks, and excessive open duration.
- [Analyze Database Errors by SQLSTATE and Release](https://telemetry.sh/sql/database-errors-by-sqlstate-release): Group database failures by portable SQLSTATE class, application operation, and release.
- [Measure Database Connection Timeouts and Churn](https://telemetry.sh/sql/database-connection-timeouts-churn): Compare connection opens, closes, acquisition timeouts, and affected requests by service and region.
- [Measure Database Replica Staleness by Region](https://telemetry.sh/sql/database-replica-staleness-by-region): Compare application-observed replica replay lag, stale reads, and failover outcomes by region.

## Interactive SQL Lab lessons

- [Summarize daily product activity](https://telemetry.sh/sql/lab/daily-product-activity): Start with one event table, group durable product milestones into UTC days, and keep successful volume separate from all attempts.
- [Build an account activation funnel](https://telemetry.sh/sql/lab/account-activation-funnel): Join the account cohort to ordered product milestones so the denominator includes every eligible account, including those that never progress.
- [Calculate LLM cost per accepted output](https://telemetry.sh/sql/lab/llm-unit-economics): Join normalized provider usage to account context, then compare raw request cost with a reviewed product outcome.
- [Connect API failures to customer impact](https://telemetry.sh/sql/lab/incident-customer-impact): Reduce request failures to one row per account before joining commercial context, preventing high-volume customers from being counted repeatedly.
- [Measure job recovery by customer plan](https://telemetry.sh/sql/lab/job-recovery-by-plan): Collapse attempt-level worker events into one logical job before comparing recovery and unresolved failures by plan.
- [Connect retained product activity to revenue context](https://telemetry.sh/sql/lab/retained-activity-and-revenue): Reduce product events to one account-level lifecycle before joining recurring revenue and collected billing outcomes.
- [Estimate AI gross-margin inputs by account](https://telemetry.sh/sql/lab/ai-gross-margin-by-account): Join account-level model cost and accepted outcomes to billing results without treating analytical estimates as invoice truth.
- [Triage billing failures with operational context](https://telemetry.sh/sql/lab/billing-failure-risk-triage): Start from failed billing outcomes, then add reduced operational signals so a review queue explains why each account needs attention.
- [Audit release coverage before comparing regressions](https://telemetry.sh/sql/lab/release-observability-coverage): Build a shared release spine before calculating rates so missing instrumentation remains null instead of looking like perfect reliability.
- [Trend daily service reliability](https://telemetry.sh/sql/lab/daily-service-reliability): Use the larger service-event fact table to calculate daily volume, errors, and error rate while retaining the denominator beside the rate.
- [Compare release reliability](https://telemetry.sh/sql/lab/release-regression-comparison): Compare equal 10-day release windows from the service-event table while keeping request volume, failures, rate, and latency together.
- [Quantify declared incident impact](https://telemetry.sh/sql/lab/declared-incident-impact): Reduce service events to an account-and-incident grain before adding incident severity and account revenue context.
- [Find database query regressions by release](https://telemetry.sh/sql/lab/database-query-regressions-by-release): Compare normalized query families across releases to find slower or newly failing operations.
- [Measure database connection-pool saturation](https://telemetry.sh/sql/lab/database-connection-pool-saturation): Rank services by maximum pool use, acquisition wait, and timeout samples.
- [Rank database lock waits and deadlocks](https://telemetry.sh/sql/lab/database-lock-waits-and-deadlocks): Aggregate lock events by blocked operation to prioritize the most disruptive contention.
- [Monitor database replication and consumer lag](https://telemetry.sh/sql/lab/database-replication-lag): Compare replica, CDC, and search-consumer lag with explicit health classifications.
- [Audit database migration reliability](https://telemetry.sh/sql/lab/database-migration-reliability): Measure migration success, rollback behavior, and duration by application release.
- [Measure database impact by customer plan](https://telemetry.sh/sql/lab/database-failures-by-customer-plan): Join database operations to account dimensions to quantify the customer impact of failures.

## Product capabilities

- [Turn application behavior into queryable event tables](https://telemetry.sh/product/structured-events): Send pragmatic JSON events for product flows, APIs, jobs, webhooks, agents, and business operations. Telemetry creates and evolves the table schema so the data is ready for SQL.
- [Ask detailed questions with the same SQL humans and agents can inspect](https://telemetry.sh/product/sql-query-api): Run DataFusion SQL over recent and historical event data, save important queries, export larger results asynchronously, and use the output in dashboards or downstream systems.
- [Filter, aggregate, and visualize a table without starting from blank SQL](https://telemetry.sh/product/explore): Explore gives operators and product teams a fast path from event fields to samples, tables, lines, bars, and stacked areas while keeping the generated query visible.
- [Keep operational and product signals readable in one shared view](https://telemetry.sh/product/dashboards): Combine Explore results, SQL query charts, result tables, section headers, and explanatory notes into dashboards that coding agents can seed and humans can refine.
- [Notify people when a queryable signal moves outside its expected range](https://telemetry.sh/product/alerts): Create threshold alerts from Explore or SQL results, evaluate complete time-series points on a schedule, and deliver actionable context to email recipients.
- [Monitor AI agent cost, tool use, and outcomes with structured events](https://telemetry.sh/product/ai-agent-observability): Capture compact events at agent, tool, model, and outcome boundaries, then use inspectable SQL to connect reliability and cost with the result a user or business workflow received.
- [Turn a plain-language question into SQL you can inspect and improve](https://telemetry.sh/product/ai-querying): Use table metadata and a focused prompt to get a first DataFusion query or visualization plan, then review the generated logic against the schema and real result.

## Use cases

- [Claude Code Observability](https://telemetry.sh/for/claude-code-observability): Give Claude Code a prompt that makes telemetry part of the implementation pass instead of a separate cleanup project.
- [Cursor Telemetry Setup](https://telemetry.sh/for/cursor-telemetry-setup): A copyable setup prompt for adding event tables, funnel tracking, and dashboards from inside Cursor.
- [Codex Instrumentation Prompt](https://telemetry.sh/for/codex-instrumentation-prompt): A focused prompt that asks Codex to instrument the rest of the product, verify events, and summarize coverage gaps.
- [OpenAI Cost Monitoring](https://telemetry.sh/for/openai-cost-tracking): Monitor OpenAI and LLM spend by model, feature, customer, latency, error rate, and outcome with SQL dashboards and budget alerts.
- [Product Analytics for Retention](https://telemetry.sh/for/product-analytics-retention): Use agent-installed structured events to learn which early actions create returning users and revenue-ready teams.
- [AI Agent Telemetry and Observability](https://telemetry.sh/product/ai-agent-observability): Instrument AI agent telemetry for runs, tool calls, retries, latency, model cost, failures, and accepted outcomes in SQL-ready event tables.
- [Background Job Monitoring](https://telemetry.sh/for/background-job-monitoring): Use structured events to see job throughput, retries, failures, dead letters, queue health, and p95 duration.
- [Webhook Debugging](https://telemetry.sh/for/webhook-debugging): Track webhook delivery, processing, retries, deduplication, downstream jobs, and failures without storing raw payloads.
- [API Reliability Monitoring](https://telemetry.sh/for/api-reliability-monitoring): Track API request volume, status codes, latency, timeouts, customer impact, and failed endpoints with SQL.
- [Crypto And Onchain Automation Monitoring](https://telemetry.sh/for/crypto-onchain-automation): Track indexed events, agent actions, transaction costs, wallet workflows, tool calls, and failed automation jobs.
- [Infrastructure Metrics With SQL](https://telemetry.sh/for/infrastructure-metrics-sql): Send structured infrastructure events when you need queryable host and container history without a large monitoring rollout.
- [Usage-Based Billing Analytics](https://telemetry.sh/for/usage-based-billing-analytics): Build a defensible usage ledger, quota dashboard, overage workflow, and billing reconciliation from idempotent structured events.
- [Security and Audit-Log Analytics](https://telemetry.sh/for/security-audit-log-analytics): Design privacy-aware security events for authentication failures, access changes, privileged actions, and incident timelines.
- [AI Agent Security Monitoring](https://telemetry.sh/for/ai-agent-security-monitoring): Monitor tool authorization, policy denials, approval queues, risky action classes, and release changes without storing prompts, credentials, or tool payloads.
- [AI Agent Quality and Evaluation](https://telemetry.sh/for/ai-agent-quality-evaluation): Connect agent runs, reviewer outcomes, human handoffs, cost, and release changes to a repeatable quality-evaluation workflow.
- [Database Reliability Monitoring with SQL](https://telemetry.sh/for/database-reliability-monitoring): Track safe query fingerprints, pool pressure, transaction rollbacks, lock contention, replication lag, and migration outcomes without collecting raw SQL parameters.
- [Frontend Performance Monitoring with SQL](https://telemetry.sh/for/frontend-performance-monitoring): Track typed LCP, INP, and CLS samples by stable route and release, then use SQL to find frontend regressions without collecting raw URLs or page content.
- [Kubernetes Reliability Monitoring with SQL](https://telemetry.sh/for/kubernetes-reliability-monitoring): Track Kubernetes workload transitions and application outcomes together so SQL can separate planned rollout activity from repeated restarts and serving impact.
- [SaaS Revenue Analytics with SQL](https://telemetry.sh/for/saas-revenue-analytics): Build an auditable SaaS revenue model from subscription movements, invoices, entitlements, and product outcomes instead of relying on disconnected billing snapshots.
- [Telemetry Data Quality Monitoring with SQL](https://telemetry.sh/for/telemetry-data-quality): Monitor event freshness, required fields, types, duplicates, schema versions, and volume so broken instrumentation is found before it becomes a misleading business or reliability metric.

## Integration guides

- [OpenAI Agent Telemetry](https://telemetry.sh/integrations/openai-agents): Log OpenAI agent runs, tool calls, model usage, latency, cost, and final outcomes with structured events.
- [Browser JavaScript and Web Vitals Telemetry](https://telemetry.sh/integrations/browser-javascript): Collect Core Web Vitals and bounded frontend outcomes through a rate-limited server proxy without exposing a Telemetry API key.
- [Vercel AI SDK Telemetry](https://telemetry.sh/integrations/vercel-ai-sdk): Track streaming completions, token usage, retries, latency, and accepted results from AI SDK workflows.
- [Inngest And Trigger.dev Job Telemetry](https://telemetry.sh/integrations/inngest-trigger-background-jobs): Instrument async workers, scheduled jobs, retries, failures, and dead-letter events with SQL-ready logs.
- [Stripe Webhook Telemetry](https://telemetry.sh/integrations/stripe-webhooks): Debug payment, subscription, invoice, retry, and downstream billing sync behavior without storing webhook bodies.
- [Supabase And Postgres App Telemetry](https://telemetry.sh/integrations/supabase-postgres): Track product workflows, database-adjacent jobs, API routes, and customer-facing failures from server code.
- [Cloudflare Worker Telemetry](https://telemetry.sh/integrations/cloudflare-workers): Log edge request status, latency, provider failures, cron runs, and queue workers from Cloudflare Workers.
- [Node.js and Express Structured Logging](https://telemetry.sh/integrations/node-express): Instrument Express route outcomes with stable route templates, status codes, request latency, and safe correlation fields.
- [Next.js Server Event Analytics](https://telemetry.sh/integrations/nextjs): Send SQL-ready events from Next.js route handlers and server actions without exposing an ingestion key to the browser.
- [Python and FastAPI Structured Logging](https://telemetry.sh/integrations/python-fastapi): Capture FastAPI request outcomes and latency with the asynchronous Telemetry client and normalized route names.
- [OpenTelemetry Context in Structured Events](https://telemetry.sh/integrations/opentelemetry): Connect Telemetry business events to existing OpenTelemetry traces by recording safe trace and span identifiers at workflow boundaries.
- [AWS Lambda Structured Event Monitoring](https://telemetry.sh/integrations/aws-lambda): Track Lambda invocations, cold starts, duration, retries, and business outcomes with compact structured events.
- [Go HTTP Server Structured Logging](https://telemetry.sh/integrations/go-http): Add typed request-outcome events to Go HTTP services for route error rates, latency percentiles, and release comparisons.
- [Ruby on Rails Structured Event Analytics](https://telemetry.sh/integrations/ruby-rails): Record Rails controller and background-workflow outcomes through Telemetry's HTTP API with safe, queryable fields.
- [Django and Celery Structured Event Monitoring](https://telemetry.sh/integrations/django-celery): Connect Django request outcomes and Celery task lifecycles with safe identifiers, latency, retries, and terminal status.
- [Laravel Structured Logging and Queue Analytics](https://telemetry.sh/integrations/laravel): Send Laravel request, command, queue, and billing outcomes as typed events without exposing application secrets or payloads.
- [.NET and Serilog Structured Event Analytics](https://telemetry.sh/integrations/dotnet-serilog): Add a focused Telemetry outcome event beside Serilog diagnostics for ASP.NET request latency, failures, releases, and customer impact.
- [Spring Boot Structured Event Monitoring](https://telemetry.sh/integrations/spring-boot): Record Spring MVC and scheduled-workflow outcomes through Telemetry's HTTP API with stable routes, latency, status, and trace context.
- [Temporal Workflow Observability](https://telemetry.sh/integrations/temporal): Track Temporal workflow outcomes, activity retries, schedule-to-start latency, and business milestones without recording workflow payloads.
- [BullMQ Queue Monitoring](https://telemetry.sh/integrations/bullmq): Measure BullMQ queue wait, execution duration, retries, failures, and dead-letter growth with SQL-ready lifecycle events.
- [AWS SQS Queue Observability](https://telemetry.sh/integrations/aws-sqs): Track SQS message age, receive attempts, processing outcomes, batch behavior, and dead-letter routing without storing message bodies.
- [Kafka Consumer Lag and Processing Analytics](https://telemetry.sh/integrations/kafka): Monitor Kafka consumer outcomes, partition lag, processing latency, retries, and poison-message handling with structured events.
- [Anthropic Claude API Telemetry](https://telemetry.sh/integrations/anthropic-sdk): Track Claude API token usage, model, latency, stop reason, errors, cost context, and reviewed product outcomes without storing prompts.
- [LangGraph Agent Observability](https://telemetry.sh/integrations/langgraph): Measure LangGraph run outcomes, node and tool failures, retries, checkpoints, human handoffs, latency, and reviewed task quality.
- [node-postgres Pool and Query Telemetry](https://telemetry.sh/integrations/node-postgres): Instrument node-postgres query fingerprints, connection acquisition, pool pressure, timeouts, transaction outcomes, and database errors without logging SQL parameters.
- [Prisma ORM Database Telemetry](https://telemetry.sh/integrations/prisma): Measure Prisma operation fingerprints, model and method latency, failures, result counts, releases, and database-dependent workflows without collecting raw query parameters.
- [Kubernetes Workload Telemetry](https://telemetry.sh/integrations/kubernetes): Send bounded Kubernetes restart, readiness, and rollout observations to Telemetry for workload-level SQL analysis.
- [Google Gemini API Telemetry](https://telemetry.sh/integrations/google-gemini): Track Gemini request latency, model usage, tokens, finish reason, errors, and reviewed product outcomes without storing prompts or generated content.
- [Amazon Bedrock Model Telemetry](https://telemetry.sh/integrations/aws-bedrock): Measure Bedrock Converse requests by model or inference profile, token usage, latency, stop reason, retries, and business outcome.
- [Azure OpenAI Responses Telemetry](https://telemetry.sh/integrations/azure-openai): Track Azure OpenAI deployment usage, token cost, latency, failures, and product outcomes with editable SQL-ready events.
- [LangChain Agent Outcome Telemetry](https://telemetry.sh/integrations/langchain): Connect LangChain agent runs and tool outcomes to product-facing cost, reliability, handoff, and acceptance metrics without duplicating raw traces.
- [Pino Structured Event Analytics](https://telemetry.sh/integrations/pino-node): Pair Pino diagnostic logs with bounded Telemetry outcome events for Node.js request, job, and product reliability analysis.
- [Winston Structured Event Analytics](https://telemetry.sh/integrations/winston-node): Connect Winston application diagnostics to small SQL-ready request, workflow, and job outcomes without duplicating the entire log stream.
- [NestJS Request and Workflow Telemetry](https://telemetry.sh/integrations/nestjs): Instrument NestJS controllers and providers with normalized route outcomes, latency, errors, releases, and approved account context.
- [Flask and SQLAlchemy Telemetry](https://telemetry.sh/integrations/flask-sqlalchemy): Measure Flask request outcomes and SQLAlchemy transaction behavior with bounded Python events, stable route templates, and safe error categories.
- [Sidekiq Job Telemetry](https://telemetry.sh/integrations/sidekiq): Track Sidekiq execution outcomes, attempts, queue wait, errors, and releases from server middleware without copying job arguments.
- [Redis and node-redis Telemetry](https://telemetry.sh/integrations/redis-node): Measure Redis command outcomes, latency, cache behavior, reconnects, and bounded error categories alongside node-redis.
- [Claude Agent SDK Telemetry](https://telemetry.sh/integrations/claude-agent-sdk): Track Claude Agent SDK run outcomes, duration, tool activity, turns, cost, and approved product signals without storing prompts or tool payloads.
- [Pydantic AI Agent Telemetry](https://telemetry.sh/integrations/pydanticai): Measure Pydantic AI run outcomes, validated outputs, retries, tool activity, latency, usage, and product acceptance with safe structured events.
- [CrewAI Workflow Telemetry](https://telemetry.sh/integrations/crewai): Track CrewAI crew and flow outcomes, task counts, handoffs, retries, latency, cost, and accepted results without retaining agent conversations.
- [Google ADK Agent Telemetry](https://telemetry.sh/integrations/google-adk): Measure Google Agent Development Kit sessions, run outcomes, tool activity, handoffs, latency, and approved product signals with SQL-ready events.
- [Mastra Agent Telemetry](https://telemetry.sh/integrations/mastra): Track Mastra agent and workflow outcomes, tool activity, latency, retries, cost, and product acceptance alongside built-in traces and evals.
- [LlamaIndex Agent Telemetry](https://telemetry.sh/integrations/llamaindex): Track LlamaIndex agent and workflow outcomes, tool activity, latency, retrieval versions, cost, and reviewed quality with structured events.
- [DSPy Program Evaluation Telemetry](https://telemetry.sh/integrations/dspy): Measure DSPy program latency, failures, metric scores, optimizer versions, model cost, and accepted outcomes across releases with SQL-ready events.
- [AutoGen Task Flow, State, and Timeout Monitoring](https://telemetry.sh/integrations/autogen): Track AutoGen task-flow state, timeouts, team and agent outcomes, tool activity, handoffs, latency, failures, cost, and releases with compact structured events.
- [Semantic Kernel Agent Telemetry](https://telemetry.sh/integrations/semantic-kernel): Measure Semantic Kernel function and agent outcomes, tool activity, model usage, latency, cost, and releases alongside OpenTelemetry traces.
- [MCP Server and Tool Telemetry](https://telemetry.sh/integrations/model-context-protocol): Track Model Context Protocol tool outcomes, latency, errors, approvals, retries, clients, and releases without storing arguments or returned content.
- [RabbitMQ Queue Telemetry](https://telemetry.sh/integrations/rabbitmq): Track RabbitMQ publish confirmation, delivery, acknowledgement, redelivery, queue wait, retries, and dead-letter outcomes with structured events.
- [MySQL Query and Pool Telemetry](https://telemetry.sh/integrations/mysql): Track normalized MySQL operations, pool wait, transaction outcomes, controlled error categories, and release regressions without storing raw SQL or parameters.
- [MongoDB Operation Telemetry](https://telemetry.sh/integrations/mongodb): Track named MongoDB operations, latency, result counts, retries, transaction outcomes, and release regressions without collecting documents or query values.
- [Google Cloud Run Telemetry](https://telemetry.sh/integrations/google-cloud-run): Track Cloud Run request and job outcomes, cold-start context, instance concurrency, retries, latency, and releases with application-owned structured events.
- [Google Cloud Pub/Sub Telemetry](https://telemetry.sh/integrations/google-cloud-pubsub): Track Pub/Sub publish, delivery, acknowledgement, redelivery, ordering, queue age, and dead-letter outcomes with stable message identifiers.
- [Azure Functions Telemetry](https://telemetry.sh/integrations/azure-functions): Track Azure Functions HTTP, timer, queue, and event-trigger outcomes with invocation, retry, latency, release, and customer-impact context.
- [Azure Service Bus Telemetry](https://telemetry.sh/integrations/azure-service-bus): Track Azure Service Bus sends, receives, lock renewal, settlement, redelivery, deferral, and dead-letter outcomes without collecting message bodies.
- [OpenAI Responses API Telemetry](https://telemetry.sh/integrations/openai-responses-api): Measure OpenAI Responses API latency, token usage, tool activity, failures, and downstream outcomes without collecting prompts or generated content.
- [LiteLLM Gateway and SDK Telemetry](https://telemetry.sh/integrations/litellm): Track LiteLLM provider routing, retries, fallbacks, token usage, latency, cost estimates, and accepted outcomes across a controlled model gateway.
- [Elixir Phoenix Telemetry Integration](https://telemetry.sh/integrations/elixir-phoenix): Attach to Phoenix request lifecycle events and forward a bounded terminal request outcome without copying connection data, parameters, or exception text.
- [AWS ECS and Fargate Telemetry Integration](https://telemetry.sh/integrations/aws-ecs-fargate): Add ECS task family, revision, availability zone, and release context to application outcomes using the local task metadata endpoint.
- [GitHub Actions Workflow Telemetry Integration](https://telemetry.sh/integrations/github-actions): Send a bounded terminal workflow outcome from GitHub Actions with run, attempt, job, conclusion, duration, and release context.
- [n8n Workflow Telemetry](https://telemetry.sh/integrations/n8n): Send n8n workflow completion, failure, retry, item-count, and downstream delivery outcomes to a bounded Telemetry event through the HTTP Request node.

## Integration categories

- [AI Agent and LLM Telemetry Integrations](https://telemetry.sh/integrations/category/ai-agent-llm): Compare implementation guides for model providers, agent frameworks, tool orchestration, retrieval systems, and AI application runtimes.
- [Node.js and TypeScript Telemetry Integrations](https://telemetry.sh/integrations/category/node-typescript): Instrument Node.js frameworks, edge runtimes, queues, database clients, loggers, webhooks, and AI applications with server-side events.
- [Python Telemetry Integrations](https://telemetry.sh/integrations/category/python): Instrument Python APIs, workers, database applications, and AI agent frameworks with synchronous or asyncio-safe structured events.
- [Background Job and Queue Telemetry Integrations](https://telemetry.sh/integrations/category/jobs-queues): Instrument schedulers, workers, queues, streams, retries, dead letters, webhooks, and durable workflows from enqueue through final outcome.
- [Database and Data-System Telemetry Integrations](https://telemetry.sh/integrations/category/databases): Instrument database clients, ORMs, caches, streams, and application-owned query boundaries without storing raw SQL or sensitive parameters.
- [Cloud and Infrastructure Telemetry Integrations](https://telemetry.sh/integrations/category/cloud-infrastructure): Instrument edge functions, serverless jobs, queues, Kubernetes workloads, streams, and cloud AI providers with customer-impact context.
- [Application Framework Telemetry Integrations](https://telemetry.sh/integrations/category/application-frameworks): Compare request, job, database, and release instrumentation patterns for server frameworks across JavaScript, Python, Elixir, PHP, Java, .NET, and Go.
- [Logging and Observability Telemetry Integrations](https://telemetry.sh/integrations/category/logging-observability): Connect application loggers, OpenTelemetry context, and framework diagnostics to compact SQL-ready outcome events without duplicating raw telemetry.
- [Browser and Edge Telemetry Integrations](https://telemetry.sh/integrations/category/browser-edge): Collect bounded frontend and edge outcomes through trusted server boundaries while protecting API keys, privacy, consent, and route cardinality.

## Event schemas

- [user_signed_up](https://telemetry.sh/event-schemas/user-signed-up): A durable account-entry event with acquisition and plan context. Keep identity pseudonymous and capture marketing attribution only after privacy review.
- [product_milestone_completed](https://telemetry.sh/event-schemas/product-milestone-completed): A generic milestone envelope for stable product outcomes such as connecting a source, running a first query, or publishing a dashboard.
- [api_request_completed](https://telemetry.sh/event-schemas/api-request-completed): A terminal request event with route templates instead of raw URLs, bounded error categories, and latency measured at the service boundary.
- [llm_request_completed](https://telemetry.sh/event-schemas/llm-request-completed): A terminal model-call event with model, tokens, latency, allocation cost, and tool outcome—without prompts or generated content.
- [background_job_completed](https://telemetry.sh/event-schemas/background-job-completed): A terminal job event that records the final outcome and attempt count once, avoiding the overcounting caused by one row per retry.
- [invoice_payment_completed](https://telemetry.sh/event-schemas/invoice-payment-completed): A payment outcome event that keeps provider identifiers pseudonymous and separates billed amount from recurring-revenue definitions.
- [webhook_delivery_completed](https://telemetry.sh/event-schemas/webhook-delivery-completed): A terminal delivery log event with attempt_count, final status_code, response_body_bytes, and bounded content type—but no customer URL, request headers, authorization, raw response body, or payload.
- [incident_impact_observed](https://telemetry.sh/event-schemas/incident-impact-observed): A bounded impact observation that connects a declared incident to a customer workflow without copying request payloads into the incident record.
- [authentication_attempt_completed](https://telemetry.sh/event-schemas/authentication-attempt-completed): A terminal sign-in outcome with bounded method, result, and risk fields. It deliberately excludes credentials, tokens, raw IP addresses, and free-form provider errors.
- [browser_performance_observed](https://telemetry.sh/event-schemas/browser-performance-observed): A sampled browser measurement with a named metric, numeric value, route template, and release context. Raw URLs, user agents, and DOM content stay outside the event.
- [database_operation_completed](https://telemetry.sh/event-schemas/database-operation-completed): A completed database operation represented by a reviewed fingerprint and coarse operation metadata. SQL text, bound values, credentials, and customer records are excluded.
- [kubernetes_workload_observed](https://telemetry.sh/event-schemas/kubernetes-workload-observed): A periodic workload snapshot with normalized Kubernetes coordinates and aggregate state. Pod logs, environment variables, secret names, and annotations are excluded.
- [ai_agent_run_completed](https://telemetry.sh/event-schemas/ai-agent-run-completed): A terminal agent-run outcome with versioned workflow, tool summary, cost, and reviewed task result. Prompts, completions, tool arguments, and retrieved content are excluded.
- [agent_tool_authorization_decided](https://telemetry.sh/event-schemas/agent-tool-authorization-decided): A policy decision recorded before a consequential agent tool call. It captures bounded tool, risk, decision, and policy fields while excluding prompts, arguments, results, credentials, and customer content.
- [feature_rollout_evaluated](https://telemetry.sh/event-schemas/feature-rollout-evaluated): A versioned feature assignment record that makes exposure rules queryable without copying targeting expressions or personal attributes.
- [agent_tool_call_completed](https://telemetry.sh/event-schemas/agent-tool-call-completed): A bounded terminal tool-call event for agent reliability analysis. Keep arguments and results in the specialist trace system and retain only approved categories and correlation identifiers.
- [rag_retrieval_evaluated](https://telemetry.sh/event-schemas/rag-retrieval-evaluated): A versioned RAG evaluation event that separates retrieval scores, answer review, latency, and cost without storing source text, prompts, or generated answers.
- [subscription_changed](https://telemetry.sh/event-schemas/subscription-changed): A revenue movement event emitted from committed billing state. Store normalized plan and movement values rather than invoice bodies or payment-provider payloads.
- [usage_meter_recorded](https://telemetry.sh/event-schemas/usage-meter-recorded): An idempotent usage-meter record with quantity, unit, meter version, and billing period. Keep raw source payloads and customer content outside the analytical event.
- [telemetry_delivery_observed](https://telemetry.sh/event-schemas/telemetry-delivery-observed): An application-owned observation of a telemetry delivery attempt. Use a separate sink or bounded sample to avoid creating a recursive event for every delivery.

## Instrumentation templates

- [AI Agent Observability Template](https://telemetry.sh/templates/ai-agent-observability): Track agent runs, tool calls, retries, model latency, errors, and accepted outcomes with structured SQL-ready events.
- [Background Job Failure Monitor](https://telemetry.sh/templates/job-failure-monitor): Capture queue, cron, import, billing sync, and webhook job health from the first run through retries and failures.
- [API Error And Latency Monitor](https://telemetry.sh/templates/api-error-monitor): Watch request volume, status codes, route latency, failed endpoints, and customer-impacting API incidents.
- [LLM Cost Tracker](https://telemetry.sh/templates/llm-cost-tracker): Measure model spend, token usage, latency, failure rate, and value signals by feature, user, and account.
- [Webhook Debugging Template](https://telemetry.sh/templates/webhook-debugging): Track delivery, processing, retries, provider status, idempotency, and downstream effects for critical webhooks.
- [Activation And Retention Template](https://telemetry.sh/templates/activation-retention): Track the path from signup to first meaningful action, retained usage, upgrade intent, and expansion signals.
- [Event Tracking Plan Template](https://telemetry.sh/templates/event-tracking-plan): Create a reviewable event catalog covering grain, ownership, fields, privacy, retention, validation, and downstream SQL dependencies.
- [AI Agent Security Audit Template](https://telemetry.sh/templates/ai-agent-security-audit): Instrument tool authorization decisions, policy versions, human approvals, and terminal outcomes with privacy-safe structured events.
- [Database Reliability Monitoring Template](https://telemetry.sh/templates/database-reliability): Instrument slow operation fingerprints, pool contention, transaction rollbacks, locks, replication lag, and migration outcomes with safe structured events.

## Product comparisons

- [PostHog For Backend Events](https://telemetry.sh/compare/posthog-backend-events): Compare PostHog and Telemetry for backend events, product analytics, SQL, dashboards, integrations, and agent-installed instrumentation.
- [Datadog Alternative For Startups](https://telemetry.sh/compare/datadog-startups): Compare Datadog and Telemetry for startup observability, structured application events, SQL dashboards, alerts, and operational ownership.
- [ClickHouse Logging API Without Running ClickHouse](https://telemetry.sh/compare/clickhouse-logging-api): Compare self-hosted ClickHouse, ClickStack, and Telemetry for structured event ingestion, SQL analytics, dashboards, and operational ownership.
- [Axiom Alternative For Structured Event Analytics](https://telemetry.sh/compare/axiom-structured-events): Compare Axiom and Telemetry for structured events, log search, SQL or APL queries, dashboards, monitors, and lightweight application observability.
- [Better Stack Logs Alternative For SQL Event Analytics](https://telemetry.sh/compare/better-stack-logs): Compare Better Stack and Telemetry for log management, structured events, SQL analytics, dashboards, alerts, incident workflows, and startup operations.
- [Honeycomb Alternative For Lightweight Wide Events](https://telemetry.sh/compare/honeycomb-wide-events): Compare Honeycomb and Telemetry for wide events, high-cardinality debugging, traces, structured business events, SQL, dashboards, and engineering workflows.
- [Grafana Loki Alternative For Structured Log SQL](https://telemetry.sh/compare/grafana-loki-structured-logs): Compare Grafana Cloud Logs, Loki, and Telemetry for structured logs, labels, metadata, SQL or LogQL queries, dashboards, alerts, and operational ownership.
- [Sentry Alternative For Structured Events and SQL](https://telemetry.sh/compare/sentry-logs-events): Compare Sentry and Telemetry for logs, errors, traces, structured application events, SQL analytics, dashboards, and developer workflows.
- [Splunk Alternative for Structured Events](https://telemetry.sh/compare/splunk-structured-events): Compare Splunk and Telemetry for structured events, logs, SQL or SPL, dashboards, alerts, APM, infrastructure monitoring, and operational ownership.
- [Elastic Alternative for Structured Event SQL](https://telemetry.sh/compare/elastic-observability-events): Compare Elastic Observability and Telemetry for structured events, logs, SQL or KQL, dashboards, alerts, APM, infrastructure, and ownership.
- [New Relic Alternative for Structured Events](https://telemetry.sh/compare/new-relic-structured-events): Compare New Relic and Telemetry for structured events, logs, SQL or NRQL, dashboards, alerts, APM, infrastructure, browser monitoring, and ownership.
- [Telemetry vs Langfuse for AI Observability](https://telemetry.sh/compare/langfuse-ai-observability): Compare Langfuse and Telemetry for LLM traces, evaluations, prompt management, agent outcome events, SQL dashboards, privacy, and deployment.
- [Telemetry vs LangSmith for AI Observability](https://telemetry.sh/compare/langsmith-ai-observability): Compare LangSmith and Telemetry for LLM traces, evaluations, datasets, agent outcome events, SQL dashboards, privacy, and self-hosting.
- [Telemetry vs Arize Phoenix](https://telemetry.sh/compare/arize-phoenix): Compare Arize Phoenix and Telemetry for AI traces, evaluations, experiments, agent outcome events, OpenTelemetry, SQL dashboards, and deployment.
- [Telemetry vs Pydantic Logfire](https://telemetry.sh/compare/pydantic-logfire): Compare Pydantic Logfire and Telemetry for AI observability, OpenTelemetry traces, token cost, tool calls, structured events, SQL, and pricing.
- [Telemetry vs Mixpanel](https://telemetry.sh/compare/mixpanel-product-analytics): Compare Mixpanel and Telemetry for product analytics, funnels, retention, structured backend events, SQL, dashboards, and operational workflows.
- [Telemetry vs Amplitude](https://telemetry.sh/compare/amplitude-product-analytics): Compare Amplitude and Telemetry for product analytics, funnels, retention, experimentation, backend events, SQL dashboards, and operational analysis.
- [Telemetry vs Braintrust](https://telemetry.sh/compare/braintrust-ai-observability): Compare Braintrust and Telemetry for AI evaluations, experiments, traces, scorers, prompt workflows, LLM costs, SQL, and product outcomes.
- [Telemetry vs Helicone](https://telemetry.sh/compare/helicone-llm-observability): Compare Helicone and Telemetry for LLM observability, AI gateway routing, sessions, model cost, caching, alerts, SQL, and product outcomes.
- [Telemetry vs Opik](https://telemetry.sh/compare/opik-ai-evaluation): Compare Opik and Telemetry for LLM traces, evaluations, datasets, experiments, test suites, production outcomes, SQL dashboards, and deployment.
- [Telemetry vs W&B Weave](https://telemetry.sh/compare/wandb-weave-ai-observability): Compare W&B Weave and Telemetry for LLM traces, evaluations, scorers, versioned prompts, feedback, production monitoring, and SQL outcomes.
- [Telemetry vs MLflow for GenAI](https://telemetry.sh/compare/mlflow-genai-observability): Compare MLflow and Telemetry for GenAI tracing, evaluations, prompt registry, experiments, production monitoring, OpenTelemetry, and SQL outcomes.
- [Telemetry vs OpenLIT](https://telemetry.sh/compare/openlit-ai-observability): Compare OpenLIT and Telemetry for OpenTelemetry-native LLM tracing, auto-instrumentation, evaluations, prompts, dashboards, SQL, and outcomes.

## Comparison guides

- [AI Observability Tools: A Workflow-Based Comparison](https://telemetry.sh/compare/guides/ai-observability-tools): Compare AI observability approaches for traces, prompts, evaluations, model cost, tool reliability, SQL analysis, and product outcomes.
- [Structured Logging and Event Analytics Tools Compared](https://telemetry.sh/compare/guides/structured-logging-event-analytics-tools): Compare log platforms, wide-event systems, error monitoring, data infrastructure, and SQL event analytics using one production workflow.

## Customer stories

- [Browserflow: From business events to answers that are easy to see](https://telemetry.sh/customers/browserflow): Browserflow founder Namu Kang describes the value of tracking, analyzing, and visualizing business activity without making the workflow feel heavy.
- [LogSnag: From raw event delivery to an answer the team can use](https://telemetry.sh/customers/logsnag): LogSnag founder Shayan Taslim describes Telemetry as a direct path from sending data to understanding what it means.
- [SwiftCX: A fast SQL workbench for logs, events, and automated reports](https://telemetry.sh/customers/swiftcx): SwiftCX founder Prem Viswanathan explains why straightforward ingestion, flexible schemas, fast SQL, and a query API make Telemetry useful in day-to-day operations.