apache/druid
49.2
Weak · 13 November 2026
936.1k
lines of production code
Java
with TypeScript
6
measurements over time
What this system is
Features
Add Aliyun OSS as a native batch input source
Users can now ingest data directly from Alibaba Cloud Object Storage Service (OSS) using the native batch input framework. This change introduces the \OssInputSource\ and supporting configuration classes (\OssClientConfig\, \OssEntity\) which allow specifying OSS endpoints, access keys, and secret keys via ingestion specs. It enables glob-based filtering of cloud objects, supports splitting by file size for parallel processing, and exposes system fields (URI, bucket, path) for ingested data, registered via the \OssInputSourceDruidModule\.
extensions-contrib/aliyun-oss-extensions/src/main/java/org/apache/druid/data · high confidence
Add Aliyun OSS deep storage support
This change introduces the Aliyun OSS extension for Druid, enabling the use of Alibaba Cloud Object Storage Service as a deep storage backend. The implementation includes components for pushing, moving, archiving, and killing data segments, as well as storing task logs and finding the latest versioned data. Configuration is provided via \OssStorageConfig\, \OssDataSegmentArchiverConfig\, \OssInputDataConfig\, and \OssTaskLogsConfig\, allowing users to specify buckets, prefixes, and archive locations.
extensions-contrib/aliyun-oss-extensions/src/main/java/org/apache/druid/storage · high confidence
Add Ambari Metrics Emitter extension
Users can now emit Druid metrics to an Apache Ambari Metrics Collector via a new extension. This adds the AmbariMetricsEmitter, which converts Druid ServiceMetricEvents into Ambari TimelineMetrics and flushes them to a configured collector host and port. The extension supports configurable filtering via two converter strategies: sending all events (SendAllTimelineEventConverter) or filtering by a whitelist of metrics and dimensions (WhiteListBasedDruidToTimelineEventConverter). It also handles AlertEvent forwarding to other configured emitters and ignores SegmentMetadataEvents.
extensions-contrib/ambari-metrics-emitter/src/main/java, extensions-contrib/influxdb-emitter, extensions-contrib/opentsdb-emitter/src/main/java · high confidence
Add Ambari Metrics Emitter extension with default metric whitelist
This change introduces the Ambari Metrics Emitter extension, enabling Druid to export metrics to Apache Ambari. The extension is registered via a new \META-INF/services\ file pointing to \AmbariMetricsEmitterModule\. Additionally, a \defaultWhiteListMap.json\ is added to define the default set of metrics exposed, covering ingestion events, JVM stats, query performance (including \query/segments/count\), and segment lifecycle metrics (including \segment/scan/active\).
extensions-contrib/ambari-metrics-emitter/src/main/resources · high confidence
Add Avro stream and OCF input formats with schema repository support
Users can now ingest Avro data from streams and Object Container Files (OCF) using the new \AvroStreamInputFormat\ and \AvroOCFInputFormat\. This change introduces a structured \AvroBytesDecoder\ interface that supports multiple decoding strategies, including inline schemas, multiple inline schemas, schema repositories, and schema registries. The extension registers these formats via \AvroExtensionsModule\ and provides concrete implementations like \SchemaRepoBasedAvroBytesDecoder\ and \Avro1124RESTRepositoryClientWrapper\ to handle schema resolution from external repositories or REST clients, enabling flexible Avro ingestion with schema discovery and flattening capabilities.
extensions-core/avro-extensions/src/main/java · high confidence
Add CloudFilesLoadSpec for IBM Cloud Object Storage integration
The CloudFiles extension now includes a new CloudFilesLoadSpec class, enabling Druid to load data segments directly from IBM Cloud Object Storage (Cloud Files). This component handles the specification of region, container, and path, and delegates segment file retrieval to the CloudFilesDataSegmentPuller, allowing users to ingest data from this specific cloud storage provider.
druid-cloudfiles-extensions · high confidence
Add DDSketch aggregation and quantile post-aggregation
This change introduces the DDSketch extension, enabling users to build and query DataDog DDSketches for approximate quantile analysis. It adds the 'ddSketch' aggregator for ingestion-time sketch construction and two post-aggregators—'quantileFromDDSketch' and 'quantilesFromDDSketch'—to extract specific or multiple quantile values from the stored sketches during query time.
extensions-contrib/ddsketch/src/main · high confidence
Add Google Compute Engine (GCE) autoscaling extension
Introduces a new autoscaling strategy for Druid workers running on Google Compute Engine. The extension includes the GceAutoScaler implementation, configuration classes (GceEnvironmentConfig), and a DruidModule for service registration, enabling automatic adjustment of worker node counts based on task load within a GCE managed instance group.
extensions-contrib/gce-extensions · high confidence
Add Kerberos authentication extension for Druid
Introduces the Druid Kerberos extension, enabling SPNEGO-based Kerberos authentication for both incoming HTTP requests and outgoing internal client calls. The extension provides a \KerberosAuthenticator\ that validates Kerberos tickets via cookies and headers, and a \KerberosHttpClient\ that automatically performs Kerberos challenges and manages authentication cookies for internal service-to-service communication. It also includes a \DruidKerberosAuthenticationHandler\ for server-side Kerberos validation and utility classes for cookie management and credential handling.
extensions-core/druid-kerberos · high confidence
Add KerberosEscalator for client credential escalation
The druid-kerberos extension now includes a KerberosEscalator implementation that allows authenticated clients to escalate their credentials. This component creates an escalated HTTP client and authentication result using configured internal client principal and keytab details, enabling secure delegation of identity within the Druid security model.
druid-kerberos · high confidence
Add KllDoublesSketch aggregation and post-aggregation support
Users can now aggregate double-precision values into KllDoublesSketches using the new KllDoublesSketchAggregatorFactory, which supports building, merging, and vectorized processing. The extension also introduces post-aggregators to analyze these sketches: KllDoublesSketchToQuantilePostAggregator for retrieving specific quantiles, KllDoublesSketchToCDFPostAggregator for computing cumulative distribution functions, and KllDoublesSketchToHistogramPostAggregator for generating histograms with either fixed split points or automatic binning. Serialization and deserialization of the sketches are handled via the new ComplexMetricSerde and ObjectStrategy implementations.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/kll · high confidence
Add Kubernetes node-label dynamic config provider
Users can now resolve Druid configuration values from the labels of the Kubernetes node where a process is running. This is implemented via the new K8sNodeLabelDynamicConfigProvider, which reads node labels from the Kubernetes API server (with caching) and maps specific label values to configuration keys, enabling use cases such as setting client rack IDs based on node zone labels.
extensions-core/kubernetes-extensions · high confidence
Add Map virtual column support
The virtual-columns extension now supports Map-type columns. This change introduces the MapVirtualColumn implementation, including specific dimension and value selectors that allow retrieving map data as Java Map objects, and registers the DruidVirtualColumnsModule to enable this functionality within the Druid segment layer.
extensions-contrib/virtual-columns/src/main · high confidence
Add Moments Sketch aggregation extension
This change introduces the Moments Sketch extension, enabling approximate quantile estimation on numeric metrics. It adds the \momentSketch\ aggregator (with configurable \k\ and \compress\ options) and \momentSketchMerge\ for combining existing sketches, along with post-aggregators \momentSketchMax\, \momentSketchMin\, and \momentSketchSolveQuantiles\ to extract statistics or estimate quantile fractions from the aggregated sketch data.
extensions-contrib/momentsketch/src/main · high confidence
Add ORC input format support
This change introduces the \orc-extensions\ module, enabling Druid to ingest data from ORC (Optimized Row Columnar) files. The extension registers the \OrcInputFormat\ via Jackson serialization, binds a Hadoop \Configuration\ instance for ORC file reading, and provides an \OrcReader\ that parses ORC records into Druid input rows. It includes an \OrcStructConverter\ to map ORC types (such as strings, integers, decimals, timestamps, and nested structures like lists and maps) to Java objects, and supports schema discovery and JSONPath-based field extraction for nested data.
extensions-core/orc-extensions · high confidence
Add OpenLineage request logging extension
The openlineage-emitter extension now includes an OpenLineageRequestLogger that captures completed Druid queries and emits OpenLineage RunEvents. Users can configure HTTP transport to send these events to an external endpoint, with options to set the namespace, queue capacity, and thread count. The logger supports SQL and job type facets, handles retries with a maximum of two attempts, and drops events with a warning if the queue is full or retries are exhausted.
openlineage-emitter · high confidence
Add Parquet input format support for native batch ingestion
The druid-parquet-extensions module now includes a ParquetInputFormat class that enables reading Parquet files during native batch ingestion tasks. This implementation handles configuration initialization, supports a binaryAsString option for data interpretation, and provides size weighting logic for task planning.
druid-parquet-extensions · high confidence
Add PostAveragerAggregatorCalculator for moving average post-processing
The moving-average-query extension now includes a PostAveragerAggregatorCalculator that applies post-averager specifications to query results. This component iterates through defined post-averagers, computes their values based on dependent fields in each row, and attaches the results to the output, enabling users to perform additional averaging calculations on top of the base moving average query results.
druid-moving-average-query · high confidence
Add Protobuf Flattener and Schema Registry-based Decoder
The protobuf extension now includes a new ProtobufFlattenerMaker that enables JSONPath and JQ-based extraction for flattening protobuf data, supporting optional nested field discovery. Additionally, a SchemaRegistryBasedProtobufBytesDecoder has been added to parse protobuf messages using the Confluent Schema Registry wire format, allowing dynamic schema retrieval via a configurable schema registry client.
druid-protobuf-extensions · high confidence
Add Protobuf-based metrics example to quickstart
The quickstart example now includes a Protobuf-based metrics pipeline. This adds a \Metrics\ message definition (proto3) with fields for unit, HTTP method, value, timestamp, HTTP code, page, metric type, and server, along with the generated Python descriptor and message class. A new publisher script (\pb\_publisher.py\) demonstrates how to read JSON metrics from standard input, serialize them using the Protobuf definition, and send them to a Kafka topic named \metrics\_pb\.
examples/quickstart/protobuf · high confidence
Add RabbitMQ Super Stream indexing support
Introduces a new indexing service for Apache Druid that enables ingestion from RabbitMQ super streams. This change adds the core implementation components—including the supervisor, task runner, IO/tuning configurations, and record supplier—allowing users to configure and run continuous indexing tasks against RabbitMQ streams using the existing seekable stream supervisor framework.
extensions-contrib/rabbit-stream-indexing-service/src/main · high confidence
Add Rackspace CloudFiles storage extension
Users can now store and load data segments using Rackspace CloudFiles as a deep storage backend. This change introduces the CloudFiles storage extension, including configuration classes for account credentials (provider, username, API key, service network toggle) and pusher settings (region, container, base path, retry limits), along with the implementation classes for pushing and pulling segments, the Guice module wiring, and utility classes for path handling and retry logic.
extensions-contrib/cloudfiles-extensions/src/main/java · high confidence
Add SQL Server metadata storage connector
Users can now store Druid metadata in Microsoft SQL Server. This change introduces the SQLServerConnector implementation, configuring the database driver, defining SQL Server-specific types (VARBINARY(MAX) for payloads, bigint IDENTITY for serials), and rewriting SQL statements to map generic boolean types to SQL Server's BIT type.
sqlserver-metadata-storage · high confidence
Add SQL Server metadata storage extension
Users can now store Druid metadata in Microsoft SQL Server. This change introduces the SQL Server metadata storage extension, including the SQLServerMetadataStorageActionHandler which adapts SQL queries for SQL Server syntax (e.g., using SELECT TOP for limits), the corresponding factory, and the Guice module that registers the SQL Server connector and handler under the 'sqlserver' type.
extensions-contrib/sqlserver-metadata-storage/src/main · high confidence
Add SpectatorHistogram extension
This change introduces the SpectatorHistogram extension, enabling Druid to ingest, store, and query Spectator-style histogram metrics as a complex column type. The implementation includes serialization and deserialization logic (SpectatorHistogramComplexMetricSerde) to handle data conversion, a column part supplier (SpectatorHistogramColumnPartSupplier) for segment construction, and an index-based complex column implementation (SpectatorHistogramIndexBasedComplexColumn) to expose histogram values for querying.
druid-spectator-histogram · high confidence
Add Thrift data input extension
Users can now ingest data serialized in Apache Thrift format by providing a Thrift schema class (optionally packaged in a JAR) and a source file. The new ThriftReader deserializes the binary or JSON-encoded Thrift data, converts it to a flattened JSON map, and parses it into Druid rows according to the configured InputRowSchema, with the extension registering the ThriftInputFormat parser via Jackson for easy configuration.
extensions-contrib/thrift-extensions/src/main/java · high confidence
Add ThriftInputFormat for reading Thrift-encoded data
Users can now ingest data encoded in Thrift format (supporting binary, compact, and JSON protocols with optional Base64 encoding) by using the new ThriftInputFormat. This input format allows specifying the Thrift class name and an optional external JAR file containing the Thrift schema, enabling integration with existing Thrift-based data sources within Druid.
druid-thrift-extensions · high confidence
Add ZooKeeper configuration files for single-machine deployment
New configuration files have been added to the examples/conf/zk directory to support single-machine ZooKeeper deployments. These include jvm.config for JVM settings (128MB heap, UTC timezone), zoo.cfg for core ZooKeeper parameters (data directory, client port, autopurge settings), and log4j2.xml for logging with rolling file policies that retain logs for 7 days.
examples/conf/zk · high confidence
Add compressed BigDecimal column storage and serialization
The druid-compressed-bigdecimal extension now provides the infrastructure to store and serialize CompressedBigDecimal values in segment files. This change introduces the CompressedBigDecimalColumnPartSupplier for reading column data, the CompressedBigDecimalLongColumnSerializer for writing scaled long representations to disk, and the CompressedBigDecimalMetricSerde to wire these components together for the new complex column type.
druid-compressed-bigdecimal · high confidence
Add git hooks to run pre-commit and pre-push checks
Developers can now install and run automated checks before committing and pushing code. The new \hooks/install-hooks.sh\ script copies the hook infrastructure (including \run-all-in-dir.py\, \pre-commit\, and \pre-push\ scripts) into the repository's \.git/hooks\ directory. The \pre-commit\ hook executes scripts in the \hooks/pre-commits/\ directory, while the \pre-push\ hook runs scripts in \hooks/pre-pushes/\, which currently includes a \checkstyle-check\ script that runs Maven checkstyle. Sample scripts are provided in \hooks/pre-commits/\_pre-commit.sample\ and \hooks/pre-pushes/\_pre-push.sample\ to demonstrate how to add custom checks.
hooks · high confidence
Add historical node configuration for single-machine deployment
New configuration files (jvm.config, main.config, runtime.properties) are provided for the Druid historical node in the single-machine deployment example. These files set up the JVM memory limits (8GB heap, 13GB direct memory), define the server entry point, and configure runtime properties such as HTTP threads, processing buffers, segment cache locations (300GB), and query cache settings (256MB Caffeine cache).
examples/conf/druid/cluster/data/historical · high confidence
Add pac4j-based OpenID Connect authentication filter
This change introduces the Pac4jFilter, a new servlet filter that enables OpenID Connect authentication for Druid using the pac4j library. The filter intercepts requests to handle the authentication flow, including redirecting users to the identity provider and processing the callback. It integrates with Druid's existing authentication chain by checking for prior successful authentication results to avoid redundant redirects, and upon successful OIDC login, it extracts the user ID from the pac4j profile and sets the Druid AuthenticationResult in the request context.
druid-pac4j · high confidence
Add single-server and cluster supervision configuration examples
New supervision configuration files have been added to the examples directory to support single-server and cluster deployments. The single-server examples (nano, micro, small, medium, large, and xlarge) provide pre-configured setups for running a full Druid instance on one machine, including ZooKeeper, coordinator-overlord, broker, router, historical, and middleManager services. Additionally, cluster-specific configurations are provided for data nodes, query nodes (broker and router), and master nodes (with and without ZooKeeper), allowing users to easily deploy and manage Druid clusters using the supervise tool.
examples/conf/supervise · high confidence
Add source and build infrastructure for demo and RADStack papers
The publications directory now includes the complete LaTeX source, bibliography, and build scripts for the 'Druid Demo' and 'RADStack' papers. This adds Makefiles to automate PDF generation using lualatex and bibtex, along with the necessary .tex, .bib, and .cls files. It also includes R scripts for generating performance plots and a .gitignore to keep generated artifacts out of version control.
publications · high confidence
Add standalone indexer configuration for Druid cluster example
The example cluster setup now includes a dedicated configuration directory for the indexer service, containing \jvm.config\ (setting 4GB heap and direct memory), \main.config\ (launching the \server indexer\ process), and \runtime.properties\ (configuring the service name, port 8091, worker capacity, and processing buffers). This allows users to run the indexer as a distinct node within the example cluster topology.
examples/conf/druid/cluster/data/indexer · high confidence
Add support for Aliyun OSS as deep storage
This change introduces the Aliyun OSS extension, enabling users to use Alibaba Cloud Object Storage Service (OSS) as a deep storage backend for Druid. The diff adds the core implementation classes, including OssDataSegmentPuller for handling data segment retrieval (supporting ZIP and GZ compression) and OssLoadSpec for defining load specifications, allowing segments to be pulled directly from OSS buckets.
aliyun-oss-extensions · high confidence
Added Druid 26.0 release notebook
A new Jupyter notebook has been added to the quickstart examples to demonstrate key features in Druid 26.0, specifically schema auto-discovery, shuffle joins, and UNNEST with arrays. This notebook provides step-by-step code examples for users to verify their Druid version and experiment with type-aware schema discovery during data ingestion.
examples/quickstart/releases · high confidence
Added middleManager configuration files for single-machine deployment
New configuration files (jvm.config, main.config, and runtime.properties) have been added for the Druid middleManager in the single-machine deployment example. These files define the JVM settings, entry point, and runtime properties such as worker capacity, task directories, and processing thread counts, enabling users to run the middleManager component in a standalone cluster setup.
examples/conf/druid/cluster/data/middleManager · high confidence
Added sketch query context and raw input extractor infrastructure
The datasketches extension now includes a new \SketchQueryContext\ class that exposes a query context flag (\sqlFinalizeOuterSketches\) to control whether outer sketches are finalized during SQL execution, defaulting to false. Additionally, a \RawInputValueExtractor\ has been added to support extracting raw input values from input rows, and the package is now annotated with \@EverythingIsNonnullByDefault\ to enforce non-null contracts across the module.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches · high confidence
Added vectorized column processor for object arrays in DataSketches
The DataSketches extension now includes a new \ToObjectVectorColumnProcessorFactory\ that enables vectorized processing for aggregators by converting column data into \Object\[\]\ arrays. This change supports vectorized execution paths for single-value dimensions, multi-value dimensions, and numeric types (float, double, long), allowing aggregators to leverage the vector processing system while maintaining compatibility with sketch implementations that do not require specialized primitive handling.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/util · high confidence
Azure deep storage now supports partial segment loads via byte-range reads
The Azure extension now allows Druid to load data segments from Azure Blob Storage using byte-range reads instead of downloading the entire file. This is enabled for segments pushed with the new 'rangeable' layout (unzipped blobs), which significantly reduces data transfer and speeds up query startup times. The implementation includes new classes (AzureByteSource, AzureSegmentRangeReader) that handle range requests with automatic retry logic for transient network errors, while legacy or zipped segments continue to use the full-download path for compatibility.
druid-azure-extensions · high confidence
Cassandra storage extension adds segment pusher and load spec implementations
The Cassandra storage extension now includes the core components required to write data segments to and read them from a Cassandra backend. Specifically, it introduces CassandraDataSegmentPusher, which compresses index files and uploads them to Cassandra using chunked storage, and CassandraLoadSpec, which enables the system to load segments back from Cassandra using the stored key. These classes implement the DataSegmentPusher and LoadSpec interfaces, respectively, forming the foundation for Cassandra-based deep storage integration.
druid-cassandra-storage · high confidence
Catalog metadata changes now sync to Brokers in real-time
The druid-catalog extension now includes a synchronization mechanism that pushes catalog metadata updates (such as table creation, column changes, and projections) from the Coordinator to Broker nodes immediately. This ensures that SQL queries executed on Brokers use the latest datasource schemas without waiting for periodic polling, reducing the window where a Broker might plan against stale metadata after a DDL statement.
druid-catalog · high confidence
Catalog model definitions for clustered segments and base tables
The server module now includes the core model classes for the new Catalog feature, specifically defining the data structures for base tables, projections, and schema registry. These changes introduce the foundational metadata objects (such as TableDefn, ObjectDefn, and Columns) that allow the system to manage clustered segments and base table specifications, enabling the wiring of row-based datasources to the serving layer.
server · high confidence · unverified
Configurable basic authentication class composition and LDAP support
The basic security extension now allows administrators to explicitly configure the classes used for authentication and authorization components (such as metadata storage updaters, cache managers, resource handlers, and cache notifiers) via the \druid.auth.basic.composition\ configuration. This change introduces new configuration classes (\BasicAuthClassCompositionConfig\, \BasicAuthCommonCacheConfig\, \BasicAuthDBConfig\, \BasicAuthLDAPConfig\, \BasicAuthSSLConfig\) that enable fine-grained control over these components, including support for LDAP authentication with optional group lookup and SSL/TLS settings for secure connections. Users can now tailor the basic security extension's behavior to their specific infrastructure needs, such as using different cache strategies or enabling LDAP-based user management.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic · high confidence
Enable automatic discovery of Aliyun OSS storage and input modules
Users can now utilize Aliyun OSS as a deep storage backend and data input source without manually configuring module loading. A new service provider file registers the OssStorageDruidModule and OssInputSourceDruidModule, allowing the Druid initialization process to automatically detect and load these capabilities when the extension is present on the classpath.
extensions-contrib/aliyun-oss-extensions/src/main/resources · high confidence
Graphite emitter extension initialization and default metric whitelist
The Graphite emitter extension is now registered for automatic initialization via the standard Druid module service provider file, ensuring it loads correctly at startup. Additionally, a default whitelist configuration has been introduced that defines which metrics are emitted by default, including query timing metrics (such as query/cpu/time and query/node/ttfb) with specific tags like dataSource and type, as well as segment and ingest metrics.
extensions-contrib/graphite-emitter/src/main/resources · high confidence
HDFS storage extension now supports HDFS as an input source
The HDFS storage extension now includes an HDFS input source, allowing Druid to read data directly from HDFS files during ingestion. This change introduces the HdfsInputSource and HdfsInputSourceFactory, enabling users to specify HDFS paths as data inputs. It also adds configuration for allowed protocols (defaulting to 'hdfs') and integrates with the existing HDFS storage module for authentication (Kerberos) and task logging, providing a unified way to handle HDFS data both for ingestion and deep storage.
extensions-core/hdfs-storage · high confidence
Initial Apache Incubator repository scaffolding and configuration
The repository has been initialized with the foundational structure required for the Apache Incubator project. This includes adding the \.asf.yaml\ file to configure GitHub notifications and pull request subject lines, setting up \.backportrc.json\ for managing backports to older release branches, and creating essential project files such as \LICENSE\, \NOTICE\, \README.template\, \AGENTS.md\ (developer guidelines), and \licenses.yaml\ (dependency license tracking). The diff also introduces the Maven Wrapper (\mvnw\) and updates \.gitignore\ and \.dockerignore\ to support the new build and distribution workflows.
(repo-wide) · high confidence
Initial Cassandra storage extension implementation
The Cassandra storage extension is introduced, providing the core components to store and retrieve data segments in a Cassandra cluster. This includes a configuration class for host and keyspace settings, a base storage class that establishes an Astyanax connection to specific index and descriptor tables, a segment puller that handles downloading and unzipping segment files with retry logic, and a Guice module that registers the Cassandra scheme for data segment pushing and Jackson subtypes for loading.
druid-opentsdb-emitter, extensions-contrib/cassandra-storage/src/main/java · high confidence
Initial Dropwizard Emitter module configuration
The Dropwizard Emitter extension is now available for use. This change introduces the \DropwizardEmitterModule\ service registration and a comprehensive \defaultMetricDimensions.json\ configuration file that defines the default dimensions, types, and time units for a wide range of Druid metrics, including query performance, segment scanning, cache statistics, and ingestion events.
extensions-contrib/dropwizard-emitter/src/main/resources · high confidence
Introduce Apache Druid JDBC driver
Adds a new JDBC driver for Apache Druid, enabling standard JDBC connectivity. The driver implements core JDBC interfaces including Connection, PreparedStatement, ResultSet, and DatabaseMetaData, and supports HTTP/HTTPS connections with basic authentication and TLS verification. It is read-only and operates in autocommit mode, meaning update operations and transaction management are not supported.
druid-jdbc-driver, jdbc-driver · high confidence
Introduce Basic HTTP Authentication and Escalation in Druid Security
The basic security extension now includes the BasicHTTPAuthenticator and BasicHTTPEscalator components, enabling HTTP Basic authentication for user login and internal client credential escalation. The authenticator validates credentials against a metadata store or custom validator and handles password parsing (including colons) per RFC 7617, while the escalator allows internal services to authenticate using a provided password provider. This change establishes the core mechanism for basic credential-based access control within the Druid security framework.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authentication · high confidence
Introduce Bloom Filter SQL expressions and aggregator base class
This change adds the foundational components for using Bloom Filters in Druid SQL queries. It introduces the \BloomKFilter\ class, a thread-safe, cache-optimized bloom filter implementation derived from Apache Hive, which supports serialization and in-situ merging via \ByteBuffer\. It also adds \BaseBloomFilterAggregator\, an abstract base class that implements both \Aggregator\ and \BufferAggregator\ interfaces to handle bloom filter state management during query execution. Finally, it provides \BloomFilterExpressions\, which registers SQL expression macros (\bloom\_filter\, \bloom\_filter\_add\, \bloom\_filter\_test\) allowing users to create, populate, and query bloom filters directly within SQL expressions.
druid-bloom-filter · high confidence
Introduce CompressedBigDecimal extension for high-precision aggregations
Adds a new Druid extension that provides a memory-efficient, mutable CompressedBigDecimal type for accumulating values without precision loss. This enables high-precision financial and revenue-based calculations by supporting SUM, MIN, and MAX aggregations on BigDecimal data. The extension includes the core data structures (ArrayCompressedBigDecimal, ByteBufferCompressedBigDecimal), a segment column implementation, and SQL support via Calcite bindings for functions like BIG\_SUM, allowing users to perform accurate aggregations on large-scale datasets.
extensions-contrib/compressed-bigdecimal/src/main · high confidence
Introduce Druid Catalog for SQL table metadata management
This change adds the Druid Catalog extension, providing a centralized metadata store for SQL table definitions. It introduces a Coordinator-side REST API for creating, updating, and deleting table specifications, along with a Broker-side cached catalog that synchronizes changes via push/pull updates. Users can now manage table schemas and column definitions through SQL DDL or the new REST endpoints, enabling consistent metadata resolution for SQL queries across the cluster.
extensions-core/druid-catalog · high confidence
Introduce Graphite emitter extension for exporting Druid metrics
Adds a new Graphite emitter extension that allows Druid to export service metrics to a Graphite server. The extension includes configuration for connection details (hostname, port, protocol, batching), a DI module for lifecycle management, and two event conversion strategies: 'all' (emits every metric with configurable namespace prefixes and dimension inclusion) and 'whiteList' (filters metrics and dimensions based on an external map file).
extensions-contrib/graphite-emitter/src/main/java · high confidence
Introduce GraphiteEmitter for exporting metrics to Graphite
Added a new GraphiteEmitter component that enables the system to export ServiceMetricEvents to a Graphite server. The emitter supports both PLAINTEXT and Pickled protocols, configurable via hostname, port, flush period, and batch size. It handles event queuing with a configurable max size and wait time, logging errors for lost events or unknown types, and explicitly ignores SegmentMetadataEvents while forwarding RequestLogEvents and AlertEvents to other configured emitters.
graphite-emitter · high confidence
Introduce Kafka Emitter extension for event emission
This change adds the Kafka Emitter extension, enabling Druid to publish metrics, alerts, request logs, and segment metadata events to Apache Kafka. The implementation includes the core emitter logic, a configuration class supporting bootstrap servers, topic selection, extra dimensions, producer configuration, and secret masking, and a Guice module for dependency injection. Users can now configure Kafka as an event destination to stream operational data to external systems.
extensions-contrib/kafka-emitter/src/main/java · high confidence
Introduce Kinesis-aware input format and record entity for streaming ingestion
The Kinesis indexing service now includes a dedicated KinesisInputFormat and KinesisRecordEntity that allow ingestion tasks to read Kinesis-specific record metadata—such as the approximate arrival timestamp and partition key—alongside the payload data. This enables users to map these Kinesis record properties directly into Druid dimensions and timestamp columns during streaming ingestion, providing more accurate time-based indexing and partition-aware data organization.
extensions-core/kinesis-indexing-service · high confidence
Introduce Kubernetes Task Scheduling extension for running Druid tasks as Kubernetes Jobs
The new kubernetes-overlord-extensions module allows Druid clusters running on Kubernetes to schedule indexing tasks as native Kubernetes Jobs instead of sending them to middle managers or indexers. This introduces a KubernetesTaskRunner that manages the lifecycle of these jobs, including dynamic capacity scaling via a configurable thread pool, support for multiple pod templates, and the ability to run tasks in different namespaces. A mixed-mode runner (k8sAndWorker) is also provided to allow tasks to be distributed between Kubernetes Jobs and traditional workers based on a configurable strategy, while metrics are enhanced to tag task pods by their pod template for better observability.
extensions-core/kubernetes-overlord-extensions · high confidence
Introduce LDAP authentication and metadata store credentials validation with coordinator cache synchronization
The druid-basic-security extension now supports LDAP-based authentication and authorization, allowing users to authenticate against an LDAP directory and retrieve group memberships. It also introduces a metadata store credentials validator for local user management. To ensure consistency across the cluster, coordinator components (CoordinatorBasicAuthenticatorCacheNotifier and CoordinatorBasicAuthorizerCacheNotifier) have been added to propagate authentication and authorization cache updates to other nodes.
druid-basic-security · high confidence
Introduce SQL INSERT and REPLACE statements with catalog support
Users can now write INSERT and REPLACE statements to load data into Druid datasources directly via SQL. The parser grammar has been extended to support the \REPLACE INTO\ syntax, including optional \PARTITIONED BY\ and \CLUSTERED BY\ clauses for catalog-backed tables, as well as \OVERWRITE\ and export file format specifications. The \EXPLAIN PLAN\ command has also been updated to support these new DML statements, allowing users to inspect the execution plan for data loading operations.
sql · high confidence
Introduce Spectator Histogram extension for metric aggregation and storage
Adds the Spectator Histogram extension, enabling Druid to ingest, store, and query Netflix Spectator-style histograms. This includes a new complex column type (\spectatorHistogram\) with dedicated aggregators (\spectatorHistogram\, \spectatorHistogramDistribution\, \spectatorHistogramTimer\) and post-aggregators (\countSpectatorHistogram\, \percentileSpectatorHistogram\, \percentilesSpectatorHistogram\). The implementation features a compact binary serialization format to minimize storage overhead, supports vectorized aggregation for improved ingestion and query performance, and handles nullable values efficiently using bitsets and offset arrays.
extensions-contrib/spectator-histogram/src/main · high confidence
Introduce T-Digest sketch aggregators and SQL support
This change adds the \tDigestSketch\ aggregation extension, enabling users to build and query T-Digest statistical sketches for approximate quantile analysis. It introduces \TDigestSketchAggregatorFactory\ to create sketches during ingestion or query time, with a configurable \maxCompression\ limit enforced via \TDigestConfig\. Post-aggregators \quantileFromTDigestSketch\ and \quantilesFromTDigestSketch\ allow extracting specific quantile values from these sketches. Additionally, SQL support is provided through \TDIGEST\_GENERATE\_SKETCH\ and \TDIGEST\_QUANTILE\ functions, allowing users to generate sketches and compute quantiles directly in SQL queries.
extensions-contrib/tdigestsketch/src/main · high confidence
Introduce audit logging and resource management utilities
Added the AuditEntry class to record and persist audit events for REST API requests, and introduced a suite of collection utilities including CloseableResourceHolder, ReferenceCountingResourceHolder, and StupidResourceHolder to manage resource lifecycles and prevent leaks. Also added CombiningIterable/Iterator for merging and deduplicating sorted data, DefaultBlockingPool with parallel initialization support to speed up node boot times, and various bitmap wrappers (WrappedImmutableRoaringBitmap, WrappedRoaringBitmap) to standardize access to RoaringBitmap operations.
druid-processing · high confidence
Introduce configurable StatsD emitter with DogStatsD support
The statsd-emitter extension now supports a fully configurable StatsD client, including native DogStatsD features such as constant tags, service-as-tag, and event emission. Users can now tune the underlying client's performance via queue size, buffer pool size, and worker counts, and can map Druid metrics to specific StatsD types (count, gauge, timer) with optional dimension filtering and range conversion through a custom dimension map file.
extensions-contrib/statsd-emitter/src/main/java · high confidence
Introduce configurable cache manager and notifier interfaces for basic authorization
The basic security extension now supports pluggable strategies for caching authorization state. New interfaces, BasicAuthorizerCacheManager and BasicAuthorizerCacheNotifier, along with implementations like CoordinatorPollingBasicAuthorizerCacheManager and NoopBasicAuthorizerCacheNotifier, allow the system to be configured for different caching behaviors (such as coordinator polling or no-op) rather than relying on a single hardcoded approach.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authorization/db/cache · high confidence
Introduce distinct count aggregation with pluggable bitmap backends
The distinct count extension now provides a new aggregation capability that counts unique values in a dimension column. It introduces a pluggable bitmap architecture, allowing users to select the underlying data structure via the \bitmapFactory\ parameter: \roaring\ (default, using RoaringBitmap), \concise\ (using ConciseBitmap), or \java\ (using BitSet). The implementation includes the \DistinctCountAggregatorFactory\ for query definition, \DistinctCountAggregator\ and \DistinctCountBufferAggregator\ for processing, and the \DistinctCountDruidModule\ to register the aggregation type \distinctCount\ with Jackson.
extensions-contrib/distinctcount/src/main/java · high confidence
Introduce gRPC query extension for Druid brokers
This change adds a new gRPC-based query extension for Druid brokers, enabling clients to submit SQL and native queries via a dedicated Netty-based gRPC server on a configurable port (default 50051). The extension includes server-side interceptors for Basic and Anonymous authentication, a health-check service for monitoring, and Protobuf-based serialization for query results. It is wired into the Druid lifecycle via a Guice module and respects client cancellations during query execution.
extensions-contrib/grpc-query/src/main · high confidence
Introduce global cached lookups extension with JDBC, URI, and static map support
The new druid-lookups-cached-global extension provides a framework for caching lookup data in memory, supporting three sources: JDBC databases, URIs (with versioned updates), and static maps. It includes a CacheScheduler to manage periodic updates and an OffHeapNamespaceExtractionCacheManager that uses MapDB for off-heap storage, allowing lookups to be cached efficiently without consuming excessive JVM heap space.
druid-lookups-cached-global · high confidence
Introduce global cached namespace lookups with JDBC, URI, and static map sources
The lookups-cached-global extension now provides a new architecture for global, cached lookups sourced from JDBC databases, URIs (files), or static maps. This change introduces the NamespaceLookupExtractorFactory to manage the lifecycle and caching of these lookups, along with introspection endpoints to inspect keys, values, and versions. It adds configuration for extraction threads and buffer sizes, supports heap-based caching with weak references for cleanup, and includes utilities like MapPopulator for parsing data sources with byte-limit warnings.
extensions-core/lookups-cached-global · high confidence
Introduce new cached lookup extension with JDBC support
The lookups-cached-single extension now provides a new implementation for cached lookups, supporting both polling and loading cache strategies. It introduces a DataFetcher interface with a new JDBC implementation (JdbcDataFetcher) that allows lookups to be backed by relational databases, including security checks for JDBC connection properties. The extension registers LoadingLookupFactory and PollingLookupFactory as Jackson subtypes and includes the necessary cache interfaces and factories for on-heap and off-heap storage.
extensions-core/lookups-cached-single · high confidence
Introduce simple-client-sslcontext extension for configurable HTTPS client SSL
The new simple-client-sslcontext extension provides a configurable SSLContext for Druid's internal HTTP clients (used by nodes, routers, and escalated clients). It allows administrators to define TLS settings such as protocol, trust and key store paths, algorithms, certificate aliases, and hostname validation via the druid.client.https configuration, and supports custom TLS certificate checking through the TLSCertificateChecker interface.
extensions-core/simple-client-sslcontext · high confidence
Introduces Derby-backed task storage and refactors indexing service Guice modules
The indexing-service now supports a Derby-based implementation for task storage via the new DerbyTaskStorageModule, which binds the MetadataStorageActionHandlerFactory for the Overlord role. This change is accompanied by a structural refactor of the indexing service's Guice modules: several modules (IndexingServiceInputSourceModule, IndexingServiceModuleHelper, IndexingServiceTuningConfigModule, SupervisorModule) have been introduced or reorganized to centralize Jackson subtype registrations and configuration binding. Additionally, new utility classes like AdjustedRuntimeInfo, Counters, and RetryPolicy have been added to support task execution and resource management.
indexing-service · high confidence
Introduces catalog table model and metadata classes
Adds the core data model classes for the Druid Catalog in the server module, including \TableMetadata\, \ResolvedTable\, \ColumnSpec\, and \TableId\ to represent table definitions and schemas. It also introduces base table metadata implementations for different table layouts (\TableBaseTableMetadata\, \RollupTableBaseTableMetadata\, \ClusteredValueGroupsBaseTableMetadata\) and a \TableDefnRegistry\ to manage table type definitions, along with a \SchemaRegistryImpl\ for built-in schema support.
druid-server · high confidence
Introduces on-demand loading and off-heap caching for single lookups
The cached-single lookup extension now supports on-demand (lazy) loading via the new LoadingLookup class, which fetches key-value pairs from a DataFetcher only when requested and caches them using configurable eviction policies. It also introduces off-heap caching capabilities through OffHeapLoadingCache (backed by MapDB) and OffHeapPollingCache, allowing lookups to operate outside the JVM heap to reduce memory pressure. Additionally, cache performance is now trackable via LookupCacheStats, exposing hit, miss, and eviction counts for both on-heap and off-heap implementations.
druid-lookups-cached-single · high confidence
Introduces segment-level locking and task action framework for ingestion
The indexing service now supports fine-grained locking at the segment level via new \SegmentLock\ and \TimeChunkLock\ classes, enabling concurrent append and replace operations on the same datasource without full-time chunk contention. This change introduces a new \TaskAction\ framework (including actions like \SegmentLockAcquireAction\, \MarkSegmentToUpgradeAction\, and \RetrieveUsedSegmentsAction\) that allows tasks to interact with the metadata store and lockbox in a structured, extensible way, improving the reliability and concurrency of parallel indexing and compaction workflows.
druid-indexing-service · high confidence
Kafka indexing service now supports pre-ingestion filtering via message headers
The Kafka indexing service can now filter records before they are ingested based on Kafka message headers. This is achieved through a new \KafkaHeaderBasedFilterEvaluator\ and associated handler interfaces (\HeaderFilterHandler\, \HeaderFilterHandlerFactory\) that evaluate Druid filters (currently supporting \InDimFilter\) against header values. To support this, a new \KafkaRecordEntity\ wraps the full \ConsumerRecord\ (including headers, key, and timestamp) for the input format, and a new \KafkaInputFormat\ blends header and key data into the resulting rows. Additionally, a \KafkaConsumerMonitor\ has been added to expose underlying Kafka consumer metrics (such as bytes consumed, fetch latency, and poll idle ratio) as Druid metrics.
extensions-core/kafka-indexing-service · high confidence
Kafka indexing supports multi-topic ingestion and header parsing
The Kafka indexing service now allows supervisors to read from multiple Kafka topics within a single task, using a topic pattern to match incoming data. This change introduces a new \KafkaTopicPartition\ model that tracks topic names alongside partition IDs to correctly manage offsets across different topics, ensuring data integrity when switching between single-topic and multi-topic modes. Additionally, the service now supports parsing Kafka message headers into Druid dimensions via a new \KafkaStringHeaderFormat\ and \KafkaStringHeaderReader\, allowing users to extract string values from message headers with configurable character encoding.
druid-kafka-indexing-service · high confidence
Multi-cluster Kubernetes task routing and API load reduction
The Kubernetes overlord extension now supports routing tasks to specific clusters using a new \Selector\ class that matches tasks based on context tags, task type, and data source. Additionally, a \CachingKubernetesPeonClient\ has been introduced to use shared informers for reading Job and Pod state from a local cache, which significantly reduces load on the Kubernetes API server by centralizing watches instead of making per-task API calls.
druid-kubernetes-overlord-extensions · high confidence
Multi-stage query module promoted to core with new catalog and execution infrastructure
The multi-stage query (MSQ) engine is now a core component rather than an extension, introducing a new developer guide and foundational infrastructure for distributed query execution. This includes a new LiveCatalogResolver that integrates the Druid catalog with SQL planning, a comprehensive counter system for tracking CPU, storage, and segment generation progress, and the Dart (MSQ-on-Broker-and-Historicals) architecture that allows queries to run directly on existing broker and historical nodes without dedicated worker tasks.
multi-stage-query · high confidence
MySQL metadata connector now supports MariaDB and configurable SSL
The MySQL metadata storage connector has been updated to support the MariaDB JDBC driver alongside the standard MySQL connector, allowing users to choose their preferred database driver. Additionally, the connector now exposes detailed SSL configuration options, including server certificate verification, trust store settings, and client certificate authentication, enabling secure connections to metadata databases.
mysql-metadata-storage · high confidence
Native Google Cloud Storage support for ingestion and deep storage
The Google extensions now provide a native implementation for reading data from Google Cloud Storage (GCS) via the new GoogleCloudStorageInputSource, allowing users to ingest data directly from GCS buckets using URIs, prefixes, or glob patterns. Additionally, the extension fully supports GCS as a deep storage backend, enabling segments to be pushed, pulled, and killed in GCS with optional unzipped storage, and allows task logs to be streamed to and from GCS.
extensions-core/google-extensions · high confidence
New AWS RDS token-based password provider extension
The druid-aws-rds-extensions module now provides a new password provider that generates temporary AWS RDS authentication tokens for database connections. Users can configure this by specifying a provider type of "aws-rds-token" along with the database user, host, port, and AWS region; the extension uses the AWS SDK V2 to generate the token at runtime, allowing for secure, credential-less database access when IAM database authentication is enabled.
extensions-core/druid-aws-rds-extensions · high confidence
New AWS common module with SDK v2 client configuration and credential providers
The new \cloud/aws-common\ module introduces a centralized configuration and utility layer for AWS services using the AWS SDK v2. It adds \AWSClientConfig\ to allow operators to configure retry strategies (Standard, Adaptive, or Legacy), connection timeouts, and S3-specific settings like legacy MD5 and path-style access. It also introduces \AWSCredentialsConfig\ and a chain of credential providers (including config-driven, file-based session credentials, environment variables, and web identity tokens) via \AWSModule\, enabling more flexible and robust authentication for S3 and other AWS services.
cloud/aws-common/src/main · high confidence
New Avro input formats and decoders with schema registry and flattening support
The avro-extensions module now includes new classes to handle Avro data ingestion more flexibly. Users can ingest Avro Object Container Files (OCF) via the new AvroOCFInputFormat, which supports reader schemas and union extraction. Data decoding is handled by new decoders: InlineSchemaAvroBytesDecoder for single inline schemas, InlineSchemasAvroBytesDecoder for multiple inline schemas with versioning, and SchemaRegistryBasedAvroBytesDecoder for fetching schemas from a Confluent Schema Registry (supporting both single and multiple URLs, plus dynamic config providers). Additionally, the AvroFlattenerMaker enables flattening of Avro records using JSONPath expressions and supports discovering nested fields, while the GenericAvroJsonProvider facilitates JSONPath queries on Avro records by handling union type extraction and Utf8 conversion.
druid-avro-extensions · high confidence
New Bitmap64ExactCountPostAggregator for exact distinct counts
Users can now perform exact distinct-count aggregations on bitmap64 fields using the new 'bitmap64ExactCount' post-aggregator. This change introduces the Bitmap64ExactCountPostAggregator class, which computes the exact cardinality of a specified bitmap64 field, and the supporting RoaringBitmap64Counter implementation that handles the underlying Roaring64NavigableMap operations for adding values, folding bitmaps, and serializing/deserializing the data.
druid-exact-count-bitmap · high confidence
New Bloom Filter extension for SQL aggregations and filters
The new druid-bloom-filter extension adds Bloom filter support to Druid queries. It introduces a BLOOM\_FILTER SQL aggregation function that builds a Bloom filter for a specified column (with a configurable maxNumEntries), and a corresponding BloomDimFilter that allows filtering rows based on membership in a Bloom filter. The extension registers the necessary Guice bindings, Jackson serializers, and SQL operator conversions to enable these capabilities.
extensions-core/druid-bloom-filter · high confidence
New Consul-based service discovery and leader election extension
The new Consul extension for Apache Druid provides an alternative to ZooKeeper for service discovery and leader election. It allows Druid nodes to register with a Consul cluster, maintain health via TTL checks, and discover peers using blocking queries. The extension also implements leader election for the Coordinator and Overlord roles using Consul sessions and KV locks. It supports TLS/mTLS for secure communication, ACL tokens, and HTTP Basic Auth (with validation to prevent cleartext credential transmission unless explicitly allowed for sidecar scenarios). Users can enable it by adding the extension to the load list and setting druid.discovery.type=consul along with the relevant connection and service configuration properties.
extensions-contrib/consul-extensions · high confidence
New DataSketches aggregators and post-aggregators for HLL, KLL, Quantiles, and Theta sketches
The druid-datasketches extension now includes new aggregator factories and post-aggregators for HLL, KLL, Quantiles (Doubles), and Theta sketches. Users can now build and merge HLL sketches with configurable lgK, target HLL type, string encoding, and rounding; construct KLL sketches with configurable k and max stream length; and build Quantiles (Doubles) sketches with configurable k, max stream length, and finalization. Theta sketch support includes constant and set-based post-aggregators for union, intersection, and complement operations. These changes enable approximate distinct counting, quantile estimation, and set operations directly within Druid queries.
druid-datasketches · high confidence
New DoublesSketch quantiles aggregators and post-aggregators
This change introduces a complete set of new components for the quantiles DoublesSketch extension in Druid. It adds new aggregator factories and implementations (including \DoublesSketchBuildAggregator\, \DoublesSketchMergeAggregator\, and their buffered/vector variants) to support building and merging quantiles sketches. It also introduces a suite of post-aggregators (\DoublesSketchToHistogramPostAggregator\, \DoublesSketchToCDFPostAggregator\, etc.) to derive histograms, CDFs, and other statistics from the sketches. The module is wired up via \DoublesSketchModule\ to register the necessary complex metric serdes, Jackson serializers, and SQL operator conversions.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles · high confidence
New Dropwizard emitter extension for exporting metrics
Adds a new \dropwizard\ emitter extension that allows Druid to export metrics using the Dropwizard metrics library. This includes a \DropwizardEmitter\ that ingests Druid service metrics and maps them to Dropwizard metric types (counters, gauges, histograms, meters, timers) via a configurable dimension map, and supports reporting to console or JMX via \DropwizardConsoleReporter\ and \DropwizardJMXReporter\. The extension is registered via \DropwizardEmitterModule\ and configured through \DropwizardEmitterConfig\, enabling users to forward Druid metrics to external systems that consume Dropwizard-compatible outputs.
extensions-contrib/dropwizard-emitter/src/main/java · high confidence
New Druid Delta Lake connector extension
This change introduces a new extension that allows Druid to ingest data directly from Delta Lake tables. It registers a \DeltaInputSource\ that leverages the Delta Kernel API to read table snapshots, supporting optional filtering for data pruning and the ability to target specific snapshot versions. The connector handles a wide range of data types—including strings, numerics, dates, timestamps, and complex types like arrays, maps, and structs—and translates Druid filter expressions into Delta Kernel predicates to push down conditions to the storage layer.
extensions-contrib/druid-deltalake-extensions/src/main · high confidence
New EC2 autoscaling extension for worker provisioning
This change introduces a new \ec2-extensions\ module that enables automatic scaling of Druid worker nodes on Amazon EC2. It provides the \EC2AutoScaler\ implementation, which uses the AWS SDK V2 to provision and terminate EC2 instances based on configured minimum/maximum worker counts, availability zones, AMI IDs, instance types, and security groups. The extension includes configuration classes for node data and user data (supporting version replacement), registers itself via the Druid module system, and adds serialization/deserialization tests to ensure correct JSON handling of the autoscaling configuration.
extensions-core/ec2-extensions · high confidence
New Iceberg ingestion extension for Druid
This change introduces a new extension that allows Druid to ingest data directly from Apache Iceberg tables. It provides a unified input source that supports multiple catalog backends, including Hive Metastore, AWS Glue, REST-based catalogs, and local file-based catalogs. The extension enables users to apply filters (such as range, interval, and time-window filters) to push down conditions to the Iceberg layer, improving ingestion performance. It also supports reading specific snapshots via time-travel queries and offers an optional vectorized read path using Apache Arrow for faster data processing. Additionally, users can control how residual filters on non-partition columns are handled, either by ignoring them (default) or failing the ingestion job to ensure data integrity.
extensions-contrib/druid-iceberg-extensions/src/main · high confidence
New JWT authenticator and enhanced OIDC configuration in the pac4j extension
The pac4j security extension now supports a new 'jwt' authenticator type that validates ID Tokens via a dedicated JwtAuthFilter, allowing users to authenticate requests using bearer tokens. The existing 'pac4j' authenticator has been updated with an OIDCConfig that exposes new configuration options for 'scope' and 'clientAuthenticationMethod', and it now supports custom SSL contexts via a new CustomSSLResourceRetriever to handle non-standard trust stores when communicating with the identity provider. These changes are wired into the Druid module via Pac4jDruidModule and include a new callback resource endpoint.
extensions-core/druid-pac4j · high confidence
New Kubernetes API client implementation for pod discovery
The \druid-kubernetes-extensions\ module now includes a new \DefaultK8sApiClient\ implementation that handles Kubernetes pod discovery. This component manages listing pods by namespace and label selector, filtering out pods that are not yet ready (e.g., OOM-killed), and watching for pod changes using the Kubernetes Java client library. It also supports patching pods, enabling dynamic configuration updates during discovery.
druid-kubernetes-extensions · high confidence
New LDAP and read-only authorization modes for basic security
The basic security extension now supports two new authorization capabilities. First, it introduces an LDAP role provider that resolves user roles by querying LDAP group memberships and mapping them to Druid roles, allowing administrators to use existing LDAP directory structures for access control. Second, it adds a read-only authorizer that automatically permits all READ actions while denying write and delete operations, which is useful for restricting access to specific data sources or clusters without requiring complex permission rules.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authorization · high confidence
New MSQ query execution counters and metrics infrastructure
The multi-stage-query module now includes a comprehensive set of counters to track query execution progress and resource usage. This adds detailed metrics for channel data flow (rows, bytes, frames, files), CPU and wall time consumption per stage, storage I/O (local and durable), segment generation progress, and warning counts. These counters are aggregated into snapshots that are propagated from workers to the controller and exposed to users via MSQ task reports, providing greater visibility into query performance and resource consumption.
druid-multi-stage-query · high confidence
New MapVirtualColumn for extracting map values as dimensions
Users can now use the MapVirtualColumn to treat key-value pairs stored in map columns as queryable dimensions. This new virtual column takes a key dimension and a value dimension, allowing queries to select specific map entries by key (using dot notation) or retrieve the entire map object, thereby enabling analysis of nested map data directly in Druid queries.
druid-virtual-columns · high confidence
New Moving Average query extension
Adds the Moving Average query type to Apache Druid, enabling users to compute moving averages over time-series data. This extension introduces the \movingAverage\ query type, which internally leverages GroupBy and Timeseries queries to aggregate data into period-based buckets, applies configurable averagers to compute the moving average, and supports post-averagers, having clauses, and limit specifications. The implementation includes the core query class, a query runner that handles the execution flow on broker nodes, a tool chest for result merging and post-computation manipulation, and associated metrics and dependency injection modules.
extensions-contrib/moving-average-query/src/main, extensions-core/postgresql-metadata-storage · high confidence
New OPA Authorizer extension for external policy decisions
This change introduces the \druid-opa-authorizer\ extension, enabling Druid to delegate authorization decisions to an external Open Policy Agent (OPA) server. The \OpaAuthorizer\ implementation sends authentication results, requested actions, and resource details to a configurable OPA endpoint, respecting a configurable timeout and ignoring unknown response fields for forward compatibility. The extension registers itself via the Druid module system and includes example configurations (including LDAP bootstrap and role-grant definitions) to demonstrate integration.
druid-opa-authorizer, extensions-contrib/druid-opa-authorizer · high confidence
New OpenLineage request logger extension for Druid
This change introduces a new OpenLineage request logger extension for Druid, allowing users to configure \druid.request.logging.type=openlineage\ to emit query lineage events. The extension supports both CONSOLE and HTTP transport modes, with the latter offering configurable TLS via trust and key stores. It captures query context (such as query type, remote address, and identity) and statistics (including duration, bytes returned, and planning time) using specific OpenLineage JSON schemas. Users can also exclude specific native query types (like segmentMetadata) from logging.
extensions-contrib/openlineage-emitter · high confidence
New OpenTelemetry emitter extension for Druid query tracing
Adds the OpenTelemetry emitter extension, which generates OpenTelemetry Spans for Druid queries by processing \ServiceMetricEvent\ events for the \query/time\ metric. The extension extracts the W3C Trace Context (\traceparent\) from the query context to link Druid spans to parent traces, and adds Druid context entries as span attributes. It is enabled by loading the \opentelemetry-emitter\ extension and setting \druid.emitter\ to \opentelemetry\ (or adding it to a composing emitter list).
extensions-contrib/opentelemetry-emitter · high confidence
New OpenTelemetry emitter for query metrics
Added a new OpenTelemetryEmitter that exports Druid 'query/time' metrics as OpenTelemetry spans. The emitter extracts trace context from incoming events, creates spans with start/end times derived from the metric data, and sets span attributes from the event's user dimensions (excluding traceparent/tracestate fields). Span status is set to OK, ERROR, or UNSET based on the 'success' dimension.
opentelemetry-emitter · high confidence
New Protobuf extension for data ingestion
The new Protobuf extension allows you to ingest Protobuf data formats. It provides a \ProtobufInputFormat\ and a \ProtobufBytesDecoder\ interface with three implementations: \FileBasedProtobufBytesDecoder\ (loading descriptors from a file path or URL), \InlineDescriptorProtobufBytesDecoder\ (loading descriptors from an inline Base64 string), and \SchemaRegistryBasedProtobufBytesDecoder\ (loading from a schema registry). The extension also includes a \ProtobufConverter\ to handle complex types like timestamps and maps, and a \ProtobufInputRowSchema\ to support timestamp extraction for complex timestamp types.
extensions-core/protobuf-extensions · high confidence
New Quidem UT module for SQL-level testing and query recording
The new quidem-ut module provides a framework for writing SQL-level tests and capturing real-world query usage. It introduces a launcher that starts a local Broker service on port 12345, which can be configured via URI to use specific test backends like KttmNestedComponentSupplier. This setup enables recording SQL statements into .iq files for validation, allowing teams to detect regressions in query results by comparing against captured baselines.
quidem-ut · high confidence
New REST API for basic authentication user management
The basic security extension now exposes a new set of REST endpoints under /druid-ext/basic-security/authentication to manage users and credentials for basic HTTP authenticators. Administrators can list, create, update, and delete users, as well as refresh caches and check load status. The implementation distinguishes between coordinator nodes (which handle persistent storage updates) and non-coordinator nodes (which listen for cache updates), ensuring consistent user state across the cluster.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authentication/endpoint · high confidence
New REST API for managing basic authorization users, roles, and group mappings
The basic security extension now exposes a new set of REST endpoints under \/druid-ext/basic-security/authorization\ to manage authorization entities. Administrators can now create, retrieve, and delete users, roles, and group mappings, as well as assign roles to users and groups and manage role permissions. The API supports querying full or simplified permission details and includes endpoints to refresh caches and check load status, with validation on authorizer names and audit logging for update operations.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authorization/endpoint · high confidence
New SQL functions for DataSketches quantiles aggregations
This change introduces SQL support for the DataSketches quantiles extension, allowing users to perform approximate quantile aggregations and post-aggregation analysis directly in SQL queries. New SQL aggregators and functions are added, including \APPROX\_QUANTILE\_DS\ for creating sketches, \DS\_QUANTILES\_SKETCH\ for object-based sketching, and post-aggregation functions such as \DS\_GET\_QUANTILE\, \DS\_GET\_QUANTILES\, \DS\_CDF\, \DS\_RANK\, \DS\_HISTOGRAM\, and \DS\_QUANTILE\_SUMMARY\ to extract statistical insights from the generated sketches.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql · high confidence
New approximate and fixed-buckets histogram aggregation types
The histogram extension now supports two new aggregation types: ApproximateHistogram (with a folding variant for merging existing histograms) and FixedBucketsHistogram. ApproximateHistogram provides a memory-efficient, approximate distribution summary with configurable resolution and limits, while FixedBucketsHistogram offers a precise distribution with fixed bin counts, configurable outlier handling (ignore, overflow, clip), and serialization versions. Both types include full support for buffer and vector aggregators, serialization/deserialization (Serde), and SQL integration via dedicated SQL aggregators, enabling users to analyze data distributions with greater flexibility and performance.
extensions-core/histogram · high confidence
New authorization entity models for roles, users, and groups
The basic security extension introduces a new set of data-model classes in the authorization entity package to represent roles, users, and groups. These include core models like BasicAuthorizerRole and BasicAuthorizerUser, alongside 'Full' variants (BasicAuthorizerRoleFull, BasicAuthorizerUserFull) that carry additional user/group membership details, and 'SimplifiedPermissions' variants (BasicAuthorizerRoleSimplifiedPermissions, BasicAuthorizerUserFullSimplifiedPermissions) that expose permissions as ResourceAction objects for easier API consumption. The diff also adds mapping and bundle classes (BasicAuthorizerGroupMapping, BasicAuthorizerGroupMappingFull, BasicAuthorizerGroupMappingMapBundle, BasicAuthorizerRoleMapBundle, BasicAuthorizerUserMapBundle, GroupMappingAndRoleMap, UserAndRoleMap) to handle group-to-role mappings and serialized map bundles, and a BasicAuthorizerPermission class that stores resource actions with compiled regex patterns for matching.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authorization/entity · high confidence
New automated Druid example configuration set
A new set of configuration files has been added to the examples directory to provide a ready-to-run, automated Druid cluster setup. This includes common JVM settings, a unified runtime properties file that configures local Derby metadata storage, local deep storage, and specific extensions (HDFS, Kafka, Datasketches, Parquet), along with dedicated runtime properties for each node type (Broker, Coordinator/Overlord, Historical, Indexer, MiddleManager, and Router). The configuration also introduces a new log4j2.xml that routes task logs to dedicated files and sets quieter logging for Kafka supervisors.
examples/conf/druid/auto · high confidence
New bar chart and multi-axis chart modules in Explore view
The Explore view now includes two new visualization modules: a bar chart and a multi-axis chart. The bar chart module allows users to visualize data by splitting on a column and aggregating a measure, with options for time bucketing and sorting. The multi-axis chart module supports plotting multiple measures on a shared time axis, featuring automatic granularity detection, timezone-aware formatting, and a brush tool for selecting time ranges. Both modules are registered in the module repository and utilize ECharts for rendering.
web-console/src/views/explore-view/modules/bar-chart-module, web-console/src/views/explore-view/modules/multi-axis-chart-module · high confidence
New coordinator-overlord configuration for Druid master nodes
Added a new \coordinator-overlord\ configuration directory under \examples/conf/druid/cluster/master\ that combines the Coordinator and Overlord services into a single process. This includes a JVM configuration file setting 15GB heap size and specific logging/encoding properties, a main class definition pointing to \org.apache.druid.cli.Main server coordinator\, and a runtime properties file that enables the overlord service within the coordinator (\druid.coordinator.asOverlord.enabled=true\), sets the service to port 8081, and tunes segment polling and indexing delays for faster ingestion.
examples/conf/druid/cluster/master · high confidence
New developer documentation and tooling in the dev/ directory
The project has consolidated development resources into a new dev/ directory, providing committers with structured instructions for managing pull requests, issues, and labels, as well as a guide for backporting changes using the sqren/backport CLI. To support local development, the update includes an IntelliJ setup guide detailing JDK 25 configuration, code coverage with JaCoCo, and remote debugging, alongside official Eclipse and IntelliJ code style XML files to standardize formatting. Additionally, a shell script is provided to automatically adjust permissions on heap dumps, and a license management document explains how to handle license and notice files for both source and binary distributions.
dev · high confidence
New dump-segment tool for inspecting v10 segment metadata
A new example tool named 'dump-segment' has been added to the examples/conf/druid/tools directory, allowing users to dump v10 segment metadata. This addition includes specific configuration files: a common runtime properties file that loads the 'druid-datasketches' extension, a log4j2 configuration that disables root logging to facilitate output piping, and a JVM configuration setting server mode, exit-on-OOM, UTC timezone, and UTF-8 encoding.
examples/conf/druid/tools · high confidence
New example configurations for Druid broker and router nodes
Added example configuration files (JVM settings, main entry points, and runtime properties) for the broker and router components in a Druid cluster. The broker example is configured with 12GB heap, 6GB direct memory, and query caching disabled to favor push-down caching, while the router example is set up as an HTTP proxy with management proxy enabled for the unified web console.
examples/conf/druid/cluster/query · high confidence
New example scripts for running Druid services and tools
The examples/bin directory now includes a set of new shell and Python scripts to help users run and interact with Druid components. This adds launcher scripts for individual services (broker, coordinator, historical, middleManager, overlord, router) that delegate to a common node.sh script, a unified run-druid script for starting services with custom configurations, and a run-java utility that automatically applies Java 11+ strong encapsulation flags. It also introduces helper tools: dsql (with Python 2 and 3 variants) for executing SQL queries, post-index-task (with Python 2 and 3 variants) for submitting and monitoring indexing tasks, dump-segment for inspecting segment metadata, generate-example-metrics for producing sample data, jconsole.sh for connecting to Druid instances with Log4j2 plugins, and a greet script for startup messaging.
examples/bin · high confidence
New filter types for Iceberg data ingestion
The Druid Iceberg extension now supports additional filter types to refine data ingestion from Iceberg tables. Users can apply equality checks (IcebergEqualsFilter), range queries with open/closed bounds (IcebergRangeFilter), time-based windowing relative to a base time (IcebergTimeWindowFilter), and interval-based filtering (IcebergIntervalFilter). These filters can be combined using logical AND (IcebergAndFilter) and OR (IcebergOrFilter) operators, allowing for complex query conditions to be pushed down to the Iceberg layer for more efficient data scanning.
druid-iceberg-extensions · high confidence
New histogram aggregation and post-aggregation capabilities
The druid-histogram extension now supports approximate and fixed-bucket histogram aggregations with new post-aggregators for extracting quantiles, equal-sized buckets, custom-bucket distributions, and single quantile values. Users can now aggregate numeric data into histograms using either the \approxHistogram\ or \fixedBucketsHistogram\ aggregator types, and subsequently transform these results into quantile estimates or bucketed distributions via the \quantile\, \quantiles\, \equalBuckets\, \customBuckets\, and \buckets\ post-aggregators. The implementation includes vectorization support for numeric columns to improve performance and allows finalizing histogram data as Base64-encoded binary strings.
druid-histogram · high confidence
New metadata storage updater interface and implementations for basic authorization
The basic security extension now includes a new \BasicAuthorizerMetadataStorageUpdater\ interface along with \CoordinatorBasicAuthorizerMetadataStorageUpdater\ and \NoopBasicAuthorizerMetadataStorageUpdater\ implementations. This adds the infrastructure for managing user, role, and group mapping data in the metadata storage, enabling the coordinator to handle authorization configuration reads and writes.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authorization/db/updater · high confidence
New modular service entry points and broker realtime selector configuration
The services module now includes new CLI entry points (CliBroker, CliCoordinator, CliHistorical, CliIndexer, CliMiddleManager, CliOverlord) and a run script, establishing the concrete wiring for each Druid process. Specifically, the Broker now supports configurable realtime server selection via the druid.broker.realtime.balancer.type and druid.broker.realtime.select.tier properties, allowing users to choose from Custom, Preferred, Strict, and Pooled tier selector strategies for realtime data.
services · high confidence
New release and license compliance automation scripts
The distribution/bin directory now includes a suite of new automation scripts to streamline release engineering and license compliance. These scripts handle generating binary license and notice files (generate-binary-license.py, generate-binary-notice.py), validating dependency licenses (check-licenses.py), and producing dependency reports (generate-license-dependency-reports.py). Additional utilities support the release process by making release notes linkable (make-linkable-release-notes.py), identifying missing backports (find-missing-backports.py), tagging milestones (tag-missing-milestones.py), listing milestone contributors and PRs (get-milestone-contributors.py, get-milestone-prs.py), and inspecting JAR notices and web console dependencies (jar-notice-lister.py, web-console-dep-lister.py). A new script (build-textfile-readme.sh) also automates README generation for distributions.
distribution/bin · high confidence
New single-server deployment configurations for micro, medium, and large profiles
Added new example configuration sets for single-server Druid deployments under examples/conf/druid/single-server, organized into micro-quickstart, medium, and large profiles. These profiles provide pre-tuned JVM settings, runtime properties, and logging configurations for the broker, coordinator-overlord, historical, middleManager, and router services, allowing users to quickly deploy a single-node cluster scaled to their resource availability.
examples/conf/druid/single-server · high confidence
New stats extension for variance, standard deviation, and Z-test aggregations
The new \extensions-core/stats\ module introduces statistical aggregation capabilities to Druid. It adds \VarianceAggregatorFactory\ and \VarianceFoldingAggregatorFactory\ for computing sample and population variance, along with \StandardDeviationPostAggregator\ for standard deviation. SQL support is provided via \BaseVarianceSqlAggregator\, enabling \VAR\_POP\, \VAR\_SAMP\, \STDDEV\_POP\, \STDDEV\_SAMP\, \VAR\, and \STDDEV\ functions. The extension also includes \ZtestPostAggregator\ for two-sample Z-tests and \PvaluefromZscorePostAggregator\ for calculating two-tailed p-values from Z-scores. Vectorized aggregators are implemented for double, float, long, and object types to optimize performance, and the module registers the necessary Jackson subtypes and SQL bindings.
extensions-core/stats · high confidence
New testcontainers module for running Apache Druid services in tests
The \druid-testcontainers\ module now provides a \DruidContainer\ class and supporting \DruidCommand\ definitions, enabling developers to spin up specific Apache Druid services (such as Overlord, Coordinator, Broker, Historical, Router, Indexer, and MiddleManager) in Docker containers for integration testing. The module includes pre-configured commands with sensible defaults for JVM options, exposed ports, and runtime properties, and supports standard Druid Docker images (versions 31.0.2, 32.0.1, and 33.0.0).
druid-testcontainers, extensions-core/druid-testcontainers · high confidence
New testing tools for cluster fault injection and metrics collection
The testing-tools extension now provides utilities for scale and fault-tolerance testing. It introduces a 'sleep' SQL function and expression macro to intentionally delay query processing, and a cluster testing mode that injects faults into Coordinator, Overlord, and task action clients to simulate delays and failures. Additionally, it adds a standalone 'eventCollector' service to collect and forward metrics emitted by other Druid nodes during tests.
extensions-core/testing-tools · high confidence
New time chart visualization in the Explore view
The Explore view now includes a new Time chart module that renders continuous time-series data using D3. Users can visualize metrics as line, area, or bar charts with support for smooth, linear, or step curves. The chart allows faceting by a specific column, stacking up to a configurable number of facets, and includes interactive features like time-range selection and shifting. It respects the configured timezone for accurate time-axis rendering and handles data granularity automatically or via user selection.
web-console/src/views/explore-view/modules/time-chart-module · high confidence
New timeMin and timeMax aggregators for timestamp columns
The time-min-max extension now provides dedicated aggregators to compute the minimum and maximum timestamps in a dataset. Users can use the new timeMin and timeMax aggregation types, which are registered via the TimestampMinMaxModule. These aggregators handle timestamp parsing and comparison, returning the earliest or latest timestamp found in the specified column.
extensions-contrib/time-min-max/src/main/java · high confidence
New variance and standard deviation aggregators in the stats extension
The stats extension now includes new \VarianceAggregatorFactory\ and \StandardDeviationPostAggregator\ classes, enabling users to calculate variance and standard deviation metrics. The variance aggregator supports float, double, long, and complex column types, while the post-aggregator computes the square root of the variance to provide standard deviation results.
druid-stats · high confidence
Prometheus emitter adds TTL-based metric expiration and configurable histogram buckets
The Prometheus emitter now supports expiring metrics that have not been updated within a configured time-to-live (TTL). When the \flushPeriod\ configuration is set, the emitter tracks the last update time for each unique label combination and automatically removes stale metrics from the Prometheus registry during periodic cleanup runs. Additionally, metric definitions in the dimension map can now specify custom \histogramBuckets\, allowing users to tailor the bucket boundaries for timer metrics instead of relying on the default set. Label tracking for TTL is disabled if no flush period is configured to avoid unnecessary overhead.
extensions-contrib/prometheus-emitter/src/main/java · high confidence
Prometheus emitter extension initialization and default metric definitions
The Prometheus emitter extension is now automatically discovered and initialized via the standard Druid module service loader file (META-INF/services/org.apache.druid.initialization.DruidModule). Additionally, a comprehensive default metrics configuration (defaultMetrics.json) is provided, defining the schema, types, dimensions, and help text for a wide range of metrics including query performance, merge buffer usage, Jetty thread pool stats, Kafka consumer metrics, ingestion counts and lags, task execution times, supervisor states, and tier-based segment management metrics.
extensions-contrib/prometheus-emitter/src/main/resources · high confidence
Promote Parquet ingestion extension to core
The Parquet ingestion module has been moved from the 'contrib' area to 'extensions-core', making it a standard, first-class extension included in core distributions. This change introduces the \ParquetExtensionsModule\ for dependency injection, a new \ParquetReader\ for row parsing, and a \ParquetToJson\ utility for file conversion, ensuring the extension is now automatically available without manual installation.
extensions-core/parquet-extensions · high confidence
Redis cache extension now supports cluster mode and TLS connections
The Redis cache extension has been enhanced to support both standalone and Redis Cluster deployments, allowing users to configure multiple nodes for high availability. Additionally, the extension now supports TLS encryption for connections, with a new configuration option to skip hostname verification if required. These changes are implemented in the new cache provider and factory classes within the extension.
extensions-contrib/redis-cache/src/main/java · high confidence
Registration of DataSketches modules for automatic initialization
The Datasketches extension now registers its specific aggregation modules (Theta, HLL, KLL, Quantiles, and Tuple) via a Java Service Provider Interface file. This ensures that these sketch-based aggregations are automatically discovered and initialized by the Druid runtime without requiring manual configuration, enabling users to utilize these statistical sketches out-of-the-box.
extensions-core/datasketches/src/main/resources · high confidence
S3 extension restructured for AWS SDK v2 and native input source support
The S3 extension has been refactored to support the AWS SDK v2, introducing a new native batch input source (S3InputSource) that allows direct ingestion from S3 objects with configurable credentials and retry logic. This change also includes updated storage connectors for segment archiving and moving, along with new catalog definitions for S3 input sources to enable SQL-based external table queries.
extensions-core/s3-extensions · high confidence
SQL support for Array-of-Doubles Tuple Sketches
Users can now use SQL functions to aggregate and query Array-of-Doubles Tuple Sketches. This change adds the \DS\_TUPLE\_DOUBLES\ aggregation function, which accepts a dimension column and optional metric columns, along with an optional final argument to specify nominal entries. It also introduces SQL operators for post-aggregation metrics (\DS\_TUPLE\_DOUBLES\_METRICS\_SUM\_ESTIMATE\) and set operations (\DS\_TUPLE\_DOUBLES\_UNION\, \DS\_TUPLE\_DOUBLES\_INTERSECT\, \DS\_TUPLE\_DOUBLES\_NOT\), allowing these sketch-based analytics to be performed directly within SQL queries.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/tuple, extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/tuple/sql · high confidence
SQL support for DataSketches HLL aggregations and post-aggregations
Users can now use HyperLogLog (HLL) sketch aggregations and post-aggregations directly in SQL queries. This change introduces the APPROX\_COUNT\_DISTINCT\_DS\_HLL SQL aggregator, which supports string, numeric, and existing HLL sketch columns, and allows specifying lgK and target HLL type parameters. Additionally, new SQL functions hll\_sketch\_estimate and hll\_sketch\_estimate\_with\_error\_bounds allow extracting point estimates and confidence intervals from HLL sketches as post-aggregations, while HLL sketch objects can be returned via DS\_HLL, merged via HLL\_SKETCH\_UNION, or serialized to strings via HLL\_SKETCH\_TO\_STRING.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql · high confidence
SQL support for Theta Sketch post-aggregations and set operations
Users can now use Theta Sketch functions directly in SQL expressions. This change introduces SQL operators for \theta\_sketch\_estimate\ (returning a double) and \theta\_sketch\_estimate\_with\_error\_bounds\ (returning a complex type with bounds), as well as set operations like \THETA\_SKETCH\_UNION\, \THETA\_SKETCH\_INTERSECT\, and \THETA\_SKETCH\_NOT\. It also adds the \APPROX\_COUNT\_DISTINCT\_DS\_THETA\ aggregator and the \DS\_THETA\ aggregator for creating sketches, enabling approximate distinct counting and sketch manipulation within SQL queries.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta/sql · high confidence
Support for partial segment downloads from S3
The S3 storage extension now supports loading segments via byte-range requests instead of always downloading the entire file. This is enabled for segments stamped as 'rangeable' at push time (uncompressed layouts), allowing the S3SegmentRangeReader to fetch only the required data chunks. This change reduces network transfer and speeds up segment loading for compatible S3 storage configurations.
druid-s3-extensions · high confidence
Support for partial segment loads via Google Cloud Storage byte-range reads
The Google storage extension now supports loading segments from Google Cloud Storage using byte-range reads instead of downloading the entire file. This is enabled by new classes: GoogleLoadSpec, which tracks whether a segment is 'rangeable' (stamped at push time), and GoogleSegmentRangeReader, which performs the actual range requests with retry logic. GoogleByteSource provides the underlying stream abstraction. This change allows for faster segment loading when only parts of a segment are needed, reducing network transfer and latency.
druid-google-extensions · high confidence
Theta sketch aggregation and post-aggregation capabilities
This change introduces the core implementation for Theta sketch aggregations in Druid. It adds the \SketchAggregator\ and \SketchBufferAggregator\ to build and merge theta sketches during query processing, along with \SketchHolder\ to manage the underlying sketch objects. It also introduces post-aggregators (\SketchEstimatePostAggregator\, \SketchToStringPostAggregator\) that allow users to extract cardinality estimates (optionally with error bounds) and debug string representations from the sketches. The \SketchModule\ registers these components, including SQL aggregator and operator conversions, making theta sketch functionality available for both standard queries and SQL.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta · high confidence
Behavioural changes
1 commit (0 fixes) modifying druid-tsfile-extensions, extensions-contrib/tsfile-extensions
A change to existing behaviour in druid-tsfile-extensions, extensions-contrib/tsfile-extensions — 1 commit, 9 files: “feat: add Apache TsFile input format extension (\#20729)” (refs \#20729).
druid-tsfile-extensions, extensions-contrib/tsfile-extensions · medium confidence · unverified
1725 commits (421 fixes) modifying processing
A change to existing behaviour in processing — 1725 commits (421 fixs), 3620 files: “HttpClient: Include error handler on all connection attempts. (\#14915)”; “Materialize scan results correctly when columns are not present in the segments (\#16619)”; “Fix extractionFns on number-wrapping dimension selectors. (\#15761)”; and 1721 more (refs \#14915, \#16619, \#15761, \#9472, \#13297, …).
processing · medium confidence · unverified
2 commits (0 fixes) modifying .mvn
A change to existing behaviour in .mvn — 2 commits, 2 files: “ci: maven cache diet; static checks re-homed; pre-pull and retries purged (\#20734)”; “Add the Maven wrapper and use it in CI (\#20496)” (refs \#20734, \#20496).
.mvn · medium confidence · unverified
5 commits (1 fix) modifying extensions-contrib/druid-exact-count-bitmap
A change to existing behaviour in extensions-contrib/druid-exact-count-bitmap — 5 commits (1 fix), 26 files: “Upgrade RoaringBitmap to 1.6.14 (\#19688)”; “refactor: replace deprecated DataSegment constructors outside the server module (\#20795)”; “fix: Reject non-numeric string literals in SUM, AVG and other numeric aggregators (\#20845)”; and 2 more (refs \#19688, \#20795, \#20845, \#18906, \#18021).
extensions-contrib/druid-exact-count-bitmap · medium confidence · unverified
Azure deep storage extension restructured with new input sources and client factory
The Azure extension in extensions-core has been refactored to introduce a new \AzureClientFactory\ that supports Azure credentials chains and managed identities, alongside new \AzureInputSource\ and \AzureStorageAccountInputSource\ classes that enable flexible data ingestion from Azure Blob Storage. This change also includes updated configuration models like \AzureAccountConfig\ and \AzureDataSegmentConfig\, and implements \AzureDataSegmentKiller\ to handle segment deletion via batch operations, improving how Druid interacts with Azure deep storage for both reading and writing data.
extensions-core/azure-extensions/src/main · high confidence
Documentation website migrated to Docusaurus 3 with Node.js 22
The Apache Druid documentation website has been rebuilt using Docusaurus 3, replacing the previous version. This migration updates the required Node.js runtime to version 22 (pinned via .node-version) and introduces new build tooling, including a mise configuration (mise.toml) for environment management. The site now features a comprehensive redirect map (redirects.js) to preserve legacy documentation URLs, a dedicated spell-check dictionary (.spelling), and automated link-linting scripts to ensure content integrity. Additionally, the UI includes custom CSS and JavaScript to add copy-to-clipboard buttons to code blocks, and the footer copyright year has been updated to 2026.
website · high confidence
GCP initialization is now lazy
The GCP module now provides HTTP transport, JSON factory, and request initializer as lazy singletons, deferring the creation of Google credentials and network resources until they are actually needed. This change improves startup performance and reduces unnecessary resource consumption for deployments that do not use GCP services.
cloud/gcp-common · high confidence
HDFS storage extension refactored with new component classes
The HDFS storage extension has been refactored to use a new set of core classes: HdfsDataSegmentKiller, HdfsDataSegmentPuller, HdfsLoadSpec, and HdfsStorageAvailabilityChecker. This change introduces a dedicated availability checker that validates HDFS connectivity at startup, updates the segment puller to use a new FileObject abstraction for HDFS interactions, and replaces the previous segment killer logic with a new implementation that supports LZ4 compression and cleans up empty parent directories. The HdfsLoadSpec now explicitly manages the puller dependency for segment loading.
druid-hdfs-storage · high confidence
Influx extensions migrate to the InputFormat interface
The Influx extensions now use the standard InputFormat interface for data ingestion, replacing the previous InfluxParser and InfluxParseSpec components. This change updates how InfluxDB line protocol data is read and parsed, ensuring compatibility with the current Druid input architecture while maintaining support for measurement whitelisting and line protocol parsing.
druid-influx-extensions · high confidence
InfluxDB line protocol ingestion now uses the InputFormat API
The InfluxDB line protocol parser has been migrated from the legacy InfluxParser/InfluxParseSpec classes to the modern InputFormat interface. This change updates the underlying parsing engine (InfluxInputFormat) and its associated grammar, allowing users to ingest InfluxDB data using the current standard input format mechanism while maintaining compatibility with existing data schemas.
extensions-contrib/influx-extensions · high confidence
Introduces pluggable metadata storage updater for basic authentication
The basic security extension now uses a new \BasicAuthenticatorMetadataStorageUpdater\ interface to manage user credentials and user maps in metadata storage. This change introduces \CoordinatorBasicAuthenticatorMetadataStorageUpdater\ as the concrete implementation that handles database interactions, polling, and initial admin/internal user setup, alongside a \NoopBasicAuthenticatorMetadataStorageUpdater\ for scenarios where direct storage updates are not required. This refactors how the basic authenticator persists and retrieves user data, decoupling the storage logic from the core authentication flow.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authentication/db/updater · high confidence
Kafka lookup extraction moved to the new Lookup framework
The Kafka extraction namespace extension has been migrated from the legacy lookup system to the new Lookup framework. This change introduces a new \KafkaLookupExtractorFactory\ that integrates with the \NamespaceExtractionCacheManager\ for centralized cache management, adds a \KafkaLookupExtractorIntrospectionHandler\ to expose the factory's active status via JAX-RS, and registers the necessary Jackson subtypes and Guice modules. The extension now depends on \druid-lookups-cached-global\ and includes updated integration tests using Testcontainers to validate the new lifecycle and serialization behavior.
extensions-core/kafka-extraction-namespace · high confidence
Moved Ranger security extension to contrib
The Ranger security extension has been relocated from the core distribution to the extensions-contrib directory. This move isolates the Ranger-specific authorizer module, its Guice bindings, and associated test resources, ensuring that users who do not require Apache Ranger integration are no longer burdened by its dependencies and configuration overhead.
extensions-contrib/druid-ranger-security · high confidence
MySQL metadata storage extension refactored with modular configuration and new input connector
The MySQL metadata storage extension has been restructured to improve configuration flexibility and security. A new MySQLInputSourceDatabaseConnector allows users to specify a custom JDBC driver class name (supporting both MySQL and MariaDB drivers) and enforces security by validating connection URL parameters against an allowlist. SSL connectivity is now managed via a dedicated MySQLConnectorSslConfig, exposing options for certificate stores, cipher suites, and TLS protocols. The driver class is configurable through MySQLConnectorDriverConfig, defaulting to the standard MySQL driver but allowing overrides. Additionally, the MySQLMetadataStorageActionHandler now applies a LIMIT clause to SQL queries to prevent unbounded result sets.
extensions-core/mysql-metadata-storage · high confidence
New EC2 autoscaling data models for IAM profiles and user data
The EC2 extensions now include new data models to support autoscaling configuration: EC2IamProfileData handles IAM instance profile specifications (name and ARN) for EC2 instances, while GalaxyEC2UserData and StringEC2UserData provide structured ways to define and serialize EC2 user data, including support for version replacement in string-based user data templates.
druid-ec2-extensions · high confidence
New Hadoop 3.3.6 tutorial environment with Zulu JDK 11
The Hadoop quickstart tutorial now provides a new Docker-based environment that runs Hadoop 3.3.6 on CentOS 7. To address the end-of-life status of the CentOS base image, the build process has been updated to use the vault.centos.org mirror. The Java runtime has been upgraded from Zulu OpenJDK 8 to Zulu OpenJDK 11, and the configuration files have been adjusted to support this version and Hadoop 3.x requirements, such as specific JVM options and YARN settings.
examples/quickstart/tutorial/hadoop · high confidence
New common configuration for Druid cluster examples
The cluster example now includes a shared configuration directory (\_common) containing common.runtime.properties and log4j2.xml. The properties file sets up a local Derby metadata store and local disk deep storage for easy testing, enables SQL and multi-stage query extensions, configures the ServiceStatusMonitor, and hides sensitive properties from the status endpoint. The logging configuration adds rolling log files that auto-delete after 7 days and routes task-specific logs to dedicated files, while reducing noise from Kafka and Jersey components.
_examples/conf/druid/cluster/\common · high confidence
Ranger security extension moved to contrib
The Druid Ranger security extension has been relocated from the core distribution to the extensions-contrib directory. This change affects the project structure and module organization, moving the RangerAuthorizer implementation and its associated classes to a separate contrib module, which may impact how the extension is built, packaged, and included in Druid distributions.
druid-ranger-security · high confidence
Redesigned Docker image build and containerized deployment
The Docker build process has been completely rewritten to use a multi-stage build that compiles Druid from source using Maven 3.9 and JDK 25, then packages the result into a minimal distroless Java 25 image. To reduce image size, duplicate JARs are replaced with symlinks via a new deduplication script, and a static bash binary is included for environments lacking a shell. The default deployment now uses PostgreSQL 17.6 for metadata storage and Zookeeper 3.5.10, configured via a new docker-compose.yml. The container runtime scripts (druid.sh, peon.sh) now support service-specific log4j overrides, configurable JVM memory settings via environment variables, and an additional classpath mechanism (DRUID\_ADDITIONAL\_CLASSPATH) for external dependencies. Separate Dockerfiles (Dockerfile.mysql, Dockerfile.mariadb) are provided to add MySQL or MariaDB connectors to the base image.
distribution/docker · high confidence
Refactored HLL sketch aggregators with optimized sketch handling and input validation
The HLL sketch aggregation logic in the datasketches extension has been refactored to improve performance, safety, and type correctness. A new \HllSketchHolder\ class now wraps sketches and unions, enabling optimized merge operations that avoid expensive HLL\_8 to HLL\_4 conversions by leveraging HLL\_8 directly. The \HllSketchBuildAggregatorFactory\ now includes strict input validation to reject unsupported complex column types, and the \HllSketchHolderObjectStrategy\ has been updated with a safer \isSafeToConvertToNullSketch\ check to prevent errors during deserialization. Additionally, the implementation now supports vectorized aggregation for both build and merge operations, and correctly handles string encoding parameters during sketch construction.
extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll · high confidence
Refactored basic authentication cache management into pluggable components
The basic authentication extension now uses a new cache management architecture to handle user map synchronization. Non-coordinator services use CoordinatorPollingBasicAuthenticatorCacheManager to periodically poll the coordinator for updates, while coordinator nodes use MetadataStoragePollingBasicAuthenticatorCacheManager to read directly from the metadata store. This change introduces BasicAuthenticatorCacheNotifier to handle state updates and includes a NoopBasicAuthenticatorCacheNotifier for scenarios where notifications are not required, allowing for more flexible configuration of how authentication database state is distributed and cached across the cluster.
extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authentication/db/cache · high confidence
SQL query planning and execution architecture refactored
The SQL module introduces a new statement lifecycle model that decouples query planning from execution, allowing for direct execution paths and improved resource management. This change includes a custom cost model (DruidVolcanoCost) that prioritizes row count over CPU and I/O to optimize plan selection, and adds support for casted literals in function arguments to resolve JDBC driver limitations. Additionally, the update standardizes timestamp and date output formatting in SQL results and integrates Avatica metrics into Druid's monitoring system.
druid-sql · high confidence
Service loader files updated to use org.apache.druid package names
The META-INF/services/org.apache.druid.initialization.DruidModule files in various extensions (including Cassandra, distinctcount, Kafka, OpenTSDB, Redis, StatsD, Thrift, Time-Min-Max, Avro, and Basic Security) have been updated to reference the new org.apache.druid.\* class names. This change aligns the module registration with the project's package rename from io.druid to org.apache.druid, ensuring the extensions are correctly discovered and initialized by the Druid runtime.
(repo-wide) · high confidence
Update DruidModule service registration to new package name
The service provider configuration for the CloudFiles extension has been updated to register the module under the new \org.apache.druid\ package namespace. This ensures the \CloudFilesStorageDruidModule\ is correctly discovered and initialized by the Apache Druid runtime following the project's package reorganization.
extensions-contrib/cloudfiles-extensions/src/main/resources · high confidence
Fixes
Fix concurrent FileSystem initialization race in ORC input format
The ORC input format now safely initializes the Hadoop FileSystem instance using a thread-safe atomic check, preventing race conditions that could occur when multiple threads attempt to initialize the FileSystem concurrently. This change ensures stable ingestion of ORC files by avoiding potential context classloader conflicts during the initialization phase.
druid-orc-extensions · high confidence
Fixes incomplete row ingestion and resource leaks in Delta Lake connector
The Delta Lake connector now correctly reads all data rows from each file instead of stopping after the first batch (typically 1,024 rows), ensuring complete data ingestion for multi-batch files. Additionally, the implementation properly closes file handles and iterators as each file is processed, preventing resource leaks when ingesting tables that span multiple files.
druid-deltalake-extensions · high confidence
Test coverage
Added Avro schema test fixture for complex data types; Added HllSketch test resources; Added JUnit 5 tests for Iceberg filter implementations; Added JUnit 5 tests for OpenTSDB emitter components; Added JUnit 5 tests for SQL Doubles Sketch aggregators; Added KLL sketch test resources; Added SQL aggregation tests for ArrayOfDoublesSketch; Added SQL aggregator tests for HllSketch; Added test coverage for DataSketches HLL aggregators; Added test data files for Compressed Big Decimal extension; Added test data for numeric quantiles sketch aggregator; Added test data resources for Datasketches extension; Added test resources for ArrayOfDoublesSketch and bucket aggregations; Added tests for Aliyun OSS input source serialization and system fields; Added tests for Array of Doubles Sketch tuple aggregations and post-aggregators; Added tests for Avro stream input format; Added tests for CompressedBigDecimal aggregators; Added tests for KllDoublesSketch aggregations and post-aggregators; Added tests for MapVirtualColumn behavior in GroupBy and TopN queries; Added tests for Theta Sketch SQL aggregators; Added tests for Thrift input format parsing and serialization; Added tests for ToObjectVectorColumnProcessorFactory; Added tests for datasketches projection aggregation; Added tests for the DDSketch aggregation extension; Added tests for the Spectator Histogram extension; Added tests for the t-digest sketch aggregation extension; Added unit tests for AWS client configuration and utility logic; Added unit tests for Ambari Metrics Emitter configuration and conversion logic; Added unit tests for Avro extensions components; Added unit tests for Azure deep storage components; Added unit tests for Azure input source components; Added unit tests for CompressedBigDecimal extension; Added unit tests for DistinctCount aggregation in GroupBy, Timeseries, and TopN queries; Added unit tests for DoublesSketch quantiles aggregators and post-aggregators; Added unit tests for DropwizardEmitterConfig; Added unit tests for KafkaEmitter configuration and event handling; Added unit tests for Momentsketch extension components; Added unit tests for Prometheus emitter configuration and metric handling; Added unit tests for Rabbit Stream Supervisor configuration and behavior; Added unit tests for RabbitMQ Stream indexing service configuration and record ingestion; Added unit tests for Redis cache configuration and cluster/standalone operations; Added unit tests for SQL Server metadata storage components; Added unit tests for statsd-emitter dimension conversion and emission behavior; Added unit tests for the Druid Delta Lake connector; Added unit tests for theta sketch aggregators and post-aggregators; Added unit tests for time-min-max aggregation extension; Embedded tests for basic and LDAP authentication with audit and MSQ coverage; Expanded embedded test coverage for storage, ingestion, and query engines; Migrate basic security extension tests to JUnit 5; New JMH benchmarks for Druid internals; Web console: add e2e tests for auto-compaction and query cancellation.
Dependencies
2857 commits updating dependencies (86 manifests)
A dependency / build maintenance change in (dependencies) — 2857 commits (275 fixs), 86 files: “Increase the max heap size for strict compilation (\#4306)”; “build(deps): bump at.yawk.lz4:lz4-java from 1.11.2 to 1.11.3 (\#20359)”; “Make first few allocatePendingSegment retries quiet”; and 2463 more (refs \#4306, \#20359, \#12203, \#18131, \#16038, …).
(dependencies) · high confidence · unverified
Housekeeping
Added bundled license files for web console dependencies
The licenses directory now includes the full text of the Apache 2.0, MIT, and SIL Open Font licenses for the web console's third-party dependencies, such as Babel, CodeMirror, Emotion, Floating UI, and Open Sans. This ensures that all required attribution and license terms for these packages are distributed with the software.
licenses · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 45 → 49 (+4.6)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 72 → 72 (-0.3)
- Architecture 47 → 47 (-0.0)
- Maturity 74 → 64 (-10.3)
- Readiness 37 → 46 (+9.2)
- Security 60 → 74 (+13.4)
- Accessibility 43 → 44 (+1.3)
- Performance 88 → 100 (+11.9)
Resolved (474)
- 102738.apply (cognitive 38) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java)
- 102738.apply (cyclomatic 16) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java)
- 174272.apply (cognitive 24) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java)
- 174272.apply (cyclomatic 16) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java)
- CostBasedAutoScaler.extractPollIdleRatio (cognitive 24) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/autoscaler/CostBasedAutoScaler.java)
- Cross-context type AuthorizationResult (server → sql)
- Cross-context type AuthorizationResult (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/DruidPlanner.java)
- Cross-context type AuthorizationResult (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/DruidPlanner.java)
- Cross-context type AuthorizationResult (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerContext.java)
- Cross-context type AuthorizationResult (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerContext.java)
- Cross-context type AuthorizationResult (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/run/SqlEngine.java)
- Cross-context type AuthorizationResult (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/run/SqlEngine.java)
- Cross-context type AuthorizationResult (server → sql) (sql/src/main/java/org/apache/druid/sql/http/SqlResource.java)
- Cross-context type ColumnSpec (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/external/Externals.java)
- Cross-context type ColumnSpec (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/CatalogTableWriter.java)
- Cross-context type ColumnSpec (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/CatalogTableWriter.java)
- Cross-context type ColumnSpec (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/CatalogTableWriter.java)
- Cross-context type ColumnSpec (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/CatalogTableWriter.java)
- Cross-context type ColumnSpec (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/ProjectionSpecTranslator.java)
- Cross-context type ColumnSpec (server → sql) (sql/src/main/java/org/apache/druid/sql/calcite/planner/ProjectionSpecTranslator.java)
- …and 454 more
New (1332)
- 102665.apply (cognitive 38) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java)
- 102665.apply (cyclomatic 16) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java)
- 174342.apply (cognitive 24) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java)
- 174342.apply (cyclomatic 16) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/SeekableStreamSupervisor.java)
- Banned license: org.openjdk.jmh:jmh-core
- Banned license: org.openjdk.jmh:jmh-generator-annprocess
- CastOperatorConversion.toDruidExpression (cyclomatic 17) (sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/CastOperatorConversion.java)
- ClassTooLong: ServerManager (server/src/main/java/org/apache/druid/server/ServerManager.java)
- CostBasedAutoScaler.extractAutoscalerMetric (cognitive 22) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/autoscaler/CostBasedAutoScaler.java)
- DefaultOperandTypeChecker.checkOperandTypes (cognitive 36) (sql/src/main/java/org/apache/druid/sql/calcite/expression/DefaultOperandTypeChecker.java)
- DefaultOperandTypeChecker.checkOperandTypes (cyclomatic 19) (sql/src/main/java/org/apache/druid/sql/calcite/expression/DefaultOperandTypeChecker.java)
- Dependency hygiene PARTLY measured — Maven build resolved part of the dependency graph, currency reported but not scored
- Duplicated block (10 lines × 2) (extensions-core/azure-extensions/src/main/java/org/apache/druid/storage/azure/AzureDataSegmentPusher.java)
- Duplicated block (11 lines × 6) (extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authentication/db/updater/CoordinatorBasicAuthenticatorMetadataStorageUpdater.java)
- Duplicated block (12 lines × 3) (sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQuery.java)
- Duplicated block (13 lines × 8) (extensions-core/druid-basic-security/src/main/java/org/apache/druid/security/basic/authentication/db/updater/CoordinatorBasicAuthenticatorMetadataStorageUpdater.java)
- Duplicated block (13–16 lines × 2) (server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java)
- Duplicated block (24 lines × 2) (processing/src/main/java/org/apache/druid/extendedset/intset/ConciseSet.java)
- Duplicated block (43 lines × 2) (processing/src/main/java/org/apache/druid/segment/data/FrontCodedIntArrayIndexed.java)
- Duplicated block (5 lines × 2) (indexing-service/src/main/java/org/apache/druid/indexing/seekablestream/supervisor/autoscaler/CostBasedAutoScaler.java)
- …and 1312 more
Changes since last survey
- 121 commits — 78 feature/other, 43 fixes
By area
- (root) — 21 commits
- server/src — 14 commits
- indexing-service/src — 9 commits
- sql/src — 9 commits
- processing/src — 8 commits
- multi-stage-query/src — 6 commits
- embedded-tests/src — 5 commits
- website/package-lock.json — 5 commits
- .github/workflows — 4 commits
- distribution/bin — 4 commits
- web-console/package-lock.json — 4 commits
- extensions-contrib/grpc-query — 3 commits
- web-console/src — 3 commits
- .github/dependabot.yml — 2 commits
- .github/scripts — 2 commits
- extensions-contrib/tdigestsketch — 2 commits
- extensions-core/kubernetes-overlord-extensions — 2 commits
- extensions-core/s3-extensions — 2 commits
- (repo) — 1 commit
- benchmarks/pom.xml — 1 commit
Notable commits
- fix: Fix [CVE redacted] by bumping brotli version for orc to 1.24.0 explicitly (#20826)
- fix: Fix query driver. (#20755)
- fix: build: fix grpc-query build on macOS 27 without Rosetta (#20730)
- fix: ci: fix the review bypass, allow only squash merges, delete merged branches (#20804)
- fix: fix flaky MSQWorkerFaultToleranceTest.test_cancelledWorker_isRetried (#20803)
- fix: fix(embedded-tests): increase LatchableEmitter timeout in CompactionTestBase to 60s (#20818)
- fix: fix(sql): avoid reducing constant complex arrays (#20664)
- fix: fix: Avoid duplicate aggregators when reusing T-Digest sketches (#20837)
- fix: fix: ComposingReadableFrameChannel reopening the last channel. (#20716)
- fix: fix: Do not launch Kubernetes tasks killed while waiting for capacity (#20738)
- fix: fix: EmptyCursorHolder#canVectorize must depend on the CursorBuildSpec. (#20822)
- fix: fix: Fail ingestion tasks when OffsetOutOfRangeException is raised (#18226)
- fix: fix: Improved "memory needed" calculations in WorkerMemoryParameters. (#20720)
- fix: fix: Keep task count dimensions for tasks the task runner still reports (#20735)
- fix: fix: LimitedBufferHashGrouper heapIndexUpdater used incorrect table. (#20861)
- fix: fix: Only mark fully contained segments unused in the segment metadata cache (#20813)
- fix: fix: Prevent a lost wakeup in SegmentLoadDropHandler from stalling segment loading (#20608)
- fix: fix: Prevent an AsyncRequest timeout race from wedging HTTP connections (#20821)
- fix: fix: Proper handling of numeric CAST to INTERVAL. (#20754)
- fix: fix: Read all data server yielders in ScanQueryFrameProcessor. (#20587)
- …and 101 more
Architecture
- Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 1 added · 0 removed
Added bounded contexts (1)
- druid-tsfile-extensions
Added dependency edges (1)
- druid-tsfile-extensions → druid-processing
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
apache/druid was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 2b71ffb375210db4905240f36d150b690bc9a85f — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.