apache/pekko

This system is Apache Pekko, a distributed actor framework that provides a typed and classic API for building concurrent, resilient applications. It implements core actor lifecycle management, reliable message delivery, and cluster coordination features such as sharding, distributed data replication, and singleton management. The codebase also includes utilities for testing, performance benchmarking, and secure serialization, serving as the foundational runtime for scalable distributed systems.

201 changes.

The project transitioned from Akka to Apache Pekko, involving a comprehensive migration of the codebase, build system, and licensing. This period established the new project identity by introducing typed actor APIs, cluster sharding, and persistence modules while replacing legacy Akka configurations and Maven builds with SBT and Pekko-specific standards.

24 changes.

This period focused on preparing the codebase for the Pekko 2.0 release by managing breaking API changes, removing deprecated methods, and updating binary compatibility filters across multiple modules. It also introduced significant new features, including Java Flight Recorder instrumentation for detailed performance monitoring, support for JDK 21 virtual threads, and a new Jackson 3 serialization module.

Introduces a new AffinityPool ExecutorService implementation that pins actors to specific threads, ensuring an actor's mailbox runs on the same thread it used previously. This change aims to reduce cache ping-pong and improve performance in scenarios with high thread contention by maintaining thread affinity for actor execution.

actor/src/main/scala/org/apache/pekko/dispatch/affinity · high confidence

This change introduces the Apache Software Foundation (ASF) license headers to the codebase, marking the transition from the previous licensing. It also adds initial source files for the new Apache Pekko project, including a JMH benchmark for log level access, platform-specific receptionist types, and several Protocol Buffers definitions for cluster metrics, cluster client, distributed pub/sub, and typed cluster messaging. These files establish the foundational message contracts and internal APIs for the Pekko actor system's cluster and typed actor modules.

(repo-wide) · high confidence

New Java Flight Recorder (JFR) events have been added to Cluster Sharding to expose internal lifecycle operations for monitoring. Users can now track entity write durations, entity additions and removals, and passivation events (including restarts) via the \Pekko.Sharding.Shard\ category in JFR, facilitating deeper observability into sharding behavior.

cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/internal/jfr · high confidence

The actor-typed module now includes internal Java Flight Recorder (JFR) event definitions and an implementation of the \ActorFlightRecorder\ interface to monitor the lifecycle and message flow of Delivery Producer and Consumer Controllers. This change introduces specific JFR events—such as controller creation, start, message sending, and demand requests—allowing users with JDK 9+ to enable detailed, low-overhead profiling of the delivery subsystem via JFR tools.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/jfr · high confidence

A new BenchRunner utility has been added to the bench-jmh module, enabling users to execute JMH benchmarks via a simple command-line interface. The tool supports 'quick' and 'full' execution modes to adjust iteration and warmup parameters, and provides a 'jitwatch' mode for JVM diagnostic tracing. It automatically parses benchmark results and prints a sorted summary of scores and units to the console for easy performance analysis.

bench-jmh/src/main/scala/org/apache/pekko · high confidence

Introduces the Java DSL for the lease coordination module, providing \Lease\ and \LeaseProvider\ classes. The \LeaseProvider\ acts as an extension that wraps the underlying Scala implementation, exposing methods to acquire, release, and check leases via Java-compatible types like \CompletionStage\ and \Optional\, enabling Java applications to utilize the coordination lease functionality.

coordination/src/main/scala/org/apache/pekko/coordination/lease/javadsl · high confidence

The cluster-sharding module now includes an internal implementation of the external shard allocation client, bridging Scala and Java APIs. This component manages shard location state using Pekko Distributed Data (LWWMap) and exposes methods to update and retrieve shard locations for both Scala (Future) and Java (CompletionStage) consumers, enabling external strategies to coordinate shard placement across the cluster.

cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/internal · high confidence

Introduces the \pekko-osgi\ module, providing classes to bootstrap and manage an ActorSystem within an OSGi environment. This includes \ActorSystemActivator\ for bundle lifecycle management, \OsgiActorSystemFactory\ for creating systems with proper classloader delegation, and \DefaultOSGiLogger\ to bridge Pekko logging with the OSGi LogService. The module also includes comprehensive tests using PojoSR to verify system registration and lifecycle behavior.

osgi · high confidence

The PKI module now includes a PEM decoder and a private key loader. The PEM decoder parses PEM-formatted data (including lax whitespace handling per RFC 7468) into DER bytes and a label. The private key loader takes this DER data and converts it into a Java \PrivateKey\, supporting both PKCS\#1 (RSA PRIVATE KEY) and PKCS\#8 (PRIVATE KEY) formats, including multi-prime RSA keys. This enables users to load private keys from PEM strings directly within the application.

pki · high confidence

The actor-typed module now includes a reference.conf file that establishes default settings for Pekko Typed actors. This configuration enables the Slf4jLogger by default, registers the Receptionist as a library extension, and defines serialization bindings for typed actor references and service keys. It also sets default values for the restart stash capacity, mailbox type, and reliable delivery controller parameters such as timeouts and flow control windows.

actor-typed/src/main/resources · high confidence

Added a suite of JMH benchmarks in the bench-jmh module to measure actor system performance, including actor creation, path validation, message passing (ping-pong and echo patterns), scheduling, and stash creation. The suite also introduces high-performance mailbox implementations (JCToolsMailbox and ManyToOneArrayMailbox) and benchmarks for the affinity-pool executor and direct byte buffer pooling to help evaluate and optimize Pekko's actor throughput and latency.

bench-jmh/src/main/scala/org/apache/pekko/actor · high confidence

A Logback configuration file has been added to the JMH benchmark resources to standardize logging output during performance testing. This configuration silences initial Logback setup messages and directs INFO-level logs to the console using a pattern that includes timestamps, log levels, logger names, markers, and MDC context, ensuring consistent and readable output for benchmark runs.

bench-jmh/src/main/resources · high confidence

Added a new multi-jvm sample in the cluster-metrics module that demonstrates how to use Pekko Cluster with consistent-hashing routers. The sample includes a StatsService that distributes word-length jobs to StatsWorker actors across a three-node cluster, an aggregator to collect results, and a corresponding test specification (StatsSampleSpec) that validates the service behavior in a distributed environment.

cluster-metrics/src/multi-jvm/scala/org/apache/pekko/cluster/metrics/sample · high confidence

The coordination module now includes a \LeaseHealthCheck\ class that verifies the accessibility of the lease API by attempting to acquire and immediately release a test lease. This check caches its result after the first successful run to avoid repeated API calls, returning true if the lease is acquired or if a conflict indicates the API is reachable, and false if any exceptions occur. Supporting configuration is provided via new \LeaseSettings\, \LeaseUsageSettings\, and \TimeoutSettings\ classes, along with \LeaseException\ and \LeaseTimeoutException\ for error handling.

coordination/src/main/scala/org/apache/pekko/coordination/lease · high confidence

The stream module now includes specialized operators for scenarios involving exactly one input and one output, available in both the Scala and Java DSLs. This includes \ZipWith1\ and \ZipLatestWith1\ for combining streams, \UnzipWith1\ for splitting streams, and corresponding \create1\ factory methods in the Java DSL (\ZipWith\, \ZipLatestWith\, \UnzipWith\). These additions complement the existing multi-input/multi-output graph shapes and provide optimized, type-safe APIs for single-port stream transformations.

stream · high confidence

Introduces the internal \ReplicatorBehavior\ implementation for the typed Distributed Data API. This component bridges the typed actor model with the classic underlying replicator, handling command translation for Get, Update, Subscribe, Unsubscribe, and Delete operations, including specific adapter logic for Java API subscribers to ensure correct message mapping and lifecycle management.

cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/internal · high confidence

New files in \cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl\ introduce a typed API for Pekko Cluster Distributed Data. This includes the \DistributedData\ extension to access the local \Replicator\, a \Replicator\ object exposing typed behaviors and message types (Get, Update, Delete) with read/write consistency options, and a \ReplicatorMessageAdapter\ to conveniently adapt replicator responses into an actor's message protocol. \ReplicatorSettings\ provides configuration access, and the package object exposes the settings type alias.

cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl · high confidence

New JMH benchmarks have been added to measure the performance of typed actors, specifically focusing on echo and ping-pong messaging patterns. The \TypedActorBenchmark\ class evaluates throughput using configurable dispatchers (such as fork-join) and mailbox types, while \TypedForkJoinActorBenchmark\ provides detailed metrics by varying the number of actors relative to available CPU cores. These benchmarks allow users to assess the efficiency of typed actor implementations under different concurrency and configuration scenarios.

bench-jmh/src/main/scala/org/apache/pekko/actor/typed · high confidence

This change introduces the internal implementation for the typed cluster receptionist, adding the \ClusterReceptionist\ actor, \ShardedServiceRegistry\ for distributing service entries across distributed-data keys, \ClusterReceptionistSettings\ for configuring write consistency and pruning intervals, and a \ClusterReceptionistConfigCompatChecker\ to ensure configuration compatibility during cluster joins.

cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/internal/receptionist · high confidence

The actor-typed routing subsystem now includes internal implementations for group and pool routers. Group routers (\GroupRouterImpl\) dynamically route messages to actors registered via the Receptionist, supporting random, round-robin, and consistent-hashing strategies, with an option to prefer local routees. Pool routers (\PoolRouterImpl\) manage a fixed set of spawned child actors, also supporting random, round-robin, and consistent-hashing routing, along with broadcast predicates and configurable routee props. Both router types use a \RoutingLogic\ trait to abstract the selection strategy, ensuring messages are distributed according to the chosen algorithm while handling dynamic changes in available routees.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/routing · high confidence

The actor module now includes a new \org.apache.pekko.util\ package containing foundational utilities. This adds \ByteString\ for efficient immutable byte sequences, \BoundedBlockingQueue\ for capacity-limited blocking operations, and \FrequencySketch\/\FrequencyList\ for cache admission policies. It also introduces \Clock\ (with a \ScheduledClock\ to reduce \nanoTime\ overhead), \Glob\ for linear-time pattern matching, and various helper classes like \BoxedType\ and \ConstantFun\.

actor/src/main/scala/org/apache/pekko/util · high confidence

New JMH benchmark files have been added to the bench-jmh module to measure the performance of ORSet merge operations (including same-node, cross-node, and complex merges) and VersionVector operations (increment, comparison, and merge). These benchmarks allow users to evaluate the throughput of these specific cluster ddata data structures under various sizes and scenarios.

bench-jmh/src/main/scala/org/apache/pekko/cluster · high confidence

New JMH benchmark files have been added to the bench-jmh module to measure performance of the remote artery subsystem. These include benchmarks for the codec (encoding/decoding envelopes), literal string encoding, send queue throughput (comparing Source.queue, actorRef, and internal SendQueue), compression table inversion, serialization format cache lookups, CountMinSketch frequency estimation, and heavy hitters tracking.

bench-jmh/src/main/scala/org/apache/pekko/remote · high confidence

New JMH benchmark files have been added to the bench-jmh module to measure performance in three areas: config path lookups (CachingConfigBenchmark), actor message dispatch via NodeQueue (NodeQueueBenchmark), and object serialization using Jackson (JacksonSerializationBench). These benchmarks allow users to profile throughput for deep config key access, high-volume message sending to actors with specific dispatchers/mailboxes, and serialization of small, medium, and large message structures including nested objects and Java interop types.

bench-jmh/src/main/scala/org/apache/pekko/dispatch, bench-jmh/src/main/scala/org/apache/pekko/serialization · high confidence

A new Java API for the Pekko Event Bus has been introduced in the \org.apache.pekko.event.japi\ package. This addition provides Java developers with \EventBus\, \LookupEventBus\, \SubchannelEventBus\, and \ScanningEventBus\ traits and abstract classes, enabling them to implement and interact with Pekko's eventing system using idiomatic Java patterns rather than relying on Scala interoperability.

actor/src/main/scala/org/apache/pekko/event/japi · high confidence

New boilerplate templates for Java API functions and tuples have been added to the actor module. Specifically, \Functions.scala.template\ defines serializable \Function1\ and \Procedure1\ interfaces to support Java 8 lambdas, while \Tuples.scala.template\ provides \Tuple1\ creation and container classes. These templates enable the generation of Java-friendly functional interfaces and tuple types within the \org.apache.pekko.japi\ package.

actor/src/main/boilerplate · high confidence

A new reference configuration file for Pekko Cluster Tools has been added, providing default settings for the DistributedPubSub extension, ClusterClientReceptionist, ClusterClient, and ClusterSingleton. This file includes specific configuration keys for actor names, roles, routing logic, gossip intervals, heartbeat intervals, failure detection parameters, and serialization bindings using the Pekko namespace, allowing users to override these defaults in their application configuration.

cluster-tools/src/main/resources, cluster/src/main/resources · high confidence

The \actor-typed\ and \cluster-sharding-typed\ Java DSL packages now include \package-info.java\ files that apply the \@NullMarked\ annotation from the jspecify library. This change introduces static null-safety annotations to these APIs, enabling better compile-time checks for nullability and improving code safety for Java users without altering runtime behavior.

actor-typed/src/main/java, cluster-sharding-typed/src/main/java/org/apache/pekko/cluster/sharding/typed/javadsl · high confidence

A new ShardingMessages.proto file has been added to define the protocol buffers used for the dynamic scaling of ShardedDaemonProcess instances. This includes messages for tracking daemon process scale state (DaemonProcessScaleState), commands to change the number of processes (ChangeNumberOfProcesses) and query the current count (GetNumberOfProcesses), and the corresponding reply (GetNumberOfProcessesReply). These definitions enable the cluster sharding system to support runtime adjustments to the number of daemon process instances.

cluster-sharding-typed/src/main/protobuf · high confidence

New reference configuration files have been added for the Actor Typed Testkit, Cluster Metrics, Cluster Typed, and Coordination modules. These files define default settings for test timeouts and logging in the testkit, cluster metrics collection and serialization, distributed data consistency and receptionist pruning in cluster typed, and lease coordination timeouts. Users can now override these defaults in their application.conf to customize behavior for these specific Pekko components.

(repo-wide) · high confidence

The cluster module has been introduced as part of the Apache Pekko project, providing the core distributed system capabilities including cluster membership management, gossip-based state propagation, failure detection via heartbeats, and remote actor watching. This implementation replaces the previous Akka-based codebase, updating all internal references, logging markers, and configuration paths from 'akka' to 'pekko' to reflect the new project identity.

cluster/src/main/scala/org/apache/pekko/cluster · high confidence

This change introduces the core Cluster Sharding extension for Apache Pekko, ported from Akka. It provides the \ClusterSharding\ extension for distributing stateful actors across a cluster with location transparency, including the \ShardCoordinator\ singleton for managing shard allocation and rebalancing, and \ShardRegion\ actors for routing messages. The implementation supports multiple state store modes (DData, Persistence, and Event Sourced Remember Entities), pluggable allocation strategies (including a new \ConsistentHashingShardAllocationStrategy\ for colocation), and entity passivation. It also includes internal health check mechanisms and utilities for managing internal coordinator state.

cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding · high confidence

The \cluster-tools\ module now includes the core implementation for the cluster singleton pattern, introducing \ClusterSingletonManager\ to coordinate a single actor instance across the cluster and \ClusterSingletonProxy\ to provide a local reference to that singleton from any node. The \ClusterSingletonManager\ supports role-based selection, configurable hand-over and removal margins, and optional lease-based coordination to ensure safe singleton transitions during node failures or partitions. The \ClusterSingletonProxy\ tracks the cluster state to locate the current singleton manager, buffering messages when the singleton is unavailable and delivering them once identified. A dedicated serializer (\ClusterSingletonMessageSerializer\) handles the internal hand-over and takeover messages used by the manager.

cluster-tools/src/main/scala/org/apache/pekko/cluster/singleton · high confidence

The actor module now includes a comprehensive reference configuration file (reference.conf) that defines default settings for the Pekko Actor system. This file establishes defaults for logging (loggers, log levels, dead letter logging), actor providers, serialization verification, router type mappings, and deployment configurations, allowing users to override specific settings in their application.conf while relying on sensible defaults for core actor behavior.

actor/src/main/resources · high confidence

The \cluster-sharding-typed\ module now includes a \reference.conf\ file that defines default settings for the ShardedDaemonProcess, including keep-alive intervals and node limits, and configures serialization bindings for typed sharding. It also establishes default configurations for the ShardingProducerController and ShardingConsumerController within the Reliable Delivery subsystem, setting buffer sizes and timeouts to support reliable message delivery across sharded entities.

cluster-sharding-typed/src/main/resources · high confidence

This change introduces the core components for Pekko's distributed publish-subscribe functionality within the cluster-tools module. It adds the \DistributedPubSubMediator\ actor, which manages topic subscriptions and message routing across cluster nodes using configurable strategies (random, round-robin, broadcast) and gossip-based synchronization. The implementation includes \DistributedPubSubSettings\ for configuration, specific message types (\Put\, \Remove\, \Subscribe\, \Unsubscribe\, \Publish\), and a \PerGroupingBuffer\ trait to handle message buffering and forwarding for specific grouping keys, ensuring ordered delivery within groups.

cluster-tools/src/main/scala/org/apache/pekko/cluster/pubsub · high confidence

This change introduces the \serialization-jackson\ module for Apache Pekko, providing a JSON and CBOR serializer based on Jackson. It includes a \reference.conf\ with default settings for Jackson modules, stream read/write constraints, and buffer recycler pools, alongside Scala implementations for serializing Pekko-specific types such as \ActorRef\, \Address\, \FiniteDuration\, \SourceRef\, and \SinkRef\. The module also supports data migration via \JacksonMigration\ and includes a MIMA compatibility filter to handle the renaming of an internal typo (\Algoritm\ to \Algorithm\).

serialization-jackson · high confidence

The discovery module now provides a unified service discovery API, allowing applications to resolve service endpoints via DNS, static configuration, or an aggregate of multiple methods. Users must configure the default discovery method (e.g., 'pekko-dns' or 'config') in \pekko.discovery.method\. The module includes \ConfigServiceDiscovery\ for resolving services defined in \application.conf\, \DnsServiceDiscovery\ for standard A/AAAA and SRV record lookups, and \AggregateServiceDiscovery\ to chain multiple discovery mechanisms. The \Discovery\ extension manages these implementations, ensuring that the same instance is reused for a given method, and provides Java/Scala APIs for performing lookups with optional port and protocol specifications.

discovery · high confidence

The persistence-testkit module now provides a complete in-memory test environment for Pekko Persistence behaviors. It includes an in-memory journal and snapshot store that emulate storage operations, allowing tests to run without a real database. The kit offers \EventSourcedBehaviorTestKit\ and \DurableStateBehaviorTestKit\ to execute commands, inspect resulting events and state, and verify serialization. It also features a \PersistenceProbe\ for observing events and snapshots, and supports configurable processing policies to simulate storage failures or rejections during tests.

persistence-testkit · high confidence

This change adds the \Slf4jLogger\ and \Slf4jLoggingFilter\ components to the \slf4j\ module, enabling Apache Pekko applications to route their internal event stream logs to the SLF4J infrastructure (such as Logback). The \Slf4jLogger\ actor processes Pekko log events and writes them to SLF4J loggers, automatically populating the Mapped Diagnostic Context (MDC) with Pekko-specific metadata like the source actor, thread name, timestamp, system address, and UID. The \Slf4jLoggingFilter\ allows the application to control Pekko's internal event stream filtering based on the log levels configured in the external SLF4J backend (e.g., \logback.xml\), ensuring that only relevant log events are published to the event stream. Tests verify that log messages, markers, and custom MDC values are correctly propagated and formatted.

slf4j · high confidence

This release adds a new serialization module based on Jackson 3, providing JSON and CBOR serialization for Pekko actors, typed actors, and streams. The module includes built-in serializers for ActorRef, Address, FiniteDuration, and stream references, along with configurable stream-read constraints (e.g., max nesting depth, document length) and compression settings (gzip, LZ4). It also supports data migration for schema evolution via JacksonMigration classes and allows customization of serialization features through configuration.

serialization-jackson3 · high confidence

This change introduces a new \ExternalShardAllocationStrategy\ for Pekko Cluster Sharding, allowing shard placement decisions to be driven by an external system rather than internal cluster state. The implementation uses DistributedData (LWWMap) to store and synchronize shard location mappings across the cluster, with a dedicated state actor handling subscriptions and lookups. A new \ExternalShardAllocation\ extension manages client instances for querying these locations, and a \ClientTimeoutException\ is added to handle communication failures. The feature includes both Scala and Java APIs (e.g., \getClient\, \create\), enabling Java applications to integrate with this external allocation mechanism.

cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external · high confidence

Added internal implementation classes for the typed delivery subsystem, including \ConsumerControllerImpl\, \ProducerControllerImpl\, and \WorkPullingProducerControllerImpl\, along with supporting types like \ChunkedMessage\ and \DeliverySerializable\. These components provide the underlying behavior for reliable, sequenced message delivery between producers and consumers, handling flow control, acknowledgment, and state management.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/internal · high confidence

Added new internal Scala files, ShardingConsumerControllerImpl and ShardingProducerControllerImpl, which provide the actor-based logic for the typed cluster sharding delivery API. The consumer controller implementation manages the lifecycle of consumer actors and stashes messages until the consumer is ready, while the producer controller implementation handles durable queue state, message sequencing, and unconfirmed message resending within a sharded entity context.

cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery/internal · high confidence

This change introduces a new asynchronous DNS resolver implementation in the \org.apache.pekko.io.dns\ package, replacing the legacy synchronous resolver. The new system provides a more detailed protocol (\DnsProtocol\) supporting A, AAAA, CNAME, and SRV record lookups, along with configurable caching policies (\CachePolicy\) for positive and negative responses. A key behavioral improvement is the introduction of multiple ID generation policies (\IdGenerator\), including a new \EnhancedDoubleHashRandom\ and support for \SecureRandom\, addressing the [CVE redacted] DNS poisoning vulnerability by allowing users to configure stronger random ID generation for DNS queries. The resolver is configured via \DnsSettings\, supporting custom nameservers, search domains, and TTL settings.

actor/src/main/scala/org/apache/pekko/io/dns · high confidence

A new programmatic configuration API is available for constructing ActorSystem settings without relying solely on configuration files. Users can now create and combine specific setup instances using the \ActorSystemSetup\ class, which supports fluent chaining via the \and\ method and provides both Scala and Java APIs for retrieving and adding settings.

actor/src/main/scala/org/apache/pekko/actor/setup · high confidence

This change adds the initial typed API implementations for Pekko Cluster and Cluster Singleton. The new \Cluster.scala\ file provides typed commands for joining (\Join\, \JoinSeedNodes\), leaving (\Leave\), and downing nodes (\Down\), along with subscriptions for cluster state changes (\Subscribe\, \SelfUp\, \SelfRemoved\) and a mechanism to set the application version asynchronously (\SetAppVersionLater\). The \ClusterSingleton.scala\ file introduces the \ClusterSingleton\ extension and \SingletonActor\ builder, allowing users to define singleton actors with configurable settings such as role, data center, and lease usage, bridging the classic cluster singleton logic to the typed actor model.

cluster-typed/src/main/scala/org/apache/pekko/cluster/typed · high confidence

The typed cluster module now includes internal adapter implementations that bridge the typed API to the classic cluster infrastructure. \AdapterClusterImpl\ provides the core cluster view and manages subscriptions for member events (such as joining, leaving, and becoming up) via a typed behavior, while \AdapterClusterSingletonImpl\ handles the initialization and proxying of cluster singletons using the classic manager and proxy actors. Additionally, \PekkoClusterTypedSerializer\ is introduced to serialize receptionist entries and pub-sub messages across the cluster using protobuf manifests, ensuring these typed components can communicate effectively within the cluster.

cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/internal · high confidence

This change introduces a new internal adapter layer in the \actor-typed\ module that bridges the gap between Pekko's typed and classic actor APIs. The new \ActorAdapter\ class wraps a typed \Behavior\ to run it within the classic actor lifecycle, handling message adaptation, supervision signals, and timer scheduling. Supporting components include \ActorContextAdapter\ to expose typed context methods (like \spawn\, \stop\, and \watch\) by delegating to the underlying classic context, \ActorRefAdapter\ for type-safe reference conversion, and \ActorSystemAdapter\ to present the classic system as a typed \ActorSystem\. The \PropsAdapter\ ensures typed actors are deployed with appropriate local scopes and mailbox configurations, while \GuardianStartupBehavior\ manages the deferred initialization of the user guardian until the system is fully bootstrapped. This infrastructure enables seamless interoperability, allowing typed actors to be spawned and managed within classic actor systems and vice versa.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/adapter · high confidence

The cluster-sharding module now includes a new protobuf serializer (ClusterShardingMessageSerializer) that handles serialization for various sharding messages, including coordinator state, shard region registrations, and entity states. This serializer enforces a maximum decompressed payload size via Decompression.maxDecompressedSize to prevent potential denial-of-service attacks from excessively large compressed payloads.

cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/protobuf · high confidence

The actor module now includes the core implementation files for the Pekko pattern library, providing the foundational building blocks for asynchronous communication and resilience. This includes the Ask pattern for sending messages and receiving Futures, the Pipe pattern for forwarding Future results to actors, and the Circuit Breaker and Backoff Supervisor patterns for handling failures and transient errors. Users can now utilize these standard patterns directly within the actor system for robust distributed application design.

actor/src/main/scala/org/apache/pekko/pattern · high confidence

This change introduces the core API for Pekko Typed Actors, establishing the foundational types and behaviors for the new actor model. It defines the \ActorRef\ and \ActorSystem\ interfaces, which serve as the primary handles for interacting with actors and managing their lifecycle. The \Behavior\ class and its \ExtensibleBehavior\ extension point allow developers to define how actors react to messages and system signals. Additionally, the \BehaviorInterceptor\ API is provided for decorating behaviors to intercept and transform messages or signals, while \Props\ and \DispatcherSelector\ enable configuration of actor execution contexts. The \ActorRefResolver\ extension handles the serialization and deserialization of actor references, and lifecycle signals such as \Terminated\, \PreRestart\, and \PostStop\ are defined to manage actor state transitions.

actor-typed/src/main/scala/org/apache/pekko/actor/typed, actor-typed/src/main/scala/org/apache/pekko/actor/typed/scaladsl · high confidence

The \actor-typed/delivery\ module now provides a new set of actors and protocols to ensure reliable, ordered message delivery between producers and consumers. \ProducerController\ and \ConsumerController\ work together to manage point-to-point delivery with flow control and automatic redelivery of lost messages, while \WorkPullingProducerController\ extends this capability to a work-pulling pattern where multiple workers pull tasks. A \DurableProducerQueue\ protocol is also introduced to allow implementations (such as \EventSourcedProducerQueue\) to persist unconfirmed messages, ensuring they survive producer crashes. These components are marked with \@ApiMayChange\ and are part of the Apache Pekko project, derived from Akka.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery · high confidence

Added the \Lease\ abstract class and \LeaseProvider\ extension in the \org.apache.pekko.coordination.lease.scaladsl\ package, providing a Scala-native API for distributed lease management. The \LeaseProvider\ acts as an Akka Extension that caches lease instances by name, configuration path, and owner, dynamically loading implementations specified in the \lease-class\ config property. It supports both Scala and Java implementations by automatically adapting Java \Lease\ instances to the Scala DSL via \LeaseAdapterToScala\, allowing users to acquire, release, and check leases with callbacks for lease loss events.

coordination/src/main/scala/org/apache/pekko/coordination/lease/scaladsl · high confidence

This change introduces the internal implementation for the new typed Cluster Sharding API in Apache Pekko. It adds the core \ClusterShardingImpl\ class which bridges the typed API to the existing classic sharding infrastructure, including an \ExtractorAdapter\ to handle message extraction and filtering of internal remember-entities store messages. The update also includes the \ShardedDaemonProcess\ implementation, enabling dynamic scaling of daemon processes with revision-based state management via distributed data, and adds necessary serialization support (\ShardingSerializer\) for sharding messages and state. Additionally, it provides a test-kit implementation (\TestEntityRefImpl\) for testing typed entity references.

cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal · high confidence

The \Topic.scala\ file introduces the public API for the typed pub/sub topic actor, providing methods to create topic behaviors, publish messages to subscribers, and manage subscriptions. It exposes Scala and Java APIs for subscribing, unsubscribing, and publishing, along with a \GetTopicStats\ command to retrieve snapshot statistics about local subscribers and topic instances across the cluster.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/pubsub · high confidence

The \stream-typed\ module now provides a Java DSL for interacting with typed actors, exposing \ActorFlow\, \ActorSink\, \ActorSource\, and \PubSub\ objects. This allows Java users to integrate typed actors with streams via \ask\ patterns, backpressured sinks, and pub/sub topics. The API uses \java.time.Duration\ for timeouts and \pekko.japi.function\ for callbacks, with null-safety enforced via \@NullMarked\. To manage the migration from the previous Akka API, MIMA filters exclude specific \IncompatibleMethTypeProblem\ and \DirectMissingMethodProblem\ issues related to function signature changes and the removal of deprecated methods.

stream-typed · high confidence

The Java DSL for the Pekko Typed Testkit is now available, providing Java-friendly wrappers for asynchronous and synchronous actor testing. This includes \ActorTestKit\ for managing actor system lifecycles in tests, \BehaviorTestKit\ for synchronous behavior testing with effect inspection, and \TestInbox\ for synchronous message testing. The release also introduces JUnit 5 support via \TestKitJUnitJupiterExtension\ and \JUnitJupiterTestKitBuilder\, alongside the existing JUnit 4 \TestKitJunitResource\. Additional utilities include \LogCapturing\ and \LogCapturingExtension\ for filtering logs to failed tests, \LoggingTestKit\ for verifying log output, \ManualTime\ for controlling time in async tests, and \SerializationTestKit\ for verifying serialization roundtrips.

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl · high confidence

Added Java DSL support for Pekko Cluster Distributed Data, providing typed wrappers for the Replicator and DistributedData extension. This includes the DistributedData extension for accessing the replicator, ReplicatorSettings for configuration, and a ReplicatorMessageAdapter to simplify interaction with the replicator from Java actors by adapting response messages to the actor's protocol.

cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl · high confidence

New Java DSL entry points (ClusterSharding and ShardedDaemonProcess) are now available in the typed cluster sharding module. These classes provide Java-friendly APIs (using java.util.Optional, IntFunction, and JFunction) that wrap the existing Scala implementations, allowing Java users to initialize sharded entities and manage sharded daemon processes with idiomatic Java types.

cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/javadsl · high confidence

The \ByteIterator\ class and its \ByteArrayIterator\ implementation have been added to the \org.apache.pekko.util\ package. This new component provides a buffered iterator over byte arrays with optimized methods for reading primitive types (short, int, long) and bulk copying data, leveraging \System.arraycopy\ and SWAR utilities for performance. It serves as a foundational utility for efficient byte sequence manipulation within the Pekko actor system.

actor/src/main/scala-2.13/org/apache/pekko/util · high confidence

The \org.apache.pekko.japi.function\ package now provides a set of serializable functional interfaces (\Function\, \Function2\, \Procedure\, \Effect\, \Predicate\, \Predicate2\, \Creator\) designed for Java interoperability. These interfaces support throwing exceptions (unlike their \java.util.function\ counterparts) and include composition methods: \Function\ and \Function2\ now support \andThen\ and \compose\, while \Predicate\ and \Predicate2\ support \negate\. An \identity\ function is also available. These interfaces are used by the internal \japi.pf\ case statement implementations to handle partial functions in the Java API.

actor/src/main/scala/org/apache/pekko/japi/function · high confidence

The \org.apache.pekko.japi\ package now includes \JavaAPI.scala\ and \Throwables.scala\, providing Java-friendly helpers. \JavaAPI.scala\ introduces a \Pair\ class for two-element tuples, a \JavaPartialFunction\ abstract class to simplify implementing partial functions in Java (with an optimized \isCheck\ mode), and a \Util\ object with methods to convert Java arrays and iterables into immutable Scala sequences. \Throwables.scala\ adds \isNonFatal\ and \isFatal\ checks mirroring Scala's \NonFatal\ logic, along with a \sneakyThrow\ utility to throw exceptions without requiring \throws\ declarations in Java signatures.

actor/src/main/scala/org/apache/pekko/japi · high confidence

The actor module now includes four new Java annotations in the \org.apache.pekko.annotation\ package to help developers understand API stability and internal boundaries: \ApiMayChange\ marks APIs that may evolve without notice, \DoNotInherit\ prevents user-code extension of closed-world classes, \InternalApi\ flags APIs that are effectively private and subject to change, and \InternalStableApi\ identifies internal APIs used across project boundaries that should remain stable. These annotations provide clearer signals for binary compatibility and usage constraints in Java code.

actor/src/main/java/org/apache/pekko/annotation · high confidence

Added OptionalUtil to provide helper methods for converting between Java Optional types and Scala Option types, addressing implicit cast limitations in Java source code. Added Unsafe to replace direct usage of sun.misc.Unsafe with java.lang.invoke.VarHandle for internal string operations, including optimized ASCII string-to-bytes copying and fast hashing that adapts to platform capabilities.

actor/src/main/java/org/apache/pekko/util · high confidence

Added a new set of Kubernetes resources and helper scripts to support running multi-node tests, specifically for Aeron media driver scenarios. This includes a base deployment template (test-node-base.yaml) that configures pods with anti-affinity rules, specific CPU/memory requests, and an emptyDir volume for the Aeron media driver, along with a setup script (setup.sh) to dynamically generate and apply these manifests for a specified number of nodes. A GKE cluster creation script (create-cluster-gke.sh) is also provided to provision the underlying infrastructure on Google Kubernetes Engine.

kubernetes · high confidence

The \actor-testkit-typed\ module now provides a dedicated Scala DSL (\org.apache.pekko.actor.testkit.typed.scaladsl\) for testing typed actors. This includes \ActorTestKit\ for asynchronous integration testing with automatic lifecycle management, \BehaviorTestKit\ for synchronous unit testing of behaviors, and \TestProbe\ for message inspection. The package also introduces framework-specific base classes like \ScalaTestWithActorTestKit\ for seamless ScalaTest integration, along with utilities for log capturing (\LogCapturing\, \LoggingTestKit\), serialization verification (\SerializationTestKit\), and manual time control (\ManualTime\).

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/scaladsl · high confidence

Added \ShardingProducerController\ and \ShardingConsumerController\ to enable reliable message delivery between producer actors and sharded consumer actors. The producer controller manages sending messages to specific entity IDs, handling flow control, buffering, and automatic resending of lost messages, with optional support for durable queues to survive producer crashes. The consumer controller manages the lifecycle of sharded consumer entities, ensuring ordered delivery and confirmation of processed messages. These components work together to provide at-least-once delivery semantics within Pekko Cluster Sharding.

cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery · high confidence

Added new \ExternalShardAllocationClient\ traits in the \cluster-sharding\ module for both Java (\javadsl\) and Scala (\scaladsl\). These APIs allow users to programmatically control shard placement within the cluster by setting or updating shard locations to specific nodes, retrieving current shard locations, and receiving confirmation of these updates. The Java API uses \CompletionStage\ and method names like \setShardLocation\, while the Scala API uses \Future\ and \updateShardLocation\. Both are marked with \@ApiMayChange\, indicating they are experimental and subject to change.

cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/javadsl, cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/scaladsl · high confidence

This change introduces two new internal actor implementations, BackoffOnRestartSupervisor and BackoffOnStopSupervisor, which handle child actor restarts and stops respectively using configurable back-off algorithms and strategies. It also adds a new Service Provider Interface (SPI) for Circuit Breaker telemetry, allowing users to configure custom metrics collection via application.conf settings for events like state transitions and call outcomes.

actor/src/main/scala/org/apache/pekko/pattern/internal · high confidence

The actor-typed Java DSL now provides \AbstractBehavior\ and \AbstractMatchingBehavior\ as object-oriented alternatives to the existing functional factory methods. \AbstractBehavior\ allows developers to define message handling by extending the class and implementing \createReceive\ with a \ReceiveBuilder\, while \AbstractMatchingBehavior\ offers a lower-overhead approach by requiring implementation of \onMessage\ and \onSignal\ methods directly. These classes support mutable state as instance variables and must be instantiated via \Behaviors.setup\ to ensure correct context injection and supervision handling.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl · high confidence

The persistence-tck module now provides a comprehensive test suite for validating custom persistence plugin implementations. This includes capability flags to conditionally enable tests for features like serialization, metadata support, optimistic concurrency (revision checks), and soft deletes, along with Java API wrappers for Journal, Snapshot Store, and Durable State Store specs to facilitate integration testing.

persistence-tck · high confidence

The actor-testkit-typed module introduces several new core model classes to support typed actor testing. CapturedLogEvent and LoggingEvent provide structured representations of log events for inspection during tests, while the Effect hierarchy (including AskInitiated, Spawned, and SpawnedAnonymous) models the observable side-effects of behavior execution, such as message asks and child spawning. Additionally, FishingOutcome defines the results of message fishing operations, TestException offers a lightweight exception for test assertions, and TestKitSettings centralizes configuration-driven timeouts and time factors for the test kit.

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed · high confidence

The \cluster-sharding-typed\ module introduces several new capabilities for managing and observing Pekko Cluster Sharding. Users can now query the local state of a ShardRegion or statistics for the entire cluster using the new \GetShardRegionState\ and \GetClusterShadingStats\ query messages. Support for Replicated Event Sourcing in sharding is added via the \ReplicatedShardingExtension\, \ReplicatedEntityProvider\, and \ShardingDirectReplication\ components, allowing entities to be sharded across multiple replicas (e.g., per data center or role) with optional direct replication for lower latency. Additionally, the \ShardedDaemonProcess\ now supports dynamic scaling through \ChangeNumberOfProcesses\ and \GetNumberOfProcesses\ commands, and includes configurable keep-alive throttling in \ShardedDaemonProcessSettings\. A \Murmur2MessageExtractor\ is also provided to map Kafka-style partitions to shards, and testkit support is extended with \TestEntityRef\ for both Scala and Java APIs.

cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed · high confidence

A new sbt AutoPlugin, AddLogTimestamps, has been added to the build infrastructure. When the system property \pekko.log.timestamps\ is set to true, it wraps the standard sbt log manager to prepend a UTC timestamp (formatted as MM-dd HH:mm:ss.SSS) to every line of console output, aiding in the analysis of build duration and timing.

project · high confidence

This entry introduces the Pekko Persistence Typed module, providing a new type-safe API for persistent actors in both Scala and Java. Key additions include EventSourcedBehavior and DurableStateBehavior with support for runtime plugin configuration, custom stash capacity, and taggers for state queries. The module adds new signal types (JournalPersistFailed, JournalPersistRejected, etc.) for handling persistence lifecycle events and introduces CRDT-based replication support (Counter, ORSet) with a new protobuf schema for serialized replicated events. Configuration defaults for stash capacity, overflow strategies, and event writer batching are also provided.

persistence-typed · high confidence

The testkit module is introduced as a new component for the Pekko project, ported from Akka to provide a comprehensive suite of tools for actor-based testing. This includes a CallingThreadDispatcher for deterministic, single-threaded actor execution, an ExplicitlyTriggeredScheduler to allow manual clock progression in tests, and specialized references like TestActorRef and TestFSMRef for inspecting internal actor state and finite state machines. The release also adds a TestBarrier for synchronization, EventFilter facilities for managing log output, and a TestJavaSerializer for ad-hoc message serialization, all configured via a new reference.conf file.

testkit · high confidence

The cluster module now includes the core Scala implementation for the Split-Brain Resolver (SBR) feature, enabling the cluster to automatically handle network partitions. This change introduces the \SplitBrainResolverProvider\ to wire the resolver into the cluster's downing mechanism, \SplitBrainResolverSettings\ to parse configuration options (such as \stable-after\, \active-strategy\, and strategy-specific settings like quorum size or lease details), and the \SplitBrainResolver\ actor along with \DowningStrategy\ logic to execute decisions (e.g., keep majority, lease majority, static quorum) and down unreachable nodes based on the selected strategy.

cluster/src/main/scala/org/apache/pekko/cluster/sbr · high confidence

Users can now configure the SO\_REUSEPORT socket option for TCP and UDP sockets via the \Inet.SO.ReusePort\ socket option. This allows multiple sockets on the same host to bind to the same port, enabling better load distribution across multiple threads or processes.

actor/src/main/scala/org/apache/pekko/io · high confidence

The legacy Makefile used for Unix-based builds and the Kernel.scala entry point file have been removed from the kernel module. This cleanup eliminates obsolete build targets and the original kernel initialization class, streamlining the project structure.

kernel · high confidence

The cluster metrics module now uses a dedicated protobuf serializer (MessageSerializer) and a restricted ObjectInputStream (NumberInputStream) to handle metric data exchange. The serializer manages compression and decompression of metrics gossip envelopes and load-balancing pool configurations, while the new NumberInputStream restricts deserialization to primitive types, Number subclasses, and java.math classes (such as BigInteger and BigDecimal), preventing arbitrary class loading vulnerabilities. This change ensures that cluster metrics are serialized safely and supports precise numeric types in metric payloads.

cluster-metrics/src/main/scala/org/apache/pekko/cluster/metrics/protobuf · high confidence

The internal implementation details for Pekko Cluster Sharding have been reorganized into the \org.apache.pekko.cluster.sharding.internal\ package. This change introduces a modular structure for key sharding capabilities: shard allocation logic is now shared via \ClusterShardAllocationMixin\ and \AbstractLeastShardAllocationStrategy\; entity passivation strategies are centralized in \EntityPassivationStrategy\; and the 'remember entities' feature is split into distinct provider and store implementations for both DData (\DDataRememberEntitiesProvider\, \DDataRememberEntitiesCoordinatorStore\, \DDataRememberEntitiesShardStore\) and Event Sourcing (\EventSourcedRememberEntitiesProvider\, \EventSourcedRememberEntitiesCoordinatorStore\, \EventSourcedRememberEntitiesShardStore\). A new \CustomStateStoreModeProvider\ is also added to support custom remember entities stores for testing.

cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/internal · high confidence

The actor dispatching subsystem has been fully migrated from Akka to Apache Pekko, updating all package names and internal references to the new project identity. This change introduces support for Java virtual threads, allowing dispatchers to be configured with a 'virtualize' option to leverage lightweight threads for improved scalability. The ForkJoinPool integration has been enhanced with a JDK-aware policy for the 'minimum-runnable' parameter to optimize performance on JDK 25+, and the dispatcher shutdown logic has been refined to ensure correct ordering when virtual threads are in use.

actor/src/main/scala/org/apache/pekko/dispatch · high confidence

The internal actor lifecycle and management logic has been reorganized from monolithic classes into distinct, modular traits within the \org.apache.pekko.actor.dungeon\ package. This change introduces separate components for managing child actors (\Children\, \ChildrenContainer\), handling actor termination notifications (\DeathWatch\), dispatching messages (\Dispatch\), and processing supervision failures (\FaultHandling\). It also adds dedicated modules for scheduling (\TimerSchedulerImpl\) and idle timeouts (\ReceiveTimeout\). For users, this represents a structural cleanup of the actor engine that improves code maintainability and separation of concerns without altering the public API or existing actor behaviors.

actor/src/main/scala/org/apache/pekko/actor/dungeon · high confidence

The coordination module now includes internal adapter classes (LeaseAdapter and LeaseAdapterToScala) that bridge the Scala and Java DSLs for the Lease API. This allows seamless interoperability between the two language-specific interfaces, ensuring that calls from one side are correctly translated to the other using standard Scala-Java conversion utilities.

coordination/src/main/scala/org/apache/pekko/coordination/lease/internal · high confidence

The release notes now exclude the new \ByteString.asInputStream\ method from binary compatibility checks, allowing this addition to be treated as a non-breaking change in the 1.0.x series.

actor/src/main/mima-filters/1.0.x.backwards.excludes · high confidence

This update configures binary compatibility filters for the \actor-testkit-typed\ module to support upcoming API changes. It adds exclusions for new \runAsk\ and \runAskWithStatus\ methods on \BehaviorTestKit\ (Java and Scala DSLs) to prevent false-positive missing-method errors, excludes a direct missing method problem in \EffectfulActorContext\ triggered by an internal sbt-mima-plugin upgrade, and accounts for the removal of the deprecated \LoggingTestKit.intercept\ method and the renaming of an internal interceptor method to \interceptBehavior\.

actor-testkit-typed/src/main/mima-filters · high confidence

The JMH benchmark module in bench-jmh/src/main/java has been migrated from the Akka namespace to Apache Pekko. This change updates the package declaration and file paths to org.apache.pekko.serialization.jackson, reflecting the project's rebranding, while preserving the existing Java message classes (JSmall, JMedium, JLarge) used for serialization performance testing.

bench-jmh/src/main/java · high confidence

New MiMa binary compatibility filter files have been added for the actor and cluster-sharding modules to manage API evolution. These filters explicitly keep certain classes and hierarchies (such as BalancingDispatcher, BackoffSupervisor internals, and PersistentShardCoordinator) as checked problems, ensuring that internal definitions narrowed to private or sealed in version 2.0.x but still present in bytecode are correctly reported against clients compiled against version 1.0.x.

actor/src/main/mima-filters, cluster-sharding/src/main/mima-filters · high confidence

This release introduces significant breaking changes to the Pekko Actor API, requiring updates to existing codebases. The \ReceiveTimeout\ message has changed from a case object to a case class with a timeout field, and the \BackoffSupervisor.calculateDelay\ method has been moved to \RetrySupport\ (deprecated in 1.2.1+). Many deprecated methods and classes have been removed, including \AbstractScheduler.schedule\, \CoordinatedShutdown.run\, and various \Futures\ and \ExecutionContexts\ utilities, with users expected to migrate to Scala standard library equivalents (e.g., \scala.concurrent.FutureConverters\, \scala.jdk.DurationConverters\). The Java API has also been refactored: \pekko.japi\ functions have moved to \pekko.japi.function\, the \pekko.japi.Option\ class and related converters are removed, and \scala.Tuple2\ is replaced by \pekko.japi.Pair\ in FSM transition handlers. Additionally, support for Scala 2.12 has been dropped, removing compatibility classes like \pekko.compat.Future\ and \JavaConverters\. Internal implementation details such as \Unsafe.instance\ and JDK 8-specific ForkJoin code have also been removed.

actor/src/main/mima-filters/2.0.x.backwards.excludes · high confidence

The ByteString.indexOf method has been updated to accept additional from and to parameters, allowing users to search for substrings within a specific range of the byte string. This change introduces a new method overload, which is excluded from binary compatibility checks to ensure a smooth upgrade path.

actor/src/main/mima-filters/1.2.x.backwards.excludes · high confidence

The cluster-sharding module has updated its binary compatibility filters to accommodate breaking changes in version 2.0. This includes the removal of deprecated methods such as \passivateIdleEntityAfter\ from \ClusterShardingSettings\, the removal of the old passivation strategy configuration, and internal refactoring of the consistent-hashing shard allocation strategy and stash traits. These changes ensure that the migration tooling correctly ignores expected API removals and signature changes during the upgrade to 2.0.

cluster-sharding/src/main/mima-filters/2.0.x.backwards.excludes · high confidence

This update adds and updates binary compatibility (MiMA) exclusion filters for the cluster-sharding-typed module to manage breaking changes in the 2.0.x release. Specifically, it excludes issues caused by the protobuf-java upgrade to 4.29.3, the removal of deprecated methods such as \passivateIdleEntityAfter\ and \withPassivateIdleEntityAfter\ from \ClusterShardingSettings\, and the removal of the old passivation strategy settings. It also accounts for internal implementation changes, including the dynamic scaling of \ShardedDaemonProcess\ instances (affecting \ShardedDaemonProcessImpl\ and \initWithContext\ methods) and the throttling of keep-alive messages (removing the \KeepAlivePinger$StartTick$\ class). Additionally, it ensures that certain definitions narrowed to private visibility are still checked against clients compiled against older versions.

cluster-sharding-typed/src/main/mima-filters · high confidence

The ClusterClient and its associated message serializer in the cluster-tools module have been ported from Akka to Apache Pekko. This includes updating package names to org.apache.pekko, replacing Akka-specific imports with Pekko equivalents, and updating license headers to reflect the Apache Software Foundation ownership. The ClusterClientSettings class remains deprecated with a recommendation to use Pekko gRPC instead, but the underlying implementation now uses Pekko's actor system and serialization infrastructure.

cluster-tools/src/main/scala/org/apache/pekko/cluster/client · high confidence

The cluster protobuf serializer now protects against decompression bombs by bounding the size of uncompressed payloads. The \ClusterMessageSerializer\ delegates decompression to a \Decompression\ utility that checks the \maxDecompressedSize\ setting, ensuring that compressed messages cannot expand beyond a safe limit during deserialization.

cluster/src/main/scala/org/apache/pekko/cluster/protobuf · high confidence

The cluster metrics module has been migrated from Akka to Apache Pekko, updating all internal actor references, extension IDs, and configuration paths (e.g., \pekko.cluster.metrics\) to align with the new project namespace. This change includes the introduction of \@DoNotInherit\ annotations on public sealed traits and abstract classes to prevent unintended external inheritance, and replaces the deprecated \scala.collection.JavaConverters\ with \scala.jdk.CollectionConverters\ for Java interop. The core functionality—periodic sampling, gossip-based distribution, and adaptive load-balancing routing based on node metrics—remains intact.

cluster-metrics/src/main/scala/org/apache/pekko/cluster/metrics · high confidence

The \cluster/jmx-client/pekko-cluster\ shell script is now deprecated and prints a warning directing users to use curl with the Apache Pekko Management HTTP API instead. The script itself remains functional for joining, leaving, marking nodes down, and querying cluster status via JMX, but it has been renamed from the Akka context to the Pekko context (e.g., \pekko:type=Cluster\ MBeans) to reflect the project's transition to the Apache Pekko Top-Level Project.

cluster/jmx-client · high confidence

The Java protobuf classes for the Replicator and Replicated Data messages have been regenerated using Protobuf version 4.36.0. This upgrade changes the underlying serialization library and wire format, requiring all cluster nodes to run the same version to ensure binary compatibility. The change includes updated MIMA filters to account for the API differences introduced by the Protobuf 4.x generator.

distributed-data · high confidence

The cluster router now strictly enforces limits when adjusting pool sizes via AdjustPoolSize. This change ensures that the number of instances created or removed respects the configured constraints, preventing the router from exceeding defined boundaries during dynamic scaling operations.

cluster/src/main/scala/org/apache/pekko/cluster/routing · high confidence

A new exclusion file has been added to the binary compatibility (MiMA) filters for the cluster-sharding module to ignore missing classes specific to Java 11's Flight Recorder. This prevents binary compatibility checks from failing due to the absence of JFR-related internal classes (such as Passivate, RememberEntityWrite, and JFRShardingFlightRecorder) on non-JDK 11 runtimes, ensuring smoother upgrades for users on different Java versions.

cluster-sharding/src/main/mima-filters/1.0.x.backwards.excludes · high confidence

The internal implementation for the typed pub-sub Topic has been added to the actor-typed module. This new TopicImpl actor manages local subscriber tracking and coordinates with the system receptionist to discover and broadcast messages to topic instances across the cluster, ensuring deduplication and efficient delivery to nodes with active subscribers.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/pubsub · high confidence

A new serializer for DistributedPubSubMediator messages has been added to the cluster-tools module, replacing previous serialization methods with a Protobuf-based approach. This change introduces GZIP compression for specific message types (Status and Delta) to reduce network overhead, while enforcing a configurable maximum decompressed size to prevent memory exhaustion attacks. The serializer handles mapping internal message structures (Status, Delta, Send, SendToAll, Publish, SendToOneSubscriber) to and from Protobuf definitions, ensuring efficient and safe inter-node communication for the pub/sub system.

cluster-tools/src/main/scala/org/apache/pekko/cluster/pubsub/protobuf · high confidence

The \actor-testkit-typed/internal\ package now provides the core internal infrastructure for the Pekko Typed test kit, replacing the previous Akka-based implementation. This includes \ActorSystemStub\ for creating a lightweight, synchronous test actor system, \BehaviorTestKitImpl\ for executing and inspecting typed behaviors, and \StubbedActorContext\ for managing child actors and effects. Logging is now captured via \TestAppender\ and \CapturingAppender\ (backed by Logback) to support the \LoggingTestKit\, and scheduling is handled by \ControlledExecutor\ to allow deterministic test execution.

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal · high confidence

This change introduces the foundational \org.apache.pekko\ package contents, replacing the previous Akka naming. It adds \Done\ and \NotUsed\ as explicit return types for operations with no meaningful value, marked with \@DoNotInherit\ to prevent external extension. It also provides \PekkoException\ and \ConfigurationException\ for error handling, and a new \PekkoVersion\ utility that allows libraries to enforce minimum version requirements, including specific logic for comparing Milestone (M) and Release Candidate (RC) pre-release versions.

actor/src/main/scala/org/apache/pekko · high confidence

The Java DSL base classes (AbstractActor, AbstractFSM, AbstractProps, Actor, ActorCell, ActorPath, ActorRef, ActorRefProvider, ActorSelection) have been migrated from the Akka namespace to Apache Pekko. This change updates the package structure and internal references to reflect the project's rebranding, ensuring that Java developers using these core actor components interact with the Pekko implementation.

actor/src/main/scala/org/apache/pekko/actor · high confidence

The Java API pattern-matching builders in \org.apache.pekko.japi.pf\ have been migrated from the Akka codebase to Apache Pekko. This includes the core \PFBuilder\ and \UnitPFBuilder\ classes, as well as specialized builders for actor supervision (\DeciderBuilder\), finite state machines (\FSMStateFunctionBuilder\, \FSMStopBuilder\, \FSMTransitionHandlerBuilder\), and actor message handling (\ReceiveBuilder\). The implementation now uses \org.apache.pekko.japi.Pair\ instead of \scala.Tuple2\ for FSM transition handlers, and the package structure has been updated to reflect the new project identity.

actor/src/main/java/org/apache/pekko/japi · high confidence

The typed receptionist and cluster delivery subsystems have been migrated to the Apache Pekko project, replacing the previous Akka implementation. This change introduces new internal components for the local receptionist (LocalReceptionist, ReceptionistImpl, ReceptionistMessages, ServiceKey, and ServiceKeySerializer) to handle service registration and discovery, and updates the reliable delivery serializer (ReliableDeliverySerializer) to serialize producer and consumer controller messages using Pekko's protobuf definitions. Users benefit from the continued support of service discovery and reliable delivery features under the new Apache Pekko branding and license, with no changes to the public API behavior.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/receptionist, cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/internal/delivery · high confidence

The actor module now uses Java VarHandles (java.lang.invoke) instead of sun.misc.Unsafe for managing internal mutable state in components such as AbstractActorRef, AbstractCircuitBreaker, and AbstractPromiseActorRef. This change improves portability and compatibility with modern Java versions by avoiding deprecated or restricted internal APIs. Additionally, the AbstractScheduler now leverages scala.jdk.DurationConverters for handling Java time.Duration conversions, aligning with updated Scala interop patterns.

actor/src/main/java/org/apache/pekko/actor · high confidence

The multi-node testkit has been updated to use Netty 4 for its underlying network transport and Protobuf 4 (version 4.36.0) for protocol serialization. This migration introduces breaking changes to the internal API of the test conductor, specifically affecting classes such as PlayerHandler, ConductorHandler, and ClientFSM. To ensure a smooth upgrade, backward-compatibility filters have been added to the MiMA configuration to exclude these known incompatibilities.

multi-node-testkit · high confidence

The \reference.conf\ file for Cluster Sharding has been replaced with a new Pekko-specific configuration that introduces granular control over entity passivation. Users can now configure advanced strategies such as \default-strategy\ (with active entity limits and SLRU replacement) and \default-idle-strategy\, along with detailed settings for admission windows, frequency-sketch filters, and replacement policies. This change also updates the configuration namespace from \akka\ to \pekko\ and includes license headers.

cluster-sharding/src/main/resources · high confidence

The internal DNS resolution subsystem has been replaced with a new asynchronous actor-based implementation. This change introduces dedicated components for managing DNS resolution lifecycles (\AsyncDnsManager\), handling in-flight request deduplication and caching (\AsyncDnsResolver\), and executing network queries (\DnsClient\ for UDP, \TcpDnsClient\ for TCP fallback). The new architecture includes hardened parsing logic for DNS messages and domain names, specifically bounding compression-pointer hops to prevent stack overflow attacks, and adds support for parsing system resolver configurations (\ResolvConfParser\). Users benefit from improved reliability, better resource management, and protection against DNS poisoning vulnerabilities inherent in the previous synchronous or less robust implementation.

actor/src/main/scala/org/apache/pekko/io/dns/internal · high confidence

The event-stream now automatically unsubscribes terminated actors via a new internal \ActorClassificationUnsubscriber\ and \EventStreamUnsubscriber\ actor, preventing stale subscriptions. Additionally, the \DeadLetterListener\ now respects the \pekko.log-dead-letters-during-shutdown\ setting, suppressing dead-letter logging during a terminating coordinated shutdown when disabled to reduce noise.

actor/src/main/scala/org/apache/pekko/event · high confidence

The actor module now includes two new internal classes to improve performance and resource management. ByteBufferCleaner provides a mechanism to explicitly release memory held by direct ByteBuffers using Java 9+ method handles, ensuring timely cleanup rather than relying on garbage collection. UnsynchronizedByteArrayInputStream offers a thread-unsafe, zero-copy alternative to the standard ByteArrayInputStream for internal use cases where synchronization overhead is undesirable.

actor/src/main/java/org/apache/pekko/io · high confidence

A new configuration file for the site-link-validator tool has been added to define how local documentation paths map to external API URLs (specifically for Pekko and Scala 2.13), including whitelists for known external link issues. Concurrently, several legacy utility scripts for code formatting—specifically those for converting tabs to spaces, normalizing line endings (DOS to Unix), and removing trailing whitespace—have been removed from the repository.

scripts · high confidence

The actor runtime now explicitly checks for \Identify\ messages before evaluating the \AutoReceivedMessage\ marker to prevent performance degradation caused by JDK-8180450. This change introduces version-specific compatibility shims for Scala 2.13 and Scala 3 that ensure \Identify\ instances are handled efficiently, avoiding the pollution of the secondary supertype cache on affected JDKs.

actor/src/main/scala-2.13/org/apache/pekko/actor, actor/src/main/scala-3/org/apache/pekko/actor · high confidence

The Java API for Pekko Persistence journal and snapshot store plugins now uses Java's CompletionStage instead of Scala's Future for asynchronous operations, including doAsyncReplayMessages, doAsyncReadHighestSequenceNr, doAsyncWriteMessages, doAsyncDeleteMessagesTo, doLoadAsync, doSaveAsync, and doDeleteAsync. Additionally, the persistence serialization layer has been regenerated with Protobuf 4.36.0, introducing a binary format change that requires migration handling for existing persisted data.

persistence · high confidence

The persistence-query module has been restructured to support the new Pekko architecture, introducing a scalable fan-out persistence query abstraction and a new \EventsBySliceFirehoseReadJournalProvider\ for efficient multi-consumer event streaming. The \EventEnvelope\ model is enhanced with \filtered\, \source\, and \tags\ fields, and a new \CurrentLastSequenceNumberByPersistenceIdQuery\ API is added. Internally, serialization has migrated to Protobuf 4.36.0, requiring a binary compatibility exclusion for the internal protobuf classes.

persistence-query · high confidence

The protobuf message classes for cluster metrics (specifically ClusterMetricsMessages.java) have been regenerated using protoc version 4.36.0. This update refreshes the generated Java code to align with the new protocol buffer compiler version, ensuring compatibility with the underlying protobuf runtime and maintaining the structure for cluster gossip messages.

cluster-metrics/src/main/java · high confidence

The cluster module's generated protobuf source files (e.g., ClusterMessages.java) have been regenerated using protoc version 4.36.0. This update ensures the Java serialization code for cluster communication messages aligns with the latest protocol buffer compiler standards, which may include internal runtime validation improvements and compatibility with the protobuf-java 4.29.3 library.

cluster/src/main/java · high confidence

The internal protobuf message classes for cluster sharding (ShardingMessages.java) have been regenerated to use the Protobuf Java runtime version 4.36.0. This update ensures the generated serialization code is compatible with the newer protobuf library version, maintaining correct message encoding and decoding for sharding envelope data.

cluster-sharding-typed/src/main/java/org/apache/pekko/cluster/sharding/typed/internal · high confidence

The Java serialization classes for cluster-sharding messages have been regenerated using protoc version 4.36.0. This update ensures the generated code aligns with the latest Protocol Buffers compiler standards, maintaining binary compatibility for cluster-sharding communication while updating the underlying code generation tooling.

cluster-sharding/src/main/java · high confidence

The internal protobuf message classes for the typed cluster module (specifically ClusterMessages.java and ReliableDelivery.java) have been regenerated using the Protobuf Java compiler version 4.36.0. This update ensures that the generated serialization code for cluster communication messages, such as ReceptionistEntry and SequencedMessage, is compatible with the updated Protobuf runtime, maintaining binary compatibility and leveraging any improvements or fixes in the 4.36.0 code generation.

cluster-typed/src/main/java · high confidence

The generated Java protobuf classes for the Cluster Client and Distributed PubSub modules have been regenerated using Protobuf Java version 4.36.0. This update refreshes the internal serialization and deserialization logic for cluster communication messages, ensuring compatibility with the updated protobuf runtime and potentially introducing performance or behavioral improvements from the new code generation tooling.

cluster-tools/src/main/java · high confidence

The project has removed the legacy configuration files for Akka logging (\akka-default.conf\, \akka.conf.template\) and the Quartz scheduler (\scheduler.properties\). This change eliminates the previous setup for daily log rolling, console logging, and the in-memory job store with a simple thread pool, indicating a shift away from these specific legacy configuration mechanisms.

config · high confidence

The \JUnit5TestKit\ annotation in the typed actor testkit has been deprecated in favor of \JUnitJupiterTestKit\. Users should update their test code to use the new \JUnitJupiterTestKit\ annotation to avoid deprecation warnings and ensure compatibility with future releases.

actor-testkit-typed/src/main/java · high confidence

The actor cell implementation now uses Java VarHandles instead of sun.misc.Unsafe to access internal fields such as the mailbox, children references, next name counter, and function references. This change improves portability and safety by avoiding deprecated or restricted internal JDK APIs while maintaining the same performance characteristics for these low-level operations.

actor/src/main/java/org/apache/pekko/actor/dungeon · high confidence

The actor dispatch subsystem (AbstractBoundedNodeQueue, AbstractNodeQueue, AbstractMailbox, and AbstractMessageDispatcher) no longer relies on the internal sun.misc.Unsafe API. Instead, it uses java.lang.invoke.VarHandles for all low-level atomic field updates and volatile accesses. This change improves portability and future-proofing by removing the dependency on JDK-internal APIs while maintaining the same lock-free concurrency semantics for message queues and mailbox status.

actor/src/main/java/org/apache/pekko/dispatch · high confidence

The project now enforces a standardized contribution workflow through new configuration files. GitHub merge behavior is restricted to squash or rebase only, and pull requests require one approving review and passing status checks for code formatting and headers. Developer guidelines are codified in AGENTS.md and CLAUDE.md, specifying mandatory use of sbt for license headers, scalafmt for Scala/Scala 3 formatting, and javafmt for Java, alongside strict rules against hand-writing headers or using AI-assistant commit trailers. Build and CI environments are configured via .jvmopts-ci and .sbtopts to optimize memory and disable blocking SecureRandom seeds, while .scala-steward.conf manages dependency updates and .scalafmt.conf defines the Scala code style.

(repo-wide) · high confidence

The routing pool and logic classes (including BalancingPool, BroadcastPool, ConsistentHashingRouter, RandomPool, and RoundRobinPool) have been moved from the Akka package structure to the new org.apache.pekko namespace. This change reflects the project's rebranding and ensures that all router components are correctly aligned with the Pekko actor system, maintaining the same functionality while updating the package declarations and internal references.

actor/src/main/scala/org/apache/pekko/routing · high confidence

Updated the internal receptionist implementation in actor-typed and cluster-typed to use Scala 3 syntax, ensuring compatibility with Scala 3.8. This includes adding new Scala 3-specific source files (Platform.scala and ClusterReceptionistProtocol.scala) that define internal types using Scala 3 match types and type aliases, replacing or supplementing previous Scala 2 implementations to support the newer compiler version.

actor-typed/src/main/scala-3, cluster-typed/src/main/scala-3 · high confidence

A new Scala 3-specific implementation of ByteIterator (and its ByteArrayIterator subclass) has been added to the util package. This file provides optimized byte iteration, including fast-path methods for reading shorts, ints, and longs via SWAR utilities, and uses System.arraycopy for bulk data copying. This change introduces a new source file for Scala 3 builds, distinct from the Scala 2.12/2.13 versions, to leverage Scala 3 syntax and performance characteristics.

actor/src/main/scala-3/org/apache/pekko/util · high confidence

The serialization module now enforces strict limits on decompressed payload size (via \pekko.serialization.max-decompressed-size\) and deserialization nesting depth (via \pekko.actor.serialization-max-nesting-depth\) to prevent resource exhaustion attacks, while also blocking HOCON \include\ directives in wire-supplied configuration to prevent unauthorized file or network access. The codebase has been fully migrated from Akka to Pekko, including package renaming, branding updates, and the introduction of new internal components such as \AsyncSerializer\ for non-blocking persistence journals, \Decompression\ and \NestedDeserialization\ for safety bounds, and optimized \PrimitiveSerializers\ for common types.

actor/src/main/scala/org/apache/pekko/serialization · high confidence

The StreamTestKit module has been restructured to provide a dedicated Java DSL, introducing new \TestSink\ and \TestSource\ factory methods in \org.apache.pekko.stream.testkit.javadsl\ that wrap the existing Scala implementations. A new \reference.conf\ file defines the \pekko.stream.testkit.all-stages-stopped-timeout\ setting (defaulting to 5 seconds), which is now explicitly used by the \assertAllStagesStopped\ methods in both the Scala and Java APIs to control how long they wait for stream stages to terminate. Additionally, the Java fluent API methods have been updated to return \this.type\ instead of abstract type members to fix unchecked warnings, and several deprecated methods like \expectNoMsg\ and the \probe\ factory methods on \TestSink\/\TestSource\ have been removed.

stream-testkit · high confidence

This change adds MiMA (Migration Manager) exclusion filters for the newly introduced \close\ method on \ActorSystem\ in both the typed and classic actor APIs. By excluding \ReversedMissingMethodProblem\ and \InheritedNewAbstractMethodProblem\ for \org.apache.pekko.actor.ActorSystem.close\ and \org.apache.pekko.actor.ExtendedActorSystem.close\, the release ensures that the addition of this lifecycle method does not trigger binary compatibility errors for existing users upgrading to version 1.3.x.

actor-typed/src/main/mima-filters/1.3.x.backwards.excludes, actor/src/main/mima-filters/1.3.x.backwards.excludes · high confidence

The release notes now exclude specific binary compatibility issues in the cluster metrics and cluster sharding protobuf message definitions caused by the upgrade to protoc 4.29.3, ensuring that the build does not fail on these expected changes.

cluster-metrics/src/main/mima-filters, cluster-sharding/src/main/mima-filters/1.1.x.backwards.excludes · high confidence

The Mapped Diagnostic Context (MDC) for typed actor logs now includes the \sourceThread\ key, which records the name of the dispatcher thread executing the actor. This change aligns typed actor logging with classic actor logging, allowing users to correlate log entries from both actor styles by the dispatching thread. The implementation adds the \SourceThreadKey\ to \ActorMdc\ and populates it with the current thread's name when the logging context is set.

actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal · high confidence

The internal dispatch mechanism now uses a single \ScalaBatchable\ utility to detect batchable runnables, consolidating checks for both Pekko's legacy \Batchable\ and Scala's standard \scala.concurrent.Batchable\. This change ensures consistent behavior across different Scala versions by abstracting away version-specific runnable implementations, allowing the actor system to correctly identify and handle batchable tasks regardless of the underlying Scala runtime details.

actor/src/main/scala/org/apache/pekko/dispatch/internal · high confidence

The migration compatibility checks (MIMA) have been updated to accommodate recent API changes in Pekko Typed. Specifically, the filters now exclude incompatible result type problems for the \onFailure\ method in \Behaviors\#Supervise\ (Java and Scala DSLs) to support the new flattened supervision syntax, and they also exclude problems related to JDK9+ JFR internal classes.

actor-typed/src/main/mima-filters/1.0.x.backwards.excludes · high confidence

This update configures the MiMa binary compatibility checker to account for breaking changes in the Pekko Typed API. It excludes incompatibilities resulting from the migration of Java API functions from the \japi\ to the \japi.function\ package, the removal of deprecated methods such as \startPeriodicTimer\ on both Java and Scala \TimerScheduler\ interfaces, and the removal of internal legacy classes like \TrickySecurityManager\. Additionally, it suppresses new warnings from the upgraded sbt-mima-plugin (1.2.0) regarding internal implementation details in \TimerScheduler\ and \ExtensionsImpl\ that are expected for the 2.0 release.

actor-typed/src/main/mima-filters/2.0.x.backwards.excludes · high confidence

This release updates the MiMa (Migration Manager) compatibility filters to account for breaking changes in underlying dependencies. Specifically, it excludes compatibility checks for protobuf message classes in the cluster client and pubsub modules due to the upgrade to protoc 4.29.3, and it excludes checks for removed deprecated methods in ClusterSingletonManager and DistributedPubSubSettings as part of the Pekko 2.0 cleanup. These changes ensure that the build correctly ignores expected API removals and signature changes associated with these dependency upgrades.

cluster-tools/src/main/mima-filters · high confidence

This update adjusts the MiMa (Migration Manager) compatibility filters to accommodate two internal changes. First, it excludes problems related to \org.apache.pekko.cluster.typed.internal.protobuf\ to account for the upgrade to protoc 4.29.3, ensuring that internal protobuf changes do not trigger false-positive binary incompatibility warnings. Second, it excludes \DirectMissingMethodProblem\ for the constructors of \ClusterSingletonManagerSettings\ and \ClusterSingletonSettings\, reflecting the removal of deprecated methods in the cluster-typed API.

cluster-typed/src/main/mima-filters · high confidence

This change updates the MiMa (Migration Manager) exclusion filters for the cluster module to accommodate recent internal refactoring and dependency upgrades. Specifically, it adds exclusions for protobuf message changes resulting from the upgrade to protoc 4.29.3, suppresses warnings for removed deprecated methods in cluster APIs (such as \CurrentClusterState\ constructors, \UniqueAddress\ members, and router settings), and resolves pre-existing incompatibilities exposed by upgrading the sbt-mima-plugin to version 1.2.0. These adjustments ensure that the binary compatibility check passes despite the removal of legacy internal APIs and serialization manifests.

cluster/src/main/mima-filters · high confidence

Added FlightRecording test utility for JFR integration; Added JMH benchmark for DNS ID generators; Added JMH benchmark for Reliable Delivery patterns; Added JMH benchmarks for Pekko Stream performance; Added JMH benchmarks for file I/O and TLS stream performance; Added JUnit 5 test for LeaseProvider in Java DSL; Added JUnit 5 tests for CompletionStages and Java Future utilities; Added JUnit 5 tests for Java API utilities; Added JUnit 5 tests for the Java Actor Test Kit; Added JUnit 5-based tests for cluster tools; Added JUnit Jupiter (JUnit 5) integration examples for Pekko Typed TestKit; Added Java DSL tests for Cluster Sharding persistence and Sharded Daemon Process; Added Java DSL tests for typed actors; Added Java compile test for cluster seed node joining; Added Java documentation and compile-only tests for typed EventStream; Added Java documentation and test examples for Replicated Event Sourcing; Added Java documentation examples and tests for cluster sharding and delivery; Added Java documentation samples and tests for typed cluster features; Added Java typed-actor documentation tests; Added Java unit tests for Pekko util components; Added Java unit tests for pattern utilities; Added Java unit tests for the actor subsystem; Added Java unit tests for typed actor system APIs; Added OutputStreamSourceStage benchmark; Added Pekko Stream TCK test suite; Added Scala 3 tests for LineNumbers utility; Added Scala DSL test suites for ActorTestKit, BehaviorTestKit, and JUnit5 builders; Added ScalaTest test suites for typed cluster sharding and sharded daemon processes; Added comprehensive test coverage for typed actor core behaviors and patterns; Added comprehensive test suite for Apache Pekko Cluster; Added documentation for test keystore and truststore resources; Added multi-JVM tests for ClusterSingletonManager resilience and lifecycle scenarios; Added multi-jvm cluster integration tests; Added multi-jvm cluster tests for typed APIs; Added multi-jvm tests for typed cluster sharding scenarios; Added multi-node cluster routing tests; Added multi-node cluster tests for Split-Brain Resolver scenarios; Added multi-node integration test infrastructure for Split Brain Resolver; Added multi-node integration tests for Cluster Client and Distributed PubSub; Added multi-node remote testing specifications; Added multi-node tests for cluster sharding coordinator role and failure scenarios; Added passivation simulator for testing sharding strategies; Added performance test for cluster sharding with remember entities; Added test configuration and logging resources for ActorTestKit; Added test configuration files for cluster-sharding passivation simulator; Added test coverage for cluster tools serialization and singleton behavior; Added test coverage for typed actor Scala DSL behaviors; Added test coverage for typed actor routing, pub-sub, and sharding test utilities; Added test coverage for typed cluster components; Added test infrastructure and specs for actor lifecycle, configuration, and path validation; Added test resource configurations for logging and mailboxes; Added test suite for cluster metrics extension; Added tests for ActorRef serialization and ActorSystem lifecycle; Added tests for ClusterSharding protobuf message serialization; Added tests for Java 21 untyped actor stash support; Added tests for LineNumbers and TypedMultiMap utilities; Added tests for LocalReceptionist behavior and ServiceKey serialization; Added tests for MapAsyncPartitioned stream operators; Added tests for PropsAdapter configuration mapping; Added tests for Receptionist API usage and External Shard Allocation behavior; Added tests for Split Brain Resolver lease configuration and cluster member addressing; Added tests for cluster metrics protobuf serialization and number handling; Added tests for cluster protobuf message serialization and decompression safety; Added tests for cluster router pool size adjustments; Added tests for cluster sharding configuration compatibility and replicated event replication; Added tests for cluster sharding health checks, lease acquisition, and allocation strategies; Added tests for cluster sharding passivation strategies; Added tests for durable and standard reliable delivery with cluster sharding; Added tests for logging adapter and MDC handling; Added tests for persistence plugin proxy, shared LevelDB journal, and serialization; Added tests for reliable delivery controllers and durable queues; Added tests for remember-entities shard store and starter behavior; Added tests for replicated sharding with JUnit 5; Added tests for the cluster testkit AutoDowning provider; Added tests for the coordination lease module; Added tests for typed EventStream subscriber behaviors; Added tests for virtual thread support in dispatchers; Added throughput benchmark tests for typed delivery; Added unit tests for PFBuilder and ReceiveBuilder; Added unit tests for internal sharding components; Java stream tests migrated to JUnit 5; New JMH benchmarks for ByteString performance.

The project has switched its build tool from Maven to SBT, introducing a new build.sbt configuration that defines the module structure (including actor, cluster, persistence, and stream modules) and manages dependencies. As part of this migration, the legacy Maven pom.xml files (including the root pom.xml, kernel/pom.xml, and api-java/pom.xml) have been removed, consolidating the build definition into the SBT environment.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 41 → 71 (+29.6)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 82 (-17.8)
• Architecture 94 (new)
• Maturity 58 → 68 (+10.2)
• Readiness 28 → 71 (+42.8)
• Security 38 → 69 (+30.2)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• High IaC: KSV-0118 (kubernetes/test-node-base.yaml)
• High IaC: KSV-0118 (kubernetes/test-node-base.yaml)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 41 more

• AbstractProps.checkCreatorClosingOver (cognitive 16) (actor/src/main/scala/org/apache/pekko/actor/AbstractProps.scala)
• ActorCell.systemInvoke (cyclomatic 22) (actor/src/main/scala/org/apache/pekko/actor/ActorCell.scala)
• ActorPath.findInvalidPathElementCharPosition (cognitive 22) (actor/src/main/scala/org/apache/pekko/actor/ActorPath.scala)
• ActorPath.findInvalidPathElementCharPosition (cyclomatic 16) (actor/src/main/scala/org/apache/pekko/actor/ActorPath.scala)
• ActorRefBackpressureSinkStage.createLogic (cognitive 17) (stream/src/main/scala/org/apache/pekko/stream/impl/ActorRefBackpressureSinkStage.scala)
• ActorRefSource.createLogicAndMaterializedValue (cognitive 41) (stream/src/main/scala/org/apache/pekko/stream/impl/ActorRefSource.scala)
• ActorRefSource.createLogicAndMaterializedValue (cyclomatic 26) (stream/src/main/scala/org/apache/pekko/stream/impl/ActorRefSource.scala)
• ActorSelection.deliverSelection (cognitive 44) (actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala)
• ActorSelection.deliverSelection (cyclomatic 16) (actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala)
• ActorSystemImpl.printTree (cognitive 21) (actor/src/main/scala/org/apache/pekko/actor/ActorSystem.scala)
• AdapterClusterImpl.subscriptionsBehavior (cyclomatic 16) (cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/internal/AdaptedClusterImpl.scala)
• AddressFromURIString.unapply (cognitive 17) (actor/src/main/scala/org/apache/pekko/actor/Address.scala)
• AggregateWithBoundary.createLogic (cognitive 38) (stream/src/main/scala/org/apache/pekko/stream/impl/fusing/AggregateWithBoundary.scala)
• AggregateWithBoundary.createLogic (cyclomatic 31) (stream/src/main/scala/org/apache/pekko/stream/impl/fusing/AggregateWithBoundary.scala)
• ArteryAeronUdpTransport.startAeron (cognitive 16) (remote/src/main/scala/org/apache/pekko/remote/artery/aeron/ArteryAeronUdpTransport.scala)
• ArteryTransport.attachControlMessageObserver (cognitive 29) (remote/src/main/scala/org/apache/pekko/remote/artery/ArteryTransport.scala)
• Association.attachOutboundStreamRestart (cognitive 34) (remote/src/main/scala/org/apache/pekko/remote/artery/Association.scala)
• Association.attachOutboundStreamRestart (cyclomatic 24) (remote/src/main/scala/org/apache/pekko/remote/artery/Association.scala)
• Association.quarantine (cognitive 22) (remote/src/main/scala/org/apache/pekko/remote/artery/Association.scala)
• Association.send (cognitive 50) (remote/src/main/scala/org/apache/pekko/remote/artery/Association.scala)
• …and 1099 more

• 102 commits — 79 feature/other, 23 fixes

• project/Dependencies.scala — 27 commits
• remote/src — 13 commits
• actor/src — 11 commits
• .github/workflows — 8 commits
• actor-tests/src — 8 commits
• docs/src — 8 commits
• project/plugins.sbt — 4 commits
• serialization-jackson/src — 4 commits
• (root) — 3 commits
• cluster/src — 3 commits
• persistence-typed/src — 2 commits
• persistence/src — 2 commits
• project/build.properties — 2 commits
• (repo) — 1 commit
• actor-testkit-typed/src — 1 commit
• bench-jmh/src — 1 commit
• coordination/src — 1 commit
• slf4j/src — 1 commit
• stream-tests/src — 1 commit
• stream/src — 1 commit

• fix: Fix image paths in substream docs (#3470)
• fix: fix: bound Jackson payload decompression size (#3491)
• fix: fix: bound compression-pointer hops in DNS name parsing (#3490)
• fix: fix: bound inbound Artery TCP frame length at framing (#3492)
• fix: fix: bound nesting depth when deserializing enclosed payloads (#3500)
• fix: fix: bound the number of entries in a compression table advertisement (#3510)
• fix: fix: bound the size a compressed payload may expand to (#3502)
• fix: fix: bounds check the lookup table indexes in gossip (#3508)
• fix: fix: check the remote deployment allow list before deserializing constructor args (#3493)
• fix: fix: close IO resources left open on abrupt or failing paths (#3532)
• fix: fix: default the Jackson max-decompressed-size to unlimited (#3515)
• fix: fix: don't dereference a null superclass in the protobuf allow list check (#3509)
• fix: fix: don't resolve HOCON includes in config that arrived in a message (#3505)
• fix: fix: don't resolve a wire-supplied manifest class the serializer will not use (#3495)
• fix: fix: handle post-Java 8 constant pool entries in LineNumbers (#3465)
• fix: fix: log the classic hostname verification warning at warning level (#3479)
• fix: fix: make AbstractPersistentActorWithTimers and AbstractFSMWithStash subclassable from Java on Scala 3 (#3475)
• fix: fix: match actor selection wildcards without backtracking (#3506)
• fix: fix: preserve StageActor demand across fused streams (#3461)
• fix: fix: reject messages whose parallel repeated fields disagree in length (#3507)
• …and 82 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

apache/pekko 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.