jeremyhi
cca95b2637
* fix(mito2): cancel flushes waiting for the WAL when the engine stops A flush waits for the WAL to be durable through the entry id it records before it writes its manifest edit. With the object store WAL in the `enqueued` mode that wait lasts until an upload succeeds, while the log store is stopped only after the engines. A graceful shutdown during an outage of the WAL's object store therefore never finished: closing a region does not cancel its running flush, stopping the worker group waits for running flushes and runs the queued ones, and a region holding writes that skipped the WAL is flushed on close. The worker group now owns a cancellation token, raised before its schedulers stop and kept raised. `RegionEngine::begin_stop`, which the region server calls before it closes regions, raises it earlier, so that a close-time flush cannot wait either. A flush polls its durability barrier first and gives up at the barrier once the token is raised: it writes no manifest edit, deletes its SSTs and fails as cancelled. A flush whose entries are already durable commits as before. The region server reports a failed close, which loses the region's writes that skipped the WAL, in its stop result. Signed-off-by: jeremyhi <fengjiachun@gmail.com> * test(mito2): wait for the outage on the store under test Signed-off-by: jeremyhi <fengjiachun@gmail.com> * fix(mito2): give a healthy WAL a grace period before a stopping engine cancels flushes A flush of a stopping engine no longer gives up its wait for the WAL as soon as the stop begins. It gives up at once while the log store reports that it fails to make entries durable, through the new `LogStore::is_failing`, and otherwise 5 s after the engine began to stop, so a healthy object store WAL uploads its last entries first and a close-time flush keeps the writes that skipped the WAL. The object store WAL reports that it fails while the last create of its backlog failed, which covers a refused and an unreachable object store, and once it is poisoned or stopped. Signed-off-by: jeremyhi <fengjiachun@gmail.com> * fix(mito2): drain the WAL for a stopping flush and cancel its failed waits A flush of a stopping engine now asks the log store to drain before it waits out the grace period, through a new `LogStore::begin_drain` that does nothing by default. The object store WAL then seals its open batch at once and, until it stops, as soon as a durability wait needs a region it holds, so a healthy store makes the entries durable after about one upload whatever its `flush_interval`, which has no upper bound. A barrier wait that fails while the engine stops, for instance on a poisoned or stopped log store, now fails the flush as cancelled like a wait that gives up. The healthy-store test no longer depends on the seal timer: its store never seals on its own, and the close must finish well within the grace period. Signed-off-by: jeremyhi <fengjiachun@gmail.com> * fix(mito2): drain the WAL when the engine begins to stop The drain started only when a stopping flush reached its durability barrier, so a close behind slow flushes that reached it after the grace period had no time left to upload its entries. The worker group now asks the log store to drain as soon as it begins to stop, and the object store WAL seals its open batch then and every later admission right away, so its entries become durable while the flushes still write their SSTs. `LogStore::begin_drain` becomes synchronous for that. The healthy-store test now writes after the stop began and closes the region only after the grace period. Signed-off-by: jeremyhi <fengjiachun@gmail.com> * fix(log-store): refuse appends once the object store WAL drains A WAL write admitted late in a stop could still be uploading when the close-time flush of its region reached an expired grace period, so the writes that skipped the WAL in that region were lost although the store was healthy. A draining object store WAL now refuses every later append, also one held back, with the stopped error, so the entries a stopping engine waits for are fixed when the stop begins and become durable while the regions still close; writes that skip the WAL are still taken. Tests cover a close-time flush whose wait completes within the grace period once a parked create is released, a close that reaches its wait after the grace period, and a drain refusing a held-back append. Signed-off-by: jeremyhi <fengjiachun@gmail.com> * fix(datanode): word a failed region close neutrally in the shutdown log A close can fail for reasons other than its flush, such as a stopped worker, and for regions without writes that skipped the WAL, so the error line no longer states that such writes were lost: it says they may be. Signed-off-by: jeremyhi <fengjiachun@gmail.com> * fix(datanode): stop the object store WAL before the region server The datanode stopped the object store WAL only after the region server, whose stop waits for flushes that wait for the WAL to become durable, so a shutdown never finished while the WAL's uploads kept failing. The WAL now stops first: its stop uploads the backlog or drops it and answers every wait for its entries, so a running, queued or close-time flush either commits or fails with the WAL-stopped error without writing a manifest edit. This replaces the stop signal and grace period the engine used to give up those waits, and the log store and engine hooks they needed. Signed-off-by: jeremyhi <fengjiachun@gmail.com> * test(datanode): check rows after a healthy shutdown and wait for the WAL stop Signed-off-by: jeremyhi <fengjiachun@gmail.com> * test: keep only the shutdown tests that prove the new stop order The engine-level tests pinned the log store's stop contract, which the log store's own tests already cover, and the stalled-create test asserted a limitation rather than a guarantee. Drop them with the testing hooks only they used; the datanode and region server tests cover the change end to end. Signed-off-by: jeremyhi <fengjiachun@gmail.com> --------- Signed-off-by: jeremyhi <fengjiachun@gmail.com>
Metrics, logs, and traces.
One engine, on your infrastructure.
A columnar database for metrics, logs, and traces on object storage. Apache-2.0 licensed core.
User Guide · API Docs · 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.
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, 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 | 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. 40% fewer wrong diagnoses, 48% fewer input tokens, 45% lower cost (write-up)
- GreptimeDB tops JSONBench's billion-record cold run test
- 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, region migration, and index creation 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.
Architecture
GreptimeDB can run in two modes:
- Standalone — single binary for development and small deployments.
- Distributed — four components, each independently scalable:
- Frontend — protocol entry (OTel, Prometheus, MySQL/PostgreSQL, gRPC, ingestion APIs for Elasticsearch/InfluxDB/Loki) and the distributed query engine. Stateless, scales horizontally.
- Datanode — region engine with WAL, memtable, SST, cache, compaction, and indexes. Persists data to object storage. Elastic.
- Metasrv — metadata, routing, repartitioning, and security. 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.
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
Read more in the full Install Guide.
Troubleshooting:
- Cannot connect to the database? Ensure that ports
4000,4001,4002, and4003are not blocked by a firewall or used by other services. - Failed to start? Check the container logs with
docker logs greptimefor further details.
Getting Started
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.
Release lines and support windows are in the version reference. For where the project is going, read the v1.0 highlights and the 2026 roadmap.
Community
We invite you to engage and contribute!
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.
Commercial Support
Scaling observability on your infrastructure? GreptimeDB Enterprise adds the operational, security, and support layer for production deployments. Contact us for details.
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.