apache/kafka
58.6
Adequate · 11 November 2026
635.3k
lines of production code
Java
primary language
5
measurements over time
What this system is
Features
Add Java Streams quickstart archetype
A new Maven archetype for the Kafka Streams Java quickstart is introduced, providing a ready-to-use project structure. It includes example source files for basic streaming patterns (LineSplit, Pipe, WordCount), a log4j2 configuration, and the necessary archetype metadata to generate a compilable project from the command line.
streams/quickstart/java · high confidence
Add Kafka 3.7.0 Docker Official Image with CDS optimization
This change introduces the Docker Official Image assets for Apache Kafka version 3.7.0 (JVM variant). The new image is based on Eclipse Temurin 21 JRE Alpine and includes scripts to generate and utilize JVM Class Data Sharing (CDS) archives (kafka.jsa and storage.jsa) to improve startup performance. It provides a complete entrypoint that handles environment variable configuration, SSL/SASL secret mounting, and broker launch, exposing port 9092 by default.
_docker/docker\_official\images · high confidence
Add SASL/SCRAM authentication support to Kafka clients
This change introduces the internal implementation for SASL/SCRAM authentication in the Kafka clients module. It adds the \ScramSaslClient\ and \ScramSaslServer\ classes to handle the authentication handshake, along with supporting utilities for credential serialization (\ScramCredentialUtils\), message formatting (\ScramFormatter\, \ScramMessages\), and mechanism configuration (\ScramMechanism\). The update also registers the SASL providers (\ScramSaslClientProvider\, \ScramSaslServerProvider\) and a server-side callback handler (\ScramServerCallbackHandler\) to integrate with Kafka's credential and token caches, enabling clients to authenticate using SCRAM-SHA-256 and SCRAM-SHA-512 mechanisms.
clients/src/main/java/org/apache/kafka/common/security/plain, clients/src/main/java/org/apache/kafka/common/security/scram/internals · high confidence
Add SCRAM authentication support to Kafka clients
This change introduces the core components for SASL/SCRAM authentication within the Kafka clients module. It adds the \ScramCredentialCallback\ and \ScramExtensionsCallback\ classes to handle credential and extension data during the authentication exchange, and provides the \ScramLoginModule\ to initialize the SCRAM client and server providers and manage username, password, and token-based authentication configurations. These classes enable users to secure their Kafka connections using the Salted Challenge Response Authentication Mechanism.
clients/src/main/java/org/apache/kafka/common/security/scram · high confidence
Add field syntax version configuration for nested field access
A new \FieldSyntaxVersion\ enum and configuration option (\field.syntax.version\) have been introduced to the Connect transforms field package. This allows users to opt into V2 syntax, which supports accessing nested fields using dotted notation, while V1 remains the default to maintain backward compatibility with root-level access only.
connect/transforms/src/main/java/org/apache/kafka/connect/transforms/field · high confidence
Add support for message headers in Kafka Connect
This change introduces the \org.apache.kafka.connect.header\ package, providing a new API for application-defined metadata attached to Connect records. It adds the \Header\ interface for immutable key-value pairs with optional schemas, the \Headers\ interface for mutable collections of these headers, and the \ConnectHeaders\ implementation which supports adding headers with various primitive types (String, Boolean, numeric, bytes) as well as complex types (List, Map, Struct) and decimal values. This enables Connect sources and sinks to pass and process structured metadata alongside record data.
connect/api/src/main/java/org/apache/kafka/connect/header · high confidence
Added Docker example fixtures for SASL and SSL configurations
New example files have been added to the docker/examples/fixtures directory to support SASL\_PLAINTEXT and SSL client and broker configurations. This includes client property files (client-sasl.properties, client-ssl.properties) defining security protocols and JAAS configurations, a server.properties file for a broker with SSL and PLAINTEXT listeners, a broker JAAS configuration file (broker\_jaas.conf) for PLAIN authentication, and credential files for keystores and truststores. These fixtures enable users to run Docker-based Kafka instances with secure SASL and SSL connections out of the box.
docker/examples/fixtures · high confidence
Added human-readable formatters for MirrorMaker2 internal topics
MirrorMaker2 now includes dedicated formatters for its internal checkpoint, heartbeat, and offset-sync topics. These new classes implement the MessageFormatter interface to deserialize internal records and output them as plain text, allowing users to easily inspect the contents of these internal topics using standard Kafka command-line tools.
connect/mirror/src/main/java/org/apache/kafka/connect/mirror/formatters · high confidence
Automatic detection of internal API usage via bytecode scanning
The api-checker tool now automatically detects when public Kafka APIs leak internal types or when external consumers reference non-public Kafka classes, using bytecode analysis via ASM instead of source-level parsing. This change introduces a new \ApiSurface\ model and \ApiSurfaceScanner\ to build an immutable view of the public API from project and reference JARs, enabling the \CascadeValidator\ to check public method signatures for internal-type leaks and the \PluginDeveloperApiUsageScanner\ to flag non-public Kafka references in consumer bytecode. A \JavadocConsistencyValidator\ also cross-validates published Javadoc HTML against bytecode audience annotations to catch missing documentation or undocumented public classes, while a \@SuppressKafkaInternalApiUsage\ annotation allows developers to silence known violations with audit reasons.
api-checker/core, api-checker/maven-plugin · high confidence
Connect plugin discovery now registers built-in connectors and converters via service providers
Kafka Connect workers can now automatically discover and use built-in components without manual configuration. Service provider files in the API, JSON, file, mirror, and transforms modules register default implementations, including StringConverter and SimpleHeaderConverter in the API, JsonConverter in the JSON module, FileStreamSourceConnector and FileStreamSinkConnector in the file module, MirrorSourceConnector, MirrorCheckpointConnector, and MirrorHeartbeatConnector in the mirror module, and a comprehensive set of transforms and predicates (such as Cast, Filter, RegexRouter, and HasHeaderKey) in the transforms module.
(repo-wide) · high confidence
Dynamic JAAS configuration and login module allowlisting for SASL
Kafka clients and brokers can now load JAAS configuration dynamically from the \sasl.jaas.config\ property instead of relying solely on the \java.security.auth.login.config\ system property or static JAAS files. This change introduces \JaasConfig\ to parse the config string and \JaasContext\ to manage the resulting login context, supporting per-listener overrides on the broker side. Additionally, administrators can now explicitly allow specific login modules via the \org.apache.kafka.allowed.login.modules\ system property, replacing the deprecated \org.apache.kafka.disallowed.login.modules\ property to improve security posture.
clients/src/main/java/org/apache/kafka/common/security · high confidence
FileStream connectors now support offset management and exactly-once semantics
The FileStreamSourceConnector and FileStreamSinkConnector now implement the \alterOffsets\ method, enabling users to modify and validate connector offsets via the REST API. For the source connector, this change introduces support for exactly-once delivery guarantees when reading from a file (while stdin remains unsupported), and adds a configurable \batch.size\ parameter to control record batching and prevent out-of-memory errors. The sink connector also gains the ability to handle offset alterations, ensuring consistent state management for file-based sinks.
connect/file/src/main/java · high confidence
Initial Gradle build infrastructure and security configuration
This change introduces the foundational Gradle build system for the project, including the Gradle wrapper (version 9.8.2) and associated configuration files. It adds a dependency-check suppression file to explicitly ignore [CVE redacted] and [CVE redacted] as false positives, and includes a SpotBugs exclusion file to suppress known false positives in Scala code and specific Java classes. Additionally, it provides an OpenAPI template for the Kafka Connect REST API and an XSL stylesheet to convert RAT license reports into HTML.
gradle · high confidence
Initial Vagrant-based local development environment for Apache Kafka
Developers can now use Vagrant to quickly spin up a local multi-node Kafka cluster for development and testing. This change introduces a complete set of provisioning scripts (base.sh, broker.sh, zk.sh) and configuration files that automate the setup of ZooKeeper and Kafka broker nodes, including the installation of JDK 17 and multiple Kafka versions (2.1.1 through 4.3.1). The environment supports both local VirtualBox and AWS EC2 providers, with specific scripts and examples for AWS spot instance usage and IAM role integration. Users can bring up the cluster using the provided vagrant-up.sh wrapper, which handles parallel provisioning and hostname management, and can customize the cluster size and resources via Vagrantfile.local.
vagrant · high confidence
Initial implementation of SASL/Kerberos client authentication
The Kafka clients now support SASL/GSSAPI (Kerberos) authentication. This change introduces the core client-side components for Kerberos security, including \KerberosLogin\ for managing ticket renewal and refresh, \KerberosClientCallbackHandler\ for handling SASL callbacks, and \KerberosError\ for distinguishing transient Kerberos errors (such as ticket validity issues) to enable automatic retries. It also adds \KerberosRule\ for mapping Kerberos principal names to local user names, supporting case transformation rules.
clients/src/main/java/org/apache/kafka/common/security/kerberos · high confidence
Initial repository structure and developer onboarding documentation
The repository now includes foundational configuration and documentation files to standardize development workflows. A new AGENTS.md file provides a comprehensive guide for automated agents and developers, detailing the Gradle-based build system, supported Java and Scala versions, repository layout, and specific commands for building, testing, and checking code quality. A CONTRIBUTING.md file establishes the license agreement and requirements for AI-generated contributions. The .asf.yaml file configures GitHub notifications to Jira and mailing lists, defines repository collaborators, and sets merge preferences. Additionally, a .gitignore file excludes build artifacts and IDE directories, while the Vagrantfile provides a standardized environment for setting up local development clusters with ZooKeeper and Kafka brokers.
(repo-wide) · high confidence
Internal telemetry infrastructure for client metrics collection
This change introduces the internal supporting classes for the new client telemetry system (KIP-714). It adds the \ClientTelemetryProvider\ to manage resource labels (such as group ID and client rack) for producers and consumers, and the \ClientTelemetrySender\ interface to handle communication with the broker via \GetTelemetrySubscriptions\ and \PushTelemetry\ requests. The \KafkaMetricsCollector\ is added to scrape existing Kafka metrics and map them to OpenTelemetry formats, while \ClientTelemetryUtils\ provides helper logic for compression, error handling, and metric selection. Additionally, \TelemetryMetricNamingConvention\ defines the rules for converting internal metric names into the canonical telemetry format.
clients/src/main/java/org/apache/kafka/common/telemetry/internals · high confidence
Introduce JMH benchmarking module for Kafka performance testing
This change adds a new \jmh-benchmarks\ module to the Kafka project, providing a dedicated space for micro-benchmarks using the Java Microbenchmark Harness (JMH). It includes a \jmh.sh\ script and a \README.md\ to simplify running benchmarks, configuring JMH flags, and integrating with profilers like async-profiler and the GC profiler. The module contains initial benchmarks for key subsystems, including ACL authorization (\AuthorizerBenchmark\, \StandardAuthorizerUpdateBenchmark\), consumer and share group partition assignment (\ConsumerAssignorBenchmark\, \ClientSideAssignorBenchmark\, \AssignmentRefinerBenchmark\), and other core components, allowing developers to measure and optimize performance characteristics.
jmh-benchmarks · high confidence
Introduce JVM-based Docker image with pre-generated CDS archives
This change adds a new Dockerfile and supporting scripts in the docker/jvm directory to provide a dedicated JVM container image for Apache Kafka. The image is built on Eclipse Temurin 25 JRE Alpine and includes logic to pre-generate JVM Shared Archive (CDS) files (kafka.jsa and storage.jsa) during the build stage, which are then utilized at runtime to optimize startup performance. It also introduces a custom launch script that configures JMX connectivity, manages the Docker wrapper setup, and applies the CDS archives for both storage formatting and server startup.
docker/jvm · high confidence
Introduce KRaft (Kafka Raft) module for metadata quorum
This change introduces the \raft\ module, which implements the KRaft (Kafka Raft) protocol to replace ZooKeeper for cluster metadata management. It includes the core \KafkaRaftClient\ for leader election and log replication, state management classes like \CandidateState\ and \LeaderState\, and configuration definitions in \KRaftConfigs\. The module also provides a standalone test server (\TestRaftServer\) and associated configuration files to allow performance testing and validation of the new quorum protocol.
raft · high confidence
Introduce Kafka Connect data model API and logical types
This change introduces the core data model for Kafka Connect, providing the \Schema\, \Struct\, and \SchemaBuilder\ classes that define the structure of records, along with logical types for \Date\, \Time\, \Timestamp\, and \Decimal\. It also adds the \SchemaProjector\ utility for converting values between compatible schemas and the \Values\ class for parsing and converting schemaless data into typed Connect objects.
connect/api/src/main/java/org/apache/kafka/connect/data · high confidence
Introduce Kafka Metadata Shell for offline metadata inspection
Adds the \kafka-metadata-shell\, a new interactive and non-interactive command-line tool that allows users to inspect and query Kafka metadata from snapshot files. The shell provides a file-system-like interface with commands such as \ls\, \cat\, \cd\, \find\, \pwd\, \tree\, \help\, \man\, \history\, and \exit\, enabling administrators to browse metadata nodes, view file contents, and search the directory hierarchy without requiring a running broker or controller.
shell · high confidence
Introduce MirrorMaker 2 CheckpointConnector for consumer group offset replication
MirrorMaker 2 now includes a new CheckpointConnector that replicates consumer group offsets from the source to the target cluster. This connector introduces new configuration properties to control the behavior, including \emit.checkpoints.enabled\ (default true) to enable or disable checkpoint emission, \emit.checkpoints.interval.ms\ (default 60s) to set the frequency, \sync.group.offsets.enabled\ (default false) to optionally write translated offsets to the target's \\_\_consumer\_offsets\ topic, and \refresh.groups.enabled\ (default true) to periodically discover new consumer groups. It also adds \groups\ and \groups.exclude\ configuration options (using the new \GroupFilter\ interface) to include or exclude specific consumer groups from replication, allowing users to precisely control which consumer state is mirrored.
connect/mirror/src/main/java/org/apache/kafka/connect/mirror · high confidence
Introduce TopicBasedRemoteLogMetadataManager implementation for tiered storage
The storage module now includes the core components for the TopicBasedRemoteLogMetadataManager, which stores remote log metadata in an internal Kafka topic. This change adds the TopicPartitionLog interface to decouple the RemoteLogManager from the Partition, along with the ProducerManager and ConsumerManager to handle publishing and consuming metadata events, and the RemoteLogMetadataCache to maintain in-memory segment lineage and state transitions. This provides a new, topic-backed mechanism for managing tiered storage metadata, replacing previous in-memory or file-based approaches.
storage · high confidence
Introduce common coordinator runtime infrastructure
The coordinator-common module now provides a shared runtime framework for Kafka coordinators (such as Group and Share coordinators). This includes core interfaces and implementations for event processing (CoordinatorEvent, CoordinatorEventProcessor), asynchronous task execution (CoordinatorExecutor), and scheduled timeouts (CoordinatorTimer). It also introduces a standardized metadata model (CoordinatorMetadataImage, CoordinatorMetadataDelta) for topic state, a record abstraction (CoordinatorRecord) with versioned serialization (CoordinatorRecordSerde), and a metrics suite (CoordinatorRuntimeMetrics) that tracks queue times, processing latencies, and thread utilization. Additionally, error handling is unified via CoordinatorOperationExceptionHelper, and state management is abstracted through CoordinatorShard and its builder.
coordinator-common/src/main · high confidence
Introduce delegation token information model
Added the \TokenInformation\ class and package documentation in the \org.apache.kafka.common.security.token.delegation\ package to represent delegation token details. This new public API exposes token metadata such as the owner, token requester, renewers, and various timestamps (issue, max, expiry), along with a \tokenId\, enabling clients to inspect and manage delegation token lifecycle data.
clients/src/main/java/org/apache/kafka/common/security/token/delegation · high confidence
Introduce experimental GraalVM-based native Kafka Docker image
Adds a new Docker image in docker/native that compiles Apache Kafka into a native binary using GraalVM 25, enabling sub-second startup times and a smaller memory footprint. The build process uses GraalVM 25 to avoid startup segfaults found in earlier versions, packages the resulting binary with Alpine Linux, and includes updated log4j2 YAML configuration files. This image is marked as experimental and intended for local development and testing rather than production use.
docker/native · high confidence
Introduce explicit nullable type support and compact array serialization in the protocol types package
The \org.apache.kafka.common.protocol.types\ package now includes new classes to support flexible protocol features: \NullableSchema\ allows struct fields to be explicitly nullable, \ArrayOf\ and \CompactArrayOf\ provide serialization for standard and varint-length arrays respectively, and \RawTaggedFieldWriter\ handles the encoding of optional tagged fields. These additions enable the Kafka wire protocol to support nullable fields and compact array encoding, which are required for flexible versioning and tagged field support in newer protocol versions.
clients/src/main/java/org/apache/kafka/common/protocol/types · high confidence
Introduce internal RecordHeader and RecordHeaders implementations
The Kafka client library now includes internal implementations for record headers: \RecordHeader\ and \RecordHeaders\ in the \org.apache.kafka.common.header.internals\ package. \RecordHeader\ provides a thread-safe, lazily initialized representation of a single header entry, converting between \ByteBuffer\ and \String\/\byte\[\]\ on demand to reduce memory overhead. \RecordHeaders\ implements the \Headers\ interface, managing a list of \RecordHeader\ instances with support for adding, removing, and iterating over headers, including a read-only mode to prevent modification after consumption. These classes form the core data structures for handling record metadata within the client.
clients/src/main/java/org/apache/kafka/common/header/internals · high confidence
Introduce internal SASL/PLAIN server implementation with constant-time password comparison
The Kafka client library now includes an internal implementation of the SASL/PLAIN authentication mechanism, consisting of a \PlainSaslServer\ that handles the protocol exchange, a \PlainServerCallbackHandler\ that validates credentials against JAAS configuration, and a \PlainSaslServerProvider\ to register the server factory. A key behavioral change in this implementation is the use of constant-time comparison (\Utils.isEqualConstantTime\) for password verification, which mitigates timing side-channel attacks during authentication.
clients/src/main/java/org/apache/kafka/common/security/plain/internals · high confidence
Introduce internal expiring credential refresh mechanism for OAuth/OIDC
Added new internal classes in the \org.apache.kafka.common.security.oauthbearer.internals.expiring\ package to manage the lifecycle and automatic renewal of expiring security credentials. The \ExpiringCredential\ interface defines the contract for credentials that have a validity window, while \ExpiringCredentialRefreshConfig\ allows users to configure refresh timing via SASL configuration properties (such as window factor, jitter, and buffer seconds). The \ExpiringCredentialRefreshingLogin\ class implements the background logic to automatically re-authenticate before credentials expire, ensuring continuous connectivity for Kafka clients and servers using OAuth/OIDC authentication.
clients/src/main/java/org/apache/kafka/common/security/oauthbearer/internals/expiring · high confidence
Introduce new GroupCoordinator module with modern group management APIs
The group-coordinator module has been introduced to replace the legacy GroupMetadataManager, providing a new runtime for managing consumer, share, and streams groups. This change adds core abstractions such as the Group interface, GroupConfig, and GroupCoordinator interface, along with record helpers for persisting group state to \_\_consumer\_offsets. It enables new capabilities like assignment batching, offload, and topology description plugins for streams groups, while maintaining backward compatibility with classic group protocols through migration policies.
group-coordinator · high confidence
Introduce new Java AdminClient API for cluster administration
This change introduces the new \Admin\ interface and its configuration class \AdminClientConfig\ in the \org.apache.kafka.clients.admin\ package, providing a modern, consistent API for managing Kafka clusters. The \Admin\ interface exposes methods for creating topics, altering configurations, managing ACLs, handling consumer and share group offsets, and performing Raft voter operations, all returning typed \KafkaFuture\ results. Accompanying this interface are numerous \Options\ classes (e.g., \CreateTopicsOptions\, \AlterConfigsOptions\, \AddRaftVoterOptions\) that allow users to configure per-operation settings like timeouts and validation flags, and \Result\ classes that wrap the asynchronous outcomes. The \AdminClientConfig\ class centralizes client configuration, including bootstrap servers, security protocols, and timeout settings, while the legacy \AdminClient\ abstract class is retained for backward compatibility but directs users to prefer the new \Admin\ interface.
clients/src/main/java/org/apache/kafka/clients/admin · high confidence
Introduce new consumer internals and share group support
This change introduces a new set of internal consumer classes to support the new consumer protocol and the Share Consumer API. Key additions include AbstractFetch for record fetching logic, AbstractMembershipManager for group membership state, and AbstractPartitionAssignor for partition assignment strategies. It also adds support for share group acknowledgements via AcknowledgementBatch, Acknowledgements, and AcknowledgementCommitCallbackHandler, along with the AsyncKafkaConsumer implementation and associated interfaces like AbstractSubscriptionState.
clients/src/main/java/org/apache/kafka/clients/consumer/internals · high confidence
Introduce pluggable ConfigProvider interface with File, Directory, and Environment variable implementations
Kafka Connect now supports late-binding configuration values through a new pluggable \ConfigProvider\ interface located in \org.apache.kafka.common.config.provider\. This change introduces three built-in implementations: \FileConfigProvider\ for loading properties from a single file, \DirectoryConfigProvider\ for loading properties from all regular files in a directory, and \EnvVarConfigProvider\ for retrieving values from environment variables. All providers support an \allowed.paths\ or \allowlist.pattern\ configuration to restrict access to specific resources, and they are automatically discovered by Kafka Connect via the Java ServiceLoader mechanism.
clients/src/main/java/org/apache/kafka/common/config/provider · high confidence
Introduce public API for Kafka record headers
The Kafka client now exposes a new \org.apache.kafka.common.header\ package containing the \Header\ and \Headers\ interfaces, allowing applications to attach and retrieve key-value metadata to and from records. The \Headers\ interface provides methods to add, remove, and query headers while preserving insertion order, and the \Header\ interface defines the key-value structure. This change replaces legacy internal structures with a dedicated, public API for record metadata.
clients/src/main/java/org/apache/kafka/common/header · high confidence
Introduce share-coordinator module for managing share group state
This change adds the new share-coordinator module, which provides the infrastructure for managing share group state within Kafka. It introduces the ShareCoordinator interface and its service implementation to handle RPC requests for initializing, writing, reading, and deleting share group state. The module includes configuration for the internal \_\_share\_group\_state topic (such as partition count, replication factor, and retention), a record schema for snapshot and update data, and an offsets manager to track redundant records for efficient pruning.
share-coordinator · high confidence
Introduce unsecured OAuthBearer validation and configuration components
The Kafka clients module now includes a new set of internal classes in the \oauthbearer.internals.unsecured\ package to support unsecured OAuth 2 bearer token handling. This includes \OAuthBearerUnsecuredLoginCallbackHandler\ for generating tokens with configurable claims (such as principal, scope, and custom extensions) and \OAuthBearerUnsecuredValidatorCallbackHandler\ for validating token expiration, time consistency, and required scopes. Supporting utilities like \OAuthBearerScopeUtils\ for scope parsing, \OAuthBearerValidationUtils\ for claim validation, and specific exceptions (\OAuthBearerConfigException\, \OAuthBearerIllegalTokenException\) are also added to facilitate this unsecured authentication flow.
clients/src/main/java/org/apache/kafka/common/security/oauthbearer/internals/unsecured · high confidence
Introduces ClientTelemetryState enum to enforce valid telemetry state transitions
The Kafka client now includes a new \ClientTelemetryState\ enum that defines the lifecycle states for client telemetry (such as \SUBSCRIPTION\_NEEDED\, \PUSH\_NEEDED\, and \TERMINATED\) and enforces valid transitions between them. This change ensures that the client's telemetry logic follows a strict state machine, preventing invalid state changes during subscription retrieval, metric pushing, and termination phases.
clients/src/main/java/org/apache/kafka/common/telemetry · high confidence
Introduces ConnectRecord API and connector utility classes
This change adds the \ConnectRecord\ abstract class to the Connect API, providing a unified record type that includes support for message headers and timestamps, replacing the previous record model. It also introduces the \ConnectorUtils\ class with a \groupPartitions\ helper to assist connector implementations in evenly distributing work across tasks, alongside standard \package-info\ files for the \connector\ and \util\ packages.
connect/api/src/main/java/org/apache/kafka/connect/connector · high confidence
Introduction of KRaft Controller Metadata Module
This change introduces the new \metadata\ module, which houses the core implementation of the KRaft controller. It includes the \AclControlManager\ for managing Access Control Lists, the \BrokerHeartbeatManager\ for tracking broker liveness and session timeouts, and the \ActivationRecordsGenerator\ for handling cluster bootstrapping and controller activation. Additionally, it adds the \BrokersToIsrs\ and \BrokersToElrs\ data structures to efficiently track broker-partition relationships for In-Sync Replicas and Eligible Leader Replicas, along with supporting classes like \ClientQuotaControlManager\ and \ClusterControlManager\.
metadata · high confidence
Introduction of TimestampType enum and package documentation
The Kafka client library now includes a new \TimestampType\ enum in the \org.apache.kafka.common.record\ package, defining constants for \NO\_TIMESTAMP\_TYPE\, \CREATE\_TIME\, and \LOG\_APPEND\_TIME\ to explicitly represent record timestamp semantics. Additionally, a \package-info.java\ file has been added to provide Javadoc documentation for the record utility components.
clients/src/main/java/org/apache/kafka/common/record · high confidence
Introduction of externalized configuration providers
The Kafka clients now support loading configuration values from external sources (such as vaults or file systems) using a variable syntax like ${provider:path:key}. This is enabled by setting the 'config.providers' property to specify which provider implementations to use, and the 'config.providers.\.param.\' properties to configure them. The AbstractConfig class handles the resolution of these variables during initialization, allowing sensitive data like passwords to be kept out of static configuration files.
clients/src/main/java/org/apache/kafka/common/config · high confidence
Introduction of public ACL model classes
The Kafka client now exposes the \org.apache.kafka.common.acl\ package as a public API, introducing \AclOperation\ and \AclPermissionType\ enums to represent access control list operations and permission types. These classes allow users to programmatically define and interpret ACL rules, such as granting or denying READ, WRITE, or ALTER permissions, using standardized byte codes and string parsing methods.
clients/src/main/java/org/apache/kafka/common/acl · high confidence
Introduction of the Transformation interface for single message transforms
The Kafka Connect API now exposes the \Transformation\ interface in the \org.apache.kafka.connect.transforms\ package, enabling connectors to apply lightweight, message-at-a-time modifications. This interface extends \Configurable\, \Closeable\, and \ConnectPlugin\, allowing implementations to be discovered via the Java \ServiceLoader\ mechanism. It defines an \apply\ method for transforming records (supporting both map and filter operations) and explicitly prohibits mutating objects reachable from the input record, requiring new record instances for changes. The interface also supports automatic metric tagging and includes a \version\ method for component identification.
connect/api/src/main/java/org/apache/kafka/connect/transforms · high confidence
Kafka Connect sink API additions and lifecycle changes
This update introduces several new capabilities and structural changes to the Kafka Connect sink API. Sink connectors can now report problematic records to a dead letter queue via the new ErrantRecordReporter interface and the errantRecordReporter() method on SinkTaskContext. To support Single Message Transforms that mutate metadata, SinkRecord now exposes the original topic, partition, and offset via originalTopic(), originalKafkaPartition(), and originalKafkaOffset(), ensuring accurate offset tracking. The SinkTask lifecycle has been refactored to use open() and close() for partition assignment instead of onPartitionsAssigned/onPartitionsRevoked, and SinkConnector gains an alterOffsets() method to handle manual offset resets via the REST API. Additionally, SinkTaskContext now provides pluginMetrics() for custom metrics and configs() to access the latest configuration, including externalized secrets.
connect/api/src/main/java/org/apache/kafka/connect/sink · high confidence
Kafka RPC protocol generator rewritten in Java
The Kafka protocol generator has been completely rewritten in Java, replacing the previous implementation. This new generator introduces a structured, object-oriented approach to code generation, featuring new core components such as \FieldSpec\, \StructSpec\, and \MessageType\ enums to define protocol schemas, alongside dedicated generators for message data, schemas, and JSON converters. It supports advanced protocol features including flexible versions, tagged fields, nullable types, and entity types, while enforcing stricter validation on schema definitions to ensure correctness of the generated Java client and broker code.
generator · high confidence
Mirror Maker 2 adds internal REST API for intra-cluster communication
Mirror Maker 2 now exposes an internal REST server that allows the source and target Connect clusters to communicate directly. This change introduces a new MirrorRestServer and an InternalMirrorResource endpoint at /{source}/{target}/connectors, enabling the target cluster to query and manage connectors on the source cluster via a dedicated REST client, which is a prerequisite for the intra-cluster communication feature.
connect/mirror/src/main/java/org/apache/kafka/connect/mirror/rest · high confidence
New API stability and audience annotations introduced
The Kafka client library now includes a new \org.apache.kafka.common.annotation\ package containing \@Public\ and \@Private\ annotations to define API audience, and \@Stable\, \@Evolving\, and \@Unstable\ annotations to define compatibility guarantees. A \@SuppressKafkaInternalApiUsage\ annotation is also added to allow controlled access to internal APIs. These annotations provide explicit documentation for users regarding which classes are part of the public surface and how stable they are across releases, supporting automated checking of internal API usage.
clients/src/main/java/org/apache/kafka/common/annotation · high confidence
New AlterConfigPolicy interface for validating configuration changes
The Kafka server now exposes the \AlterConfigPolicy\ interface in the \org.apache.kafka.server.policy\ package, allowing administrators to enforce custom policies on alter config requests. By setting the \alter.config.policy.class.name\ broker configuration, users can provide a pluggable implementation that validates parameters (such as replication factor or retention settings) before they are applied, throwing a \PolicyViolationException\ to reject invalid changes while allowing other resources in the same request to proceed.
clients/src/main/java/org/apache/kafka/server/policy · high confidence
New Connect CLI entry points and numeric/boolean converters
The Connect runtime now includes dedicated CLI entry points for distributed and standalone modes (ConnectDistributed, ConnectStandalone) via a new AbstractConnectCli base class, simplifying worker initialization. Additionally, new built-in converters have been added to support Boolean, Byte Array, Float, Double, Integer, Long, and generic Number types, enabling direct serialization and deserialization of these primitive data formats without requiring custom converter implementations.
connect/runtime/src/main · high confidence
New Connect REST extension API for custom JAX-RS resources
Kafka Connect now exposes a new pluggable REST extension mechanism via the \ConnectRestExtension\ interface in the \connect/api\ module. This allows plugin developers to register custom JAX-RS resources, such as filters, REST endpoints, and providers, by implementing the interface and providing a service provider configuration file. The extension receives a context providing access to the JAX-RS \Configurable\ and cluster state, enabling deep integration with the Connect REST API while maintaining standard plugin discovery and lifecycle management.
connect/api/src/main/java/org/apache/kafka/connect/rest · high confidence
New Connect health API for monitoring cluster state
The \org.apache.kafka.connect.health\ package introduces a new public API that allows REST extensions to query the current status of connectors and tasks, including their states, worker IDs, and error traces. This API also provides access to cluster-level metadata, such as the backing Kafka cluster ID, enabling better observability and integration for external monitoring tools.
connect/api/src/main/java/org/apache/kafka/connect/health · high confidence
New Connect predicates for filtering records by header, tombstone status, or topic name
This location introduces three new predicate implementations for Kafka Connect: HasHeaderKey, which matches records containing a specific header name; RecordIsTombstone, which matches records with a null value; and TopicNameMatches, which matches records whose topic name satisfies a configured Java regular expression. These predicates enable users to filter data streams based on header presence, tombstone state, or topic naming patterns within their Connect pipelines.
connect/transforms/src/main/java/org/apache/kafka/connect/transforms/predicates · high confidence
New Docker image build, test, and release tooling
This change introduces a comprehensive set of Python scripts and documentation in the \docker/\ directory to support building, testing, and releasing Apache Kafka Docker images. It adds support for both JVM-based and GraalVM-based native images, including scripts to build multi-architecture images (\docker\_release.py\), run sanity tests (\docker\_build\_test.py\), and prepare sources for Docker Official Images (\prepare\_docker\_official\_image\_source.py\). The tooling also includes GitHub Actions workflows for automated builds, testing, and nightly CVE scanning, along with a \server.properties\ file configured for KRaft mode to ensure consistent behavior in containerized deployments.
docker · high confidence
New Gradle plugins for automatic internal and public API usage checking
External Kafka plugin and application developers can now use the new \KafkaInternalApiChecker\ Gradle plugin to automatically detect usage of internal Kafka APIs in their compiled bytecode. The plugin registers a \kafkaInternalApiChecker\ task that scans class files against the public API surface defined by \@InterfaceAudience.Public\ annotations in the Kafka client JARs on the classpath. It includes a safety net (\failOnNoKafkaDependency\) to fail builds if no Kafka dependency is found, preventing silent false-negatives. Additionally, the \KafkaPublicApiChecker\ plugin is introduced for internal Kafka development to verify consistency between Javadoc HTML files and public API annotations, ensuring that public API changes are properly documented.
api-checker/gradle-plugins, gradle-plugins · high confidence
New Kafka Connect Source API for exactly-once and transaction boundaries
The Kafka Connect source API now includes explicit support for exactly-once semantics and connector-defined transaction boundaries. Source connectors can declare their exactly-once capabilities via the new \ExactlyOnceSupport\ enum and the \SourceConnector.exactlyOnceSupport()\ method. Additionally, connectors can define their own transaction boundaries using the new \ConnectorTransactionBoundaries\ enum, the \SourceConnector.canDefineTransactionBoundaries()\ method, and the \TransactionContext\ interface, which allows tasks to commit or abort transactions at the batch or record level. The \SourceTask\ class introduces a \TRANSACTION\_BOUNDARY\_CONFIG\ property and a \TransactionBoundary\ enum (POLL, INTERVAL, CONNECTOR) to configure this behavior. The \SourceTaskContext\ now provides access to a \TransactionContext\ and \PluginMetrics\, while \SourceConnectorContext\ exposes the \OffsetStorageReader\. The \SourceRecord\ class is updated to include source partition and offset metadata, and \SourceConnector\ gains an \alterOffsets()\ method for manual offset management.
connect/api/src/main/java/org/apache/kafka/connect/source · high confidence
New Kafka Connect exception classes in the errors package
The \org.apache.kafka.connect.errors\ package now includes a set of public exception classes to help connector and task developers handle specific failure scenarios. \ConnectException\ serves as the top-level exception for the framework, while \DataException\ covers data API errors. Specific subclasses include \AlreadyExistsException\ for duplicate entity creation, \NotFoundException\ for missing connectors or tasks, \IllegalWorkerStateException\ for invalid method invocations, \RetriableException\ for operations that can be attempted again, \SchemaBuilderException\ for schema building errors, and \SchemaProjectorException\ for schema projection errors. All classes are marked with \@InterfaceAudience.Public\ and are available for use in connector implementations.
connect/api/src/main/java/org/apache/kafka/connect/errors · high confidence
New Kafka Producer API and supporting classes
This release introduces the new \org.apache.kafka.clients.producer\ package, providing a modern, public API for producing records to Kafka. The core \KafkaProducer\ class implements the new \Producer\ interface, which supports transactional semantics (init, begin, commit, abort), asynchronous sends with callbacks, and configurable metrics. The API includes \ProducerRecord\ for defining messages with keys, values, headers, and timestamps, and \ProducerConfig\ for managing settings like \acks\, \linger.ms\, and \batch.size\. New interfaces like \ProducerInterceptor\ allow users to modify records before sending and react to acknowledgements, while \Partitioner\ enables custom partitioning logic. A \MockProducer\ is provided for testing, and \BufferExhaustedException\ offers a specific exception for buffer-full scenarios, extending \TimeoutException\ for backward compatibility.
clients/src/main/java/org/apache/kafka/clients/producer · high confidence
New Kafka Streams examples and documentation tests
The \streams/examples\ module now includes several new demo applications—PipeDemo, WordCountDemo, WordCountProcessorDemo, WordCountTransformerDemo, TemperatureDemo, and PageViewTypedDemo—along with a JsonTimestampExtractor to demonstrate various Kafka Streams capabilities. Additionally, new JUnit 5 tests have been added for the WordCount demos and developer guide testing scenarios, utilizing the TopologyTestDriver and MockProcessorContext to validate stream processing logic.
streams/examples · high confidence
New MirrorMaker 2 client library for managing internal topics and offsets
The \connect/mirror-client\ module now provides a public API for interacting with MirrorMaker 2 internal resources. It introduces the \ReplicationPolicy\ interface and two implementations: \DefaultReplicationPolicy\, which prefixes remote topics with a configurable source cluster alias and separator, and \IdentityReplicationPolicy\, which preserves original topic names (useful for legacy migration or one-way replication). The \MirrorClient\ class allows users to discover heartbeat and checkpoint topics, determine upstream clusters, calculate replication hops, and translate remote consumer group offsets to local ones. Configuration is handled via \MirrorClientConfig\, which supports custom replication policies, separator characters, and internal topic naming conventions.
connect/mirror-client/src/main · high confidence
New Predicate interface for conditional SMT application
Connect now exposes a new \Predicate\ interface in the \org.apache.kafka.connect.transforms.predicates\ package, allowing users to define custom logic for conditionally applying transformations (such as the \Filter\ transformation) to records. Implementations are discoverable via the Java \ServiceLoader\ mechanism and support metrics registration through the \Monitorable\ interface, enabling more granular control over record processing pipelines.
connect/api/src/main/java/org/apache/kafka/connect/transforms/predicates · high confidence
New PropertyFileLoginModule for basic-auth extension
The basic-auth extension now includes a PropertyFileLoginModule that authenticates users against a plaintext properties file (format username=password). Users can specify the file path via the 'file' option; the module caches the file in memory and logs warnings if the file is empty or errors if it cannot be loaded. Note that this implementation is not intended for production use as credentials are stored in plaintext.
connect/basic-auth-extension/src/main/java · high confidence
New Single Message Transforms for Kafka Connect
This release introduces a suite of new Single Message Transforms (SMTs) to the Kafka Connect transforms module, enabling more flexible record manipulation. The new transforms include Cast for type conversion, ExtractField for pulling specific fields from records, Flatten for denormalizing nested structures, HoistField for wrapping values, InsertField for adding metadata or static values, and MaskField for data masking. Additionally, header manipulation is enhanced with HeaderFrom (to move or copy fields to headers), DropHeaders (to remove specific headers), and InsertHeader (to add a literal header value). A new Filter transform is also provided to conditionally drop records from the pipeline. These transforms are available for both record keys and values and support configuration options such as replacing null values with defaults.
connect/transforms/src/main/java/org/apache/kafka/connect/transforms · high confidence
New and updated client-side exception classes for error handling
The Kafka client library introduces a comprehensive set of new exception classes in the \org.apache.kafka.common.errors\ package to provide more granular error reporting. This includes a base \ApiException\ class, specialized exceptions for authentication and authorization failures (such as \AuthenticationException\, \AuthorizationException\, and \ClusterAuthorizationException\), and specific error types for transactional and group coordination issues (like \ConcurrentTransactionsException\ and \CoordinatorNotAvailableException\). Additionally, new exceptions are added to handle broker registration states (\BrokerIdNotRegisteredException\), mirroring operations (\ClusterMirrorAlreadyExistsException\), and network/bootstrap resolution failures (\BootstrapResolutionException\), allowing applications to catch and handle these specific failure modes more effectively.
clients/src/main/java/org/apache/kafka/common/errors · high confidence
New asynchronous consumer event-driven architecture
The Kafka consumer client introduces a new internal event-driven architecture to replace the previous synchronous blocking model. This change adds a comprehensive set of event classes (such as AsyncPollEvent, CommitAsyncEvent, and various metadata and subscription events) and handlers (ApplicationEventHandler, BackgroundEventHandler) that decouple application thread operations from the background network thread. For users, this enables a more responsive consumer implementation where API calls like poll() and commit() are non-blocking and executed asynchronously, improving performance and reducing the risk of blocking the application thread during network I/O or group coordination.
clients/src/main/java/org/apache/kafka/clients/consumer/internals/events · high confidence
New client telemetry interfaces with push interval context
The \org.apache.kafka.server.telemetry\ package now provides a new set of public interfaces (\ClientTelemetryExporter\, \ClientTelemetryExporterProvider\, \ClientTelemetryContext\, \ClientTelemetryPayload\) for server-side metrics reporters to receive client telemetry. Unlike the deprecated \ClientTelemetry\ and \ClientTelemetryReceiver\ interfaces, the new API includes a \pushIntervalMs\ in the context, allowing exporters to better manage metric lifecycle and expiration. The old interfaces are marked for removal in Kafka 5.0.0.
clients/src/main/java/org/apache/kafka/server/telemetry · high confidence
New client-side networking and bootstrap configuration infrastructure
The Java client introduces a new internal networking layer and bootstrap configuration model to improve connection management and DNS resolution. This includes new classes for tracking node API versions (ApiVersions), handling request/response metadata (ClientRequest, ClientResponse), and managing connection states with exponential backoff (ClusterConnectionStates, ConnectionState). It also adds explicit configuration for DNS lookup strategies (ClientDnsLookup) and asynchronous bootstrap resolution (BootstrapConfiguration, CommonClientConfigs), allowing clients to handle DNS failures more gracefully and support evolving features like canonical name resolution and configurable timeout budgets.
clients/src/main/java/org/apache/kafka/clients · high confidence
New client-side replica selection API
The Kafka client now exposes a new \org.apache.kafka.common.replica\ package containing a pluggable \ReplicaSelector\ interface, a \PartitionView\ for inspecting partition state, and a default \RackAwareReplicaSelector\ implementation. This allows clients to programmatically determine the preferred read replica for a partition based on rack awareness and replica catch-up status, enabling more intelligent fetch routing from followers when supported by the broker.
clients/src/main/java/org/apache/kafka/common/replica · high confidence
New committer-tools scripts for PR management, contributor updates, and license verification
The committer-tools directory now includes several new scripts to assist committers with routine tasks. The reviewers.py script helps generate and append 'Reviewers' trailers to Pull Request bodies by analyzing Git history. The refresh\_collaborators.py script automates updating the .asf.yaml file with top non-committer contributors. The verify\_license.py tool checks that the LICENSE-binary file accurately reflects the dependencies in the release tarball. Additionally, the find-unfinished-test.py script identifies hanging tests in Gradle logs, and the update-cache.sh script updates a local branch reference to the latest Gradle build cache commit.
committer-tools · high confidence
New common cache abstraction and thread-safe implementation
The Kafka client library now includes a new \org.apache.kafka.common.cache\ package providing a reusable \Cache\ interface (supporting get, put, remove, and size operations) and a \SynchronizedCache\ wrapper that makes any cache implementation thread-safe. This addition allows internal components to leverage a standardized caching mechanism, though the package is explicitly marked as unsupported and subject to change without warning.
clients/src/main/java/org/apache/kafka/common/cache · high confidence
New common client interfaces and enums for group management and cluster metadata
The \org.apache.kafka.common\ package introduces several new public types to support group state tracking and cluster metadata callbacks. \GroupState\ and \GroupType\ enums define the lifecycle states and types for consumer, classic, share, and streams groups, with \ConsumerGroupState\ deprecated in favor of \GroupState\. \ClassicGroupState\ is added for legacy group state handling. \ClusterResourceListener\ is a new callback interface allowing interceptors, serializers, deserializers, and metrics reporters to receive updates on cluster metadata changes. \Reconfigurable\ extends \Configurable\ to support dynamic configuration updates at runtime. \ElectionType\ and \IsolationLevel\ enums are added for leader election and transactional read semantics. \TopicCollection\ provides a unified way to handle topic operations by name or ID. \InvalidRecordException\ is introduced as a specific exception for invalid records. \KafkaFuture\ is defined as an abstract base class for asynchronous operations, supporting conversion to \CompletionStage\ and chaining via \thenApply\ and \whenComplete\. \Node\ now includes an \isFenced\ field to indicate broker fencing status. \Metric\ and \MetricName\ interfaces/classes are present for metric tracking. \MessageFormatter\ is an interface for formatting consumer records for display.
clients/src/main/java/org/apache/kafka/common · high confidence
New consumer APIs and configuration options for share group and close behavior
The consumer client introduces several new public APIs and configuration options. A new \AcknowledgeType\ enum (ACCEPT, RELEASE, REJECT, RENEW) and \AcknowledgementCommitCallback\ interface are added to support the share group consumer's acknowledgement model. The \CloseOptions\ class allows users to customize the consumer close process, specifically controlling the timeout and whether the consumer leaves the group or remains in it (e.g., for static members). The \ConsumerConfig\ adds \group.protocol\ (classic/consumer) and \group.remote.assignor\ configurations to support the new consumer group protocol. Additionally, the \Consumer\ interface now includes \setRebalanceListener(RebalanceListener)\ and \subscribe(SubscriptionPattern)\, and \ConsumerRecord\ exposes \deliveryCount\ for share group semantics.
clients/src/main/java/org/apache/kafka/clients/consumer · high confidence
New delegation token caching and credential callback internals
The Kafka client now includes internal classes to manage delegation tokens and associated SCRAM credentials. \DelegationTokenCache\ provides a thread-safe cache for storing token information, mapping HMACs to token IDs, and managing SCRAM credentials per token, ensuring that HMAC entries are correctly removed when a token is deleted. \DelegationTokenCredentialCallback\ extends \ScramCredentialCallback\ to include token owner and expiry timestamp details, supporting the periodic re-authentication mechanism for SASL connections.
clients/src/main/java/org/apache/kafka/common/security/token/delegation/internals · high confidence
New feature versioning support classes in Kafka clients
The Kafka clients package now includes \SupportedVersionRange\ and \package-info.java\ to support the programmatic handling of logical feature versions. \SupportedVersionRange\ extends \BaseVersionRange\ to define min/max version constraints for features, providing methods to check version compatibility and convert between version ranges and maps. This change introduces the foundational data structures for the feature versioning system (KIP-584) within the client library, allowing clients to understand and communicate supported feature versions.
clients/src/main/java/org/apache/kafka/common/feature · high confidence
New in-process Kafka cluster test harness (ClusterInstance and KafkaClusterTestKit)
The test-common-runtime module now includes a new in-process Kafka cluster test harness that starts real BrokerServer and ControllerServer instances within the test JVM, eliminating the need for Docker. This harness provides a ClusterInstance interface and KafkaClusterTestKit implementation, along with supporting utilities like AdminUtils for leader election, SslManager for SSL configuration, MockFaultHandler for fault injection, and PreboundSocketFactoryManager to ensure port reuse during broker restarts. Tests using this harness gain faster startup times and direct access to server internals.
test-common/test-common-runtime · high confidence
New internal admin API driver framework for transaction and group offset operations
The admin client internals now include a new request-handling framework (AdminApiDriver) with dedicated handlers for aborting transactions (AbortTransactionHandler) and altering consumer/share group offsets (AlterConsumerGroupOffsetsHandler, AlterShareGroupOffsetsHandler). This introduces a structured approach to building and processing requests for these operations, including specific error handling for transaction fencing and coordinator availability.
clients/src/main/java/org/apache/kafka/clients/admin/internals · high confidence
New internal metrics management classes for consumer operations
This change introduces a new set of internal classes in the consumer metrics package to manage and expose operational metrics for Kafka consumers. Specifically, it adds managers for tracking heartbeat latency and rates, offset commit performance, and detailed rebalance events (including latency, success/failure counts, and partition assignment counts). It also introduces dedicated metrics for the asynchronous consumer's internal event queues and network polling, as well as poll idle ratios and commit synchronization times for standard consumers. These classes centralize the registration and lifecycle management of these JMX metrics, ensuring they are properly cleaned up when the consumer closes.
clients/src/main/java/org/apache/kafka/clients/consumer/internals/metrics · high confidence
New internal metrics utilities and plugin metrics implementation
The Kafka client now includes new internal classes in the \org.apache.kafka.common.metrics.internals\ package to support metrics management. \MetricsUtils\ provides helper methods for time conversion and creating ordered tag maps using \LinkedHashMap\. \PluginMetricsImpl\ implements the \PluginMetrics\ interface, allowing plugins to register and manage their own metrics and sensors with proper lifecycle handling and tag isolation. Additionally, \IntGaugeSuite\ is introduced to efficiently manage a suite of integer gauges with bounded capacity and lock-free pending changes.
clients/src/main/java/org/apache/kafka/common/metrics/internals · high confidence
New memory management and network channel abstractions
This change introduces the \org.apache.kafka.common.memory\ package, providing a \MemoryPool\ interface and implementations (\SimpleMemoryPool\, \GarbageCollectedMemoryPool\) to explicitly manage buffer allocation and detect memory leaks. It also adds core network channel infrastructure, including the \Authenticator\ interface for handling SASL and SSL authentication, the \ChannelBuilder\ interface for constructing channels, and the \ChannelState\ enum to track connection lifecycle states (e.g., \AUTHENTICATE\, \READY\). These components form the foundation for the new network client and broker channel handling.
clients/src/main/java/org/apache/kafka/common/network · high confidence
New metrics stat implementations in Kafka clients
The \org.apache.kafka.common.metrics.stats\ package now includes a comprehensive set of statistical aggregators for client metrics, including \Avg\, \Min\, \Max\, \CumulativeSum\, \CumulativeCount\, \WindowedSum\, \WindowedCount\, \Rate\, \SimpleRate\, \TokenBucket\, \Value\, and \Histogram\. These classes provide the underlying logic for calculating averages, counts, sums, rates, and distribution histograms, enabling more detailed and accurate monitoring of Kafka client performance and behavior.
clients/src/main/java/org/apache/kafka/common/metrics/stats · high confidence
New pluggable Java Authorizer API (KIP-504)
This change introduces a new public API for implementing custom authorization plugins in Kafka brokers. It adds the \Authorizer\ interface, which defines methods for startup, synchronous request authorization (\authorize\), and asynchronous ACL management (\createAcls\, \deleteAcls\). The API includes \AuthorizableRequestContext\ to provide request metadata (such as listener, principal, and client address) to plugins, and \AuthorizationResult\ to indicate allow/deny outcomes. Additionally, it provides \AuthorizerServerInfo\ for broker configuration metadata during startup and \CidrUtils\ to support CIDR-based IP matching in authorization logic.
clients/src/main/java/org/apache/kafka/server/authorizer · high confidence
New pluggable client quota callback interface
The \clients\ module now includes the \org.apache.kafka.server.quota\ package, introducing the \ClientQuotaCallback\ interface and supporting types (\ClientQuotaEntity\, \ClientQuotaType\) that allow users to implement custom logic for computing and managing client quotas on the broker side. This change provides the client-side API definitions required for the new quota callback mechanism, including methods for determining quota metric tags, retrieving quota limits, handling quota updates/removals, and detecting when quota resets are required. The \updateClusterMetadata\ method is deprecated as it is unsupported in KRaft mode.
clients/src/main/java/org/apache/kafka/server/quota · high confidence
New pluggable policy interface for overriding connector client configurations
Kafka Connect now exposes the \ConnectorClientConfigOverridePolicy\ interface in the \connect/api\ module, allowing administrators to define custom policies that validate which Kafka client properties (such as SASL credentials or optimization settings) a connector is permitted to override. This change introduces the core API contract (\ConnectorClientConfigOverridePolicy\) and the request model (\ConnectorClientConfigRequest\) that workers use to enforce these rules before starting a connector or validating its configuration via the REST API. Implementations of this interface can be discovered via the Java ServiceLoader mechanism to provide fine-grained control over per-connector client configuration.
connect/api/src/main/java/org/apache/kafka/connect/connector/policy · high confidence
New pluggable storage API for Connect converters and headers
The \connect.api\ module now exposes a new \org.apache.kafka.connect.storage\ package containing the core interfaces and default implementations for data serialization. This includes the \Converter\ interface for record keys and values, the \HeaderConverter\ interface for message headers, and the \OffsetStorageReader\ interface for source connector offset management. To support these interfaces, the package provides \ConverterConfig\ and \StringConverterConfig\ for configuration, the \ConverterType\ enum, and built-in implementations \StringConverter\ and \SimpleHeaderConverter\. This change establishes the public API contract for how Connect plugins discover and configure serialization components.
connect/api/src/main/java/org/apache/kafka/connect/storage · high confidence
New primitive and collection serialization classes added to the Kafka clients
The \org.apache.kafka.common.serialization\ package now includes a comprehensive set of built-in serializers and deserializers for common data types. This release adds support for \Boolean\, \Byte\ (via \ByteArray\), \ByteBuffer\, \Bytes\, \Double\, \Float\, \Integer\, \Long\, and \UUID\, along with a \List\ serializer/deserializer for handling collections. These classes implement the new \Serializer\, \Deserializer\, and \Serde\ interfaces, providing users with ready-to-use components for serializing primitive and complex types without needing custom implementations.
clients/src/main/java/org/apache/kafka/common/serialization · high confidence
New public API for Bytes and utility classes in Kafka clients
The \org.apache.kafka.common.utils\ package now includes \Bytes\, \Time\, \Timer\, and \SystemTime\ as part of the public API (via KIP-1247). \Bytes\ provides an immutable wrapper for byte arrays with caching for hash codes and lexicographic comparison, primarily for use in Kafka Streams state stores and serialization. \Time\ and \Timer\ offer a clock abstraction and timeout management utilities to simplify blocking calls with timeouts in client code. While \Bytes\ is now officially public, \Time\ and \Timer\ are exposed but not yet fully designated as public API, with their status to be addressed in a future KIP. Other classes in the package remain internal utilities.
clients/src/main/java/org/apache/kafka/common/utils · high confidence
New public API for Kafka tools plugins
The \tools-api\ module now exposes a public plugin interface for Kafka tools, allowing users to write custom decoders and record readers. This includes the \Decoder\ interface with built-in implementations for strings, integers, longs, and a default passthrough decoder, as well as the \RecordReader\ interface used by ConsoleProducer to ingest data from input streams. These additions provide a standardized way to extend tool behavior without modifying core code.
tools/tools-api · high confidence
New public API interfaces for group partition assignment and Kafka Streams topology plugins
The \group-coordinator-api\ module now exposes a new public API for consumer and share group partition assignment, including interfaces like \PartitionAssignor\, \GroupSpec\, \MemberAssignment\, and \SubscriptionType\, along with a new public API for Kafka Streams topology management, featuring the \StreamsGroupTopologyDescriptionPlugin\ SPI and related data models like \StreamsGroupTopologyDescription\ and \TaskAssignor\. This allows external implementations to provide custom partition assignors for consumer and share groups, and enables broker-side plugins to store, forward, or expose Kafka Streams topology descriptions pushed by clients.
group-coordinator/group-coordinator-api · high confidence
New public authentication interfaces for pluggable security mechanisms
The \org.apache.kafka.common.security.auth\ package now exposes a set of new public interfaces and classes that enable custom authentication implementations. Users can now implement \KafkaPrincipalBuilder\ to derive custom principal types from SSL or SASL contexts, and \SslEngineFactory\ to customize SSL engine creation and dynamic reconfiguration. The package also introduces \AuthenticationContext\ to provide session details (protocol, address, listener name) to builders, \KafkaPrincipalSerde\ for inter-broker principal serialization, \AuthenticateCallbackHandler\ for SASL configuration, and \SecurityProviderCreator\ for custom Java security providers. Additionally, \SaslExtensionsCallback\ supports SASL mechanism extensions, and \SecurityProtocol\ defines the standard protocol enums.
clients/src/main/java/org/apache/kafka/common/security/auth · high confidence
New resource type enums for ACLs
The Kafka client now includes new public enums in the \org.apache.kafka.common.resource\ package to define ACL resources. \ResourceType\ enumerates supported resource kinds including TOPIC, GROUP, CLUSTER, TRANSACTIONAL\_ID, DELEGATION\_TOKEN, and USER, while \PatternType\ defines pattern matching behaviors (LITERAL, PREFIXED, MATCH, ANY) for resource names. These types provide the foundational data structures for the AdminClient's authorization and ACL management capabilities.
clients/src/main/java/org/apache/kafka/common/resource · high confidence
New test connectors added to connect/test-plugins
The connect/test-plugins module now includes MockConnector, MockSinkTask, MockSourceTask, SchemaSourceConnector, SchemaSourceTask, VerifiableSinkConnector, VerifiableSinkTask, VerifiableSourceConnector, and VerifiableSourceTask, along with their service-provider registrations. These connectors are intended for system testing: MockConnector/Task simulate connector or task failures with configurable delays, SchemaSourceConnector/Task produce static Struct data with optional multiple schemas and throughput throttling, and VerifiableSource/Sink connectors emit JSON metadata to stdout to validate message processing and offset management across distributed workers.
connect/test-plugins · high confidence
New test infrastructure for filtering flaky and new tests
The test-common module now includes a new @Flaky annotation and a JUnit PostDiscoveryFilter (KafkaPostDiscoveryFilter) that allows tests to be categorized as flaky or new. This enables selective execution of these test categories during CI runs, improving reliability by isolating unstable tests and tracking newly added ones.
test-common/test-common-util · high confidence
New utility classes for Kafka Connect transforms
Added five new utility classes to the transforms package to support Single Message Transforms: NonEmptyListValidator and RegexValidator for configuration validation, Requirements for runtime type checking of records and schemas, SchemaUtil for copying schema metadata, and SimpleConfig as a lightweight AbstractConfig implementation.
connect/transforms/src/main/java/org/apache/kafka/connect/transforms/util · high confidence
OAuth client\_credentials authentication now supports JWT client assertions
The Kafka client now supports authenticating to OAuth providers using a client assertion (a self-signed JWT) instead of a client secret for the client\_credentials grant type. This is implemented via new internal classes in the OAuth bearer secured package, including ClientAssertionRequestFormatter to build the token request, ClientCredentialsRequestFormatterFactory to select the authentication method, and supporting utilities for configuration and validation. The factory uses a three-tier fallback: file-based assertion, locally-generated assertion, or client secret, ensuring backward compatibility while allowing more secure, secret-less authentication.
clients/src/main/java/org/apache/kafka/common/security/oauthbearer/internals/secured · high confidence
Register BasicAuthSecurityRestExtension via ServiceLoader
The basic-auth-extension now registers its REST implementation (BasicAuthSecurityRestExtension) through the standard Java ServiceLoader mechanism by adding the META-INF/services/org.apache.kafka.connect.rest.ConnectRestExtension file. This ensures the extension is automatically discovered and integrated into the Kafka Connect REST layer without requiring manual configuration.
connect/basic-auth-extension/src/main/resources · high confidence
Registration of new ConfigProvider implementations for environment variable support
The Kafka clients now register DirectoryConfigProvider and EnvVarConfigProvider alongside the existing FileConfigProvider in the service provider list. This enables users to retrieve configuration values from environment variables and directory-based sources, supporting the KIP-887 feature for externalized configuration management.
clients/src/main/resources/META-INF · high confidence
SASL/OAUTHBEARER authentication now supports custom extensions
Kafka clients and brokers can now exchange custom SASL extensions during the OAuthBearer authentication handshake. The client-side \OAuthBearerSaslClient\ retrieves extensions from the login callback handler and includes them in the initial response via the new \OAuthBearerClientInitialResponse\ class, which validates extension keys and values against RFC 7628. On the server side, \OAuthBearerSaslServer\ passes these extensions to the callback handler for validation via \OAuthBearerExtensionsValidatorCallback\, allowing custom authorization logic based on extension data. This change enables richer authentication metadata to be passed between client and server without altering the core token validation flow.
clients/src/main/java/org/apache/kafka/common/security/oauthbearer/internals · high confidence
TopologyTestDriver test utilities now support record headers and partition assignment
The \streams/test-utils\ module introduces \TestInputTopic\ and \TestOutputTopic\ classes that allow users to pipe records with explicit headers and read them back, enabling tests for header-based processing. The \TestRecord\ class now supports explicit partition assignment, allowing tests to verify partition-specific logic. Additionally, a new \TopologyTestDriverBuilder\ provides a fluent API for constructing the driver, deprecating the old constructors.
streams/test-utils · high confidence
Windows batch scripts added for Kafka tools and Connect
Windows users now have native .bat wrappers for the full suite of Kafka command-line tools (including topics, consumer groups, ACLs, storage, and performance tests) and Kafka Connect (standalone and distributed modes). These scripts invoke the corresponding Java classes via kafka-run-class.bat, enabling Windows users to run administrative, operational, and testing commands without relying on Unix shell scripts or workarounds.
bin/windows · high confidence
Removals
Removal of Hadoop and Pig integration components
The Hadoop producer contrib module has been removed, deleting the \KafkaOutputFormat\, \KafkaRecordWriter\, \TextPublisher\ example, and \AvroKafkaStorage\ Pig storage class. Users can no longer use these components to stream data from Hadoop MapReduce jobs or Apache Pig scripts directly into Kafka.
contrib/hadoop-producer/src · high confidence
Removal of deprecated Hadoop consumer example components
The DataGenerator, SimpleKafkaETLJob, and SimpleKafkaETLMapper classes in the Hadoop consumer contrib module have been removed. These components, which provided a basic example for generating test events and processing them via a Hadoop MapReduce job, are no longer part of the distribution.
contrib/hadoop-consumer/src/main/java/kafka/etl/impl · high confidence
Removal of embedded consumer and producer performance system tests
The \system\_test\ directory no longer includes the embedded consumer replication test or the producer performance benchmarks. Specifically, the \embedded\_consumer\ and \producer\_perf\ subdirectories, along with their associated shell scripts, configuration files, and expected output logs, have been deleted. Users can no longer run these specific local system tests to verify message replication across brokers or measure producer throughput.
_system\test · high confidence
Removal of legacy sbt 0.7.5 build configuration
The project's build system configuration files for sbt 0.7.5 have been removed, including \project/build.properties\, \project/build/KafkaProject.scala\, and \project/plugins/Plugins.scala\. This change eliminates the custom sbt project definitions, plugin configurations, and dependency management logic that were previously used to compile and package the Kafka core, examples, performance tools, and contrib modules.
project · high confidence
Removal of the C++ Kafka client library
The C++ client library (kafkaconnect) has been removed from the project. This change deletes the entire \clients/cpp\ directory, including the source code for the producer and encoder, the build system files (Autoconf/Automake), and the associated unit tests. Users can no longer build or use this C++ client to connect to Kafka.
clients/cpp · high confidence
Removal of the Hadoop Kafka ETL consumer module
The Kafka Hadoop consumer module, located in contrib/hadoop-consumer/src/main/java/kafka/etl, has been removed. This change deletes the Java classes responsible for integrating Kafka with Hadoop MapReduce, including the input format, record reader, job configuration, and context classes. Users relying on this specific contrib module for Hadoop-based Kafka data ingestion will no longer have access to these components.
contrib/hadoop-consumer, contrib/hadoop-consumer/src/main/java/kafka/etl · high confidence
Removal of the Ruby client library
The Ruby client library (kafka-rb) has been removed from the project. This change deletes the entire \clients/ruby\ directory, including the source code for the producer and consumer, build scripts, and documentation, meaning Ruby users can no longer use this bundled client to produce or consume messages.
clients/go, clients/ruby · high confidence
Removal of the experimental Clojure client library
The \clients/clojure\ directory, containing the \kafka-clj\ Clojure client implementation, has been completely removed. This deletion includes the core producer and consumer logic, serialization utilities, build configuration (\project.clj\), and associated tests. The client is no longer available for use until it can be correctly implemented and refactored.
clients/clojure · high confidence
Removal of the legacy C\# Kafka client library
The C\# client library located in \clients/csharp\ has been completely removed. This change deletes the entire source tree, including the \Producer\ and \Consumer\ classes, request models (such as \FetchRequest\ and \ProducerRequest\), connection handling, and associated configuration files like \.gitignore\ and \LICENSE\. Users relying on this specific .NET implementation will no longer have access to these client components.
clients/csharp · high confidence
Removal of the legacy PHP Kafka client library
The \clients/php\ directory, which contained the legacy PHP Kafka client library (including the Producer, Consumer, and core protocol classes), along with its associated examples and PHPUnit test suite, has been removed. This change eliminates the deprecated PHP client implementation from the codebase.
clients/php · high confidence
Removed legacy Python client library
The legacy Python client library (kafka-python-client v0.6) has been removed from the clients/python directory. This deletion eliminates the previous implementation that used a custom binary message format and direct socket connections for producing messages, effectively removing this specific client interface from the product.
clients/python · high confidence
Removed local Eclipse project configuration and bundled Highcharts assets from the performance testing tool
The performance testing tool no longer includes local Eclipse project metadata (\.classpath\, \.project\) or a \README.md\ file, removing the previous local build instructions and IDE-specific configuration. Additionally, the bundled Highcharts JavaScript library (\highcharts.js\) and its exporting module (\exporting.js\) have been removed from the \report-html/js/\ directory, meaning the performance report generation no longer relies on these specific client-side charting assets.
perf · high confidence
API
Refactor metrics API to use MetricValueProvider and Gauge
The metrics API has been refactored to decouple metric value retrieval from the \Metric\ interface. A new \MetricValueProvider\<T\>\ interface now serves as the base for providing metric values, implemented by the new \Gauge\<T\>\ interface for instantaneous readings and the \Measurable\ interface for computed statistics. The \KafkaMetric\ class now wraps a \MetricValueProvider\ instead of a \Metric\, and the \JmxReporter\ has been updated to handle these new provider types, ensuring that metrics are correctly exposed via JMX.
clients/src/main/java/org/apache/kafka/common/metrics · high confidence
Architecture
Centralized broker security configuration definitions
The \BrokerSecurityConfigs\ class has been introduced in the \clients\ module to serve as the single source of truth for broker-side security configuration keys, defaults, and documentation strings. This change consolidates previously scattered definitions (such as those for SSL principal mapping, SASL callback handlers, and certificate reconfiguration options) into a shared internal API, ensuring consistent configuration validation and documentation across both the broker and client libraries.
clients/src/main/java/org/apache/kafka/common/config/internals · high confidence
Migration of core CLI tools to the tools module
The \tools\ module now contains the primary implementation of several key command-line utilities, including \AclCommand\, \BrokerApiVersionsCommand\, \ClientMetricsCommand\, \ClusterTool\, \ConsoleProducer\, and \DelegationTokenCommand\. This change moves these tools out of the core server codebase into a dedicated module, providing a cleaner separation between server internals and administrative utilities. The implementations have been rewritten in Java and now utilize the \Admin\ client for cluster interactions, supporting both bootstrap servers and bootstrap controllers.
tools · high confidence
Move server-side common classes to the server-common module
Several classes previously located in other modules have been relocated to the new server-common module to consolidate shared server-side utilities. This includes the ClientIdAndBroker class for request statistics, the DirectoryId class for managing log directory assignments, the DeferredEventQueue for managing deferred log operations, the StateChangeLogger for consistent state-change logging, and various metadata and security utilities such as AssignmentsHelper, ConfigRepository, MetaPropertiesVersion, PropertiesUtils, KafkaEventQueue, CredentialProvider, DelegationTokenManager, ApiMessageAndVersion, CheckpointFile, and ControllerRequestCompletionHandler.
server-common · high confidence
Refactor network layer to use sealed interfaces for requests and responses
The server's network layer has been refactored to use Java sealed interfaces (\BaseRequest\ and \Response\) to strictly define the set of allowed request and response types. This change introduces new concrete types such as \CallbackRequest\, \CloseConnectionResponse\, \EndThrottlingResponse\, and \NoOpResponse\, replacing previous ad-hoc handling. It also centralizes socket server configuration constants in \SocketServerConfigs\ and moves request-to-JSON conversion logic into \RequestConvertToJson\, improving type safety and code organization for broker network operations.
server · high confidence
Refactored protocol layer to use generated message classes and centralized API definitions
The \org.apache.kafka.common.protocol\ package has been restructured to support the new automated RPC generation system. \ApiKeys\ is now a central enum mapping API keys to \ApiMessageType\, consolidating API metadata and listener filtering. Manual request/response classes have been replaced by generated \ApiMessage\ implementations, with serialization logic moved to \MessageUtil\ and \ObjectSerializationCache\. The \Protocol\ class now generates HTML documentation from schema definitions, and \SendBuilder\ enables zero-copy network transmission for generated messages. Additionally, \Errors\ has been expanded to include new error codes for KRaft, Share Groups, and Streams Groups.
clients/src/main/java/org/apache/kafka/common/protocol · high confidence
Tiered storage API classes moved to the storage-api module
The tiered storage API classes, including the RemoteStorageManager interface, RemoteLogMetadataManager interface, and associated metadata classes (such as RemoteLogSegmentMetadata and LogSegmentData), have been moved from the clients module to the new storage-api module. This change reorganizes the codebase to better separate the core storage API definitions from the client-facing interfaces.
storage/api · high confidence
Transaction coordinator refactored to Java with new configuration and state management
The transaction-coordinator module has been migrated from Scala to Java, introducing new Java classes for transaction state management (TransactionState, TransactionMetadata), configuration (TransactionLogConfig, TransactionStateManagerConfig, AddPartitionsToTxnConfig, TransactionConfig), and producer ID management (ProducerIdManager, RPCProducerIdManager). This refactoring includes the addition of a new transaction record serialization layer (TransactionCoordinatorRecordSerde) and internal data structures (PendingCompleteTxnAndMarkerEntry, TxnMarkerQueue) to support the new coordinator architecture.
transaction-coordinator · high confidence
Trogdor test framework is extracted into its own module
The Trogdor test and benchmarking framework has been moved out of the tools directory into a dedicated gradle module. This change introduces the core Trogdor components—including the Agent, Coordinator, REST resources, and common utilities—along with a new README and .gitignore, establishing the standalone structure for this development-only stress-testing tool.
trogdor · high confidence
Behavioural changes
1141 commits (79 fixes) modifying repository
A change to existing behaviour in repository — 1141 commits (79 fixs), 7 files: “KAFKA-2072; Replace StopReplica Request/Response with their org.apache.kafka.common.requests equivalents”; “KAFKA-17890: Move DelayedOperationPurgatory to server-common (\#17636)”; “KAFKA-17406: Move ClientIdAndBroker to server-common module (\#16967)”; and 1137 more (refs \#17636, \#16967, \#21412, \#9689, \#21302, …).
repository · medium confidence · unverified
14 commits (2 fixes) modifying clients/src/main/java/org/apache/kafka/common/record/internal
A change to existing behaviour in clients/src/main/java/org/apache/kafka/common/record/internal — 14 commits (2 fixs), 24 files: “KAFKA-20128 Add missing TimestampType to java doc and move non-public classes to internal subpackage (\#21412)”; “MINOR: Fix RandomAccessFile leak in FileRecords.openChannel (\#22878)”; “KAFKA-16304: Offline the log directory on a disk error in the zero-copy Fetch path (\#23445)”; and 11 more (refs \#21412, \#22878, \#23445, \#23303, \#22654, …).
clients/src/main/java/org/apache/kafka/common/record/internal · medium confidence · unverified
2 commits (0 fixes) modifying mirror-coordinator
A change to existing behaviour in mirror-coordinator — 2 commits, 9 files: “KAFKA-21379: Add mirror coordinator record schemas and serde (\#23979)”; “KAFKA-21224: Add mirror-level configs (\#23843)” (refs \#23979, \#23843).
mirror-coordinator · medium confidence · unverified
3000 commits (478 fixes) modifying streams
A change to existing behaviour in streams — 3000 commits (478 fixs), 1161 files: “KAFKA-20173: Propagate headers into serde 2/N (\#21536)”; “KAFKA-3196; Added checksum and size to RecordMetadata and ConsumerRecord”; “KAFKA-17489: Do not handle failed tasks as tasks to assign (\#17115)”; and 2997 more (refs \#21536, \#17115, \#8146, \#13831, \#6933, …).
streams · medium confidence · unverified
320 commits (33 fixes) modifying clients/src/main/java/org/apache/kafka/clients/producer/internals
A change to existing behaviour in clients/src/main/java/org/apache/kafka/clients/producer/internals — 320 commits (33 fixs), 17 files: “KAFKA-9279: Fail producer transactions for asynchronously-reported, synchronously-encountered ApiExceptions (\#11508)”; “KAFKA-3196; Added checksum and size to RecordMetadata and ConsumerRecord”; “KAFKA-20128 Add missing TimestampType to java doc and move non-public classes to internal subpackage (\#21412)”; and 316 more (refs \#11508, \#21412, \#11149, \#8000, \#9103, …).
clients/src/main/java/org/apache/kafka/clients/producer/internals · medium confidence · unverified
4148 commits (422 fixes) modifying kafka
A change to existing behaviour in kafka — 4148 commits (422 fixs), 843 files: “KAFKA-9279: Fail producer transactions for asynchronously-reported, synchronously-encountered ApiExceptions (\#11508)”; “MINOR: increase RocksDb parallelism”; “KAFKA-13046: add test coverage for AbstractStickyAssignorTest (\#11156)”; and 4144 more (refs \#11508, \#11156, \#17115, \#7460, \#17636, …).
kafka · medium confidence · unverified
4259 commits (488 fixes) modifying core
A change to existing behaviour in core — 4259 commits (488 fixs), 391 files: “KAFKA-2072; Replace StopReplica Request/Response with their org.apache.kafka.common.requests equivalents”; “KAFKA-16126: Kcontroller dynamic configurations may fail to apply at startup”; “KAFKA-3196; Added checksum and size to RecordMetadata and ConsumerRecord”; and 4248 more (refs \#17636, \#18230, \#7616, \#17840, \#16387, …).
core · medium confidence · unverified
Added license files for new and existing dependencies
The project now includes specific license text files for several dependencies in the \licenses/\ directory. This adds the CDDL v1.1 license for the main distribution, and individual license files for argparse, classgraph, Eclipse Distribution License 1.0, Eclipse Public License 2.0, hdrHistogram, jline, jopt-simple, jsr305, mock-oauth2-server, paranamer, pcollections, protobuf-java, re2j, slf4j, and zstd-jni. This ensures compliance with the licensing terms of these libraries.
licenses · high confidence
Deprecation of the Kafka Streams Scala DSL module
The \streams/streams-scala\ module, which provided a Scala wrapper around the Kafka Streams DSL (including classes like \KStream\, \KTable\, \StreamsBuilder\, and configuration objects like \Consumed\ and \Grouped\), is now deprecated as of version 4.3.0. Users are advised to migrate to the standard Java \org.apache.kafka.streams\ API. The diff shows these Scala wrapper classes are marked with \@deprecated\ annotations and primarily act as thin delegates to the underlying Java implementations, utilizing implicit conversions for type safety and function literals.
streams/streams-scala · high confidence
Examples rewritten for modern Kafka clients with new transactional demos
The examples directory has been completely rewritten to use the modern Java client API (org.apache.kafka.clients) instead of the legacy Scala/ZooKeeper-based clients. The old \SimpleConsumerDemo\ and \KafkaConsumerProducerDemo\ (which relied on \kafka.javaapi\ and ZooKeeper connection strings) have been removed or replaced with implementations using \KafkaConsumer\ and \KafkaProducer\. The \Consumer\ and \Producer\ helper classes now configure clients via \ConsumerConfig\ and \ProducerConfig\ properties (e.g., \bootstrap.servers\, \group.id\) rather than static ZooKeeper properties. Additionally, new examples have been added: \KafkaExactlyOnceDemo\ and \ExactlyOnceMessageProcessor\ demonstrate exactly-once semantics using transactional producers and \read\_committed\ isolation levels, while \TransactionalClientDemo\ provides a template for transactional word-count processing with robust error handling. The shell scripts (\java-producer-consumer-demo.sh\, \exactly-once-demo.sh\) have been updated to invoke these new Java classes via \kafka-run-class.sh\.
examples · high confidence
Internal refactoring and new utility classes in Kafka clients
This change introduces several new internal classes to the Kafka clients module to improve code organization, safety, and compatibility. A new \ClusterResourceListeners\ class centralizes the management and notification of cluster metadata updates. \KafkaCompletableFuture\ is added to prevent user code from erroneously completing futures returned by Kafka APIs. \PartitionStates\ provides a thread-safe, round-robin partition state builder optimized for fetch request serialization. \Topic\ consolidates topic validation logic, including checks for internal topics and metric name collision characters. \SecurityManagerCompatibility\ and its \CompositeStrategy\ implementation provide a shim to support both legacy and modern Java security APIs, ensuring graceful degradation across different JRE versions. Finally, \UnsupportedProtocolFieldException\ is introduced as a specific subtype of \UnsupportedVersionException\ to distinguish unsupported fields from unsupported API versions.
clients/src/main/java/org/apache/kafka/common/internals · high confidence
Internal utility classes moved to org.apache.kafka.common.utils.internals
A broad set of internal utility classes—including AbstractIterator, AppInfoParser, BufferSupplier, ByteBufferInputStream, ByteBufferOutputStream, ByteBufferUnmapper, ByteUtils, Checksums, ChildFirstClassLoader, ChunkedBytesStream, CircularIterator, CloseableIterator, ConfigUtils, CopyOnWriteMap, ImplicitLinkedHashCollection, ImplicitLinkedHashMultiCollection, KafkaThread, ThreadUtils, ExponentialBackoff, ExponentialBackoffManager, Crc32C, Sanitizer, OperatingSystem, Java, Exit, and ProducerIdAndEpoch—have been relocated from the public org.apache.kafka.common.utils package to the new internal package org.apache.kafka.common.utils.internals. This change restricts direct access to these implementation details for external consumers, signaling that they are not part of the stable public API.
clients/src/main/java/org/apache/kafka/common/utils/internals · high confidence
Introduce automated protocol generation for Kafka request and response classes
The \org.apache.kafka.common.requests\ package has been refactored to use an automated protocol generation system. New base classes \AbstractRequest\ and \AbstractResponse\ now wrap generated data objects (e.g., \AddOffsetsToTxnRequestData\), replacing the previous manual serialization and parsing logic. This change standardizes how request and response schemas are handled, simplifying the implementation of new RPCs and ensuring consistency across the client library.
clients/src/main/java/org/apache/kafka/common/requests · high confidence
JSON Converter supports numeric decimal format and configurable null replacement
The JSON Converter now allows decimal values to be serialized as native JSON numbers (e.g., 10.2345) instead of the default base-64 encoded strings, controlled by the new \decimal.format\ configuration option. Additionally, the \replace.null.with.default\ setting now correctly prevents emitting default values for Struct fields when the field is null, ensuring that nulls are preserved as intended rather than being overwritten by schema defaults.
connect/json/src/main/java · high confidence
Major overhaul of bin scripts: new tools, KRaft support, and modernized runtime
The bin directory has been significantly restructured to support the new 'tools' module and KRaft metadata quorum. Many legacy scripts (e.g., \kafka-console-consumer.sh\, \kafka-topics.sh\) now delegate to updated Java classes in the \org.apache.kafka.tools\ package, while several obsolete scripts (like \kafka-consumer-shell.sh\ and Zookeeper-specific start/stop scripts) have been removed. New scripts have been added for KRaft management (\kafka-metadata-quorum.sh\, \kafka-metadata-shell.sh\), Connect internal topics (\connect-internal-topics.sh\), plugin path inspection (\connect-plugin-path.sh\), and share consumer groups (\kafka-share-groups.sh\, \kafka-console-share-consumer.sh\). The \kafka-run-class.sh\ script has been rewritten to use Gradle build paths, support Scala 2.13, and exclude test jars by default. Additionally, \kafka-server-start.sh\ now defaults to Log4j2 and supports the \-daemon\ flag, and \kafka-broker-api-versions.sh\ is deprecated in favor of \kafka-cluster.sh\.
bin · high confidence
Migrate configuration files from ZooKeeper to KRaft mode
The configuration files in the \config\ directory have been updated to support the new KRaft (ZooKeeper-less) mode. New sample files \broker.properties\ and \controller.properties\ are provided with KRaft-specific settings such as \process.roles\, \node.id\, and \controller.quorum.bootstrap.servers\. Existing files like \consumer.properties\ and \producer.properties\ have been rewritten to use \bootstrap.servers\ instead of the deprecated \zk.connect\ and \zk.connectiontimeout.ms\ parameters. Additionally, the legacy \log4j.properties\ and \zookeeper.properties\ files have been removed, replaced by \log4j2.yaml\ and \connect-log4j2.yaml\ respectively, and new sample configurations for Kafka Connect (standalone, distributed, file, console) and MirrorMaker 2.0 have been added.
config · high confidence
New Docker entrypoint scripts for configuration and security validation
Added a set of new bash scripts in docker/resources/common-scripts (bash-config, configure, configureDefaults, run) that serve as the core entrypoint logic for the Docker container. These scripts enforce strict environment variable handling, automatically derive KAFKA\_LISTENERS from ADVERTISED\_LISTENERS, validate SSL/SASL certificate paths and credentials, and ensure required JVM options are set for JMX and security, providing a more robust and secure initialization process for users running Kafka in Docker.
docker/resources · high confidence
New checkstyle configuration files for Scala formatting and module import control
The checkstyle directory now includes a \.scalafmt.conf\ file to enforce Scala 2.13 formatting rules (version 3.10.3) and a set of \import-control-\*.xml\ files that define package-level import allowlists and disallows for various modules (e.g., api-checker, clients-integration-tests, coordinator-common, core, examples, jmh-benchmarks, mirror-coordinator, share-coordinator, storage). These files standardize code style and enforce architectural layering by restricting which packages each module can import.
checkstyle · high confidence
Refactored OAuthBearer authentication layer with new JWT retrievers and validators
The SASL/OAUTHBEARER authentication implementation has been restructured to separate JWT retrieval and validation concerns into distinct, pluggable components. New public interfaces \JwtRetriever\ and \JwtValidator\ allow for flexible token acquisition and verification strategies. The \DefaultJwtRetriever\ now supports multiple grant types, including \client\_credentials\ (via \ClientCredentialsJwtRetriever\) and \jwt-bearer\ (via \JwtBearerJwtRetriever\), as well as loading tokens from local files (\FileJwtRetriever\). On the validation side, \DefaultJwtValidator\ delegates to \BrokerJwtValidator\ for robust signature and claim verification (including required issuer/audience checks) when a JWKS endpoint is configured, or to \ClientJwtValidator\ for basic structural validation on the client side. This change provides a more modular and reusable OAuth layer while maintaining backward compatibility through the default configurations.
clients/src/main/java/org/apache/kafka/common/security/oauthbearer · high confidence
Refactored SASL authentication into modular login and principal builder components
The SASL authentication logic in the Kafka client has been restructured to improve modularity and support dynamic configuration. A new \AbstractLogin\ base class and \DefaultLogin\ implementation now handle the core JAAS login context lifecycle, while \LoginManager\ introduces a caching mechanism that supports both static and dynamic JAAS configurations, allowing login managers to be reused and released based on reference counts. Additionally, \DefaultKafkaPrincipalBuilder\ provides a centralized implementation for building \KafkaPrincipal\ objects from SSL and SASL authentication contexts, including support for Kerberos short naming and SSL principal mapping, replacing previous scattered logic.
clients/src/main/java/org/apache/kafka/common/security/authenticator · high confidence
Refactored SSL engine factory and added common name logging for expired certificates
The SSL security package has been refactored to introduce a new \SslFactory\ that wraps the \SslEngineFactory\ and supports dynamic reconfiguration of SSL settings (such as keystores and truststores) at runtime. Additionally, a new \CommonNameLoggingSslEngineFactory\ has been added to extend the default SSL engine factory; this implementation logs the common name of expired client certificates, improving observability for administrators monitoring TLS connections.
clients/src/main/java/org/apache/kafka/common/security/ssl · high confidence
Refactored compression implementation to support configurable levels and lazy loading
The compression logic in the Kafka clients has been restructured to introduce a unified \Compression\ interface and specific codec implementations (Gzip, Snappy, LZ4, Zstd, NoCompression). This change enables configurable compression levels, most notably for GZIP (via \GzipOutputStream\) and LZ4 (via \Lz4BlockOutputStream\), allowing users to trade off CPU usage against compression ratio. Additionally, the implementation now supports lazy loading of codecs, meaning compression libraries are only initialized when actually used, reducing startup overhead. The refactoring also moves internal utilities like \BufferSupplier\ and \ByteBufferInputStream\ to an internal package to clarify the public API surface.
clients/src/main/java/org/apache/kafka/common/compress · high confidence
Release process rewritten in Python with automated Docker workflow triggers
The release tooling has been completely rewritten in Python (replacing the previous shell-based scripts) to streamline the release candidate and final release process. This new release script now automatically triggers Docker image build and release workflows on GitHub Actions via the REST API after an RC tag is pushed, eliminating the need for manual intervention. The process now requires Python 3.12 and JDK 25, persists configuration in a local JSON file, and includes dedicated modules for Git, GPG, JIRA notes, and SVN interactions.
release · high confidence
Removal of bundled Autoconf and Libtool build scripts
The build system for the C++ client no longer includes the bundled GNU build infrastructure scripts. Specifically, the \clients/cpp/build-aux\ directory has been cleared of \config.guess\, \config.sub\, \depcomp\, \install-sh\, \ltmain.sh\, \missing\, and the \m4/\ directory containing \libtool.m4\ and related macros. This change removes the local copies of these tools, implying the project now relies on system-installed versions or a different build mechanism for configuration and library linking.
clients/cpp/build-aux · high confidence
Test coverage
1 commit adding/updating tests in streams/upgrade-system-tests-44; 2 commits adding/updating tests in clients/src/test/resources/serializedData; Added Docker sanity test suite for Kafka containers; Added Docker test fixtures for SASL\_PLAINTEXT and SSL configurations; Added JUnit 5 unit tests for FileStream connectors and tasks; Added Kafka Streams 3.2.0 upgrade system tests; Added Kafka Streams upgrade system tests for v1.1; Added Kafka Streams upgrade system tests for version 2.0; Added Kafka Streams upgrade system tests for versions 2.7 and 2.8; Added MockRebalanceListener test utility; Added SSL security tests for TLS 1.2/1.3, principal mapping, and certificate logging; Added Streams upgrade system tests for version 2.2; Added Streams upgrade system tests for versions 2.4 and 2.5; Added consumer integration tests and test utilities; Added integration tests for File Stream Source and Sink connectors; Added integration tests for GroupAuthorizer; Added integration tests for Kafka AdminClient operations; Added integration tests for Kafka producer transaction and lifecycle behaviors; Added integration tests for SocketServer memory pool cleanup; Added integration tests for custom client quota callbacks; Added mock SSL security providers for testing; Added system tests for Kafka Streams 2.1 upgrade and cooperative rebalance behavior; Added system tests for Kafka Streams 4.1 upgrade validation; Added system tests for Kafka Streams upgrade paths from v0.10 and v0.11; Added system tests for Kafka Streams upgrades to versions 4.2.0 and 4.3.0; Added test configuration file for JSON connector tests; Added test coverage for OAuth Bearer secured internals; Added test service provider files for SinkConnector and SourceConnector; Added tests for ApiKeyVersionsProvider; Added tests for ApplicationEventProcessor and CompletableEventReaper; Added tests for CIDR validation and AlterConfigPolicy metadata equality; Added tests for FieldPath abstraction and syntax versioning; Added tests for JsonConverter configuration and data conversion; Added tests for Kafka client exception hierarchy; Added tests for KafkaProtocolFaultProxy routing and bootstrap validation; Added tests for ListSerializer, ListDeserializer, and Serialization roundtrips; Added tests for NonEmptyListValidator null and empty list handling; Added tests for OAuth Bearer security components; Added tests for RackAwareReplicaSelector; Added tests for SASL client authentication failure handling and login manager caching; Added tests for TokenInformation equality and hash code consistency; Added tests for client telemetry state transitions; Added tests for config providers and path validation; Added tests for consumer metrics managers; Added tests for internal record batch and control record components; Added tests for relocated internal utility classes; Added unit tests for ACL client classes; Added unit tests for Admin Client configuration and result objects; Added unit tests for Basic Auth REST extension and JAAS filter; Added unit tests for Connect CLI, standalone config parsing, and new converter/policy implementations; Added unit tests for Connect storage converters; Added unit tests for Connector reconfiguration and initialization behavior; Added unit tests for ConnectorUtils.groupPartitions; Added unit tests for HasHeaderKey and TopicNameMatches predicates; Added unit tests for JAAS configuration parsing and SASL extensions; Added unit tests for Kafka Connect Single Message Transforms; Added unit tests for Kafka Connect data types and schema utilities; Added unit tests for Kafka client configuration classes; Added unit tests for Kafka client internals; Added unit tests for Kafka client internals and configuration; Added unit tests for Kafka client utility classes; Added unit tests for Kafka common classes; Added unit tests for Kafka compression codecs; Added unit tests for Kafka feature versioning classes; Added unit tests for Kafka metrics stats components; Added unit tests for Kafka metrics subsystem; Added unit tests for Kafka network client components; Added unit tests for Kafka protocol client utilities; Added unit tests for Kafka protocol message generation and serialization; Added unit tests for Kafka protocol request and response classes; Added unit tests for Kafka protocol serialization and type handling; Added unit tests for Kafka security authentication components; Added unit tests for Kerberos name parsing and rule processing; Added unit tests for LRUCache; Added unit tests for MirrorClient, ReplicationPolicy, and MirrorRecordVersion; Added unit tests for MirrorMaker 2 checkpoint and heartbeat components; Added unit tests for OAuthbearer expiring credential configuration and login logic; Added unit tests for PLAIN SASL server authentication; Added unit tests for RecordHeaders; Added unit tests for ResourceType enum; Added unit tests for SASL/OAUTHBEARER client and server internals; Added unit tests for SCRAM authentication internals; Added unit tests for SinkConnector and SinkRecord; Added unit tests for SourceConnector and SourceRecord; Added unit tests for coordinator-common runtime components; Added unit tests for unsecured OAuthBearer internals; Expanded unit test coverage for consumer internals; Initial commit of Kafka system test framework; New Connect integration test fixtures for embedded clusters and plugin isolation; New Kafka Streams integration tests for joins, dead-letter queues, and task stickiness; New MockClient test fixture for Kafka client testing; New integration tests for client rebootstrap, topic creation, and metadata version upgrades; New test fixtures for Kafka client testing; New test fixtures for coordinator runtime testing; New test fixtures for protocol fault injection and mock components; New test infrastructure API for declarative Kafka cluster testing; New test utilities for Kafka client testing; Removal of Ruby client test suite.
Dependencies
1259 commits updating dependencies (22 manifests)
A dependency / build maintenance change in (dependencies) — 1259 commits (85 fixs), 22 files: “MINOR: parameter name fix for maxScalacThreads (\#12151)”; “KAFKA-19182 Move SchedulerTest to server module (\#19608)”; “KAFKA-18186 Set \options.release\ to make Intellij configure suitable language level automatically (\#18104)”; and 1254 more (refs \#12151, \#19608, \#18104, \#11296, \#21412, …).
(dependencies) · high confidence · unverified
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 56 → 59 (+2.2)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 65 → 63 (-1.8)
- Architecture 87 → 87 (-0.2)
- Maturity 73 → 77 (+4.1)
- Readiness 49 → 53 (+3.8)
- Security 53 → 53 (+0.0)
- Performance 81 → 95 (+13.7)
Resolved (370)
- 1.hasNext (cognitive 27) (tools/src/main/java/org/apache/kafka/tools/LineMessageReader.java)
- AclCommandOptions.checkArgs (cognitive 16) (tools/src/main/java/org/apache/kafka/tools/AclCommand.java)
- AclCommandOptions.checkArgs (cyclomatic 17) (tools/src/main/java/org/apache/kafka/tools/AclCommand.java)
- Change coupling: CheckpointBench.java ↔ PartitionCreationBench.java (jmh-benchmarks/src/main/java/org/apache/kafka/jmh/server/CheckpointBench.java)
- Change coupling: PartitionMakeFollowerBenchmark.java ↔ PartitionCreationBench.java (jmh-benchmarks/src/main/java/org/apache/kafka/jmh/partition/PartitionMakeFollowerBenchmark.java)
- Change coupling: ShareSessionContext.java ↔ ShareSessionCache.java (server/src/main/java/org/apache/kafka/server/share/context/ShareSessionContext.java)
- Change-coupling hub: ReplicaFetcherThreadBenchmark.java → PartitionMakeFollowerBenchmark.java, UpdateFollowerFetchStateBenchmark.java, PartitionCreationBench.java (jmh-benchmarks/src/main/java/org/apache/kafka/jmh/fetcher/ReplicaFetcherThreadBenchmark.java)
- ClassTooLong: AclCommand (tools/src/main/java/org/apache/kafka/tools/AclCommand.java)
- ClassTooLong: ConfigCommand (tools/src/main/java/org/apache/kafka/tools/ConfigCommand.java)
- ClassTooLong: ConsumerGroupCommand (tools/src/main/java/org/apache/kafka/tools/consumer/group/ConsumerGroupCommand.java)
- ClassTooLong: DumpLogSegments (tools/src/main/java/org/apache/kafka/tools/DumpLogSegments.java)
- ClassTooLong: ProducerPerformance (tools/src/main/java/org/apache/kafka/tools/ProducerPerformance.java)
- ClassTooLong: ReassignPartitionsCommand (tools/src/main/java/org/apache/kafka/tools/reassign/ReassignPartitionsCommand.java)
- ClassTooLong: ReplicaVerificationTool (tools/src/main/java/org/apache/kafka/tools/ReplicaVerificationTool.java)
- ClassTooLong: ShareGroupCommand (tools/src/main/java/org/apache/kafka/tools/consumer/group/ShareGroupCommand.java)
- ClassTooLong: StreamsGroupCommand (tools/src/main/java/org/apache/kafka/tools/streams/StreamsGroupCommand.java)
- ClassTooLong: StreamsResetter (tools/src/main/java/org/apache/kafka/tools/StreamsResetter.java)
- ClassTooLong: TopicCommand (tools/src/main/java/org/apache/kafka/tools/TopicCommand.java)
- ClassTooLong: TransactionsCommand (tools/src/main/java/org/apache/kafka/tools/TransactionsCommand.java)
- ClassTooLong: VerifiableConsumer (tools/src/main/java/org/apache/kafka/tools/VerifiableConsumer.java)
- …and 350 more
New (215)
- AssignmentBuilder.updateMemberAssignments (cognitive 16) (group-coordinator/src/main/java/org/apache/kafka/coordinator/group/assignor/uniform2/AssignmentBuilder.java)
- Boundary-crossing change coupling: GroupSpecImpl.java ↔ TargetAssignmentBuilderBenchmark.java (group-coordinator/src/main/java/org/apache/kafka/coordinator/group/modern/GroupSpecImpl.java)
- Change coupling: GroupSpecImpl.java ↔ TargetAssignmentBuilder.java (group-coordinator/src/main/java/org/apache/kafka/coordinator/group/modern/GroupSpecImpl.java)
- Change coupling: ReplicaFetcherThreadBenchmark.java ↔ PartitionMakeFollowerBenchmark.java (jmh-benchmarks/src/main/java/org/apache/kafka/jmh/fetcher/ReplicaFetcherThreadBenchmark.java)
- Change coupling: ReplicaFetcherThreadBenchmark.java ↔ UpdateFollowerFetchStateBenchmark.java (jmh-benchmarks/src/main/java/org/apache/kafka/jmh/fetcher/ReplicaFetcherThreadBenchmark.java)
- Change-coupling hub: PartitionCreationBench.java → ReplicaFetcherThreadBenchmark.java, PartitionMakeFollowerBenchmark.java, UpdateFollowerFetchStateBenchmark.java, CheckpointBench.java (jmh-benchmarks/src/main/java/org/apache/kafka/jmh/server/PartitionCreationBench.java)
- ClassTooLong: GlobalStateManagerImpl (streams/src/main/java/org/apache/kafka/streams/processor/internals/GlobalStateManagerImpl.java)
- ClassTooLong: ShareConsumeBenchWorker (trogdor/src/main/java/org/apache/kafka/trogdor/workload/ShareConsumeBenchWorker.java)
- Duplicated block (11 lines × 2) (group-coordinator/src/main/java/org/apache/kafka/coordinator/group/modern/consumer/ConsumerGroup.java)
- Duplicated block (12 lines × 2) (clients/src/main/java/org/apache/kafka/clients/consumer/internals/events/ApplicationEventProcessor.java)
- Duplicated block (16–19 lines × 2) (tools/src/main/java/org/apache/kafka/tools/VerifiableConsumer.java)
- Duplicated block (6 lines × 5) (clients/src/main/java/org/apache/kafka/common/requests/DeleteShareGroupStateRequest.java)
- Duplicated block (6–7 lines × 2) (group-coordinator/src/main/java/org/apache/kafka/coordinator/group/GroupCoordinatorService.java)
- Duplicated block (7 lines × 2) (tools/src/main/java/org/apache/kafka/tools/DumpLogSegments.java)
- Edited copy of a member (10 corresponding lines) (clients/src/main/java/org/apache/kafka/clients/consumer/internals/AutoOffsetResetStrategy.java)
- Edited copy of a member (10 corresponding lines) (clients/src/main/java/org/apache/kafka/common/protocol/MessageUtil.java)
- Edited copy of a member (10 corresponding lines) (clients/src/main/java/org/apache/kafka/common/requests/DeleteShareGroupStateRequest.java)
- Edited copy of a member (10 corresponding lines) (clients/src/main/java/org/apache/kafka/common/requests/MetadataResponse.java)
- Edited copy of a member (10 corresponding lines) (clients/src/main/java/org/apache/kafka/common/requests/OffsetCommitResponse.java)
- Edited copy of a member (10 corresponding lines) (clients/src/main/java/org/apache/kafka/common/requests/OffsetCommitResponse.java)
- …and 195 more
Changes since last survey
- 157 commits — 142 feature/other, 15 fixes
By area
- group-coordinator/src — 43 commits
- clients/src — 31 commits
- streams/src — 17 commits
- core/src — 16 commits
- clients/clients-integration-tests — 8 commits
- coordinator-common/src — 7 commits
- tools/src — 4 commits
- metadata/src — 3 commits
- server-common/src — 3 commits
- streams/integration-tests — 3 commits
- (root) — 2 commits
- docs/operations — 2 commits
- mirror-coordinator/src — 2 commits
- storage/src — 2 commits
- tests/kafkatest — 2 commits
- .github/configs — 1 commit
- .github/scripts — 1 commit
- .github/workflows — 1 commit
- connect/basic-auth-extension — 1 commit
- connect/runtime — 1 commit
Notable commits
- fix: KAFKA-21398 Fix the docs of UUIDSerializer (#24031)
- fix: MINOR: Copartitioning check uses the fixed repartition topics of the whole topology (#24127)
- fix: MINOR: Cover copartition enforcement with fixed repartition topics end to end (#24148)
- fix: MINOR: Fix Javadoc in coordinator-common (#24144)
- fix: MINOR: Fix Javadoc of Group (#24050)
- fix: MINOR: Fix Javadoc of GroupCoordinator (#24044)
- fix: MINOR: Fix consumer close timeout version check (#24096)
- fix: MINOR: Fix log and exception messages in GroupMetadataManager (#24030)
- fix: MINOR: Fix log and exception messages in the coordinator runtime (#24161)
- fix: MINOR: Fix pending sync member errors in ClassicGroup (#24032)
- fix: MINOR: Fix race in StreamsGroupWarmupTaskIntegrationTest (#23944)
- fix: MINOR: Fix the refiner's restored-something check (#23942)
- fix: MINOR: Fix the unknown record type warning in CoordinatorLoaderImpl (#24143)
- fix: MINOR: Fix units of the default Streams integration test startup timeout (#24149)
- fix: MINOR: Fix vacuous assertions in DescribeTopicPartitionsRequestHandlerTest (#24117)
- change: KAFKA-16304: Report file read errors from SslTransportLayer.transferFrom as such (#23928)
- change: KAFKA-18039 Test all versions of quorum responses in RequestResponseTest (#23949)
- change: KAFKA-18574 Sort test tables in JUnit summary by class and test name (#23945)
- change: KAFKA-19042 Rewrite TransactionsBounceTest from Scala to Java (#23879)
- change: KAFKA-19818 Move ClientQuotaMetadataManager logic to the metadata module (#23555)
- …and 137 more
Architecture
- Unchanged — 0 containers · 5 contexts · 1 edges
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/kafka 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 11 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 62dca4dd544bddfc0913ca199a704b95c94d23e1 — the exact code this score is about.
- Scored under rubric-2026.11.2 — 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.29+preprod-106b68c3c303.