This is the Prometheus monitoring system, a production-grade application that scrapes and stores time-series metrics, evaluates PromQL queries, generates alerts, and supports remote write/read. The codebase is structured as a monolith with clearly separated packages: a time-series database (TSDB) with advanced compression (XOR, varbit, histogram encoding), a PromQL parser and engine, a scrape manager with start-time synthesis for cumulative metrics, a notifier for Alertmanager integration, service discovery for 15+ cloud/container platforms, remote storage adapters, and a REST API with OpenAPI specs. The system runs as a single binary with optional agent mode. Two web UIs (React and Mantine) provide querying, alert management, and configuration views. The architecture is modular: each major component (TSDB, PromQL, scrape, notifier) has a clean interface and can be independently tested or replaced.
InfluxDB 3 Core (IOx) is a production-grade, open-source time-series database written in Rust. It ingests data via line protocol (HTTP/gRPC), stores it in Apache Parquet on object storage (S3, Azure, GCP, local), and serves queries via SQL (DataFusion), InfluxQL, and FlightSQL. The architecture is a single binary (`influxdb3`) that combines an HTTP server (port 8181), gRPC FlightSQL endpoint, CLI, and an embedded Python processing engine for plugin-based triggers. The system is designed for low-latency last-value queries, high-throughput writes, and efficient columnar storage with catalog persistence as versioned binary logs and snapshots on object store. The codebase is a large Rust workspace (~40+ crates) with a clear separation of concerns: core libraries (`core/`) for query planning, Arrow utilities, authorization, and metrics; server crates (`influxdb3_*`) for catalog management, write buffering, processing engine, and system tables. Key entry points include `influxdb3/src/main.rs` (CLI), `influxdb3_server/src/unified_service/` (HTTP/gRPC routing), and `influxdb3_catalog/src/` (catalog operations). The query engine is built on a forked DataFusion with custom physical optimizers (gapfill, dedup, sort, union) and InfluxQL planning. External dependencies include object store backends, protobuf for gRPC, and Python (via PyO3) for plugins. The repository demonstrates high craftsmanship with several reusable patterns: a versioned binary record format for catalog persistence with forward-compatibility guarantees, a hook-based cache system with S3-FIFO eviction, a generic copy-on-write repository pattern, and a run-optimized merge sort for streaming sorted data. However, the large workspace, forked DataFusion pinned to a commit, and multiple catalog versions (v1–v4) introduce maintenance drift risks. The codebase is actively maintained with extensive tests, benchmarks, and CI/CD.
This is a Rust library providing an async client for InfluxDB 1.x and 2.x (compatibility mode). It supports writing and reading data via the InfluxDB HTTP API, with a fluent query builder for constructing line protocol write queries and read queries. The library offers optional serde integration for deserializing query results into Rust structs using a custom Serde deserializer that handles InfluxDB's column/value array format. It also includes a derive macro (`InfluxDbWriteable`) for automatically generating write queries from structs. The architecture is centred around a `Client` struct that wraps a `reqwest` HTTP client, with support for authentication (basic auth and token-based) and multiple HTTP backends via feature flags. The codebase is well-structured, with clean separation of concerns, extensive unit and integration tests, and a strong emphasis on correct line protocol escaping. The custom serde deserializer is a notable highlight, demonstrating advanced Serde patterns for transforming array-of-arrays into map-like structures. The project is actively maintained with recent commits and a clear release process.
M3 is a distributed time-series database and metrics platform originally developed by Uber and now under the Linux Foundation. It provides a full-stack solution for collecting, aggregating, storing, and querying high-volume metric data at scale. The system comprises multiple services: m3dbnode (storage node with custom encoding and persistence), m3coordinator (routing and downsampling gateway), m3aggregator (clustered metrics aggregation with quantile estimation), and m3query (PromQL/Graphite query engine). These services communicate via Thrift, gRPC, and HTTP, and are coordinated through an etcd-based cluster management layer that handles placement, leader election, and configuration distribution. The architecture is highly performance-oriented, featuring extensive object pooling, zero-copy I/O, custom bit-level encoding (m3tsz), and an inverted index (m3ninx) backed by FST segments and Roaring Bitmaps for fast metadata search. The codebase is written in a custom Go-like transpiled language and includes generated code for mocks, protobuf, and Thrift bindings. It integrates deeply with Prometheus (remote write, scrape, and query) and Graphite protocols, and provides a React-based admin UI (m3ctl) for namespace and rule management. The repository also contains a comprehensive suite of unit, integration, and property-based tests, along with Docker-based development and CI environments.