influxdata/influxdb
 Watch   
 Star   
 Fork   
17 days ago
influxdb

v3.11.8 | 10-29-26

The following are some highlighted updates with the newest release for InfluxDB 3. Learn more via our full Release Notes.

Updates

Core

Features

  • Processing engine Python updated to 3.13.18: Picks up the security fixes released since 3.13.15.

Bug fixes

  • Queries that exceed memory limits returned 500: The HTTP query endpoints now map DataFusion memory-pool exhaustion to 429 Too Many Requests instead of 500. If the error occurs during query execution, pretty and parquet output return 429. For CSV, JSON, and JSON Lines output, execution errors still end the HTTP 200 response early, even before the first rows. Some Core queries still return 500, such as a query on a table that runs out of memory while deduplicating data. Enterprise already mapped resource-exhaustion errors to 429.
  • Catalog deadlock when checking a deleted table: Checking whether a table is deleted now takes the catalog lock once. Previously, a catalog change that arrived between its two reads could deadlock the catalog.
  • WAL plugins received values under the wrong column names: Rows passed to a WAL trigger's plugin now use the column names of their own record batch. Previously, when a flush held batches with the same columns in a different order, later batches used the first batch's column names.
  • Other bug fixes and performance improvements

Enterprise

All Core updates are included in Enterprise. Additional Enterprise-specific updates:

Features

  • Faster file index loading (Parquet engine): Loading a table's file index, including during a storage engine upgrade, now sorts each posting list once. Previously, every generation re-sorted each list it touched, so a table with many generations loaded slowly and used more memory.
  • Faster reads of compaction metadata (Parquet engine): Compaction and snapshot metadata files are now parsed in one pass, including during a storage engine upgrade. Previously, each was parsed twice.
  • Table index cache starts once the server is ready (Parquet engine): On ingest nodes, the table index cache now starts its background work when the server reports ready, instead of at the beginning of startup.

Bug fixes

  • Storage engine upgrade completed with unconverted Parquet files: If a Parquet file fails every conversion attempt, the ingest node now reports failed in system.upgrade_parquet_node. The last_message column identifies the file and its error. The cluster upgrade also fails. To resume the upgrade, follow the retry procedure. Previously, the node dropped the file and reported its upgrade as complete.
  • Storage engine upgrade stalled after an ingest node was removed: The upgrade now drops a removed ingest node from its roster once its Parquet files are converted or absorbed. Previously, a removed ingest node held the cluster at upgrading forever.
  • Overwrites lost after a query node restart (upgraded storage engine): After a restart, a query node now reads gen0 files in the order they were written, so the latest write to a series and timestamp wins. Previously, a query could return the value from before an overwrite until compaction.
  • Nodes stopped applying compaction updates after falling behind (Parquet engine): A node that refreshes its view of compacted data no longer reads the detail of each generation the compaction removed. Previously, a node more than --compaction-cleanup-wait behind the compactor failed every refresh with generation detail not found until it restarted.
  • Retention stopped after Gen1 file cleanup deleted a snapshot (Parquet engine): The table index cache now skips a snapshot that Gen1 file cleanup already deleted. Previously, the missing snapshot failed the cache initialization, and retention didn't run until the next restart.
  • Restarted node listed as stopped by its previous process: A process that is shutting down no longer marks its node stopped once another process has registered under the same --node-id. Previously, a slow shutdown could mark the running replacement as stopped, and on the upgraded storage engine query nodes stopped following its WAL.
  • Other bug fixes and performance improvements
17 days ago
influxdb

v1.13.2

Please see https://docs.influxdata.com/influxdb/v1/about_the_project/release-notes/#v1132 for official release notes.

Bug fixes

Maintenance

OSS BINARY FILES SHA256
influxdb-1.13.2_linux_amd64.tar.gz 4b1254ebcef8361baab2e0e4313e7e2821d56bea34bc0d5a63c0c2312cdd41c1
influxdb-1.13.2_linux_arm64.tar.gz 5f334b94cb02c20a063698f25155171013f61f9c6c7deb07e83b825247413f69
influxdb-1.13.2_darwin_amd64.tar.gz f54909cb3f3960f49023309b30bf91a5bdd4ce7f037dbeff7a3363d71da19e5d
influxdb-1.13.2-windows_amd64.zip 5e61905d8a50d1775ae329183a1c2b4f798abd6328b812a7bf27870ae2fe87bb
OSS UBUNTU AND DEBIAN PACKAGE FILES SHA256
influxdb_1.13.2-1_amd64.deb c072144aa2aed112c0ae46a099b9e3677ac5d0c8b17abba8699d3bad5b3d603e
influxdb_1.13.2-1_arm64.deb d25674a563084400f34761945e810b2aa4f3ed8dd586a264705257dc0e950b31
OSS REDHAT & CENTOS PACKAGE FILES SHA256
influxdb-1.13.2.aarch64.rpm c69b796e2c8f6ef6b1df7e5de99a5abe797b2903875b229b7c534e129e1a946d
influxdb-1.13.2.x86_64.rpm 8241f6c01459648467caca61353487400fc5ec9e472b4f677955245fb2639445
17 days ago
influxdb

v3.12.2 | 10-29-26

The following are some highlighted updates with the newest release for InfluxDB 3. Learn more via our full Release Notes.

Updates

Core

Features

  • influxdb3 debug catalog repair: This offline command, added in v3.11.6, is now also available on 3.12.2. It repairs a catalog that fails to load because of a duplicate table name or a reused table or database ID. Stop every node before you run it with --execute.
  • Processing engine Python updated to 3.13.18: Picks up the security fixes released since 3.13.15.

Bug fixes

  • Queries that exceed memory limits returned 500: The HTTP query endpoints now return 429 Too Many Requests when a query exhausts the DataFusion memory pool. Previously, they returned 500. For CSV, JSON, and JSON Lines output, this applies when the query fails before it returns any rows. An error after the first rows still ends the HTTP 200 response early. Some Core queries still return 500, such as a query on a table that runs out of memory while deduplicating data. Enterprise already mapped resource-exhaustion errors to 429.
  • Catalog deadlock when checking a deleted table: Checking whether a table is deleted now takes the catalog lock once. Previously, a catalog change that arrived between its two reads could deadlock the catalog.
  • WAL plugins received values under the wrong column names: Rows passed to a WAL trigger's plugin now use the column names of their own record batch. Previously, when a flush held batches with the same columns in a different order, later batches used the first batch's column names.
  • Other bug fixes and performance improvements

Enterprise

All Core updates are included in Enterprise. Additional Enterprise-specific updates:

Features

  • Faster file index loading (Parquet engine): Loading a table's file index, including during a storage engine upgrade, now sorts each posting list once. Previously, every generation re-sorted each list it touched, so a table with many generations loaded slowly and used more memory.
  • Faster reads of compaction metadata (Parquet engine): Compaction and snapshot metadata files are now parsed in one pass, including during a storage engine upgrade. Previously, each was parsed twice.
  • Table index cache starts once the server is ready (Parquet engine): On ingest nodes, the table index cache now starts its background work when the server reports ready, instead of at the beginning of startup.
  • Fewer file downloads per query (upgraded storage engine): A query now downloads only the run set files whose key range covers the queried field family. Previously, it also downloaded files that held only the table's other field families.
  • Faster merging of overlapping files (upgraded storage engine): When a query merges rows from several files, each output column is now built in one vectorized step instead of row by row.

Bug fixes

  • Storage engine upgrade completed with unconverted Parquet files: If a Parquet file fails every conversion attempt, the ingest node now reports failed in system.upgrade_parquet_node. The last_message column identifies the file and its error. The cluster upgrade also fails. To resume the upgrade, follow the retry procedure. Previously, the node dropped the file and reported its upgrade as complete.
  • Storage engine upgrade stalled after an ingest node was removed: The upgrade now drops a removed ingest node from its roster once its Parquet files are converted or absorbed. Previously, a removed ingest node held the cluster at upgrading forever.
  • Overwrites lost after a query node restart (upgraded storage engine): After a restart, a query node now reads gen0 files in the order they were written, so the latest write to a series and timestamp wins. Previously, a query could return the value from before an overwrite until compaction.
  • Query node could miss writes from a stopping ingest node (upgraded storage engine): A query node now keeps following an ingest node that is stopping and fetches its remaining WAL files after it acknowledges the stop. Previously, the query node could stop fetching before the node flushed its last writes.
  • Trailing WAL fetch could hang after an ingest node stopped (upgraded storage engine): A query node's fetch of a stopped ingest node's remaining WAL files now completes. Previously, it could wait forever on files its workers had already fetched.
  • Nodes stopped applying compaction updates after falling behind (Parquet engine): A node that refreshes its view of compacted data no longer reads the detail of each generation the compaction removed. Previously, a node more than --compaction-cleanup-wait behind the compactor failed every refresh with generation detail not found until it restarted.
  • Retention stopped after Gen1 file cleanup deleted a snapshot (Parquet engine): The table index cache now skips a snapshot that Gen1 file cleanup already deleted. Previously, the missing snapshot failed the cache initialization, and retention didn't run until the next restart.
  • Restarted node listed as stopped by its previous process: A process that is shutting down no longer marks its node stopped once another process has registered under the same --node-id. Previously, a slow shutdown could mark the running replacement as stopped, and on the upgraded storage engine query nodes stopped following its WAL.
  • Schema changes lost when upgrading a Core node to Enterprise: Upgrading from Core now promotes the node's live catalog. Previously, if the Core node had first run a release before 3.10, the upgrade promoted a stale catalog checkpoint, so schema changes made since then were missing.
  • Other bug fixes and performance improvements
2026-10-15 00:00:41
influxdb

v3.12.1 | 10-14-26

The following are some highlighted updates with the newest release for InfluxDB 3. Learn more via our full Release Notes.

Updates

Core

Features

  • Faster startup after large file removals: At startup, the files that snapshots and checkpoints mark as removed are now dropped from each table's file list in one pass. Previously, every removed file scanned the table's whole file list, so startup slowed sharply after many files were removed from a large table.

Bug fixes

  • Catalog failed to load after upgrading to v3.12.0: The server now loads a catalog in which a table has more than one field family with the same automatically generated name. Core releases before v3.10.0 and Enterprise releases before v3.9.0 could write such names when fields were added to an existing table. v3.12.0 rejected them, so a node with an affected catalog failed to start.
  • Acknowledged writes lost after a forced snapshot and a restart: WAL flushes now run one at a time. Previously, a forced Parquet snapshot, triggered by write buffer memory or --force-snapshot-max-age, could run while an earlier WAL file was still being written, and recorded that file as covered before its rows reached the buffer. If the node restarted before the next snapshot, it skipped that file and the acknowledged writes in it were lost.
  • Overwrites lost across snapshots: When two Parquet files hold the same time window because it was persisted across two snapshots, a point in the later file now wins over a point with the same series and timestamp in the earlier file. Previously, the earlier file could win, so a query returned the value from before the overwrite.
  • Failed streaming queries returned 200: A query in CSV, JSON, or JSON Lines format that fails before it returns any rows, such as a sort that exceeds the memory limit, now returns the error status and message. Previously, the server sent 200 and then dropped the connection, so clients saw an empty body and a transport error. An error after the first rows still ends the response early.
  • Writes near the maximum timestamp: A line with a timestamp later than 2262-04-11T23:39:59.999999999Z is now rejected with a 400 error. Previously, a timestamp that close to the maximum could panic the WAL flush when the server forced a snapshot.
  • system.parquet_files listed files under the wrong tables: A query on system.parquet_files without a table_name filter now lists only the tables in the current database. Previously, it could list the current database's files under the names of tables in other databases that had the same table ID.
  • Other bug fixes and performance improvements

Enterprise

All Core updates are included in Enterprise. Additional Enterprise-specific updates:

Features

  • Larger bulk import batches (upgraded storage engine): The new --compactor-import-batch-size option sets the largest batch of staged data that one bulk import merge reads at once. The default is 4gb and is configurable up to one quarter of --compactor-input-size-budget.
  • Faster ingest node startup with many snapshots (upgraded storage engine): An ingest node no longer reads every snapshot manifest in object storage at startup. Previously, it read them all, so startup time grew with the number of manifests. The first start on v3.12.1 still reads every manifest once. system.pt_ingest_files now lists the files from the newest manifest plus the snapshots taken since the node started.
  • Faster compaction I/O (Parquet engine): The compactor now uploads a finished output file while it encodes the next one, and checks up to 8 input files at a time. Previously, it did both one file at a time.
  • WAL flush wait metric (Parquet engine): The new influxdb3_parquet_wal_flush_lock_wait_seconds histogram reports how long a WAL flush waited for an earlier flush to finish. The kind label is timed for the regular flush interval and forced for a flush that forces a snapshot.

Bug fixes

  • Missing rows after changing a table's file index columns (Parquet engine): The file index now records which columns each compacted generation indexed. A query that filters on a column that only some generations indexed scans the other generations instead of skipping them. Previously, after you added or removed file index columns, such a query could return incomplete results from compacted data.
  • Overwrites reverted to the older value (upgraded storage engine): When the ingest buffer merges new writes into data it already merged for the same time window, a later write now wins over an earlier write to the same series and timestamp. Previously, the earlier value could replace the later one.
  • Storage engine upgrade failed with more than one compact node: During an upgrade to the upgraded storage engine, only the compact node that holds the compactor lease now drives the upgrade. Previously, every compact node drove it at the same time, their progress updates conflicted, and the upgrade could be marked as failed.
  • Compactor replanned forever against a missing data file (upgraded storage engine): A run set whose data file is confirmed gone from object storage is now skipped after three failed compaction attempts, so planning moves on to other work. Previously, the compactor planned the same compaction on every pass, and it failed every time. Skipped run sets are counted in influxdb3_compactor_skipped_run_sets with reason="auto_data_file_not_found". Compactions of new snapshots and imports aren't covered.
  • Bulk import could stall object storage requests (upgraded storage engine): The server no longer leaves object storage requests unfinished while it checks the status of uploaded imports. Previously, during a credential refresh, one of those requests could hold the object store client's credential lock and never release it, so every other request on the node waited behind it: the server stayed up but stopped reading from and writing to object storage.
  • Nodes without query mode built an unused file index (Parquet engine): Only nodes that run in query mode, including all, now load the compacted data file index at startup. Previously, compact and process nodes also loaded it, which used startup time and memory for an index they never read. A node that skips the index logs compacted-data file index not loaded.
  • Ingest node refused to restart after an unclean stop (Parquet engine): An ingest node that stopped without a clean shutdown now starts again. Previously, if a snapshot covered all of its WAL or a forced snapshot ran during startup, the node could fail every start with an error that it was still running in another process, though no other process existed.
  • Other bug fixes and performance improvements
2026-10-14 22:58:20
influxdb

v3.11.7 | 10-14-26

The following are some highlighted updates with the newest release for InfluxDB 3. Learn more via our full Release Notes.

Updates

Core

Bug fixes

  • Catalog failed to load after upgrading to v3.11.6: The server now loads a catalog in which a table has more than one field family with the same automatically generated name. Core releases before v3.10.0 and Enterprise releases before v3.9.0 could write such names when fields were added to an existing table. v3.11.6 rejected them, so a node with an affected catalog failed to start.
  • Acknowledged writes lost after a forced snapshot and a restart: WAL flushes now run one at a time. Previously, a forced Parquet snapshot, triggered by write buffer memory or --force-snapshot-max-age, could run while an earlier WAL file was still being written, and recorded that file as covered before its rows reached the buffer. If the node restarted before the next snapshot, it skipped that file and the acknowledged writes in it were lost.
  • Other bug fixes and performance improvements

Enterprise

All Core updates are included in Enterprise. Additional Enterprise-specific updates:

Features

  • WAL flush wait metric (Parquet engine): The new influxdb3_parquet_wal_flush_lock_wait_seconds histogram reports how long a WAL flush waited for an earlier flush to finish. The kind label is timed for the regular flush interval and forced for a flush that forces a snapshot.

Bug fixes

  • Two processes with the same --node-id (upgraded storage engine): When two ingest-capable processes run with the same --node-id, the one that loses a snapshot write now logs another process is writing under this node id and exits, so only one writer survives.
  • Ingest node refused to restart after an unclean stop (Parquet engine): An ingest node that stopped without a clean shutdown now starts again. Previously, if a snapshot covered all of its WAL or a forced snapshot ran during startup, the node could fail every start with an error that it was still running in another process, though no other process existed.
2026-10-01 17:52:47
influxdb

v3.12.0 | 10-01-26

The following are some highlighted updates with the newest release for InfluxDB 3. Learn more via our full Release Notes.

Updates

InfluxDB 3.12 makes bulk import faster and adds distributed compaction (beta), per-database schema enforcement, and generally available user authentication and role-based access control to InfluxDB 3 Enterprise. Before you upgrade, review Upgrade InfluxDB.

[!Important]

Back up your catalog before you upgrade

InfluxDB 3.12 adds a catalog record that v3.11.x can't read. After the upgrade, you can't roll back to v3.11.x unless you have a catalog backup.

The catalog records the new feature level automatically. On a single node, this happens the first time you start v3.12. In a cluster, it happens once every running node runs v3.12. It happens whether or not you use the new features. This applies to Core and Enterprise.

After that, v3.11.x refuses to load the catalog and returns an error like the following:

this node's feature level (core=<N>, enterprise=<N>) is below the cluster's committed level (core=<N>, enterprise=<N>); upgrade required

Before you upgrade:

  1. Back up everything under {prefix}/catalog/, including the catalog snapshot and logs under catalog/v3/.
  2. Keep the backup until you're sure you won't roll back.

To roll back to v3.11.x, restore the backup. For details, see Before you upgrade.

Core

Features

  • Add columns to an existing table: influxdb3 update table now takes --tags (tag names) and --fields (name:type), and the new PATCH /api/v3/configure/table endpoint does the same over HTTP. You can only add columns. Adding a column that already exists with the same type does nothing, and a different type returns an error.
  • Trigger defaults in the create trigger API: trigger_settings and disabled are now optional when you create a trigger through POST /api/v3/configure/processing_engine_trigger. They default to run_async=false, error_behavior=log, and disabled=false. Previously, a request that omitted either field returned 400.
  • Regular expressions as IN lists: More anchored regular expressions, such as ^host-(01|02)$ or ^val[1-4]$, are now rewritten as an IN list (or NOT IN for !~), up to 1,000 values, in SQL and InfluxQL.
  • Narrower InfluxQL scans with LIMIT, OFFSET, and fill(N): These queries now read only the columns they reference. Previously, they read every column in the table, so queries on wide tables were slower than the same query without these clauses.
  • Faster startup with many tables: Replaying the catalog no longer copies a database's whole schema for every table it creates or alters, so startup time no longer grows quadratically with the number of tables in a database.
  • Faster startup with many snapshots: Snapshot manifests are parsed in parallel at startup, on up to half of the available cores. On Enterprise, this applies to the Parquet engine.

Bug fixes

  • InfluxQL SPREAD with negative values: SPREAD now returns the difference between the maximum and minimum when every value is negative. Previously, it returned the negated minimum.
  • Packaged service failed to start on SELinux hosts: On RHEL-family hosts with SELinux enforcing, the systemd unit from the .deb and .rpm packages exited with status 226. No configuration change is needed.
  • One query on a large Parquet file could run a node out of memory: A query now fetches each Parquet file once per scan. Previously, every partition of the scan fetched and buffered its own copy of the whole file, so one query against a 4.4 GB file could use about 70 GB. To restore the old behavior, set --datafusion-config iox.share_cached_parquet_loader_fetches:false.
  • Repeated downloads under Parquet cache pressure: The Parquet cache no longer evicts files that are still downloading, and no longer starts a second download of a file that is already being fetched. Previously, a cache under sustained pressure could download the same file over and over.
  • Other bug fixes and performance improvements

Breaking changes

  • Finite default for --max-concurrent-queries: The --max-concurrent-queries default is now the larger of 50 and 4 times the node's query parallelism. Previously, the default was effectively unlimited. Queries over the limit wait for a slot instead of failing. An explicit value below 16, or below the node's query parallelism, logs a startup warning.
  • WAL buffer limit enforced: --wal-max-buffered-writes (default 100000) was never enforced. When the WAL buffer is full, writes now return 429 Too Many Requests, so retry them after a short delay. On Enterprise, this applies to the Parquet engine.
  • HTTP and gRPC request metrics split by protocol: http_requests* metrics now count only HTTP requests, and grpc_requests* metrics count only gRPC requests. Previously, both counted every request, so dashboards that sum the two families will show lower values. The path and method_path labels now use route templates, such as /api/v3/engine/:path. Unrecognized paths are reported as other. Panels that filter on a literal path that includes an ID return no data.
  • DataFusion 52.5: The query engine is upgraded from DataFusion 51.0 to 52.5. pow() and power() with integer arguments now return a float.
  • New system table columns: system.databases adds a schema_mode column at the end. system.nodes adds conn_info, and system.tables adds retention_period_ns, both before existing columns, so the column order of SELECT * on those tables changes.

Enterprise

All Core updates are included in Enterprise. Additional Enterprise-specific updates:

Features

  • Distributed compaction (beta, upgraded storage engine): Compaction jobs can now run on every compact node in the cluster, not only on the node that holds the compactor lease. Set --compactor-dispatch-target to the same value on every compact node:

    • local (default): The lease holder runs all compaction, as in v3.11.
    • all: The lease holder and every other compact node run compaction.
    • remote: Only the other compact nodes run compaction. With no other compact node available, compaction waits.

    A compact node receives work only if it sets --internode-bind-addr. Use compact nodes of the same size. The lease holder plans for the smallest --compactor-input-size-budget and --compactor-max-concurrent-merges among them. If a node fails, its jobs are retried on another node. New influxdb3_compactor_* metrics report worker connections, dispatch activity, and which node holds the lease (influxdb3_compactor_is_primary).

  • Processing Engine on dedicated process nodes: Process nodes (--mode process or --mode all) now run triggers for the whole cluster:

    • Every process node follows the WAL of every ingest node through object storage, so WAL triggers fire on a process node for writes sent to any ingest node. Previously, a WAL trigger fired only on the node that received the write. A new process node starts from the present and doesn't fire on existing WAL.
    • The trigger's --node-spec now selects which process nodes' schedulers own the trigger. Each owning scheduler spreads runs across itself and the other running process nodes that set --internode-bind-addr. A node that doesn't have the plugin file in its --plugin-dir declines the run, and another node runs it. Keep plugin directories and Python packages the same on every process node.
    • Each process node saves its scheduler state to object storage every second and at shutdown. After a restart, it replays schedule ticks that came due while it was down, resumes following the WAL where it stopped, and keeps pending retries. Make sure your plugins handle a repeated run. Triggers that were disabled or deleted while the node was down stay that way.
    • New options: --trigger-retry-max-attempts (default 5) sets the attempts before a failing invocation is discarded when the trigger uses --error-behavior retry, --trigger-work-silence-timeout (default 60s) sets how long a scheduler waits on a silent node before giving up the run, and --processing-engine-restart-state-snapshot-interval (default 1s) sets how often scheduler state is saved.
  • Schema enforcement: Create a database with influxdb3 create database --schema-mode explicit (or "schema_mode": "explicit" in the API) to reject writes to tables and columns you haven't declared. Declare tables with influxdb3 create table and add columns with influxdb3 update table --tags --fields. Every write path enforces it, including the Processing Engine and bulk import, on both storage engines. The default, implicit, keeps schema-on-write. You can't change a database's schema mode after you create it. After you add columns through one node, other nodes can reject writes to them until their next catalog sync (--catalog-sync-interval, default 1s). Core rejects --schema-mode explicit with a 400 error.

  • Bulk import from object storage (upgraded storage engine): influxdb3 import from-object-store (and POST /api/v3/enterprise/import) imports Parquet files that are already in object storage, without streaming them through the client. The source is a prefix in the cluster's own object store or an s3://bucket/prefix URL. The server reads the source with its own object store credentials and tries an S3 server-side copy first (--import-attempt-server-side-copy, default true), falling back to streaming.

  • Faster bulk import uploads (upgraded storage engine): Uploaded files are converted into slices of up to 128 MiB that compaction processes in parallel, so large imports use more of the compactor's cores.

  • Database-scoped import permissions: Creating an import now requires write permission on the target database instead of an admin token. Listing imports requires the describe action on at least one database and returns only the import jobs for databases the token can describe. For example, grant db:<DATABASE_NAME>:describe,write for an import job.

  • Write timestamp bounds (upgraded storage engine): The new --write-timestamp-max-past and --write-timestamp-max-future options reject lines whose explicit timestamp is further from the request time than the given duration. Lines without a timestamp are accepted. Both are off unless set, apply to every database, and are read by each ingest node, so set the same values on every ingest node. Rejections are counted in influxdb3_write_timestamp_rejections_total.

  • Faster ORDER BY time ... LIMIT queries (upgraded storage engine): SQL queries sorted by time with a LIMIT now read time windows in sort order and stop once they have enough rows. Previously, they scanned and sorted every window in the queried time range.

  • User authentication and role-based access control (GA): Username and password sign-in, single sign-on (OAuth), and role-based access control are now generally available. They remain opt-in: --user-auth-type defaults to none, and custom role authoring stays off (--rbac-authoring-disabled defaults to true). Existing token workflows are unchanged. See Manage users.

  • Integrated Explorer 1.11: The Explorer UI embedded in influxdb3 serve --mode ...,webui is updated to 1.11.

    • Explorer connects to its own cluster automatically, with no URL or token to enter: at once with --without-auth, or after you sign in when user authentication is on. With token authentication alone, Explorer still asks for a URL and token.
    • With user authentication on and no users yet, Explorer opens a setup page that creates the first administrator and shows the operator token once. With OAuth sign-in only, the page shows the influxdb3 manage init-admin --oauth-id command to run instead.
    • The new --webui-public-uri option sets the public URL for single sign-on. Register <PUBLIC_URI>/auth/callback as the redirect URI with your identity provider.
    • Sessions are stored on the server and last 120 days. Changing --webui-session-secret signs everyone out.
    • When you turn on user authentication on a deployment that used the v3.11 UI, Explorer offers once per browser to move saved dashboards, queries, and settings into the signed-in account. Saved API keys and tokens aren't moved.
    • Adds Area, Single Stat, Gauge, and Pie visualizations, and EXPLAIN ANALYZE in the SQL editor.
  • Orphaned file cleanup (upgraded storage engine): The primary compactor now finds and deletes compacted files in object storage that nothing references, left behind by crashes or failed jobs. The first pass starts a few minutes after the compactor first starts on v3.12, then passes repeat every 7 days. Objects modified in the last 24 hours are never deleted, and passes don't run during a restore. To only record candidates, set --compactor-sweep-mode dry-run. To turn off cleanup, set --compactor-sweep-interval off. The offline, read-only influxdb3 debug sweep list, influxdb3 debug sweep report, and influxdb3 debug verify-references commands inspect cleanup passes and check that every file a checkpoint references exists.

  • New metrics (upgraded storage engine):

    • Per-ingest-node compaction progress: influxdb3_compactor_uncompacted_snapshots and influxdb3_compactor_last_compacted_snapshot_sequence, labeled by node_id.
    • Data file cache: influxdb3_file_cache_admission_rejected_total counts fetches refused by the cache budget, and influxdb3_file_cache_fetched_bytes_total counts bytes fetched from object storage.
    • Ingest time spread: influxdb3_snapshot_windows, influxdb3_snapshot_windows_seen_24h, and influxdb3_snapshot_rows_by_window_age_total show how many time windows each snapshot touches and how old incoming rows are.
  • New Processing Engine metrics: influxdb3_processing_engine_scheduler_* gauges for pending, running, retrying, and auto-disabling invocations, influxdb3_processing_engine_wal_*_watermark and influxdb3_processing_engine_timer_*_watermark_unix_seconds for how far each process node has followed the WAL and the schedule clock, and influxdb3_processing_engine_restart_state_checkpoints for saved scheduler state. These apply to both storage engines.

Bug fixes

  • Missing rows from IN filters against a file index (Parquet engine): A filter with an IN list of four or more values on a column the file index doesn't cover, such as a field, no longer skips every compacted file. Previously, such a query returned no rows from compacted data. An equality or IN filter could also skip every file after you narrowed a table's file index columns.
  • Login response time revealed valid usernames: A username and password login now takes the same time whether or not the username exists. Previously, a login for an unknown username returned faster, which revealed whether a username existed. This affects deployments with --user-auth-type basic.
  • Removing a node could delete acknowledged writes (upgraded storage engine): Removing a node that still has snapshots the compactor deferred now returns 409 Conflict and names the deferred snapshots. Previously, removal deleted those files, losing writes that had been acknowledged.
  • Two processes with the same --node-id (upgraded storage engine): When two ingest-capable processes run with the same --node-id, the one that loses a snapshot write now logs another process is writing under this node id and exits, so only one writer survives.
  • Two primary compactors on S3 (upgraded storage engine): Each compactor lease renewal now writes a unique value. Previously, a renewal wrote identical content with an unchanged ETag, so a standby compactor could take the lease immediately after a renewal while the primary kept running.
  • Retention kept deleting after it was cleared (upgraded storage engine): After you remove the last retention period, the compactor stops applying the old cutoffs. Previously, it kept deleting backfilled and late-arriving data by the old cutoffs until it restarted.
  • Restore on GCS and compactor deletes during a restore (upgraded storage engine): A restore on Google Cloud Storage now holds its lease past the first renewal, so a second restore started at the same time returns 409 Conflict. The compactor now holds its deletes while a restore runs. Previously, it could delete files the restore had just copied back.
  • No compaction on new clusters with --shard-count above 1 (upgraded storage engine): A new cluster started with --shard-count greater than 1 now compacts. Previously, it never compacted, and query nodes eventually ran out of memory.
  • Growing ingest file inventory (upgraded storage engine): system.pt_ingest_files and ingest node memory now track only live files. Previously, they grew with every file written for the life of the process.
  • Repeated object storage reads for new ingest nodes (upgraded storage engine): Query nodes no longer fetch an ingest node's recent files from object storage on every query when that ingest node joined after the query node started.
  • Future-dated data displaced current data in the cache (upgraded storage engine): Cache preloading no longer warms time windows that start more than one window length in the future. Previously, every future window was warm, so data timestamped far in the future could use the preload budget before the current window loaded.
  • /ready briefly reported not ready: Expected object storage conflicts, such as a lost conditional write, no longer mark the node as not ready.
  • Package install failures reported as success: The package install API and influxdb3 install package now return an error with the end of the pip output when pip fails. Previously, they returned success, and the missing package surfaced later as a ModuleNotFoundError.
  • Row deletes could remove the rows they were meant to keep (upgraded storage engine): A rewrite that applies a row delete keeps the files the delete doesn't touch by their original ID. Previously, it also queued those files for deletion, so after the cleanup cooldown the rows the delete was meant to preserve were gone and later reads of the run set failed with Object not found. On the first start after upgrading from an affected v3.11.x, stale row-delete entries in the persisted delete queue are dropped instead of replayed.
  • Backup and restore could hang (upgraded storage engine): The backup copy loop now keeps its in-flight copies running while it writes progress. Previously, a copy that held the object store client's credential-refresh lock was left unpolled during a progress write, which blocked every request on that client and the backup or restore never finished.
  • Rows lost when clearing the Parquet WAL after switching to the upgraded storage engine: When a node starts on the upgraded storage engine with unflushed Parquet WAL, clearing that backlog no longer re-runs snapshots the previous process recorded but never persisted. Previously, a re-run could overwrite a manifest, and its Parquet file, so the rows it held were listed by no manifest.
  • Queries that exceed memory limits returned 500: The HTTP query endpoints now return 429 Too Many Requests when a query fails because the data file cache budget or the DataFusion memory pool is exhausted. Previously, they returned 500. Flight already returned RESOURCE_EXHAUSTED for the same errors.
  • Other bug fixes and performance improvements

Breaking changes

  • Data file cache is a hard limit (upgraded storage engine): --file-cache-size now also counts data file bytes held by running queries. When the budget is used up, the query that needs more fails with 429 Too Many Requests and a file access cache budget exhausted error instead of the node using memory beyond the budget. Query nodes that were killed for running out of memory under this load now stay up and fail individual queries.
  • Nodes without query mode refuse data queries (Parquet engine): Nodes that don't run the query mode now return 405 Method Not Allowed for data queries. System table queries still work. Previously, these nodes answered data queries, sometimes with partial results. The upgraded storage engine already behaved this way.
  • --node-spec and WAL triggers on multiple process nodes: --node-spec no longer pins where a trigger runs; it selects the process nodes whose schedulers own the trigger. With the default, all, every process node owns the trigger and now follows every ingest node's WAL, so a WAL trigger runs once per process node for each WAL flush. To run a WAL trigger once per flush in a cluster with more than one process node, set --node-spec to a single node.
  • Request triggers return 503 when their queue is full: A request trigger with 60 pending invocations now returns 503 Service Unavailable with trigger queue is full. Previously, the request waited for a free slot.
  • Username and password sessions must be renewed: Access tokens issued to users who sign in with a username and password now must carry the cluster's catalog UUID as the aud claim. Access tokens issued before v3.12 are rejected. Refresh the token or sign in again. API tokens aren't affected.
  • --compaction-max-num-files-per-plan has no effect (Parquet engine): The compactor no longer limits plans by input file count. Setting the option logs a deprecation warning.
  • Metric changes: The unused influxdb3_memory_pool_evictions, influxdb3_memory_pool_rejections, influxdb3_memory_pool_eviction_bytes, influxdb3_memory_pool_eviction_size_bytes, and influxdb3_memory_pool_eviction_duration_seconds metrics are removed. influxdb3_compaction_plans_skipped (Parquet engine) now reports reason="memory_exhaustion" with no phase label, instead of reason="file_limit".
2026-09-18 01:33:30
influxdb

v3.11.5 | 09-17-26

The following are some highlighted updates with the newest release for InfluxDB 3. Learn more via our full Release Notes.

Updates

Core

Features

  • Age-based snapshot trigger: The new --force-snapshot-max-age option (default 1h) forces a snapshot once the oldest WAL data that isn't in a snapshot reaches that age. Previously, snapshots triggered only on WAL file count or buffer memory, so a node receiving few or no writes could hold hours of data in memory and replay all of it on its next restart.

Bug fixes

  • Other bug fixes and performance improvements

Enterprise

All Core updates are included in Enterprise. Additional Enterprise-specific updates:

Features

  • Parquet engine WAL and snapshot metrics: Parquet engine nodes that ingest data now report WAL files and bytes not yet covered by a persisted snapshot (influxdb3_parquet_wal_pending_files, influxdb3_parquet_wal_pending_bytes), buffered bytes and the threshold that forces a snapshot (influxdb3_parquet_write_buffer_bytes, influxdb3_parquet_write_buffer_memory_threshold_bytes), the time of the last successful snapshot (influxdb3_parquet_snapshot_last_success_timestamp_seconds), and failed snapshot attempts by error_code (influxdb3_parquet_snapshot_failures_total).
  • Stalled storage engine upgrade reporting: system.upgrade_parquet_node now flags a node whose upgrade has stopped making progress (stalled, stalled_since), and reports when it last progressed (last_progress_at), how many times the compactor restarted during the upgrade (restarts), and conversion and import progress. Previously, an upgrade that had stopped making progress looked the same as one still in progress.
  • Compaction completion logging (Parquet engine): The compactor logs each completed compaction at INFO level, so the logs show whether compaction is running.
  • Stuck compaction warning (Parquet engine): The compactor logs a compaction not planned warning when a table has enough uncompacted files for a compaction but none has been planned for 15 minutes, and repeats it every 15 minutes while the condition holds.

Bug fixes

  • Missing rows from filtered queries on tables without tags (upgraded storage engine): A query with a WHERE clause, including one with only a time predicate, now returns compacted data from a table that has no tag columns. Previously, once such a table's data compacted, a filtered query could return no rows, while the same query without a WHERE clause returned every row.
  • Compaction stopped while work waited for memory (upgraded storage engine): Compaction work waiting for memory is no longer aborted as stuck before it starts. Previously, when more work was scheduled than memory could admit, the waiting work was aborted and retried until its compaction failed, after which the compactor stopped planning new work, including snapshots.
  • Missing rows from tag queries after a compactor restart (Parquet engine): Removing a generation now removes only that generation's file index entries. Previously, a compact-only node numbered its files from zero again after a restart, so removing an older generation also removed the index entries for a live file with the same number, and queries that filter on an indexed tag value skipped that file and returned incomplete results.
  • Startup stalled on large compaction metadata: Compaction summary, compaction detail, and generation detail reads larger than 128 MiB are now fetched as 16 MiB ranged reads, so a slow or failed transfer retries one range. Previously, a single whole-object GET restarted a multi-gigabyte download from byte 0, so a node loading Parquet engine compacted data at startup, including during a storage engine upgrade, could stall without an error.
  • Stopped nodes blocked an At-Home license node from starting: The At-Home license single-node check now ignores nodes in the stopped or removing state. Previously, any other node registered in the catalog prevented startup.
  • Ingest-only nodes built an unused file index: Nodes that run only in ingest mode (--mode ingest) no longer build the Parquet engine's compacted data file index at startup, including during a storage engine upgrade, which reduces their startup memory. Ingest-only nodes never use the index.
  • Unneeded file index decoding during a storage engine upgrade: The upgrade now reads only the file list from each generation's detail object when it discovers files to import. Previously, it also decoded the file index, which added CPU and memory cost to compactor startup on tables with large indexes.
  • Spurious snapshot sequence error on first startup (upgraded storage engine): A new node starting with an empty object store no longer logs a snapshot sequence seeds disagree error.
  • Other bug fixes and performance improvements
2026-09-05 01:11:26
influxdb

v3.9.13 | 09-04-26

The following are some highlighted updates with the newest release for InfluxDB 3. Learn more via our full Release Notes.

Updates

Core

Bug fixes

  • Snapshot manifest skipped for an empty snapshot: Every snapshot sequence number now lands a manifest, including a snapshot with nothing to persist. Previously the manifest was skipped, leaving a permanent hole in the sequence. Consumers that walk the sequence by exact key cannot tell a skipped snapshot from a manifest that failed to persist, so a single hole stalled Enterprise compaction on that node and blocked its read replicas.
  • Unnecessary node shutdown after a retried WAL write: Each WAL file now carries a nonce in its object metadata, so a node recognizes its own write and shuts down only for a file written by another node. Previously, a conditional PUT that was applied but returned a 500 was retried, and the node read the resulting 412 as a second process holding the same --node-id and shut down, though the file was durable and correct.
  • Restarted downloads of large manifests and checkpoints at startup: Snapshot manifest and checkpoint reads larger than 128 MiB are now fetched as 16 MiB ranged reads, so a slow or failed transfer retries one range. Previously, a single whole-object GET restarted a multi-gigabyte download from byte 0.
  • Panic on oversized duration values: Time arithmetic now saturates at the minimum or maximum representable timestamp instead of panicking when a duration is too large to represent. Previously, an oversized user-supplied duration produced a panic and could put the server into a startup panic loop.
  • Processing engine Python updated to 3.13.15: Picks up the security fixes in that release.
  • Other bug fixes and performance improvements

Enterprise

All Core updates are included in Enterprise. Additional Enterprise-specific updates:

Features

  • Startup phase logging: The server logs the start and completion of each startup phase, so a node killed during startup shows which phase it was in.

Bug fixes

  • File index left behind when a generation expires: Retention now deletes a generation's detail object along with its Parquet files. Previously the detail, which holds the file index describing those files, was left unreferenced in object storage. On a table with high-cardinality index columns the detail is the larger of the two, so retention shrank the data and accumulated the indexes for the life of the cluster.
  • Slow compaction catch-up behind a lagging node: The compactor now accumulates the rerun signal across every node in a cycle. Previously it kept only the last node's value, so a caught-up node could end the cycle after a single snapshot and leave a lagging node advancing one snapshot per check interval until restart.
  • Other bug fixes and performance improvements
2026-09-05 00:52:20
influxdb

v3.10.6 | 09-04-26

The following are some highlighted updates with the newest release for InfluxDB 3. Learn more via our full Release Notes.

Core

Features

  • --shutdown-timeout graceful shutdown bound: This new option (default 30s) caps how long the server waits for active connections to drain during shutdown before forcibly closing them. Set it to 0s to skip the drain.

Bug fixes

  • Crash loop migrating a catalog written by Core: Catalog snapshots deserialize again when the node spec is missing from trigger, last value cache, and distinct value cache entries, defaulting to all nodes. Core never writes that field, so the unified deserializer rejected Core-written checkpoint files and the v2-to-v3 catalog migration crash-looped on upgrade.
  • Snapshot manifest skipped for an empty snapshot: Every snapshot sequence number now lands a manifest, including a snapshot with nothing to persist. Previously the manifest was skipped, leaving a permanent hole in the sequence. Consumers that walk the sequence by exact key cannot tell a skipped snapshot from a manifest that failed to persist, so a single hole stalled Enterprise compaction on that node and blocked its read replicas.
  • Unnecessary node shutdown after a retried WAL write: Each WAL file now carries a nonce in its object metadata, so a node recognizes its own write and shuts down only for a file written by another node. Previously, a conditional PUT that was applied but returned a 500 was retried, and the node read the resulting 412 as a second process holding the same --node-id and shut down, though the file was durable and correct.
  • Panic on oversized duration values: Time arithmetic now saturates at the minimum or maximum representable timestamp instead of panicking when a duration is too large to represent. Previously, an oversized user-supplied duration produced a panic and could put the server into a startup panic loop.
  • Processing engine Python updated to 3.13.15: Picks up the security fixes in that release.
  • Other bug fixes and performance improvements

Enterprise

All Core updates are included in Enterprise. Additional Enterprise-specific updates:

Features

  • Startup phase logging: The server logs the start and completion of each startup phase, so a node killed during startup shows which phase it was in.

Bug fixes

  • Privilege escalation through role assignment: Creating, updating, and deleting a role, and assigning roles to a user, now require admin authorization. Previously a non-admin subject holding User:Update, or User:Create with roles in the request, could grant permissions beyond its own. This affects the user authentication preview, which is off by default (--without-user-auth true); deployments that have not enabled it are unaffected.
  • File index left behind when a generation expires: Retention now deletes a generation's detail object along with its Parquet files. Previously the detail, which holds the file index describing those files, was left unreferenced in object storage. On a table with high-cardinality index columns the detail is the larger of the two, so retention shrank the data and accumulated the indexes for the life of the cluster.
  • Slow compaction catch-up behind a lagging node: The compactor now accumulates the rerun signal across every node in a cycle. Previously it kept only the last node's value, so a caught-up node could end the cycle after a single snapshot and leave a lagging node advancing one snapshot per check interval until restart.
  • Other bug fixes and performance improvements
2026-09-05 00:52:20
influxdb

v3.11.4 | 09-04-26

The following are some highlighted updates with the newest release for InfluxDB 3. Learn more via our full Release Notes.

Updates

Core

Bug fixes

  • Overwrites in the write buffer resolved arbitrarily: Writes that repeat a series key and timestamp within one write buffer chunk now resolve to the last acknowledged write, in query results and in the persisted Parquet file. Previously the duplicate rows tied on both deduplication sort keys and an unstable sort picked an arbitrary survivor, so a superseded version could win. An overwrite that arrives while a snapshot is persisting also now wins over the frozen rows it replaces.
  • Snapshot manifest skipped for an empty snapshot: Every snapshot sequence number now lands a manifest, including a snapshot with nothing to persist. Previously the manifest was skipped, leaving a permanent hole in the sequence. Consumers that walk the sequence by exact key cannot tell a skipped snapshot from a manifest that failed to persist, so a single hole stalled Enterprise compaction on that node and blocked its read replicas.
  • Stale plugin source after re-enabling a trigger: Stopping a trigger now drops its plugin from the worker's in-memory cache, so re-enabling it re-reads the code. Since v3.11.0 the cache was insert-only, so disabling and re-enabling a trigger resumed the cached copy and never contacted the plugin repository again, which is the documented way to pick up a new version of a gh: plugin.
  • Plugin source retained after a database was deleted: Deleting a database now evicts its triggers' cached plugin source. Previously it stayed resident until the server restarted.
  • Processing engine Python updated to 3.13.15: Picks up the security fixes in that release.
  • Other bug fixes and performance improvements

Enterprise

All Core updates are included in Enterprise. Additional Enterprise-specific updates:

Features

  • Startup phase logging: The server logs the start and completion of each startup phase, so a node killed during startup shows which phase it was in.

Bug fixes

  • Privilege escalation through role assignment: Creating, updating, and deleting a role, and assigning roles to a user, now require admin authorization. Previously a non-admin subject holding User:Update, or User:Create with roles in the request, could grant permissions beyond its own. This affects the user authentication preview, which is off by default (--user-auth-type none); deployments that have not enabled it are unaffected.
  • Out-of-memory clearing the WAL backlog during a storage engine upgrade: The upgrade now snapshots during WAL replay whenever the buffer reaches a quarter of the query executor's memory pool, instead of buffering the whole backlog and persisting it in one pass. Each snapshot removes the WAL files it covers, so a restart resumes from the last one rather than replaying from the beginning.
  • Out-of-memory importing a large source during a storage engine upgrade: Bulk import now admits a job by its estimated working set rather than its compressed size, runs a job larger than the compactor's input-size budget on its own, and refuses a source that cannot fit at all with an error naming the budget it would need. Previously an oversized source was retried until the node ran out of memory, with no attempt recorded.
  • File index left behind when a generation expires: Retention now deletes a generation's detail object along with its Parquet files. Previously the detail, which holds the file index describing those files, was left unreferenced in object storage. On a table with high-cardinality index columns the detail is the larger of the two, so retention shrank the data and accumulated the indexes for the life of the cluster.
  • Compactor replans forever against a missing index file (upgraded storage engine): A run set whose index object is confirmed gone from object storage is now skipped after three failed reads on separate scheduler passes, so planning moves on to other work. Previously every planner that read the index failed, abandoned the plan, and recreated it on the next tick indefinitely. The skip list is in memory only: a restart clears it, and a repaired index is picked up again.
  • Empty snapshot manifests were never deleted: Gen1 cleanup now deletes a consumed manifest that references no files. Previously it returned early on such a manifest without deleting it, and because cleanup retains the oldest entries in each batch, undeletable manifests could eventually fill every batch and starve cleanup.
  • Stale plugin source after a catalog restore: Restoring a catalog now evicts the worker's cached plugin source, so restarted triggers re-read their code. Previously a trigger whose restored definition matched the cached one resumed the pre-restore source without contacting the plugin repository.
  • Spurious memory reservation warning at startup: The warning threshold is now above the sum of the shipped percentage defaults, which come to 90 percent of detected memory. Previously a server running the default configuration warned about itself.
  • Other bug fixes and performance improvements