o11ylite

What O11yLite stores and how it runs

O11yLite is a free, open source OpenTelemetry backend powered by DuckDB and SQLite. The README describes it as a single process that handles logs, metrics, and traces together, rather than running separate services for each signal. It ingests telemetry over the OpenTelemetry protocol using both OTLP gRPC and OTLP HTTP, which are the standard transport paths clients use to send data to an OpenTelemetry collector or backend. The README emphasizes that one container runs the entire stack, covering ingestion, storage, query, and the user interface, so an operator does not assemble several components. Storage uses DuckDB together with DuckLake, and the README says telemetry is kept as open Parquet files, which are a columnar format that analytics tools can read without a proprietary database. This design aims to give fast analytical queries without heavy infrastructure such as a distributed cluster. The project is licensed under AGPL 3.0, a strong copyleft license that requires derived network served software to share its source, which is a meaningful choice for anyone deploying it as a service. The README presents the backend as a smaller but capable alternative to large observability fleets, suitable for teams that want one process instead of a distributed system.

Automatic schema evolution and wide events

A notable feature in the README is automatic schema evolution. When new fields appear in incoming telemetry, O11yLite makes them queryable columns automatically, without manual schema management. This matters because telemetry shape changes often in real systems, and a backend that requires an administrator to alter a schema on every new field becomes a maintenance burden. The README links this to a philosophy of wide events over scattered logs. Traditional logging produces many narrow, context free lines per request that are optimized for writing rather than querying, while the project favors a single rich record per unit of work that carries the context needed, such as user info, business data, feature flags, and timings. The README says O11yLite's automatic schema evolution and high cardinality columnar storage are built specifically to make this style practical, and it invites users to send 50 field spans and have every field become queryable without configuration. The combination of wide events and automatic columns means a team can add context to telemetry and immediately query it. This is presented as a core design belief of the project, not just a convenience feature. The README invites users to send spans with many fields so every field becomes queryable, which illustrates the intended usage directly.

Exploring, alerting, and notebooks

The README lists several ways to use the stored telemetry. Explore lets a user query and visualize traces, logs, and metrics through a built in query builder and a trace waterfall view, which is the standard way to see how a request flowed through services. Alert rules let a user define conditions and send notifications through Alertmanager compatible webhooks, so the backend fits into existing alerting pipelines that already speak the Alertmanager format. Notebooks let a user compose and share investigative workflows that combine queries and notes, which supports the kind of open ended debugging a single dashboard cannot capture. The README also describes the backend as agent native: it includes OAuth PKCE and an agent skill package that lets LLM agents query telemetry, manage alerts, and edit notebooks out of the box. That skill package is referenced as a documentation file within the repo. Together these features move O11yLite from a passive store into an interactive investigation tool, where a human or an agent can both ask questions of the data and record the findings. The README presents explore, alert, and notebook as the three interactive pillars on top of ingestion and storage. The three named pillars cover the path from raw signal to shared investigation without requiring a separate external tool for each.

Agent native access and project philosophy

The agent native label in the README points to two concrete things. First, the backend includes OAuth PKCE, which is the standard OAuth flow that lets a client authenticate without handling secrets directly, suitable for letting an external agent obtain scoped access. Second, the project ships an agent skill package, documented in a file the README links, that lets LLM agents query telemetry, manage alerts, and edit notebooks without custom integrations. This is the same data the human UI exposes, just accessed through a defined skill rather than clicks. The broader philosophy section argues the backend for observability does not need to be a distributed fleet of indexes and stores, and that a single process with open file storage can be enough for many teams. The README frames O11yLite as smaller but still capable, contrasting it with heavy observability infrastructure. By storing open Parquet files and using DuckDB for analytics, the project keeps the data portable and queryable by other tools, which aligns with the open format claim. The mix of standard OTLP ingestion, automatic schema growth, a built in UI, alerting, notebooks, and agent skills covers the full path from receiving telemetry to acting on it. The OAuth PKCE flow and the agent skill package are the concrete pieces that let an agent operate without a custom integration.

Editorial conclusion

O11yLite is written in Clojure and published under the AGPL 3.0 license. The README states it ingests telemetry over OTLP gRPC and OTLP HTTP and runs the whole stack as a single container.