influxdata/influxdb

This system is InfluxDB 3 Core, a time-series database that ingests data via HTTP and gRPC APIs and executes queries using SQL and InfluxQL through the DataFusion engine. It manages persistent storage with a Write-Ahead Log and Parquet files in object storage, while optimizing performance through configurable in-memory caches for distinct values, last records, and Parquet data. The platform supports a processing engine for Python-based triggers, enforces role-based access control, and exposes internal state and metrics via system tables and a comprehensive CLI.

26 changes.

This period established the core infrastructure for InfluxDB 3, introducing a modular Rust-based architecture with a new CLI, server, and client libraries. It implemented critical data persistence components, including a binary catalog, a modular write-ahead log, and asynchronous deletion mechanisms, alongside a processing engine supporting Python plugins. The work also defined the operational baseline through comprehensive CI/CD pipelines, Linux packaging, and telemetry systems.

19 changes.

This period focused on restructuring the codebase by introducing dedicated crates for query execution, internal APIs, and core data types to resolve circular dependencies and centralize logic. Significant features included implementing a comprehensive RBAC authorization system, enhancing the processing engine with Python plugin support, and adding a distinct value cache for query optimization. The work also established robust operational foundations through graceful shutdown coordination, unified HTTP/gRPC request handling, and extensive CLI and server integration testing.

21 changes.

This period focused on establishing the foundational core libraries for InfluxDB 3, including authorization, client utilities, and distributed catalog caching. It also involved implementing key data access protocols such as FlightSQL and HTTP Write APIs, alongside building out the query engine with support for InfluxQL and SQL gap-filling.

The \influxdb3\_processing\_engine\_telemetry\ crate now tracks and reports how often each plugin trigger runs. It aggregates invocation counts by database, trigger, plugin, and entrypoint (writes, requests, or scheduled calls), normalizes plugin filenames for consistent reporting, and limits the telemetry payload to the 255 most-invoked triggers to keep metrics concise.

_influxdb3\_processing\_engine\telemetry · high confidence

The catalog has been upgraded to version 3, replacing the previous JSON serialization with a compact, binary framing format that is approximately 5–6 times smaller and avoids full deserialization on load. This new architecture introduces a persistence boundary where on-disk record types are frozen and separate from runtime types, ensuring that the on-disk format can evolve independently of the in-memory API. To support mixed-version clusters during upgrades, the system now uses version-gated records and a cluster-wide committed feature level, allowing nodes to ignore records they do not yet understand. Additionally, the catalog now fully supports GDPR-compliant hard deletion of resources, ensuring that all log files and snapshots containing data for deleted databases or tables are properly compacted and removed from object storage to prevent data retention.

_influxdb3\catalog · high confidence

The \influxdb3\ binary is now structured with a dedicated library crate (\influxdb3/src/lib.rs\) and a minimal main entrypoint (\main.rs\). This change introduces a comprehensive CLI interface with subcommands for managing the server lifecycle (\serve\), data operations (\write\, \query\), and resource management (\create\, \delete\, \show\, \enable\, \disable\, \update\, \install\). It also includes diagnostic tools (\debug\, \test\) and enforces specific runtime configurations, such as defaulting to the \ring\ TLS provider and handling deprecated options like \--package-manager\ with explicit warnings. The accompanying test suite (\lib\_tests.rs\) validates CLI argument parsing, deprecation warning logic, and log filter expansion behavior.

influxdb3/src · high confidence

This change introduces the foundational structure for the InfluxDB 3 project, adding essential configuration and documentation files. It includes an \.editorconfig\ to enforce consistent code formatting (LF line endings, specific indentation for Rust and Docker files), a \.langcheck.yml\ for inclusivity checks, and a \Dockerfile\ that builds the \influxdb3\ binary using Rust 1.92 on Debian Bookworm with support for Python-based processing engines. Additionally, it provides comprehensive documentation in \CONTRIBUTING.md\ (covering issue submission, PR guidelines, and testing with \cargo-nextest\), \PROFILING.md\ (detailing profiling strategies and tools), \README\_processing\_engine.md\ (explaining the embedded Python VM implementation), and \RELEASE.md\ (outlining the release candidate process).

(repo-wide) · high confidence

Adds the \influxdb3\_client\ crate, providing a programmatic HTTP client for InfluxDB 3 Core. This library enables users to interact with the server via methods for writing Line Protocol (with optional gzip compression and precision settings), executing SQL and InfluxQL queries (with support for query parameters and JSON output), and managing resources like databases, tables, and last caches. It includes built-in TLS support (with options for custom CA certificates and skipping verification) and authentication via bearer tokens.

_influxdb3\client · high confidence

The last cache functionality has been moved into the \influxdb3\_cache\ crate and re-implemented to support hierarchical key columns, explicit or automatic value column selection, and time-to-live (TTL) based eviction. Queries against the last cache now support predicate pushdown via DataFusion filters, allowing efficient filtering on key columns. Additionally, a new metric \influxdb3\_last\_values\_cache\_query\_duration\ is exposed to track the latency of last cache queries, aiding in performance monitoring.

_influxdb3\_cache/src/last\cache · high confidence

This change adds the \influxdb3\_py\_api\ crate, providing the runtime interface for Python-based processing engine plugins. It introduces a \PyPluginCallApi\ object that exposes methods for logging (\info\, \warn\, \error\), querying data, and writing line protocol (both batched via \write\ and synchronous via \write\_sync\). The API includes a \LineBuilder\ class for constructing line protocol strings and a \PyCache\ for managing trigger-scoped and global key-value storage with optional TTLs. Additionally, it implements a \ProcessingEngineLogger\ to persist plugin logs to a dedicated table and ensures plugins cannot write to the internal \\_internal\ database.

_influxdb3\_py\api · high confidence

A new distinct value cache has been added to the \influxdb3\_cache\ module to store and manage unique combinations of tag and string field values for table columns. This feature allows the database to serve queries involving distinct values more efficiently by caching these results and supporting predicate pushdown via a new \distinct\_cache\ SQL table function. The implementation includes a provider for managing cache lifecycle and background eviction, ensuring that cached data remains fresh and bounded by configurable cardinality and age limits.

_influxdb3\_cache/src/distinct\cache · high confidence

The system now caches Parquet files in memory to reduce repeated reads from object storage during query execution. This change introduces a new cache implementation in the \influxdb3\_cache\ crate that supports both immediate loading (when data is already available) and eventual loading (pulling data from object store asynchronously). To help monitor performance, the cache exposes metrics for access patterns (hits, misses, and misses while fetching) as well as cache size in bytes and number of files, allowing users to track cache effectiveness and memory usage.

_influxdb3\_cache/src/parquet\cache · high confidence

The new influxdb3\_types crate centralizes shared type definitions and validation logic for InfluxDB 3. It introduces a DatabaseName type that enforces length (1–511 characters) and character constraints (alphanumeric, slash, underscore, hyphen) to maintain compatibility with InfluxDB v1 naming conventions, including error handling with truncated strings for safe display. It defines a Precision enum for timestamp handling that supports auto-detection of units (seconds, milliseconds, microseconds, nanoseconds) along with short-form aliases (s, ms, us, u, ns, n) and truncation logic for default timestamps. The crate also provides HTTP request/response structures for configuring distinct and last value caches, managing processing engine plugins, and handling hard deletion times, as well as constants for Arrow array size limits and utilities for structured error logging.

_influxdb3\types · high confidence

The \influxdb3\_process\ crate now provides centralized access to core process identity and build information. Users can retrieve the package version (including nightly suffix handling), build-time Git revision hashes, and a unique process lifetime UUID. These utilities support the \/ping\ API and other components that need to report versioning and system stats.

_influxdb3\process/src · high confidence

The \core/catalog\_cache\ crate now provides a strongly-consistent, distributed key-value cache for the catalog service, exposing a local in-memory store, an HTTP API server, a remote client, and a quorum coordinator. The HTTP API supports GET, PUT, and LIST operations with generation-based conditional updates and an ETag mechanism to prevent stale writes. The LIST endpoint uses a new v2 protocol (size-prefixed protobuf) to stream entries efficiently, reducing round-trips when hydrating the cache. The quorum layer coordinates reads and writes across the local cache and two remote replicas, ensuring consistency by validating generations and handling partial failures gracefully. A memory limiter with Not-Recently-Used (NRU) eviction protects against unbounded memory growth, and observers allow external systems to track cache mutations for metrics or secondary indices.

_core/catalog\_cache, core/influxdb\_influxql\_parser, core/jemalloc\stats · high confidence

The \influxdb3\_telemetry\ crate now implements a complete telemetry system that collects and reports usage metrics. It gathers CPU and memory usage every minute, aggregates write and read events (including line counts, byte sizes, and request counts) with per-minute and one-hour summaries, and captures static instance details like OS, version, and storage engine type. The system also reports processing engine trigger counts, plugin trigger invocations, and installed Python packages. Collected data is sent to a configurable telemetry endpoint via a background task, with the payload structure defined in \TelemetryPayload\.

_influxdb3\telemetry · high confidence

The new \influxdb3\_sys\_events\ crate provides a \SysEventStore\ that captures instrumentation events in a type-safe, per-type ring buffer (default capacity 10,000). Events are timestamped via a \TimeProvider\ and can be retrieved as typed vectors or directly as Arrow \RecordBatch\ objects via the \ToRecordBatch\ trait, enabling efficient, clone-free access for system tables. The module includes benchmarks and unit tests validating ring buffer overflow behavior and store operations.

_influxdb3\_sys\events · high confidence

The new \influxdb3\_shutdown\ crate provides a \ShutdownManager\ that coordinates application shutdown by ensuring backend tasks (such as flushing the WAL) complete before the HTTP/gRPC frontend is terminated. Components register via \ShutdownManager::register\ to receive a \ShutdownToken\, allowing them to perform cleanup and signal completion, which prevents data loss or errors during process termination.

_influxdb3\shutdown · high confidence

InfluxDB 3 packages now include native Linux service management, supporting both systemd and SysV init systems. The installation process creates the necessary user/group, installs systemd unit files with hardened security settings (such as restricted namespaces and private tmp), and sets up a systemd generator to handle SELinux-specific configurations. For systems without systemd, SysV init scripts are provided. A cross-platform launcher script handles process execution, daemonization, and SSL certificate configuration for affected RHEL platforms, ensuring consistent behavior across Linux, macOS, and Windows.

.circleci/packages/influxdb3 · high confidence

Users can now use the \influxdb3 show system\ command to list, retrieve, and summarize data from InfluxDB 3 system tables. This new CLI capability includes subcommands for listing available system tables, querying specific system tables with optional limits and field selection, and generating summaries. The command supports standard output formats (excluding Parquet) and integrates with existing TLS configuration options (custom CA certificates and certificate verification toggles) for secure connections.

influxdb3/src/commands/show · high confidence

A new Dockerfile.ci has been added to define the environment for InfluxDB 3 CI tests, based on the Debian Bookworm Rust slim image. This image installs essential build tools (git, clang, lld, protobuf-compiler), system utilities (jq, shellcheck, yamllint), and the Google Cloud CLI. It also installs InfluxDB 2.0.4 OSS for integration testing and sets up cargo-hakari and cargo-deny for dependency management. Additionally, a new entrypoint.sh script is introduced to handle environment variable substitution for command-line arguments before execution.

docker · high confidence

This change introduces a suite of new CircleCI scripts that establish the infrastructure for building, validating, and publishing multi-architecture (amd64/arm64) Docker images and binary packages. The \docker\_build\_release.bash\ script handles the build process with platform-specific arguments, while \publish.bash\ manages pushing multi-arch manifests to Quay. \fetch-python-standalone.bash\ automates the download and verification of Python build-standalone artifacts for various targets, and \validate\ ensures the resulting binaries are correctly linked and portable. Additionally, \install-cargo-deny.bash\ adds a pinned, verified installation of the cargo-deny tool for dependency auditing.

.circleci/scripts · high confidence

This update introduces a suite of new command-line interface commands in the \influxdb3\_commands\ crate. Users can now inspect the internal catalog state using \influxdb3 debug catalog\ (with subcommands to list, view snapshots, and inspect log sequences). Data interaction is expanded with new \query\ and \write\ commands that support SQL and InfluxQL, various output formats (including Parquet), file input, and streaming writes with configurable concurrency and size limits. Additionally, plugin lifecycle management is now accessible via CLI commands to install packages, enable/disable triggers, and test WAL and schedule plugins.

_influxdb3\commands · high confidence

The \influxdb3 create\ command now supports generating last caches and triggers, allowing users to configure caching and event-driven actions directly from the CLI. Additionally, a new \create token\ subcommand enables the generation of admin tokens, including support for named tokens, offline generation to files, and JSON output formatting.

influxdb3/src/commands/create · high confidence

The CLI now includes new subcommands under \influxdb3 create\, \delete\, \show\, and \update\ to manage processing engine triggers, authentication tokens, and system tables. Users can create, delete, and update triggers (including uploading plugin files), manage database and table schemas, and view system information such as plugin files and retention policies via the \show system\ and \show plugins\ commands.

influxdb3/src/commands · high confidence

The \influxdb3\_clap\_blocks\ crate introduces a new set of CLI argument parsers and configuration helpers for InfluxDB 3 Core. Users can now configure DataFusion query execution via \--datafusion-max-parquet-fanout\ and \--datafusion-use-cached-parquet-loader\, and pass arbitrary DataFusion settings with \--datafusion-config\. Disk and memory sizes are now strictly parsed with explicit unit suffixes (e.g., \100mb\, \2gb\) or percentages for memory, rejecting bare numbers to prevent ambiguity. Object store configuration supports S3, GCS, and Azure with explicit credential and endpoint arguments, and the local file store now automatically cleans up intermediate directories. The Processing Engine CLI exposes plugin directory, virtual environment, and concurrency limit options, while the Tokio runtime configuration allows fine-grained control over thread counts, runtime types, and scheduler intervals.

_influxdb3\_clap\blocks · high confidence

This change introduces two new core crates: \core/flightsql\ and \core/iox\_http\. The \core/flightsql\ crate provides the implementation for the Arrow FlightSQL protocol, including command structures (\FlightSQLCommand\, \PreparedStatementHandle\), a planner (\FlightSQLPlanner\) to translate FlightSQL requests into DataFusion logical plans, and metadata handlers for SQL info and XDBC type information. The \core/iox\_http\ crate centralizes HTTP write API logic, defining a \WriteRequestUnifier\ trait that abstracts parsing for both V1 and V2 Write APIs across single-tenant and multi-tenant modes, along with specific implementations for each mode and associated authorization logic.

(repo-wide) · high confidence

The \core/trace\_http\ crate introduces a new Tower-based \TraceLayer\ that instruments HTTP and gRPC requests, extracting distributed trace context from B3 and Jaeger headers and recording RED metrics (request counts, durations, and response sizes). It adds a \Classification\ system that distinguishes server errors from client errors and introduces a dedicated \ResourceExhausted\ category for requests rejected due to capacity limits, ensuring these do not incorrectly inflate server-error SLOs. Additionally, the \core/generated\_types\ crate adds generated protobuf types for Google RPC status codes and error details, providing conversion helpers to \tonic::Status\ to standardize error reporting across the platform.

_core/generated\_types, core/trace\http · high confidence

The \influxdb3\_id\ crate now provides a macro-generated set of strongly-typed identifiers (DbId, TableId, ColumnId, NodeId, etc.) that implement a common CatalogId trait, replacing previous ad-hoc integer usage. To improve performance and consistency, the crate introduces \SerdeVecMap\ and \SerdeVecSet\, which wrap \IndexMap\/\IndexSet\ with a fast \FxHasher\ and serialize as ordered vectors of tuples to preserve insertion order during WAL and disk persistence. This change ensures that catalog data (like database and table names) is serialized in a deterministic, backward-compatible format while offering faster iteration and lookup speeds compared to standard hash maps.

_influxdb3\id · high confidence

The \core/influxdb\_iox\_client\ crate now provides a unified client library for interacting with InfluxDB IOx services. This includes dedicated modules for the catalog, compactor, delete, health, ingester, namespace, query log, reflection, schema, store, table, and write APIs. It also introduces a Flight API client for native SQL/InfluxQL queries with parameterized support, a FlightSQL client for standard SQL operations, and a new \BatchedWriteClient\ that accumulates line protocol writes to reduce network overhead by flushing in configurable batches or intervals.

_core/influxdb\_iox\client, core/trogging · high confidence

The \core/influxdb2\_client\ crate introduces a new Rust SDK for the InfluxDB 2.0 API, providing asynchronous methods to manage buckets, labels, and organizations, perform Flux queries (including suggestions, analysis, and AST retrieval), write line protocol data, and handle server setup and health checks. The library includes generated models for AST nodes and query dialects, along with comprehensive unit tests for all API endpoints.

_core/influxdb2\_client, core/ingester\_query\grpc · high confidence

This change introduces the core InfluxQL query execution engine within the \iox\_query\_influxql\ crate. It adds a new query planner (\frontend/planner.rs\) that translates InfluxQL statements into DataFusion logical and physical plans, enabling users to run InfluxQL queries against the database. Additionally, it implements specific InfluxQL aggregate functions—\MODE\, \PERCENTILE\, and \SPREAD\—as user-defined functions (UDFs) in \aggregate.rs\, allowing these calculations to be used directly in InfluxQL queries.

_core/iox\_query\influxql · high confidence

The write buffer now includes an asynchronous time-based priority queue (\async\_collections::PriorityQueue\) that schedules tasks to execute only when their target time is reached, and a \deleter\ module that uses this queue to manage the hard deletion of databases and tables. This introduces a two-step deletion lifecycle: objects are first marked for deletion, then a background task waits until the configured hard-delete time to notify the object store to remove the data, followed by a grace period before the catalog entry is permanently removed. This ensures that deletion operations are decoupled from the write path and executed reliably in the background.

_influxdb3\write · high confidence

This change introduces several new core libraries: \core/authz\ provides a gRPC-based authorization client (\IoxAuthorizer\) that validates tokens and checks permissions against the \influxdata.iox.authz.v1\ protocol, including instrumentation for latency metrics and HTTP header extraction; \core/client\_util\ offers shared client functionality with a \Connection\ builder for gRPC and HTTP endpoints, namespace translation utilities, and Tower middleware for setting request headers; \core/datafusion\_util\ adds DataFusion configuration helpers for IOx-specific settings (such as parquet pushdown and batch sizing) and expression utilities; and \core/backoff\ implements an exponential backoff mechanism with jitter for retrying transient errors.

(repo-wide) · high confidence

The \influxdb3\_authz\ crate has been ported from the enterprise codebase to the core product, introducing a complete authorization framework. This change adds a new \TokenAuthenticatorAndAuthorizer\ that enforces access control for both user accounts and API tokens, supporting granular permissions for databases, system resources (Health, Metrics, Ping, Ready), and token management. It introduces a role-based permission model with a built-in \Admin\ role and defines specific actions (Read, Write, Create, Delete, Describe) for database and system resources, along with comprehensive unit tests to validate the permission logic.

_influxdb3\authz · high confidence

The \core/data\_types\ crate has been introduced to centralize shared data structures for the system. This includes \ColumnsByName\ and \ColumnSchema\ for managing table column definitions, \NamespaceName\ with strict validation for org/bucket identifiers, and \PartitionKey\/\PartitionTemplate\ for defining and resolving data partitioning schemes (including support for tag-value and bucket-based partitioning with percent-encoding). The crate also defines \SequenceNumberSet\ for efficient tracking of write sequence numbers, \ServiceLimits\ (such as \MaxTables\ and \MaxColumnsPerTable\) to enforce namespace-level constraints, and \HashBuckets\/\MessageList\ for optimized snapshot and catalog cache storage.

_core/data\types · high confidence

This release introduces two new core libraries: \iox\_query\_params\ and \iox\_time\. The \iox\_query\_params\ crate provides a \StatementParams\ collection and utilities for managing InfluxDB bind parameters, including conversions to/from protobuf and JSON, and integration with DataFusion logical plans. The \iox\_time\ crate introduces a \Time\ struct wrapping UTC timestamps with safe arithmetic operations (saturating on overflow) and a \TimeProvider\ trait for abstracting time sources, enabling better testability and consistent time handling across the system.

_core/iox\_query\_params, core/iox\time · high confidence

This change introduces the \oss/core\ library, providing shared infrastructure for InfluxDB 3 Core, Enterprise, and IOx. It adds the \arrow\_util\ crate containing utilities for Arrow data handling, including a mutable \BitSet\, a \StringDictionary\ for efficient string interning, dictionary optimization, and RFC3339 timestamp formatting. The update also establishes the CI pipeline via CircleCI configuration for formatting, linting, auditing, testing, and documentation, alongside standard project files like the Apache 2.0 and MIT licenses.

core · high confidence

The \core/object\_store\_mem\_cache\ crate now includes a new cache system that manages in-memory caching with a background reactor for pruning and garbage collection. Users benefit from an extensible \Hook\ trait that allows intercepting cache events (insert, fetch, evict) to implement features like memory limiting, level-based triggers, and metrics observation. The system also introduces a \Loader\ for deduplicating concurrent data-fetching futures and a \Reactor\ that drives eviction decisions asynchronously, ensuring that cache maintenance does not block user requests.

_core/object\_store\_mem\_cache, core/parquet\_file, core/service\common · high confidence

The \influxdb3\_internal\_api\ crate has been introduced to centralize internal interfaces and resolve circular dependencies. It provides a \QueryExecutor\ trait that implements \SHOW DATABASES\ and \SHOW RETENTION POLICIES\ for the InfluxQL API, with retention policies now reporting a \duration\ field. Additionally, it defines a Service-Level Logging (SLL) system via the \SllSink\ trait and \SystemEvent\ enum, enabling OSS background subsystems (such as WAL flushes, snapshots, and retention cleanup) to emit structured events for enterprise service logging.

_influxdb3\_internal\api · high confidence

This change introduces new internal types and builders to support Data Manipulation Language (DML) operations and efficient serialization of table batches. It adds the \DmlMeta\ and \DmlOperation\ types in \core/dml\ to track metadata and distinguish between write and delete actions. In \core/mutable\_batch\_pb\, new \encode\ and \decode\ modules handle the conversion of \MutableBatch\ data to and from protobuf formats, including specific logic for handling null masks and string packing. Additionally, \core/table\_batch\ introduces a new builder system with \ColumnBuilder\, \DictionaryBuffer\, and \StringBuffer\ to construct column data efficiently, supporting dictionary encoding for tags and packed strings for field values.

_core/dml, core/mutable\_batch\_pb, core/table\batch · high confidence

The \core/metric\ crate introduces a new, lightweight metrics abstraction for IOx, replacing the previous custom shim built on top of OpenTelemetry. This new implementation provides a cleaner API with minimal dependencies, decoupling metric recording from export to allow for easier instrumentation and testing. It supports standard metric types including \U64Counter\, \U64Gauge\, \CumulativeGauge\, \U64Histogram\, and \DurationHistogram\, all managed through a central \Registry\ that handles attribute-based observation reporting.

core/metric · high confidence

The \object\_store\_limit\ crate introduces a \LimitObjectStore\ wrapper that controls the maximum number of concurrent object store operations using an instrumented semaphore. This allows users to prevent resource exhaustion by limiting outstanding requests, while exposing detailed utilization metrics (permits in use, waiters, acquire duration) via \AsyncSemaphoreMetrics\. The implementation includes a \BypassLimit\ extension that allows specific control-plane operations (like lease renewals) to skip the concurrency limit entirely, ensuring they are not starved by data-plane backlogs. Tests verify correct permit accounting, queuing behavior, and the bypass functionality.

_object\_store\limit · high confidence

The \object\_store\_utils\ crate now provides a suite of tools to improve reliability and observability when interacting with object storage. It introduces \AdaptiveGetExt\ and \AdaptivePutExt\ extension traits that automatically switch between single-part and chunked/multipart operations based on object size (thresholds of 128 MiB for reads and 16 MiB for writes), preventing HTTP timeouts on large files while avoiding overhead for small ones. A new \ObservedObjectStore\ wrapper tracks operation outcomes to support a lock-free \/ready\ health check endpoint, classifying errors into categories like AuthFailure, NotFound, and ConfigError. Additionally, \RetryableObjectStore\ adds configurable exponential backoff retries to common operations, and test helpers like \LostResponseStore\ and \VersionKeyedStore\ are available to simulate ambiguous network failures and version-keyed backend behaviors for robust testing.

_object\_store\utils · high confidence

The query engine now includes new DataFusion analyzer rules to support advanced time-series operations. The \HandleGapFill\ rule enables gap-filling semantics for SQL queries using \DATE\_BIN\_GAPFILL()\ and related functions like \LOCF()\, transforming the logical plan to insert a \GapFill\ node that fills missing time intervals. Additionally, the \ExtractSleep\ rule handles the \sleep\ UDF by rewriting it into a \SleepNode\ extension, allowing controlled delays in query execution. These changes are supported by new configuration options in \IoxConfigExt\ for managing query limits and behavior, and are registered via \register\_iox\_analyzers\ in the session context.

_core/iox\query · high confidence

The \influxdb3\_query\_executor\ crate has been introduced to centralize query execution logic. It provides the \QueryExecutorImpl\ which handles both SQL and InfluxQL queries by delegating to the \iox\_query\ execution engine and DataFusion planning. This change includes a dedicated \Planner\ for generating physical execution plans and a \SchemaExec\ operator to manage schema metadata during query execution, effectively separating the query execution responsibilities from the core write buffer and catalog modules.

_influxdb3\_query\executor · high confidence

The \influxdb3\_server\ crate has been replaced with a new implementation that exposes a comprehensive set of HTTP API endpoints (including v1, v2, and v3 write/query paths, processing engine configuration, and plugin management) and adds TLS support for secure connections. This change introduces a new server architecture using Hyper 1, featuring a unified service model, centralized route template definitions for metrics, and a gRPC Flight service interface, effectively establishing the core server foundation for InfluxDB 3 Core.

_influxdb3\server/src · high confidence

The \influxdb3\_startup\ crate now provides core infrastructure for the node boot process. It introduces \early\_logging\ to output consistent, color-coded log messages before the main tracing system is initialized, ensuring operators see startup diagnostics even if the full logger fails. It adds \env\compat\ to handle backwards compatibility by aliasing legacy unprefixed environment variables to the new \INFLUXDB3\\-prefixed names, emitting deprecation warnings when old variables are used. Finally, it implements \phase\ tracking to monitor and report the duration and status of distinct startup stages (such as catalog loading, WAL replay, and listener binding) via a \StartupPhaseObserver\ interface, providing detailed visibility into the boot sequence.

_influxdb3\startup · high confidence

A new \system\ schema is now available in queries, exposing tables such as \queries\, \last\_caches\, \distinct\_caches\, \parquet\_files\, \databases\, \tables\, \nodes\, and \influxdb\_schema\. For internal operations, it also includes \tokens\, \plugin\_files\, \processing\_engine\_triggers\, \processing\_engine\_trigger\_arguments\, and \processing\_engine\_logs\. This allows users to inspect active queries, cache states, storage files, and processing engine details directly via SQL.

_influxdb3\_system\tables · high confidence

This change introduces a new \influxdb3\_system\_tables\_common\ crate that provides shared implementations for several new system tables, alongside a new \influxdb3\_catalog\_macros\ crate to standardize catalog record definitions. Users can now query \system.influxdb\_schema\ to view table and column metadata using InfluxDB terminology (e.g., measurement, tag, field), \system.databases\ to inspect database retention and deletion status, \system.distinct\_caches\ and \system.last\_caches\ to monitor cache configurations, \system.generation\_durations\ to track compaction generation stats, and \system.nodes\ to view cluster node health and state. The \influxdb3\_catalog\_macros\ crate supports this by providing a \\#\[catalog\_record\]\ procedural macro that enforces strict type allowlists and field-shape fingerprints for catalog records, ensuring on-disk compatibility.

_influxdb3\_catalog\_macros, influxdb3\_system\_tables\common · high confidence

The v1 query API has been implemented with a new handler and error model. The \V1HttpHandler\ now processes \/query\ and \/ping\ endpoints, supporting InfluxQL queries with optional \SHOW DATABASES\ and \SHOW RETENTION POLICIES\ capabilities. Query results are streamed in CSV, JSON (compact and pretty), and MessagePack formats, with support for both buffered and chunked response modes. The new error handling distinguishes between client errors (e.g., missing parameters, invalid MIME types) and server errors, mapping them to appropriate HTTP status codes.

_core/iox\_v1\_query\api · high confidence

The processing engine now manages isolated Python virtual environments for plugins, allowing triggers to declare and install external Python dependencies automatically. Administrators can enable or disable this package installation capability via a \--package-manager\ flag, and the system includes safeguards such as path traversal validation for plugin files and proper virtual environment initialization across platforms.

_influxdb3\_processing\engine · high confidence

The \cli\_types\ crate now provides shared constants and logic for the \--max-concurrent-queries\ CLI flag, used by both OSS and Enterprise \influxdb3\ binaries. It defines a maximum limit of \tokio::sync::Semaphore::MAX\_PERMITS\, an advisory minimum of 16, and a default calculation that uses a floor of 50 queries or 4 queries per core of effective parallelism (whichever is higher). The \resolve\_max\_concurrent\_queries\ function allows operators to override this default, while the \MaxConcurrentQueries\ type validates input to ensure it is a positive integer within the allowed range.

_cli\types · high confidence

A new \influxdb3\_cache\ crate has been created to centralize cache implementations, specifically exposing modules for distinct value caching, last-value caching, and Parquet caching. This refactoring consolidates previously scattered cache logic into a single library, accompanied by test helpers to facilitate validation of write operations and catalog interactions within this new structure.

_influxdb3\cache/src · high confidence

The build system has been updated to automatically embed the current Git commit hash (full and short formats) into the binary at compile time. This allows the application to expose precise version and revision information, such as via the \/ping\ API, ensuring that users can identify the exact code version running. The build script checks for environment variables \GIT\_HASH\ and \GIT\_HASH\_SHORT\ first, falling back to \git rev-parse\ if they are not provided.

_influxdb3\process · high confidence

The CI package build system now targets the 'influxdb3-core' product name (renamed from 'influxdb3') and defines a strict versioning schema for v3.0.0 releases, including pre-release qualifiers (alpha, beta, rc) and package build numbers. The Linux packages (DEB/RPM) are configured to recommend the 'influxdata-archive-keyring' and conflict with 'influxdb3-enterprise'. A new launcher test suite validates configuration parsing and executable checks, while a sandbox verification plugin is included to test systemd security controls.

.circleci/packages · high confidence

The \influxdb3\_wal\ crate has been restructured into a new, modular architecture that separates WAL concerns into distinct components: \create\ for test helpers, \object\_store\ for the core WAL implementation and replay logic, \serialize\ for file format handling (including CRC32 integrity checks and durable corruption detection), \observer\ for catalog-snapshot event tracking, and \snapshot\_tracker\ for managing when WAL files are snapshotted. This change introduces a new \Wal\ trait with methods like \write\_ops\_unconfirmed\ and \flush\_buffer\, a \WalConfig\ struct with configurable parameters such as \gen1\_duration\ and \wal\_replay\_concurrency\_limit\, and a \WalObjectStore\ implementation that handles concurrent file loading and sequential replay. The serialization module now enforces file type identifiers and CRC32 checksums, distinguishing between durable corruption (e.g., truncated files, CRC mismatches) and transient errors (e.g., bitcode deserialization failures). Additionally, the snapshot tracker now supports age-based forced snapshots via \oldest\_period\_added\_at\ and handles future data scenarios by forcing snapshots when WAL periods exceed three times the snapshot size.

_influxdb3\wal · high confidence

The \influxdb3 serve\ command now includes a new \cli\params\ module that captures user-provided CLI arguments for logging or telemetry while automatically redacting sensitive values (such as AWS keys, TLS certificates, and passwords) and masking them as '\\\\\\\'. Additionally, a new \jemalloc\ module exposes jemalloc memory statistics (active, allocated, metadata, mapped, resident, retained) as a \jemalloc\_memstats\_bytes\ gauge metric. To ensure backward compatibility with pre-3.11 configurations, the serve command now accepts legacy size-option spellings (e.g., \--parquet-mem-cache-size\, \--exec-mem-pool-bytes\) with bare-number values interpreted as megabytes, while the new strict spellings (e.g., \--file-cache-size\) require explicit units; the system also preserves the inert \--hard-delete-default-duration\ flag to avoid breaking third-party reseller configurations.

influxdb3/src/commands/serve · high confidence

The server now uses a new \UnifiedService\ to route incoming requests to either the HTTP API or the gRPC service based on the request type. This change consolidates request processing, allowing both HTTP and gRPC endpoints to share the same underlying service infrastructure. Additionally, a \RemoteAddrLayer\ middleware is introduced to inject the client's remote address into request extensions, making it available for downstream processing.

_influxdb3\_server/src/unified\service · high confidence

The internal snapshot format for the last cache catalog has been updated to include new metadata fields. Database and table entries now explicitly track a \retention\_period\ (e.g., 7 days for the default internal database) and support hard deletion via \deleted\ and \hard\_delete\_time\ fields. This reflects the underlying schema changes that allow for configurable data retention and permanent removal of databases and tables, ensuring the cached catalog state accurately mirrors these lifecycle management capabilities.

_influxdb3\_cache/src/last\cache/snapshots · high confidence

Added CLI snapshot tests for system schema tables and distinct cache operations; Added integration tests for write buffer deduplication; Added server snapshot tests for CLI, query, and write operations; Added snapshot tests for write buffer deduplication plans; Added test fixtures for file-based input validation; Expanded CLI integration test coverage; Expanded server test coverage for authentication, concurrency limits, and system tables; New test helpers for mocking and tracking object store operations.

This release includes routine updates to 2786 commits affecting 95 dependency manifests. The changes primarily consist of minor version bumps for various Rust crates, including serde, sqlx, clap, tokio, and datafusion, as well as updates to build tools and test dependencies. These updates ensure the project uses the latest stable versions of its dependencies without introducing new features or behavioral changes for end users.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 44 → 64 (+19.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 98 → 88 (-10.5)
• Architecture 69 → 98 (+29.0)
• Maturity 58 → 65 (+6.9)
• Readiness 25 → 67 (+41.6)
• Security 56 → 54 (-1.5)
• Domain Modelling 87 (new)
• Event Sourcing 100 (new)

• Dimension evaluation failed
• Duplicated block (15 lines × 2) (.circleci/packages/test_influxdb3-launcher.py)
• Duplicated block (6 lines × 2) (.circleci/packages/test_influxdb3-launcher.py)
• LLM evaluation failed
• Low IaC: DS-0026 (docker/Dockerfile.ci)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No artifact signing
• No automated tests
• No exposed public API
• No tests found
• Secret: aws-access-token (core/test_fixtures/cpu.parquet)
• Secret: aws-access-token (core/test_fixtures/no-timezone.parquet)
• Secret: aws-access-token (core/test_fixtures/no-timezone.parquet)
• Test reliability not included

• Args::parse (cognitive 17) (influxdb3_catalog_macros/src/lib.rs)
• Boundary-crossing change coupling: create.rs ↔ manager.rs (influxdb3/src/commands/create.rs)
• Boundary-crossing change coupling: lib.rs ↔ lib.rs (influxdb3_query_executor/src/lib.rs)
• Boundary-crossing change coupling: lib.rs ↔ mod.rs (influxdb3_query_executor/src/lib.rs)
• Boundary-crossing change coupling: serialize.rs ↔ http.rs (influxdb3_catalog/src/serialize.rs)
• Boundary-crossing change coupling: serve.rs ↔ sender.rs (influxdb3/src/commands/serve.rs)
• Boundary-crossing change coupling: serve.rs ↔ snapshot_tracker.rs (influxdb3/src/commands/serve.rs)
• Boundary-crossing change coupling: snapshot_tracker.rs ↔ mod.rs (influxdb3_wal/src/snapshot_tracker.rs)
• Boundary-crossing change coupling: snapshot_tracker.rs ↔ queryable_buffer.rs (influxdb3_wal/src/snapshot_tracker.rs)
• BufferedInput::need_more (cognitive 28) (core/iox_query/src/exec/gapfill/buffered_input.rs)
• BufferedResponseStream::poll_next_unpin (cognitive 24) (core/iox_v1_query_api/src/response/buffered.rs)
• CODEOWNERS assigns no owner to any path
• Catalog::background_update (cognitive 20) (influxdb3_catalog/src/catalog/versions/v2/enterprise.rs)
• Catalog::list_hard_deleted_dbs_tables (cognitive 21) (influxdb3_catalog/src/catalog/versions/v2.rs)
• Catalog::list_hard_deleted_dbs_tables (cognitive 21) (influxdb3_catalog/src/catalog/versions/v3/catalog.rs)
• Catalog::update_to_sequence_number (cognitive 17) (influxdb3_catalog/src/catalog/versions/v3/catalog.rs)
• CatalogCache::insert (cognitive 16) (core/catalog_cache/src/local/mod.rs)
• CatalogMetrics::operation_observer (cognitive 30) (influxdb3_catalog/src/catalog/versions/v2/metrics.rs)
• CatalogRequestFuture::call (cognitive 34) (core/catalog_cache/src/api/server.rs)
• Change coupling: catalog.rs ↔ serialize.rs (influxdb3_catalog/src/catalog.rs)
• …and 796 more

• 3 commits — 3 feature/other, 0 fixes

• (root) — 2 commits
• influxdb3_catalog/src — 1 commit

• change: chore(install_influxdb): update to 3.11.1 for default version installed (#27584)
• change: chore(sync): influxdb_pro 2026-09-18 (#27642)
• change: chore: remove install_influxdb.sh, now maintained in influxdb-install (#27586)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

influxdata/influxdb was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.