* feat(promql): fold pi() and answer quantile as a complete aggregate pi() folds through constant_value like any other constant, so pi() * x, clamp_max(x, pi()) and quantile(pi()/4, x) all compile natively. The value is std::f64::consts::PI on both routes. Note this is wider than the legacy planner, which does not treat a call as a literal and so rejects those parameter positions; it is an extension of constant support, not a narrowing. quantile now binds a Complete fold that retains the group's input and answers with the existing aggregate_quantile kernel. A quantile has no partial kernel, so split.rs and the state binding are untouched and a Partial/Final quantile cannot exist: validate refuses it and check_cut declines the cut. A partitioned input therefore gathers above per-series prefixes instead of folding per partition, which is the only correct distributed shape for a non-associative aggregate -- the raw-source boundary keeps fragments from being read as whole series, and the router merges a raw identity once every input reaches EOF. The retained input is not a fixed-width state: a quantile keeps every group until EOF and cannot spill, so it is bounded by pool admission, which the module doc now states. Its parameter is sparse, covering the grid positions the input actually holds rather than the window they span. Two points 100k positions apart used to allocate an 800KB dense parameter before any admission; now the parameter and the kernel's position/value copy are charged by row bound before allocation, and retaining a series reserves the Vec capacity it is about to grow to rather than one slot. A test runs two distant points under a 64KiB pool and finishes with nothing left reserved. quantile over a histogram no longer falls back: the legacy planner groups it with min, max, stddev and stdvar, skipping histogram samples and reporting an info, so the admission check now refuses only sum and avg, which fold the payload. The native runtime asserts the same info as min over a histogram-only chunk. Signed-off-by: discord9 <discord9@163.com> * fix(promql): bill a quantile's retained chunks the way a binary operand is billed series_bytes charges the whole Arrow parent buffer a slice points into, and every histogram table it references, so a series handed over as many slices of one buffer was charged once per chunk: two thousand one-row slices of a 16 KB array came to ~32 MB against a 4 MiB pool and were refused around the 260th, while min over the same input answered. Retained chunks are now billed as a binary operand bills its operand: operand_chunk_bytes measures what each chunk holds on its own, with the parent buffer counted once across its slices, and unbilled_tables bills each histogram table once, remembered by allocation address. QuantileInput::bytes() reports real residency -- its own size, the vector's capacity and the folded held bytes -- instead of a per-chunk sum, so every resize settles on what the node actually keeps. The capacity pre-booking stays and is kept out of held, so a vector slot is not charged twice. The regression hands one array over as 2000 single-row slices under a 4 MiB pool and asserts min and quantile answer the same and both return their reservation. Restoring the old billing makes it fail with ResourcesExhausted, which is the failure it exists to catch. Signed-off-by: discord9 <discord9@163.com> * fix(promql): bill a quantile's retained input once per allocation The previous change stopped charging every chunk for the whole parent buffer, but the figure was still not self-consistent in three ways. operand_chunk_bytes subtracted the whole of fields_bytes() and added back only the row bytes of the slice, so a small slice of a big buffer was billed as small while the whole allocation stayed resident, and a validity bitmap was not counted at all. Retained chunks are now billed per Arrow allocation, keyed on the buffer's data pointer and charged at capacity, the same way unbilled_tables bills histogram tables. The no-identity alternative -- bill every chunk for the whole buffer -- over-estimates and would refuse a legal query, which is the reported bug mirrored. series_bytes includes size_of::<Series>(), and QuantileInput::bytes() also counted every vector slot, so each used slot paid for its Series twice. The chunk figure now carries only what sits beside the samples and the struct is left to the vector. pending() returned the incoming chunk's figure for every fold, but the quantile retainer books its own figure before the push, so that backing was reserved twice and could refuse a query before any memory was actually held. finish_quantile also settled on the output while its input was still alive by value; it now drops the input first. Billing only; no answer changes. A 2000-chunk input goes from 1,757,960 to 1,181,968 bytes (the 2000 x 288 of double-counted structs plus one 16 KB allocation billed once), and every quantile billing test ends with the pool empty. Five mutations -- rows-only figure, no buffer dedup, per-chunk series_bytes, grid-wide parameter, struct added back per chunk -- each fail the test that covers them. Signed-off-by: discord9 <discord9@163.com> * test(promql): cover a quantile over no input and drop its redundant guards A quantile whose input holds no sample in range has no positions to build a parameter from, so it hands the kernel an empty scalar and answers nothing. No test reached that: replacing the fallback with an error left every quantile and aggregate test green. The new one runs the node without pushing a chunk at all and asserts an empty answer with the pool back to zero. new_quantile also re-checked the stage, the kind and the grid. validate already refuses a Partial or Final quantile -- aggregate_state_binding has no state for one -- and the node's schema is the tree's validated output, so those checks could not fire. The quantile is now passed in from the arm that destructured it. The billing test's comment described the operand_chunk_bytes model; the quantile bills chunk_bytes_beside_samples plus the Arrow allocations its slices point into. Signed-off-by: discord9 <discord9@163.com> * test(promql): answer a quantile over a multi-input tree instead of declining it quantile stopped being a kind the runtime refuses, so the query that pinned that refusal now answers natively. It moved out of the declines test into its own case, which asserts the existing plan answers 3/16, that the route plans a fused node for it, and that the native rows equal the legacy ones. The grouping-by-a-value-field case stays where it was. Signed-off-by: discord9 <discord9@163.com> --------- Signed-off-by: discord9 <discord9@163.com>
Metrics, logs, and traces.
One engine, on your infrastructure.
User Guide · API Docs · Live Demo · Roadmap 2026 · Slack
stable for production · canary includes pre-releases · nightly is a weekly snapshot of main
Introduction
GreptimeDB is an open-source observability database. Metrics, logs, and traces run on one columnar engine over object storage and share one table model: tags, timestamp, and fields. When signals carry common identifiers such as service, host, or trace ID, you can correlate them in SQL without moving data between databases.
Ingest through OpenTelemetry, Prometheus Remote Write, Loki Push, or Elasticsearch Bulk. Use SQL across observability data and PromQL for metrics. Migrate ingestion one signal at a time without rebuilding your collectors.
One Query Across Signals
OpenTelemetry ingestion writes spans to opentelemetry_traces and log records to
opentelemetry_logs. Both tables carry trace_id, so correlating them is a join:
-- The slowest failed spans in the last hour,
-- with the log lines emitted inside those same traces.
SELECT
t.service_name,
t.span_name,
t.duration_nano / 1000000 AS duration_ms,
l.timestamp AS log_time,
l.severity_text,
l.body
FROM opentelemetry_traces t
JOIN opentelemetry_logs l ON l.trace_id = t.trace_id
WHERE t.timestamp > now() - INTERVAL '1' HOUR
AND t.span_status_code = 'STATUS_CODE_ERROR'
ORDER BY t.duration_nano DESC
LIMIT 20;
Metrics join the same way, on any tag the tables share, such as service,
host, or pod.
Try GreptimeDB
For AI agents — paste this prompt into your agent:
Read https://docs.greptime.com/SKILL.md and follow the instructions
to deploy, configure, ingest, and query GreptimeDB.
docker run -p 127.0.0.1:4000-4003:4000-4003 \
-v "$(pwd)/greptimedb_data:/greptimedb_data" \
--name greptime --rm \
greptime/greptimedb:latest standalone start \
--http-addr 0.0.0.0:4000 \
--grpc-bind-addr 0.0.0.0:4001 \
--mysql-addr 0.0.0.0:4002 \
--postgres-addr 0.0.0.0:4003
Dashboard: http://localhost:4000/dashboard
Or skip the install and try the Live Demo.
Next: Quickstart, the full Install Guide, Demo Scenes, and the FAQ.
Why You Might Use It
- You run Prometheus plus Loki or Elasticsearch and want one backend instead of three
- You have outgrown Prometheus on cardinality or retention and don't want the Thanos/Mimir operational surface
- You are hitting Loki's query performance limits as log volume grows
- You need long retention on object storage without a separate analytics stack
- You want to query telemetry with SQL, not only a domain query language
- You are storing GenAI or agent telemetry (OTel GenAI conventions) alongside infrastructure signals
Learn more in Why GreptimeDB.
What's Supported
| Ingest | OpenTelemetry (OTLP), Prometheus Remote Write (with native histograms over Remote Write 2.0), Loki Push, Elasticsearch Bulk, InfluxDB line protocol, gRPC |
| Query | SQL, PromQL, Jaeger-compatible trace queries, MySQL and PostgreSQL wire protocols |
| Storage | S3, GCS, Azure Blob and S3-compatible endpoints as primary storage, with memory and local-disk caches |
| Built in | Pipelines that parse and transform logs at ingestion, retention policies, downsampling, continuous aggregation, explicit table partitioning, and inverted / skipping / fulltext indexes |
Compute and storage are disaggregated: object storage holds the data, while memory and local-disk caches keep recent and frequently queried data close to compute.
Benchmarks
- Agent RCA Bench: LLM agents doing root cause analysis over GreptimeDB versus Prometheus + Loki + Tempo, 168 investigations per interface across six models. 40% fewer wrong diagnoses, about 48% fewer input tokens, about 45% lower estimated cost (write-up)
- JSONBench billion-record cold run: first place as of March 2025
- TSBS Benchmark
- More benchmark reports
Compatibility and Migration
Compatibility is per protocol, and query-side coverage is narrower than ingestion.
| Compatible | Not compatible | |
|---|---|---|
| Prometheus | Remote Write ingestion; PromQL queries | Gaps are listed in PromQL compatibility |
| Loki | Push ingestion; dual-write through Grafana Alloy makes the cutover gradual | LogQL and the rest of the Loki query API |
| Elasticsearch | _bulk ingestion in the open-source core; QueryDSL partially, in Enterprise |
Most other Elasticsearch APIs |
Limitations and Edition Boundary
Cluster deployment, object storage, the Flow engine, and every ingestion protocol listed above are in the Apache-2.0 build. Repartitioning and region migration are manual operations there.
Read replicas, workload isolation, and automated repartitioning are GreptimeDB Enterprise features, along with enterprise security and governance. The Enterprise overview has the current list, and pricing has the edition comparison. For GreptimeDB Enterprise inquiries, contact us.
Architecture
GreptimeDB can run in two modes:
- Standalone — single binary for development and small deployments.
- Distributed — four components, each independently scalable:
- Frontend — protocol endpoints and the distributed query engine. Stateless, scales horizontally.
- Datanode — region engine with WAL, memtable, SST, cache, compaction, and indexes. Persists data to object storage.
- Metasrv — metadata, region routing, and cluster coordination (DDL procedures, failover, region migration, repartitioning). Backed by a pluggable KV layer (etcd or RDS).
- Flownode (optional) — continuous flow computation (streaming and materialized views).
For deeper coverage, see the architecture doc or DeepWiki.
Build From Source
Prerequisites:
- Rust toolchain — stable, pinned by
rust-toolchain.toml - Protobuf compiler (>= 3.15)
- C/C++ building essentials:
gcc/g++/autoconfand the glibc dev package (libc6-devon Ubuntu,glibc-develon Fedora) - Python toolchain (optional, only for some test scripts)
Build and run:
make # build greptime binary
cargo run -- standalone start # start in standalone mode
Common dev commands:
make fmt # format Rust code
make clippy # lint (fails on warnings)
make test # unit + integration tests (uses cargo-nextest)
make sqlness-test # SQL regression tests
See the Contribution Guidelines for the full developer workflow.
Tools & Extensions
- Kubernetes: GreptimeDB Operator
- Helm Charts: Greptime Helm Charts
- Dashboard: Web UI
- gRPC Ingester: Go, Java, C++, Erlang, Rust, .NET, TypeScript
- Grafana Data Source: GreptimeDB Grafana data source plugin
- Grafana Dashboard: Official Dashboard for monitoring
Project Status
GreptimeDB is generally available, with stable APIs and regular releases. It runs in production at scale — OceanBase Cloud operates 80+ GreptimeDB clusters managing 300 TB of logs, cutting log storage cost by 60%+ after migrating from Grafana Loki. See more in case studies.
Releases follow Semantic Versioning. For where the project is going, read the v1.0 highlights, the 2026 roadmap, and what we mean by an observability database.
Community
If GreptimeDB is useful to you, please star the repo.
License
GreptimeDB is an open-core project. Its core is licensed under the Apache License 2.0.
A small set of peripheral, enterprise-only features are gated behind the
enterprise Cargo feature (not built by default) and are governed by the
separate GreptimeDB Enterprise License. Source files under
that license carry an explicit Enterprise License header.
Contributing
- Read our Contribution Guidelines.
- Explore Internal Concepts and DeepWiki.
- Pick up a good first issue and join the #contributors Slack channel.
Acknowledgement
Special thanks to all contributors! See AUTHOR.md.
- Uses Apache Arrow™ (memory model)
- Apache Parquet™ (file storage)
- Apache DataFusion™ (query engine)
- Apache OpenDAL™ (data access abstraction)
All trademarks, logos, and brand names referenced in this README and in the Overview diagram are the property of their respective owners. Their use is for identification purposes only and does not imply endorsement or affiliation.
