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.
- Processing engine Python updated to 3.13.18: Picks up the security fixes released since 3.13.15.
- Queries that exceed memory limits returned
500: The HTTP query endpoints now map DataFusion memory-pool exhaustion to429 Too Many Requestsinstead of500. If the error occurs during query execution,prettyandparquetoutput return429. For CSV, JSON, and JSON Lines output, execution errors still end the HTTP200response early, even before the first rows. Some Core queries still return500, such as a query on a table that runs out of memory while deduplicating data. Enterprise already mapped resource-exhaustion errors to429. - 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
All Core updates are included in Enterprise. Additional Enterprise-specific updates:
- 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.
- Storage engine upgrade completed with unconverted Parquet files: If a Parquet file fails every conversion attempt, the ingest node now reports
failedinsystem.upgrade_parquet_node. Thelast_messagecolumn 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
upgradingforever. - 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-waitbehind the compactor failed every refresh withgeneration detail not founduntil 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
v1.13.2
Please see https://docs.influxdata.com/influxdb/v1/about_the_project/release-notes/#v1132 for official release notes.
- Resolve unimplemented interface member (#27715) in https://github.com/influxdata/influxdb/pull/27716
- Update go version to 1.26.10 in https://github.com/influxdata/influxdb/pull/27730
| 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 |
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.
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.
- Queries that exceed memory limits returned
500: The HTTP query endpoints now return429 Too Many Requestswhen a query exhausts the DataFusion memory pool. Previously, they returned500. 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 HTTP200response early. Some Core queries still return500, such as a query on a table that runs out of memory while deduplicating data. Enterprise already mapped resource-exhaustion errors to429. - 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
All Core updates are included in Enterprise. Additional Enterprise-specific updates:
- 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.
- Storage engine upgrade completed with unconverted Parquet files: If a Parquet file fails every conversion attempt, the ingest node now reports
failedinsystem.upgrade_parquet_node. Thelast_messagecolumn 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
upgradingforever. - 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
stoppingand 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-waitbehind the compactor failed every refresh withgeneration detail not founduntil 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
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.
- 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.
- 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 sent200and 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.999999999Zis now rejected with a400error. Previously, a timestamp that close to the maximum could panic the WAL flush when the server forced a snapshot. system.parquet_fileslisted files under the wrong tables: A query onsystem.parquet_fileswithout atable_namefilter 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
All Core updates are included in Enterprise. Additional Enterprise-specific updates:
- Larger bulk import batches (upgraded storage engine): The new
--compactor-import-batch-sizeoption sets the largest batch of staged data that one bulk import merge reads at once. The default is4gband 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_filesnow 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_secondshistogram reports how long a WAL flush waited for an earlier flush to finish. Thekindlabel istimedfor the regular flush interval andforcedfor a flush that forces a snapshot.
- 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_setswithreason="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
querymode, includingall, 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 logscompacted-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
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.
- 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
All Core updates are included in Enterprise. Additional Enterprise-specific updates:
- WAL flush wait metric (Parquet engine): The new
influxdb3_parquet_wal_flush_lock_wait_secondshistogram reports how long a WAL flush waited for an earlier flush to finish. Thekindlabel istimedfor the regular flush interval andforcedfor a flush that forces a snapshot.
- 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 logsanother process is writing under this node idand 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.
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.
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]
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 requiredBefore you upgrade:
- Back up everything under
{prefix}/catalog/, including the catalog snapshot and logs undercatalog/v3/.- 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.
- Add columns to an existing table:
influxdb3 update tablenow takes--tags(tag names) and--fields(name:type), and the newPATCH /api/v3/configure/tableendpoint 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_settingsanddisabledare now optional when you create a trigger throughPOST /api/v3/configure/processing_engine_trigger. They default torun_async=false,error_behavior=log, anddisabled=false. Previously, a request that omitted either field returned 400. - Regular expressions as
INlists: More anchored regular expressions, such as^host-(01|02)$or^val[1-4]$, are now rewritten as anINlist (orNOT INfor!~), up to 1,000 values, in SQL and InfluxQL. - Narrower InfluxQL scans with
LIMIT,OFFSET, andfill(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.
- InfluxQL
SPREADwith negative values:SPREADnow 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
systemdunit from the.deband.rpmpackages exited with status226. 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
- Finite default for
--max-concurrent-queries: The--max-concurrent-queriesdefault 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(default100000) was never enforced. When the WAL buffer is full, writes now return429 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, andgrpc_requests*metrics count only gRPC requests. Previously, both counted every request, so dashboards that sum the two families will show lower values. Thepathandmethod_pathlabels now use route templates, such as/api/v3/engine/:path. Unrecognized paths are reported asother. 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()andpower()with integer arguments now return a float. - New system table columns:
system.databasesadds aschema_modecolumn at the end.system.nodesaddsconn_info, andsystem.tablesaddsretention_period_ns, both before existing columns, so the column order ofSELECT *on those tables changes.
All Core updates are included in Enterprise. Additional Enterprise-specific updates:
-
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-targetto 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-budgetand--compactor-max-concurrent-mergesamong them. If a node fails, its jobs are retried on another node. Newinfluxdb3_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 processor--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-specnow 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-dirdeclines 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(default5) sets the attempts before a failing invocation is discarded when the trigger uses--error-behavior retry,--trigger-work-silence-timeout(default60s) sets how long a scheduler waits on a silent node before giving up the run, and--processing-engine-restart-state-snapshot-interval(default1s) 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 withinfluxdb3 create tableand add columns withinfluxdb3 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, default1s). Core rejects--schema-mode explicitwith a 400 error. -
Bulk import from object storage (upgraded storage engine):
influxdb3 import from-object-store(andPOST /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 ans3://bucket/prefixURL. The server reads the source with its own object store credentials and tries an S3 server-side copy first (--import-attempt-server-side-copy, defaulttrue), 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
describeaction on at least one database and returns only the import jobs for databases the token can describe. For example, grantdb:<DATABASE_NAME>:describe,writefor an import job. -
Write timestamp bounds (upgraded storage engine): The new
--write-timestamp-max-pastand--write-timestamp-max-futureoptions 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 ininfluxdb3_write_timestamp_rejections_total. -
Faster
ORDER BY time ... LIMITqueries (upgraded storage engine): SQL queries sorted bytimewith aLIMITnow 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-typedefaults tonone, and custom role authoring stays off (--rbac-authoring-disableddefaults totrue). Existing token workflows are unchanged. See Manage users. -
Integrated Explorer 1.11: The Explorer UI embedded in
influxdb3 serve --mode ...,webuiis 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-idcommand to run instead. - The new
--webui-public-urioption sets the public URL for single sign-on. Register<PUBLIC_URI>/auth/callbackas the redirect URI with your identity provider. - Sessions are stored on the server and last 120 days. Changing
--webui-session-secretsigns 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 ANALYZEin the SQL editor.
- Explorer connects to its own cluster automatically, with no URL or token to enter: at once with
-
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-onlyinfluxdb3 debug sweep list,influxdb3 debug sweep report, andinfluxdb3 debug verify-referencescommands 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_snapshotsandinfluxdb3_compactor_last_compacted_snapshot_sequence, labeled bynode_id. - Data file cache:
influxdb3_file_cache_admission_rejected_totalcounts fetches refused by the cache budget, andinfluxdb3_file_cache_fetched_bytes_totalcounts bytes fetched from object storage. - Ingest time spread:
influxdb3_snapshot_windows,influxdb3_snapshot_windows_seen_24h, andinfluxdb3_snapshot_rows_by_window_age_totalshow how many time windows each snapshot touches and how old incoming rows are.
- Per-ingest-node compaction progress:
-
New Processing Engine metrics:
influxdb3_processing_engine_scheduler_*gauges for pending, running, retrying, and auto-disabling invocations,influxdb3_processing_engine_wal_*_watermarkandinfluxdb3_processing_engine_timer_*_watermark_unix_secondsfor how far each process node has followed the WAL and the schedule clock, andinfluxdb3_processing_engine_restart_state_checkpointsfor saved scheduler state. These apply to both storage engines.
- Missing rows from
INfilters against a file index (Parquet engine): A filter with anINlist 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 orINfilter 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 Conflictand 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 logsanother process is writing under this node idand 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-countabove 1 (upgraded storage engine): A new cluster started with--shard-countgreater than1now compacts. Previously, it never compacted, and query nodes eventually ran out of memory. - Growing ingest file inventory (upgraded storage engine):
system.pt_ingest_filesand 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.
/readybriefly 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 packagenow return an error with the end of thepipoutput whenpipfails. Previously, they returned success, and the missing package surfaced later as aModuleNotFoundError. - 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 Requestswhen a query fails because the data file cache budget or the DataFusion memory pool is exhausted. Previously, they returned500. Flight already returnedRESOURCE_EXHAUSTEDfor the same errors. - Other bug fixes and performance improvements
- Data file cache is a hard limit (upgraded storage engine):
--file-cache-sizenow also counts data file bytes held by running queries. When the budget is used up, the query that needs more fails with429 Too Many Requestsand afile access cache budget exhaustederror 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
querymode now return405 Method Not Allowedfor 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-specand WAL triggers on multiple process nodes:--node-specno 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-specto a single node.- Request triggers return 503 when their queue is full: A request trigger with 60 pending invocations now returns
503 Service Unavailablewithtrigger 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
audclaim. 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-planhas 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, andinfluxdb3_memory_pool_eviction_duration_secondsmetrics are removed.influxdb3_compaction_plans_skipped(Parquet engine) now reportsreason="memory_exhaustion"with nophaselabel, instead ofreason="file_limit".
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.
- Age-based snapshot trigger: The new
--force-snapshot-max-ageoption (default1h) 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.
- Other bug fixes and performance improvements
All Core updates are included in Enterprise. Additional Enterprise-specific updates:
- 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 byerror_code(influxdb3_parquet_snapshot_failures_total). - Stalled storage engine upgrade reporting:
system.upgrade_parquet_nodenow 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
INFOlevel, so the logs show whether compaction is running. - Stuck compaction warning (Parquet engine): The compactor logs a
compaction not plannedwarning 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.
- Missing rows from filtered queries on tables without tags (upgraded storage engine): A query with a
WHEREclause, 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 aWHEREclause 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
stoppedorremovingstate. 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 disagreeerror. - Other bug fixes and performance improvements
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.
- 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-idand 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
All Core updates are included in Enterprise. Additional Enterprise-specific updates:
- 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.
- 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
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.
--shutdown-timeoutgraceful shutdown bound: This new option (default30s) caps how long the server waits for active connections to drain during shutdown before forcibly closing them. Set it to0sto skip the drain.
- 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-idand 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
All Core updates are included in Enterprise. Additional Enterprise-specific updates:
- 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.
- 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, orUser:Createwith 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
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.
- 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
All Core updates are included in Enterprise. Additional Enterprise-specific updates:
- 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.
- 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, orUser:Createwith 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