Imply Enterprise and Hybrid release notes

Imply releases include Imply Manager, Pivot, Clarity, and Imply's distribution of Apache Druid®. Imply delivers improvements more quickly than open source because Imply's distribution of Apache Druid uses the primary branch of Apache Druid. This means that it isn't an exact match to any specific open source release. Any open source version numbers mentioned in the Imply documentation don't pertain to Imply's distribution of Apache Druid.

The following release notes provide information on features, improvements, and bug fixes up to Imply LTS release 2026.01-lts. Read all release notes carefully, especially the Upgrade and downgrade notes, before upgrading. Additionally, review the deprecations page regularly to see if any features you use are impacted.

important

The 2026 LTS removes backwards compatibility behavior that was previously optional. Review these changes and make updates to your deployment prior to upgrading to the 2026 LTS.

For more information, see the upgrade notes for Legacy SQL behavior.

If you are upgrading by more than one version, read the intermediate release notes too.

Note the following end-of-support dates:

End of support for the 2025.01 LTS is planned for 2027. This means that the 2025.01 LTS release line will stop receiving any patches, including security updates, at that point.
On June 29, 2026, Imply 2024.01 LTS reached EOL. This means that the 2024.01 LTS release line no longer receive any patches, including security updates. Imply recommends that you upgrade to the latest LTS or STS release.

For more information, see Lifecycle Policy.

See Previous versions for information on older releases.

Imply evaluation

New to Imply? Get started with an Imply Hybrid (formerly Imply Cloud) Free Trial or start a self-hosted trial at Get started with Imply!

With Imply Hybrid, the Imply team manages your clusters in AWS, while you control the infrastructure and own the data. With self-hosted Imply, you can run Imply on *NIX systems in your own environment or cloud provider.

Imply Enterprise

If you run Imply Enterprise, see Imply product releases & downloads to access the Imply Enterprise distribution. When prompted, log on to Zendesk with your Imply customer credentials.

Druid highlights

Legacy two-valued logic removed

The legacy two-valued logic and the corresponding properties that support it have been removed. The ANSI SQL compatible three-valued logic is the only option.

If you used the properties to maintain the legacy behavior, you must do the following before upgrading:

Update your queries and downstream apps prior so that you continue to get the results you expect. - Remove the configs used to enable the legacy behavior

For more information, see the Legacy SQL behavior upgrade note as well as the migration guide

Legacy Booleans and null handling behavior removed

The legacy Boolean and null handling behavior as well as the corresponding properties that support it have been removed.

If you used the properties to maintain the legacy behavior, you must do the following before upgrading:

Update your queries and downstream apps prior so that you continue to get the results you expect. - Remove the configs used to enable the legacy behavior

For more information, see the Legacy SQL behavior upgrade note as well as the migration guide

Java support

Druid now supports Java 25. As part of this change, support for Java 21 and 17 have been deprecated. Support for Java 11 ended with the 2025 LTS.

(id: 71114) (id: 69553)

Query reports for Dart

Dart now supports query reports for running and recently completed queries. The reports can be fetched from the /druid/v2/sql/queries/<sqlQueryId>/reports endpoint.

The format of the response is a JSON object with two keys, query and report. The query key is the same info that is available from the existing /druid/v2/sql/queries endpoint. The report key is a report map including an MSQ report.

You can control the retention behavior for reports using the following configs:

druid.msq.dart.controller.maxRetainedReportCount: Max number of reports that are retained. The default is 0, meaning no reports are retained
druid.msq.dart.controller.maxRetainedReportDuration: How long reports are retained in ISO 8601 duration format. The default is PT0S, meaning time-based expiration is turned off

#18886 (id: 71070)

Segment format

The new version 10 segment format improves upon version 9. Version 10 supports partial segment downloads, a feature provided by the experimental virtual storage fabric feature. To streamline partial fetches, the contents of the base segment contents get combined into a single file named druid.segment.

As part of this new segment format, you can use the bin/dump-segment tool to view segment metadata. The tool outputs serialized JSON.

Set druid.indexer.task.buildV10=true to have Druid create segments using the new version.

Note that prior versions of Imply don't support the new segment format. If you downgrade from 2026.01 STS to a prior release and enabled the new segment format, you must first reindex any version 10 segments to version 9. After you reindex, you can proceed with the downgrade.

#18880 #18901 (id: 70870)

`statsd` metrics

The following metrics have been added to the default list for statsd:

task/action/run/time
task/status/queue/count
task/status/updated/count
ingest/handoff/time

#18846 (id: 70763)

Cost-based autoscaling for streaming ingestion

Druid now supports cost-based autoscaling for streaming ingestion that optimizes task count by balancing lag reduction against resource efficiency.. This autoscaling strategy uses the following formula:

totalCost = lagWeight × lagRecoveryTime + idleWeight × idlenessCost

which accounts for the time to clear the backlog and compute time:

lagRecoveryTime = aggregateLag / (taskCount × avgProcessingRate) — time to clear backlog
idlenessCost = taskCount × taskDuration × predictedIdleRatio — wasted compute time

#18819 (id: 70789) (id: 70629)

Record offset and partition

You can now ingest the record offset (offsetColumnName) and partition (partitionColumnName) using the KafkaInputFormat. Their default names are kafka.offset and kafka.partition respectively .

The dimensions added by default are very high cardinality and will result in bigger segment sizes. If you don't want to ingest these dimensions, add them to your exclusion list.

#18757 (id: 70372)

Additional ingestion configurations

You can now use the following configs to control how your data gets ingested and stored:

maxInputFilesPerWorker: Controls the maximum number of input files or segments per worker.
maxPartitions: Controls the maximum number of output partitions for any single stage, which affects how many segments are generated during ingestion.

#18826 (id: 70654)

Numeric fields in nested columns

You can now choose between full dictionary-based indexing and nulls-only indexing for long/double fields in nested columns. Set NestedCommonFormatColumnFormatSpec to either LongFieldBitmapIndexEncoding and DoubleFieldBitmapIndexEncoding.

#18722 (id: 70192)

Improved `indexSpec`

You can now specify a format specification for each JSON column individually, which will override the indexSpec defined in the ingestion job. Additionally, a system-wide default indexSpec can be set using the druid.indexing.formats.indexSpec property.

#17762 #18638 (id: 69629) (id: 69305) (id: 69304)

Jetty 12

Druid now uses Jetty 12. Your deployment may be impacted depending, specifically with regards to URI compliance and SNI host checks.

For more information, see the upgrade note for Jetty

Dimension schemas

At ingestion time, dimension schemas in dimensionsSpec are now strictly validated against allowed types. Previously, an invalid type would fall back to string dimension. Now, such values are rejected. Users must specify a type that's one of the allowed types. Omitting type still defaults to string, preserving backward compatibility.

#18565 (id: 69260)

cgroup v2 support

cgroup v2 is now supported, and all cgroup metrics now emit cgroupversion to identify which version is being used.

The following metrics automatically switch to v2 if v2 is detected: CgroupCpuMonitor , CgroupCpuSetMonitor, CgroupDiskMonitor,MemoryMonitor. CpuAcctDeltaMonitor fails gracefully if v2 is detected.

Additionally, CgroupV2CpuMonitor now also emits cgroup/cpu/shares and cgroup/cpu/cores_quota.

#18705

Use SET statements for query context parameters

You can now use SET statements to define query context parameters for a query through the Druid console or the API. For example, you can include the following in your query to set the timeout:

SET timeout = 20000;

Dart query engine (beta)

The Dart query engine is designed to support highly complex queries, such as large joins, high-cardinality GROUP BY, sub-queries and common table expressions. You'll typically find these types of query used in ad-hoc, data warehouses. They should be familiar to developers using Apache Spark and Presto. Dart uses multi-threaded workers, conducts in-memory shuffles, and accesses locally cached data directly, rather than reading from deep storage.

To use Dart, add the following to _common/common.runtime.properties:

druid.msq.dart.enabled = true

Then, include the engine query context parameter in your queries and set it to msq-dart.

For more information, see SQL queries using the Dart engine. For information on configuring Pivot to use Dart, see Enable Dart on a data cube.

(id: 67698) (id: 67261) (id: 66855) (id: 66854) (id: 66853) (id: 66852) (id: 64665) (id: 64258) (id: 65720) (id: 66042)

Projections (alpha)

Projections significantly reduce the number of rows to scan when processing certain queries. Therefore, they can greatly improve the performance. A projection is pre-aggregated data that matches a commonly used query. When you run the query, Druid uses the projection to process the query, reducing the number of rows processed, leading to lower compute and i/o costs.

You define projections either as part of an ingestion, in the catalog for a datasource, or in the compaction spec for a datasource.

(id: 67624) (id: 67552) (id: 67493) (id: 67393) (id: 67365) (id: 67274) (id: 67128)

Multiple supervisors for a datasource

You can now use more than one supervisor to ingest data into the same datasource. Use the id field to distinguish between supervisors ingesting into the same datasource (identified by spec.dataSchema.dataSource for streaming supervisors).

(#18149) (#18082)

Segment metadata cache

You can now enable segment metadata caching on the Overlord to significantly improve performance of various segment read, commit, and allocate actions performed by the Overlord during ingestion. You can also enable it on the Coordinator to improve performance of segment metadata polls

Set druid.manager.segments.useIncrementalCache to one of the following values:

never: never use the incremental cache.
ifSynced: use the incremental cache if it's up-to-date. This setting doesn't block service startup.
always: always use the incremental cache. This setting blocks service startup until the cache has synced with the metadata store at least once.

If you enable incremental caching, you can control the polling period using druid.manager.segments.pollDuration (defaults to PT1M). Set the config to an ISO 8601 format duration.

You can use the following metrics to monitor the performance of the segment metadata cache:

Show the metrics

segment/used/count
segment/unused/count
segment/pending/count
segment/metadataCache/sync/time
segment/metadataCache/deleted
segment/metadataCache/skipped
segment/metadataCache/used/stale
segment/metadataCache/used/updated
segment/metadataCache/unused/updated
segment/metadataCache/pending/deleted
segment/metadataCache/pending/updated
segment/metadataCache/pending/skipped

(#17996) (id: 67034) (#17935) (id: 66709) (#17947) (id: 66639) (#17653)

Historical clones

You can use Historical clones to speed up rolling updates when you want to launch a new Historical as a replacement for an existing one.

Set the cloneServers field in the Coordinator dynamic config to a map from the target Historical server to the source Historical:

  "cloneServers": {"historicalClone":"historicalOriginal"}

When you query your data, you can prefer (preferClones), exclude (excludeClones), or include (includeClones) clones by setting the query context parameter cloneQueryMode. By default, clones are excluded while querying.

(id: 65717) (id: 66707) (id: 65718) (#17863) (#17899)(#17956)

Embedded kill tasks on the Overlord (alpha)

You can now run kill tasks directly on the Overlord itself. You need to have segment metadata cache enabled. Embedded kill tasks provide several benefits; they:

kill segments as soon as they're eligible
don't take up a task slot
finish faster since they use optimized metadata queries and don't launch a new JVM
kill a small number of segments per task to avoid holding locks on an interval for too long
skip locked intervals to avoid head-of-line blocking
require minimal configuration
can keep up with a large number of unused segments in the cluster.

Use the following configurations for this feature:

druid.manager.segments.killUnused.enabled - Enable or disable the feature
druid.manager.segments.killUnused.bufferPeriod - The duration before Druid permanently removes a segment from metadata and deep storage. Use this as a buffer period to prevent data loss if you may need data after it's marked unused.

As part of this feature, new metrics have been added:

Show the metrics

Metric	Description	Dimensions
`segment/killed/metadataStore/count`	Number of segments permanently deleted from metadata store	`dataSource`, `taskId`, `taskType`, `groupId`, `tags`
`segment/killed/deepStorage/count`	Number of segments permanently deleted from deep storage	`dataSource`, `taskId`, `taskType`, `groupId`, `tags`
`segment/kill/queueReset/time`	Time taken to reset the kill queue on the Overlord. This metric is emitted only if `druid.manager.segments.killUnused.enabled` is true.
`segment/kill/queueProcess/time`	Time taken to fully process all the jobs in the kill queue on the Overlord. This metric is emitted only if `druid.manager.segments.killUnused.enabled` is true.
`segment/kill/jobsProcessed/count`	Number of jobs processed from the kill queue on the Overlord. This metric is emitted only if `druid.manager.segments.killUnused.enabled` is true.
`segment/kill/skippedIntervals/count`	Number of intervals skipped from kill due to being already locked. This metric is emitted only if `druid.manager.segments.killUnused.enabled` is true.	`dataSource`, `taskId`

(#18028) (id: 66111)

Improved the query results API

The query results API (GET /druid/v2/sql/statements/{queryId}/results) now supports an optional filename parameter. When provided, the response uses the Content-Disposition header to instruct web browsers to save the results as a file instead of displaying them inline.

(#17840) (id: 66215)

Increase segment load speed (alpha)

You can now increase the speed at which segments get loaded on a Historical by providing a list of servers for the Coordinator dynamic config turboLoadingNodes. For these servers, the Coordinator ignores druid.coordinator.loadqueuepeon.http.batchSize and uses the value of the respective numLoadingThreads instead. Note that putting a Historical in turbo-loading mode might affect query performance since more resources would be used by the segment loading threads.

(#17775) (id: 65714)

Overlord APIs for compaction (alpha)

You can use the following Overlord compaction APIs to manage compaction status and configs. These APIs work seamlessly irrespective of whether compaction supervisors are enabled or not.

Method	Path	Description	Required permission
GET	`/druid/indexer/v1/compaction/config/cluster`	Get the cluster-level compaction config	Read configs
POST	`/druid/indexer/v1/compaction/config/cluster`	Update the cluster-level compaction config	Write configs
GET	`/druid/indexer/v1/compaction/config/datasources`	Get the compaction configs for all datasources	Read datasource
GET	`/druid/indexer/v1/compaction/config/datasources/{dataSource}`	Get the compaction config of a single datasource	Read datasource
POST	`/druid/indexer/v1/compaction/config/datasources/{dataSource}`	Update the compaction config of a single datasource	Write datasource
GET	`/druid/indexer/v1/compaction/config/datasources/{dataSource}/history`	Get the compaction config history of a single datasource	Read datasource
GET	`/druid/indexer/v1/compaction/status/datasources`	Get the compaction status of all datasources	Read datasource
GET	`/druid/indexer/v1/compaction/status/datasources/{dataSource}`	Get the compaction status of a single datasource	Read datasource

(#17834)(id: 66269)

Faster segment metadata operations

Enable segment metadata caching on the Overlord with the runtime property druid.manager.segments.useCache. This feature is off by default.

You can set the property to the following values:

never: Cache is disabled (default).
always: Reads are always done from the cache. Service start-up will be blocked until the cache has synced with the metadata store at least once. Transactions are blocked until the cache has synced with the metadata store at least once after becoming leader.
ifSynced: Reads are done from the cache only if it has already synced with the metadata store. This mode does not block service start-up or transactions unlike the always setting.

As part of this change, additional metrics have been introduced:

segment/metadataCache/sync/time
segment/metadataCache/transactions/readOnly
segment/metadataCache/transactions/writeOnly
segment/metadataCache/transactions/readWrite

(#17653) (#17824) (#17785) (id: 66110) (id: 65819)

Compaction supervisors (experimental)

You now configure compaction supervisors with the following Coordinator compaction config:

useSupervisors - Enable compaction to run as a supervisor on the Overlord instead of as a Coordinator duty.
engine - Choose between native and msq to run compaction tasks. The msq setting uses the MSQ task engine and can be used only when useSupervisors is true.

Previously, you used runtime properties for the Overlord. Support for these has been removed.

(#17782) (id: 65912)

Automatic kill task interval

The Coordinator can optionally issue kill tasks for cleaning up unused segments. Starting with this release, individual kill tasks are limited to processing 30 days or fewer worth of segments per task by default. This improves performance of the individual kill tasks.

The previous behavior (no limit on interval per kill task) can be restored by setting druid.coordinator.kill.maxInterval = P0D.

(#17680) (id: 63023)

Join hints in MSQ task engine queries

Druid now supports hints for SQL JOIN queries that use the MSQ task engine. This allows queries to provide hints for the JOIN type that should be used at a per join level. Join hints recursively affect sub queries.

select /*+ sort_merge */ w1.cityName, w2.countryName
from
(
  select /*+ broadcast */ w3.cityName AS cityName, w4.countryName AS countryName from wikipedia w3 LEFT JOIN wikipedia-set2 w4 ON w3.regionName = w4.regionName
) w1
JOIN wikipedia-set1 w2 ON w1.cityName = w2.cityName
where w1.cityName='New York';

(#17406) (id: 62998)

Front-coded dictionaries

You can specify that Druid uses front-coded dictionaries feature during segment creation. Once Druid starts using segments with front-coded dictionaries, you can't downgrade to a version where Druid doesn't support front-coded dictionaries. For more information, see Migration guide: front-coded dictionaries.

Concurrent append and replace

Concurrent append and replace is now generally available.

Deprecation updates

CentOS support for Imply Enterprise: if you are using CentOS, migrate to a supported operating system: RHEL 7.x and 8.x or Ubuntu 18.04 and 20.04. Support is planned to end in April 2025.
ioConfig.inputSource.type.azure storage schema: update your ingestion specs to use the azureStorage storage schema, which provides more capabilities. Support is planned to end in 2026.01 STS.
ZooKeeper-based task discovery: it has not been the default method for task discovery for several releases. Support is planned to end in 2026.01 STS.

For features that have reached end of support in 2025.01 STS, see End of support.

For a more complete list of deprecations including upcoming ones, see Deprecations.

Segment management APIs

APIs for marking segments as used or unused have been moved from the Coordinator to the Overlord service:

Mark all segments of a datasource as unused: POST /druid/indexer/v1/datasources/{dataSourceName}
Mark all (non-overshadowed) segments of a datasource as used: DELETE /druid/indexer/v1/datasources/{dataSourceName}
Mark multiple segments as used POST /druid/indexer/v1/datasources/{dataSourceName}/markUsed
Mark multiple (non-overshadowed) segments as unused POST /druid/indexer/v1/datasources/{dataSourceName}/markUnused
Mark a single segment as used: POST /druid/indexer/v1/datasources/{dataSourceName}/segments/{segmentId}
Mark a single segment as unused: DELETE /druid/indexer/v1/datasources/{dataSourceName}/segments/{segmentId}

(#17545) (id: 64884)

Improve metadata IO

You can now reduce the metadata I/O during segment allocation by using the following Overlord runtime property: druid.indexer.tasklock.batchAllocationReduceMetadataIO. This property is set to true by default.

When set to true, the Overlord only fetches necessary segment payloads during segment allocation.

(#17496) (id: 64772)

New metrics for GroupBy queries

When merging the groupBy results, the following metrics are now emitted by the GroupByStatsMonitor:

mergeBuffer/used: Number of merge buffers used.
mergeBuffer/acquisitionTimeNs: Total time required to acquire merge buffer.
mergeBuffer/acquisition: Number of queries that acquired a batch of merge buffers.
groupBy/spilledQueries: Number of queries that spilled onto the disk.
groupBy/spilledBytes: Spilled bytes on the disk.
groupBy/mergeDictionarySize: Size of the merging dictionary.

(#17360) (id: 62147)

Auto-compaction using compaction supervisors (alpha)

You can run automatic compaction using compaction supervisors on the Overlord rather than Coordinator duties. Compaction supervisors provide the following benefits over Coordinator duties:

Can use the supervisor framework to get information about the auto-compaction, such as status or state
More easily suspend or resume compaction for a datasource
Can use either the native compaction engine or the MSQ task engine
More reactive and submits tasks as soon as a compaction slot is available
Tracked compaction task status to avoid re-compacting an interval repeatedly

For more information, see Auto-compaction using compaction supervisors

(#16291)

Projections (alpha)

Datasources now support projections as an alpha feature. They can improve query performance by pre-aggregating data. They are similar to materialized views but are part built into a segment and are automatically used when a query fits the projection.

To use a projection, you must ingest a datasource using JSON-based ingestion. Include a projections block in your ingestion spec with the following fields: type, name, virtualColumns, groupingColumns, and aggregators. Note that you can have projections that only include aggregators and no grouping columns, such as when you want to create a projection for the sum of certain columns.

Then, use the following query context flags when running either a native query or SQL query:

useProjection: accepts a specific projection name and instructs the query engine that it must use that projection, and will fail the query if the projection does not match the query
forceProjections: accepts true or false and instructs the query engine that it must use a projection, and will fail the query if it cannot find a matching projection
noProjections: accpets true or false and instructs the query engines to not use any projections

Note that auto-compaction does not preserve projections.

For more information, see the open source Druid issue for projections.

(#17214) (id: 64172) (#17484) (id: 64763)

Realtime query processing for multi-value strings

Realtime query processing no longer considers all strings as multi-value strings during expression processing, fixing a number of bugs and unexpected failures. This should also improve realtime query performance of expressions on string columns.

This change impacts topN queries for realtime segments where rows of data are implicitly null, such as from a property missing from a JSON object.

Before this change, these were handled as [] instead of null, leading to inconsistency between processing realtime segments and published segments. When processing segments, the value was treated as [], which topN ignores. After publishing, the value became null, which topN does not ignore. The same query could have different results before and after being persisted

After this change, the topN engine now treats [] as null when processing realtime segments, which is consistent with published segments.

This change doesn't impact actual multi-value string columns, regardless of if they're realtime.

(#17386) (id: 63771) (id: 64672)

Pivot highlights

Authentication token selection now prioritizes datasource access

Authentication token selection now filters tokens by datasource access before applying priority ranking. Previously, Pivot always selected the highest-priority token regardless of whether it included the requested datasource, which could block access to datasources you had valid permissions for.

If no token matches your requested datasources, the system falls back to selecting your highest-priority token.

(id: 70502)

Multi-axis line chart improvements

Improved the ability to customize the y-axis in the multi-axis line chart. You can now:

Set a custom tick mark interval.
Specify a maximum value for the y-axis.
Change the label orientation.

(ids 67040, 67436, 67039)

Alerts improvements

You can now trigger alerts based on the previous value of a measure. To do this, set an alert condition to greater than or less than Previous value.

Imply Manager highlights

There have been various improvements to Imply Manager, including the following:

Support for additional instance types
Security improvements and fixes

For a full list, see the release updates.

Upgrade and downgrade notes

In addition to the upgrade and downgrade notes, review the deprecations page regularly to see if any features you use are impacted.

Minimum supported version for rolling upgrade

See Supported upgrade paths in the Lifecycle Policy documentation.

Legacy SQL behavior

In the 2026 LTS, you can't continue to use non-ANSI SQL compliant behavior for Booleans, nulls, and two-valued logic.

For more information on how to update your queries, see the SQL compliant mode migration guide.

Make sure you update your queries to account for this behavior and remove the following configs before you upgrade:

druid.generic.useDefaultValueForNull=true
druid.expressions.useStrictBooleans=false
druid.generic.useThreeValueLogicForNativeFilters=false

The configs no longer affect your query results. Additionally, if these configs are set to the legacy behavior, Druid services fail to start.

If you want to continue to get the same results, you must update your queries or your results will be incorrect after you upgrade.

For information about updating your queries, see the migration guide

Kafka offset and partition dimensions

The Kafka input format now supports the Kafka offset and partitions. These fields will automatically be added if you use type-aware schema auto-discovery unless you use the dimensionExclusions field to explicitly specify dimensions to ignore.

#18757

Hadoop-based ingestion

Hadoop-based ingestion is scheduled for removal in the 2026 STS and 2027 LTS. Migrate to SQL-based ingestion.

As part of the deprecation, you must now explicitly opt-in to using the deprecated index_hadoop task type. To opt-in, set druid.indexer.task.allowHadoopTaskExecution to true in your common.runtime.properties file. For more information, see #18239.

Imply Hybrid MySQL upgrade

The RDS end of support date for MySQL 8.0.x is scheduled for July 31, 2026.

Although Amazon offers extended support, you can use Imply Hybrid Manager to upgrade your MySQL instance to MySQL 8.4. New clusters will use MySQL 8.4 by default.

The upgrade should have little to no impact on your queries but does require a reconnection to the database. The process can take an hour and services will reconnect to the database during the upgrade.

In preparation for the upgrade, you must apply the following policy to grant sufficient permissions to the Cloud Manager IAM role:

Show the policy

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "rds:CreateBlueGreenDeployment",
        "rds:PromoteReadReplica"
      ],
      "Resource": [
        "arn:aws:rds:*:*:pg:*",
        "arn:aws:rds:*:*:deployment:*",
        "arn:aws:rds:*:*:*:imply-*"
      ],
      "Effect": "Allow"
    },
    {
      "Action": [
        "rds:AddTagsToResource",
        "rds:CreateDBInstanceReadReplica",
        "rds:DeleteBlueGreenDeployment",
        "rds:DescribeBlueGreenDeployments",
        "rds:SwitchoverBlueGreenDeployment"
      ],
      "Resource": "*",
      "Effect": "Allow"
    }
  ]
}

After you grant the permissions, click Apply changes for Amazon RDS MySQL Update on the Overview page of Imply Hybrid Manager.

Segment formats

Starting in 2026.01 LTS, Imply supports a new segment format, version 10. Prior versions of Imply don't support the new segment format. If you want to downgrade from 2026.01 LTS to a prior release and enabled the new segment format, you must first reindex any version 10 segments to version 9. After you reindex the data, you can proceed with the downgrade.

#18880

MSQ tasks during rolling upgrades

MSQ query_controller tasks can fail during a rolling update due to the addition of new counters that are not backwards compatible with these older versions. You can either retry any failed queries after the update completes or you can set includeAllCounters to false in the query context for any MSQ jobs that need to run during the rolling update.

(#18761) (id: 70389)

Jetty 12 SNI host checks

Jetty 12 by default has strict enforcement of RFC3986 URI format. This is a change from Jetty 9. As part of this update, a new server configuration option has been added: druid.server.http.uriCompliance. To avoid potential breaking changes in existing Druid deployments, this config defaults to LEGACY, which uses the more permissive URI format enforcement that Jetty 9 used. If the cluster you operate does not require legacy compatibility, we recommend you use the upstream Jetty default of RFC3986 in your Druid deployment. See the jetty documentation for more info.

Jetty 12 servers do strict SNI host0 checks when TLS is enabled. If the host your client is connecting to the server with does not match what is in the keystore, even if there is only one certificate in that keystore, it will return a 400 response. This could impact some use cases, such as folks connecting over localhost for whatever reason. If this change will break your deployment, you can opt-out of the change by setting druid.server.http.enforceStrictSNIHostChecking to false in the runtime.properties for some or all of your Druid services. It is recommended that you modify your client behavior to accommodate this change in jetty instead of overriding the config whenever possible.

#18424 #18623 (id: 69549)

Async download extension

If you load the imply-sql-async extension, you must remove this extension before you upgrade. This extension was used for the old async download. Support for that feature was dropped in the 2025.01 release.

Deprecation notices

For a more complete list of deprecations and their planned removal dates, see Deprecations.

Java versions

Druid now supports Java 25. As part of this change, support for Java 21 and 17 have been deprecated. Support for Java 21 and 17 will be removed in the 2027 LTS. Support for Java 11 ended with the 2025 LTS.

(id: 71114) (id: 69553)

Hadoop-based ingestion

Hadoop-based ingestion is scheduled for removal in the 2026 STS and 2027 LTS. Migrate to SQL-based ingestion.

Some segment loading configs deprecated

The following segment related configs are now deprecated and will be removed in future releases:

replicationThrottleLimit
useRoundRobinSegmentAssignment
maxNonPrimaryReplicantsToLoad
decommissioningMaxPercentOfMaxSegmentsToMove

Use smartSegmentLoading mode instead, which calculates values for these variables automatically.

End of support

ZooKeeper-based task discovery

Use HTTP-based task discovery instead, which has been the default since 2022.

`ioCOnfig.inputSource.type.azure` storage schema

Update your ingestion specs to use the azureStorage storage schema, which provides more capabilities.

Imply evaluation​

Imply Enterprise​

Druid highlights​

Legacy two-valued logic removed​

Legacy Booleans and null handling behavior removed​

Java support​

Query reports for Dart​

Segment format​

statsd metrics​

Cost-based autoscaling for streaming ingestion​

Record offset and partition​

Additional ingestion configurations​

Numeric fields in nested columns​

Improved indexSpec​

Jetty 12​

Dimension schemas​

cgroup v2 support​

Use SET statements for query context parameters​

Dart query engine (beta)​

Projections (alpha)​

Multiple supervisors for a datasource​

Segment metadata cache​

Historical clones​

Embedded kill tasks on the Overlord (alpha)​

Improved the query results API​

Increase segment load speed (alpha)​

Overlord APIs for compaction (alpha)​

Faster segment metadata operations​

Compaction supervisors (experimental)​

Automatic kill task interval​

Join hints in MSQ task engine queries​

Front-coded dictionaries​

Concurrent append and replace​

Deprecation updates​

Segment management APIs​

Improve metadata IO​

New metrics for GroupBy queries​

Auto-compaction using compaction supervisors (alpha)​

Projections (alpha)​

Realtime query processing for multi-value strings​

Pivot highlights​

Authentication token selection now prioritizes datasource access​

Multi-axis line chart improvements​

Alerts improvements​

Imply Manager highlights​

Upgrade and downgrade notes​

Minimum supported version for rolling upgrade​

Legacy SQL behavior​

Kafka offset and partition dimensions​

Hadoop-based ingestion​

Imply Hybrid MySQL upgrade​

Segment formats​

MSQ tasks during rolling upgrades​

Jetty 12 SNI host checks​

Async download extension​

Deprecation notices​

Java versions​

Hadoop-based ingestion​

Some segment loading configs deprecated​

End of support​

ZooKeeper-based task discovery​

ioCOnfig.inputSource.type.azure storage schema​

Imply evaluation

Imply Enterprise

Druid highlights

Legacy two-valued logic removed

Legacy Booleans and null handling behavior removed

Java support

Query reports for Dart

Segment format

`statsd` metrics

Cost-based autoscaling for streaming ingestion

Record offset and partition

Additional ingestion configurations

Numeric fields in nested columns

Improved `indexSpec`

Jetty 12

Dimension schemas

cgroup v2 support

Use SET statements for query context parameters

Dart query engine (beta)

Projections (alpha)

Multiple supervisors for a datasource

Segment metadata cache

Historical clones

Embedded kill tasks on the Overlord (alpha)

Improved the query results API

Increase segment load speed (alpha)

Overlord APIs for compaction (alpha)

Faster segment metadata operations

Compaction supervisors (experimental)

Automatic kill task interval

Join hints in MSQ task engine queries

Front-coded dictionaries

Concurrent append and replace

Deprecation updates

Segment management APIs

Improve metadata IO

New metrics for GroupBy queries

Auto-compaction using compaction supervisors (alpha)

Projections (alpha)

Realtime query processing for multi-value strings

Pivot highlights

Authentication token selection now prioritizes datasource access

Multi-axis line chart improvements

Alerts improvements

Imply Manager highlights

Upgrade and downgrade notes

Minimum supported version for rolling upgrade

Legacy SQL behavior

Kafka offset and partition dimensions

Hadoop-based ingestion

Imply Hybrid MySQL upgrade

Segment formats

MSQ tasks during rolling upgrades

Jetty 12 SNI host checks

Async download extension

Deprecation notices

Java versions

Hadoop-based ingestion

Some segment loading configs deprecated

End of support

ZooKeeper-based task discovery

`ioCOnfig.inputSource.type.azure` storage schema