Skip to content
CAI
Software that uses CAICheck a score

apache/pekko-http

63.5

Adequate · 7 November 2026

64k

lines of production code

Scala

with Java

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add HTTP caching support with LfuCache and CachingDirectives

Introduces a new caching module for Apache Pekko HTTP, providing an LRU-based cache implementation (LfuCache) backed by Caffeine and a set of HTTP directive helpers (CachingDirectives) to easily cache route results. Users can now wrap routes with caching logic using the \cache\ or \alwaysCache\ directives, which respect \Cache-Control\ headers like \no-cache\ and \max-age=0\, and create caches with configurable settings for capacity and expiration times.

http-caching/src/main/scala/org/apache/pekko/http/caching · high confidence

Add Jackson 3 JSON marshaller and unmarshaller for Java

A new Jackson 3 integration is available for Pekko HTTP Java, providing \Marshaller\ and \Unmarshaller\ implementations that use the \tools.jackson\ library (Jackson 3) to serialize and deserialize JSON. The implementation includes a configurable \ObjectMapper\ and \JsonFactory\, allowing users to tune stream read/write constraints (such as max nesting depth, string length, and token count) and select a buffer recycler pool strategy (e.g., thread-local, bounded) via the \pekko.http.marshallers.jackson3\ configuration section. This replaces or supplements previous Jackson 2-based marshalling by offering explicit support for the newer Jackson 3 API surface.

http-marshallers-java/http-jackson3 · high confidence

Add Java DSL ContentTypeResolver interface and CorrespondsTo annotation

The Java DSL for HTTP server directives now includes a new \ContentTypeResolver\ functional interface, allowing users to provide custom mappings from file names to content types, along with a convenience method to bridge to the Scala DSL. Additionally, an internal \@CorrespondsTo\ annotation has been added to help maintain consistency between Java and Scala DSL method implementations.

http/src/main/java/org/apache/pekko/http/javadsl/server/directives · high confidence

Add Java mapping support for CORS settings and header ranges

The http-cors module now includes a Java mapping layer that bridges Scala and Java DSLs for CORS configuration. Specifically, it provides implicit conversions for CorsSettings and HttpHeaderRange, enabling Java users to seamlessly interact with the CORS settings and header range models defined in the Scala implementation.

http-cors/src/main/scala/org/apache/pekko/http/cors · high confidence

Add Munit-based route testing support

The http-testkit-munit module now provides a new way to test Pekko HTTP routes using the Munit testing framework. Users can extend the MunitRouteTest trait to write route tests with Munit's assertion style, supporting standard route testing features like header manipulation, response checking, rejection handling, and async route execution.

http-testkit-munit · high confidence

Add Pekko HTTP engine benchmarks

Added a suite of JMH benchmarks in the \http-bench-jmh\ module to measure the performance of the Pekko HTTP engine. These benchmarks cover connection pool handling, HTTP header parsing, entity discarding, message-to-frame rendering, server request processing, and WebSocket frame masking, providing developers with metrics to track engine efficiency.

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

Add Pekko-specific logging macros for Scala 2 and 3

The parsing module now includes internal logging helper macros (LogHelperMacro) for both Scala 2 and Scala 3, enabling efficient, lazy-evaluation of log messages via compile-time reification and inline quotes. These macros are integrated into the LogHelper trait, which provides a unified interface for debug, info, and warning logging with context prefixes, ensuring that log message evaluation is skipped when the corresponding log level is disabled.

parsing · high confidence

Add Server-Sent Events marshalling support

The \EventStreamMarshalling\ trait and its companion object have been added to the HTTP module, enabling users to marshal a \Source\[ServerSentEvent, Any\]\ directly into an HTTP response with the \text/event-stream\ content type. By importing \EventStreamMarshalling.toEventStream\, developers can seamlessly convert streams of Server-Sent Events into HTTP entities, facilitating the implementation of real-time event push functionality.

http/src/main/scala/org/apache/pekko/http/scaladsl/marshalling/sse · high confidence

Add default LfuCache configuration for HTTP caching

A new reference configuration file has been added for the HTTP caching module, defining default settings for the LfuCache. Users can now rely on these defaults, which set a maximum cache capacity of 512 entries, an initial capacity of 16, and infinite time-to-live and time-to-idle values, or override them in their own application.conf.

http-caching/src/main/resources · high confidence

Added CORS benchmark for performance testing

A new JMH benchmark class (CorsBenchmark) has been added to the http-bench-jmh module to measure the performance of Pekko HTTP CORS handling. The benchmark establishes a local HTTP server and runs throughput tests comparing a baseline route against routes using default CORS settings, including both standard GET requests and preflight OPTIONS requests.

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

Added HTTP/2 client-server and server-processing benchmarks

New JMH benchmark files have been added to the \http-bench-jmh\ module to measure HTTP/2 performance. \H2ClientServerBenchmark\ evaluates the round-trip processing of HTTP requests and responses over an HTTP/2 connection, including support for frame-type throttling via configuration. \H2ServerProcessingBenchmark\ measures the server's ability to process raw HTTP/2 frames, specifically counting HEADERS and SETTINGS frames. Both benchmarks utilize the \org.apache.pekko\ package structure and configure the Pekko HTTP engine with specific settings for stream concurrency and entity handling.

http-bench-jmh/src/main/scala/org/apache/pekko/http/impl/engine/http2 · high confidence

Added JMH benchmark runner and test source generators

The http-bench-jmh module now includes a BenchRunner utility that parses command-line arguments (such as 'quick' or 'full') to configure and execute JMH benchmarks, printing the aggregated results. Additionally, BenchTestSource classes were added to provide efficient, pre-allocated integer and generic element streams for use in benchmark scenarios.

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

Added Java DSL SSE event stream marshaller

A new \EventStreamMarshalling\ object has been added to the Java DSL marshalling package, providing a \toEventStream\ marshaller that allows a \Source\ of \ServerSentEvent\s to be marshalled into an HTTP response entity.

http/src/main/scala/org/apache/pekko/http/javadsl/marshalling/sse · high confidence

Added Java DSL unmarshalling for Server-Sent Events

Users can now unmarshal HTTP entities with a \text/event-stream\ media type into a \Source\ of \ServerSentEvent\s using the new \EventStreamUnmarshalling\ object in the Java DSL. This component provides \fromEventsStream\ methods that bridge the existing Scala unmarshalling implementation to the Java API, allowing Java applications to consume Server-Sent Event streams directly.

http/src/main/scala/org/apache/pekko/http/javadsl/unmarshalling/sse · high confidence

Added Java example applications for Pekko HTTP server with HTTP/HTTPS support

New Java example applications have been added to the http-tests module, demonstrating how to run a Pekko HTTP server. SimpleServerApp shows a calculator service that can operate over HTTP or HTTPS (using a PKCS12 keystore), while SimpleServerHttpHttpsApp demonstrates running both HTTP and HTTPS servers simultaneously on the same system. These examples utilize the updated org.apache.pekko package namespace and Java 15+ string formatting syntax.

http-tests/src/main/java/org/apache/pekko/http/javadsl/server/examples/simple · high confidence

Added Java pet store example application

A new Java-based pet store example has been added to the http-tests module, demonstrating Pekko HTTP routing with Jackson marshalling. The example includes a PetStoreController for handling pet deletion and a PetStoreExample application that serves a web interface and exposes REST endpoints for retrieving, creating, and deleting pets via an in-memory data store.

http-tests/src/main/java/org/apache/pekko/http/javadsl/server/examples/petstore · high confidence

Added Server-Sent Events line parser benchmark

A new JMH benchmark has been added to measure the performance of the Server-Sent Events (SSE) line parser. The benchmark, located in the \http-bench-jmh\ module, evaluates parsing speed across various event sizes (1 KB to 1 MB) and chunk sizes (512 to 8192 bytes), providing data on how these parameters impact algorithm performance.

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

Added migration rule for Akka HTTP server binding methods

A new Scalafix rule, MigrateToServerBuilder, has been added to automatically refactor deprecated Akka HTTP server binding methods (such as bindAndHandle, bindAndHandleAsync, bindAndHandleSync, and bind) to the new Pekko HTTP ServerBuilder API. This change allows users to automatically update their codebase to use the modern builder pattern, including handling arguments for interface, port, connection context, settings, and logging, while providing a warning if custom materializers are detected.

http-scalafix/scalafix-rules · high confidence

Added a configuration file for the site-link-validator tool to ensure the integrity of links in the generated documentation. The configuration maps external API prefixes (such as Pekko HTTP ScalaDoc and Java API) to local unidoc targets, ignores specific generated files like the license report, and excludes known problematic external URLs (including Stack Overflow, GitHub, and reactive manifesto) that frequently cause CI failures due to rate limiting or connectivity issues.

scripts · high confidence

Initial project scaffolding and governance configuration for Apache Pekko HTTP

This change establishes the foundational repository structure for Apache Pekko HTTP, introducing essential governance and development configuration files. It adds \.asf.yaml\ to configure GitHub repository settings, including protected branches (main, 1.0.x–1.4.x), required status checks, and notification routing. It introduces \.gitattributes\ to enforce Unix line endings, \.gitignore\ for build artifacts, and \.jvmopts\/\.jvmopts-ci\ to set JVM memory and encoding defaults. Developer tooling is configured via \.scala-steward.conf\ (pinning Scala 3.3 LTS and sbt 1.x, excluding Pekko core updates), \.scalafmt.conf\ (version 3.11.5, Scala 2.13/3 dialect), and \.scalafix.conf\ for import sorting and unused code removal. The entry also adds \AGENTS.md\ and \CLAUDE.md\ to define rules for AI coding agents, alongside standard project files like \CONTRIBUTING.md\, \LICENSE\, \NOTICE\, \README.md\, \CHANGELOG.md\, and \SECURITY.md\.

(repo-wide) · high confidence

Introduce Pekko HTTP CORS module with Java DSL and configuration

Adds the new \pekko-http-cors\ module, providing Java DSL classes (\HttpHeaderRange\, \HttpHeaderRanges\, \HttpOriginMatcher\) to support CORS functionality, alongside a \reference.conf\ file that defines default settings for allowed origins, headers, methods, credentials, and caching behavior.

http-cors/src/main/java · high confidence

Introduce Pekko HTTP CORS module with strict origin validation

The new \pekko-http-cors\ module provides Scala and Java directives to handle Cross-Origin Resource Sharing (CORS) for Pekko HTTP routes. It includes configurable settings for allowed origins, methods, headers, credentials, and max-age, along with a rejection handler for invalid requests. A key behavioral change in this release is that every origin listed in the request's \Origin\ header must be individually allowed; previously, a single match might have sufficed, but now if a request lists multiple origins and any one of them is not permitted, the entire request is rejected to prevent echoing unauthorized origins in the response.

http-cors/src/main/scala/org/apache/pekko/http/cors/scaladsl · high confidence

Introduce Pekko HTTP marshalling support with new type aliases and implicit marshallers

The marshalling package now provides a complete set of implicit marshallers for converting Scala types into HTTP requests and responses. This includes predefined marshallers for common types such as String, Array\[Byte\], ByteString, and FormData, as well as support for Option, Either, Future, and Try wrappers. New type aliases (ToEntityMarshaller, ToResponseMarshaller, etc.) simplify the API, while traits like GenericMarshallers and PredefinedToResponseMarshallers enable content-type negotiation, error handling for non-2xx status codes, and entity streaming support. Users can now easily marshal complex types into HTTP responses using standard Scala idioms.

http/src/main/scala/org/apache/pekko/http/scaladsl/marshalling · high confidence

Introduction of ExceptionHandlerBuilder for Java DSL

The Java HTTP server DSL now includes an ExceptionHandlerBuilder class, providing a fluent API for users to construct exception handlers. This builder allows developers to define custom routing logic for specific exception types using match methods (by class, with predicates, or by equality) and a catch-all matchAny method, simplifying the process of handling errors in HTTP routes.

http/src/main/java/org/apache/pekko/http/javadsl/server · high confidence

JUnit Jupiter support for Java route tests

The Java HTTP testkit now provides JUnit Jupiter (JUnit 5) support alongside the existing JUnit 4 implementation. Users can write route tests using JUnit 5 annotations by extending the new \JUnitJupiterRouteTest\ class, which manages the \ActorSystem\ lifecycle via a JUnit 5 extension (\ActorSystemExtension\). The legacy \JUnitRouteTest\ and \ActorSystemResource\ classes are now deprecated in favor of the Jupiter equivalents.

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

Jackson marshaller now supports configurable buffer recycler pools

The Java Jackson marshaller has been updated to allow users to configure the underlying Jackson buffer recycler pool via the \pekko.http.marshallers.jackson.buffer-recycler.pool-instance\ configuration setting. This change enables tuning memory allocation and recycling strategies (such as thread-local, concurrent-deque, shared-concurrent-deque, bounded, or non-recycling pools) to better fit specific application performance profiles, while also applying stricter stream read/write constraints defined in the configuration.

http-marshallers-java/http-jackson/src/main/java · high confidence

Java DSL caching directives for HTTP server routes

Added the CachingDirectives class in the Java DSL, providing Java-facing wrappers for HTTP route caching. This includes directives to cache route results based on a keyer function (cache, alwaysCache), a directive to bypass caching when prohibited by Cache-Control headers (cachingProhibited), and a helper to create an LfuCache instance with configurable settings.

http-caching/src/main/scala/org/apache/pekko/http/javadsl · high confidence

Java DSL unmarshalling API and standard type support

The Java HTTP DSL now exposes a dedicated \Unmarshallers\ interface for creating custom unmarshallers via synchronous or asynchronous functions, as well as combining multiple unmarshallers with \firstOf\. Additionally, the \StringUnmarshallers\ class provides ready-to-use unmarshallers for parsing strings into standard Java types (String, Byte, Short, Integer, Long, Float, Double, Boolean, UUID) in both decimal and hexadecimal formats, simplifying data binding for common scenarios.

http/src/main/java/org/apache/pekko/http/javadsl/unmarshalling · high confidence

New Java Cache interface for HTTP caching

A new \Cache\ interface has been added to the Java DSL (\org.apache.pekko.http.caching.javadsl\), providing methods to manage cached \CompletionStage\ values. This interface supports retrieving or generating cached futures (\getFuture\, \getOrFulfil\, \getOrCreateStrict\), querying cache state (\getOptional\, \getKeys\, \size\), and managing entries (\remove\, \clear\).

http-caching/src/main/java · high confidence

New Java DSL Coder and RegexConverter utilities

The Java HTTP DSL now includes a new Coder enum that exposes predefined HTTP compression codecs (Gzip, Deflate) with configurable levels, allowing Java users to encode and decode HTTP messages and byte strings using the underlying Scala implementation. Additionally, a new RegexConverters utility class provides a method to convert Java Pattern objects into Scala Regex instances without recompilation, facilitating interoperability between Java and Scala regex handling within the HTTP layer.

http/src/main/java/org/apache/pekko/http/javadsl/coding · high confidence

New Java DSL common utilities for entity streaming and function application

The Java DSL now includes new support classes in the \org.apache.pekko.http.javadsl.common\ package. \EntityStreamingSupport\ provides the API for configuring and handling framed entity streaming (such as JSON and CSV), allowing users to define content types, framing decoders/renderers, and parallel marshalling settings. Additionally, \PartialApplication\ offers a utility to partially apply Java functions, simplifying the creation of single-argument functions from multi-argument ones.

http/src/main/scala/org/apache/pekko/http/javadsl/common · high confidence

New Java DSL for CORS handling in Pekko HTTP

This change introduces the Java DSL API for the new Pekko HTTP CORS module, providing Java-specific wrappers for the underlying Scala implementation. Users can now configure CORS policies using the \CorsSettings\ class (supporting creation from Config, config strings, or ActorSystem) and apply them via \CorsDirectives\ methods like \cors\ and \corsRejectionHandler\. The API also exposes \CorsRejection\ types to handle specific failure causes such as invalid origins, methods, or headers, enabling Java applications to integrate CORS support seamlessly.

http-cors/src/main/scala/org/apache/pekko/http/cors/javadsl · high confidence

New strategy for handling oversized Server-Sent Events (SSE) messages

A new \OversizedSseStrategy\ enum has been added to the Java DSL settings, allowing users to configure how the HTTP server handles SSE messages that exceed the configured \max-line-size\. The available strategies are \FailStream\ (the default, which fails the stream with an \IllegalStateException\ to maintain backward compatibility), \LogAndSkip\ (logs a warning and continues processing), \Truncate\ (logs an info message and truncates the message to the max line size), and \DeadLetter\ (sends the message to dead letters). This setting provides explicit control over error handling and stream resilience for oversized SSE payloads.

http/src/main/java/org/apache/pekko/http/javadsl/settings · high confidence

Pekko HTTP testkit source files added with updated package names

The http-testkit module now includes the core Scala source files for the Pekko HTTP testkit, including utilities for marshalling/unmarshalling, route testing, and WebSocket probing. These files have been migrated from the 'akka' to the 'org.apache.pekko' package namespace and updated with the Apache Pekko license headers, establishing the foundational test infrastructure for the new project.

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

XML marshalling support added for NodeSeq

The http-xml module now provides marshalling and unmarshalling capabilities for Scala's \NodeSeq\ type, allowing HTTP entities to be automatically converted to and from XML data. This includes support for standard XML media types (text/xml, application/xml, etc.) and implements a secure SAX parser configuration that disables external entities and DOCTYPE declarations to prevent XXE attacks.

http-marshallers-scala/http-xml · high confidence

Behavioural changes

Add default testkit timeout configuration

A new reference.conf file has been added to the http-testkit module, establishing default timeout values of 1 second for both marshalling and route testing operations via pekko configuration keys.

http-testkit/src/main/resources · high confidence

Apache Pekko HTTP caching API migration

The HTTP caching module has been migrated from the Akka codebase to Apache Pekko, updating the package namespace to org.apache.pekko.http.caching.scaladsl. This change includes the introduction of new Scala DSL components (Cache, CachingSettings, LfuCacheSettings) that bridge the Scala API with the Java DSL using Scala Future Converters and updated collection converters, ensuring compatibility with the Pekko ecosystem while maintaining the existing caching behavior for users.

http-caching/src/main/scala/org/apache/pekko/http/caching/scaladsl · high confidence

Breaking API changes in Java DSL duration types and functional interfaces

The http-caching module introduces breaking changes to the Java DSL. Methods in LfuCacheSettings (getTimeToLive, getTimeToIdle) now return Java Durations instead of Scala Durations. Additionally, Cache methods (getFuture, getOrFulfil, getOrCreateStrict) have been updated to use Pekko's functional interfaces. These changes are excluded from binary compatibility checks to allow the transition.

http-caching/src/main/mima-filters · high confidence

Jackson marshaller configuration defaults and buffer recycler settings

A new reference configuration file for the Pekko HTTP Jackson marshaller has been added, defining default constraints for JSON reading and writing. It sets limits for nesting depth, number/string/name length, and document/token counts, aligning with Jackson 2.18 defaults. Additionally, it configures the Jackson buffer recycler pool, defaulting to 'thread-local' with a bounded pool size of 100, allowing users to override these settings in their application.conf.

http-marshallers-java/http-jackson/src/main/resources · high confidence

Java DSL Marshaller API migrated to Apache Pekko

The Java DSL Marshaller component has been updated to use the \org.apache.pekko\ package namespace, replacing the previous \akka\ references. This change ensures that the Java-facing marshalling utilities (such as \Marshaller\, \Unmarshaller\, and related helpers) are consistent with the broader Apache Pekko project identity, while maintaining the same functional API for converting between Java types and HTTP entities.

http/src/main/scala/org/apache/pekko/http/javadsl/marshalling · high confidence

Java DSL cache settings now use java.time.Duration

The Java DSL for HTTP caching settings has been updated so that the \getTimeToLive\ and \getTimeToIdle\ methods on \LfuCacheSettings\ now return \java.time.Duration\ instead of \scala.concurrent.duration.Duration\. Corresponding \withTimeToLive\ and \withTimeToIdle\ builder methods now accept \java.time.Duration\ for idiomatic Java usage, while retaining Scala-specific overloads. This is a breaking change for Java users who previously relied on the Scala duration type.

http-caching/src/main/scala/org/apache/pekko/http/caching/javadsl · high confidence

Java DSL model classes migrated to Apache Pekko namespace

The Java DSL model classes in \http-core\ (such as \HttpEntity\, \HttpMessage\, \FormData\, and \DateTime\) have been migrated from the \akka\ to the \org.apache.pekko\ package namespace. This change updates the package declarations and internal references to align with the project's rebranding, ensuring that Java API users interact with the Pekko-branded types while maintaining the same functional interfaces and behaviors.

http-core · high confidence

Java DSL server directives migrated to Apache Pekko

The Java DSL server directives in the \org.apache.pekko.http.javadsl.server.directives\ package have been migrated from the Akka namespace to Apache Pekko. This change updates the package structure and internal imports to use \org.apache.pekko\ identifiers, ensuring the Java HTTP server API aligns with the broader Pekko project. For users, this represents a foundational update to the library's branding and namespace, requiring any direct references to the old Akka package paths to be updated to the new Pekko equivalents.

http/src/main/scala/org/apache/pekko/http/javadsl/server/directives · high confidence

Java DSL server package migrated to Apache Pekko

The Java DSL server components (including Directives, ExceptionHandler, PathMatchers, RejectionHandler, Rejections, RequestContext, Route, RouteResult, and RoutingJavaMapping) have been migrated from the Akka namespace to the Apache Pekko namespace. This change updates the package structure to org.apache.pekko.http.javadsl.server and replaces internal references to akka.\* with pekko.\*, ensuring the Java HTTP server API is aligned with the Apache Pekko project.

http/src/main/scala/org/apache/pekko/http/javadsl/server · high confidence

Java DSL unmarshalling API migrated to Apache Pekko

The Java DSL unmarshalling components in \http/src/main/scala/org/apache/pekko/http/javadsl/unmarshalling\ have been updated to use the \org.apache.pekko\ package namespace, reflecting the project's transition from Akka. This includes the introduction of \StringUnmarshaller\ for creating string unmarshallers and the addition of \UnsupportedContentTypeException\ to the Java API, allowing Java users to handle unsupported content type errors explicitly. The core \Unmarshaller\ object and class now delegate to the Pekko implementation while maintaining the existing Java-facing methods like \async\, \sync\, and \unmarshal\.

http/src/main/scala/org/apache/pekko/http/javadsl/unmarshalling · high confidence

Migrate HTTP unmarshalling to Apache Pekko package

The unmarshalling module has been migrated from the Akka namespace to Apache Pekko, updating all Scala source files (including GenericUnmarshallers, MultipartUnmarshallers, PredefinedFromEntityUnmarshallers, PredefinedFromStringUnmarshallers, Unmarshal, and the package object) to use the \org.apache.pekko\ package structure. This change ensures compatibility with the Apache Pekko distribution while preserving the existing unmarshalling capabilities for entities, strings, and multipart data.

http/src/main/scala/org/apache/pekko/http/scaladsl/unmarshalling · high confidence

Migrate build infrastructure to Apache Pekko

The project's build system has been fully migrated from Akka to Apache Pekko. This includes renaming the package from \akka\ to \org.apache.pekko\, updating the core dependency to Pekko 2.0.0-M4, and replacing Akka-specific SBT plugins with their Pekko equivalents (such as \sbt-pekko-build\ and \pekko-sbt-paradox\). The build now targets Java 17, enforces stricter compiler warnings for Scala 3, and updates copyright headers to reflect the Apache Software Foundation license.

project · high confidence

Migration of HTTP server directives to Apache Pekko

The HTTP server directive implementations (including Attribute, Basic, CacheCondition, Coding, Cookie, Execution, FormField, FramedEntityStreaming, Future, Header, Host, and Marshalling directives) have been migrated from the Akka package to the Apache Pekko namespace. This change updates all internal imports and package declarations to use org.apache.pekko, ensuring the directives function correctly within the Apache Pekko HTTP server environment.

http/src/main/scala/org/apache/pekko/http/scaladsl/server/directives · high confidence

New HTTP server configuration defaults for SSE and resource handling

A new reference configuration file has been added to define default settings for the HTTP server. This includes specific limits and handling strategies for Server-Sent Events (SSE), such as maximum event and line sizes and policies for oversized data (defaulting to failing the stream). It also configures HTTP routing behaviors, including enabling verbose error messages control, ETag support, jar file caching for resources, and range request coalescing limits.

http/src/main/resources · high confidence

New Java and Scala settings APIs for routing and server-sent events

The HTTP module now exposes dedicated settings classes for routing and server-sent events (SSE) in both the Java and Scala DSLs. RoutingSettings allows users to configure verbose error messages, file get conditionals, vanity footers, range request limits, and chunk decoding sizes, and introduces a new useJarFileCache option (since 2.0.0) to optimize serving resources from JAR files by leveraging the JDK's jar file cache. ServerSentEventSettings provides configuration for SSE parsing, including maximum event and line sizes, empty event emission, and strategies for handling oversized lines and events (since 1.3.0), with both Java and Scala APIs offering fluent builders and config-based creation.

http/src/main/scala/org/apache/pekko/http/javadsl/settings, http/src/main/scala/org/apache/pekko/http/scaladsl/settings · high confidence

Pekko HTTP coding module restructured with memory leak fixes

The HTTP coding module has been migrated to the org.apache.pekko namespace and rewritten for Scala 3. To address memory leaks in Deflate and Gzip decompression, the implementation now ensures that deflater and inflater end() methods are called during cleanup, and ByteBuffers are handed directly to the Inflater and CRC32 classes for better performance. The public API is streamlined through the Coders object (Coders.Gzip, Coders.Deflate, Coders.NoCoding), while the previous direct implementation classes are deprecated as internal API.

http/src/main/scala/org/apache/pekko/http/scaladsl/coding · high confidence

Pekko HTTP common module files added with Apache 2.0 license

The \http/src/main/scala/org/apache/pekko/http/scaladsl/common\ directory now contains the core Scala source files for the HTTP common module, including \EntityStreamingSupport\, \JsonEntityStreamingSupport\, \CsvEntityStreamingSupport\, and \NameReceptacle\. These files implement the package under the new \org.apache.pekko\ namespace and are licensed under the Apache License, version 2.0, reflecting the project's transition from Akka to Apache Pekko.

http/src/main/scala/org/apache/pekko/http/scaladsl/common · high confidence

Ported Scala HTTP server DSL to Apache Pekko

The core Scala HTTP server DSL, including routing directives, request context, and exception handling, has been migrated from the Akka namespace to Apache Pekko. This change updates the package structure to \org.apache.pekko.http.scaladsl.server\ and replaces all internal Akka references with Pekko equivalents, ensuring the framework continues to function under the new Apache Pekko project identity.

http/src/main/scala/org/apache/pekko/http/scaladsl/server · high confidence

Server-Sent Events unmarshalling with configurable size limits

The SSE unmarshalling logic in \EventStreamUnmarshalling\ has been updated to use the new \EventStreamParser\, which introduces explicit configuration for handling oversized messages. Users can now control how the parser reacts when lines or events exceed the configured \maxLineSize\ (default 4KiB) and \maxEventSize\ (default 8KiB) via \OversizedSseStrategy\, allowing for strategies beyond the previous default failure behavior.

http/src/main/scala/org/apache/pekko/http/scaladsl/unmarshalling/sse · high confidence

Spray JSON marshalling support migrated to Apache Pekko

The Spray JSON HTTP marshaller implementation has been ported from Akka to Apache Pekko, updating all Scala source files and tests to use the \org.apache.pekko\ package namespace. This change ensures that the \SprayJsonSupport\ trait and its associated streaming capabilities function correctly within the Pekko HTTP ecosystem, maintaining compatibility with existing spray-json protocols while adopting the new project's internal APIs and licensing headers. Also in this area: 1 commit (0 fixes) modifying http-marshallers-scala/http-spray-json.

http-marshallers-scala/http-spray-json/src/main · medium confidence · unverified

Update benchmark JVM arguments to remove deprecated option

The JMH benchmark configuration in CommonBenchmark.scala has been updated to remove the -XX:+UseBiasedLocking JVM argument, which is no longer supported in recent Java versions. This ensures the benchmarks run correctly without errors related to removed or deprecated JVM flags.

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

Updated MiMa compatibility filters for 2.0.x release

This change updates the binary compatibility filters (MiMa) for the http-cors module to align with the 2.0.x release. It excludes checks for \HttpHeaderRange\ becoming sealed, allows new \concat\ methods added to \HttpHeaderRange\ in both Scala and Java DSLs, and suppresses errors for the removal of deprecated \defaultSettings\ methods in \CorsSettings\. These adjustments ensure that the release is treated as a valid binary-compatible update despite these specific API changes.

http-cors/src/main/mima-filters · high confidence

Updated SSL certificates and added calculator demo page for HTTP tests

The test resources in http-tests have been updated to regenerate SSL certificates using the new example domain name 'akka.example.org' (previously 'pekko.example.org' in the instructions, now reflected in the cert CN), ensuring TLS tests run against the correct identity. Additionally, a new calculator.html demo page has been added to the web resources, providing a simple UI for testing add, subtract, and multiply HTTP endpoints.

http-tests/src/main/resources · high confidence

Updated binary compatibility filters for Pekko HTTP 2.0.x

This update configures the MiMa binary compatibility checker for the 2.0.x release line by adding new exclusion filters. These changes account for breaking API adjustments in the Java DSL, specifically the switch from Scala \Duration\ to Java \Duration\ return types and refactoring of the \ExceptionHandlerBuilder\. The filters also suppress warnings for removed deprecated methods (such as \HttpApp\, \extractUpgradeToWebSocket\, and various directive helpers), internal implementation details in settings classes, and bytecode differences caused by Scala 3's future lazy vals and MiMa version upgrades. Additionally, it acknowledges the new \useJarFileCache\ routing setting.

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

Updated boilerplate templates for Java path matchers and Scala directive instances

The boilerplate templates in the HTTP server module have been updated to regenerate Java path matcher classes and Scala directive instances. The Java path matcher template now generates classes supporting up to 22 path segments, including specific handling for the Tuple22 limit, and adds a \map\ method to \PathMatcher1\ for Java function compatibility. Additionally, new or updated templates for form field, parameter, and tuple utility instances (ApplyConverter, ConstructFromTuple, TupleAppendOne, TupleFold) ensure that generated Scala directives and internal tuple operations are correctly instantiated for varying tuple arities.

http/src/main/boilerplate · high confidence

Updated multi-JVM test infrastructure for Apache Pekko

The multi-JVM test suite in http-tests has been migrated from the Akka namespace to Apache Pekko, updating package declarations and imports to org.apache.pekko. This change includes new or refreshed test support files: STMultiNodeSpec for HTTP multi-node test bases, PerfFlamesSupport for recording JVM performance metrics, TestTags for categorizing timing and performance tests, and QuietReporter to control ScalaTest output verbosity. Users running these tests will see the Pekko branding and licensing headers, and the test execution behavior remains consistent with the previous Akka-based setup.

http-tests/src/multi-jvm · high confidence

Test coverage

1 commit adding/updating tests in http-tests/src/test/java/org/apache/pekko/http/javadsl/common; 6 commits adding/updating tests in http-marshallers-scala/http-spray-json/src/test; 8 commits adding/updating tests in http-tests/src/test/java/docs; Added HPACK encoder and decoder benchmarks; Added HTTP/2 integration and unit tests; Added HTTP/2 server manual test application; Added JMH benchmark for ASCII byte conversion methods; Added JUnit 5 tests for Java DSL route testing and form/header directives; Added Java DSL API and SSE marshalling tests using JUnit 5; Added Java DSL server tests migrated to JUnit 5; Added Java HTTP/2 server test example; Added Java tests for SSE unmarshalling and oversized line strategies; Added Java unit tests for SSE strategy and routing settings; Added Scala 3 compatibility shim for string operations in tests; Added URI parser benchmark; Added binary compatibility tests for FormFieldDirectives; Added comprehensive test coverage for Pekko HTTP server routing; Added comprehensive test coverage for server directives; Added comprehensive test suite for HTTP coding stages; Added documentation for test fixture with non-ASCII filenames; Added test configuration for TLS engine selection; Added test coverage for HTTP marshalling and content negotiation; Added test coverage for JSON and XML marshalling support; Added test coverage for Pekko HTTP Scala DSL features; Added test coverage for multipart unmarshalling and general unmarshalling behaviors; Added test resources for HTTP module; Added test suite for HTTP Scalafix rules; Added test suites for ScalatestRouteTest and Specs2RouteTest; Added tests for Jackson unmarshalling error handling and configuration constraints; Added tests for Java DSL directive consistency and custom header support; Added tests for LfuCache concurrency and CachingDirectives behavior; Added tests for OversizedSseStrategy and RoutingSettings equality; Added tests for SSE unmarshalling line parsing and oversized message handling; Added tests for the MigrateToServerBuilder scalafix rule; Added tests for the new Pekko HTTP CORS module; Java DSL directive tests migrated to JUnit 5; Migrate Java DSL documentation examples to Pekko and JUnit 5.

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

How this codebase got here

Score

  • CAI 52 → 64 (+11.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 64 → 64 (+0.0)
  • Architecture 76 → 75 (-0.9)
  • Maturity 31 → 55 (+23.9)
  • Readiness 84 → 84 (+0.0)
  • Security 81 → 76 (-4.8)
  • Performance 79 → 91 (+12.7)

Resolved (17)

  • Hotspot: http-core/src/main/scala/org/apache/pekko/http/impl/engine/ws/Handshake.scala (http-core/src/main/scala/org/apache/pekko/http/impl/engine/ws/Handshake.scala)
  • Off-boarding risk: anonymized user #1
  • Orphaned file (http-core/src/main/java/org/apache/pekko/http/javadsl/model/HttpMessage.java)
  • Orphaned file (http-core/src/main/scala/org/apache/pekko/http/impl/engine/client/pool/SlotState.scala)
  • Orphaned file (http-core/src/main/scala/org/apache/pekko/http/impl/model/parser/SimpleHeaders.scala)
  • Orphaned file (http-core/src/main/scala/org/apache/pekko/http/javadsl/ClientTransport.scala)
  • Orphaned file (http-core/src/main/scala/org/apache/pekko/http/scaladsl/model/headers/LinkValue.scala)
  • Orphaned file (http-marshallers-scala/http-spray-json/src/main/scala/org/apache/pekko/http/scaladsl/marshallers/sprayjson/SprayJsonSupport.scala)
  • Orphaned file (http-testkit/src/main/scala/org/apache/pekko/http/javadsl/testkit/TestRouteResult.scala)
  • Orphaned file (http/src/main/scala/org/apache/pekko/http/javadsl/common/EntityStreamingSupport.scala)
  • Orphaned file (http/src/main/scala/org/apache/pekko/http/javadsl/marshalling/Marshaller.scala)
  • Orphaned file (http/src/main/scala/org/apache/pekko/http/javadsl/server/Rejections.scala)
  • Orphaned file (http/src/main/scala/org/apache/pekko/http/javadsl/server/directives/FileUploadDirectives.scala)
  • Orphaned file (http/src/main/scala/org/apache/pekko/http/javadsl/server/directives/FutureDirectives.scala)
  • Orphaned file (http/src/main/scala/org/apache/pekko/http/scaladsl/common/CsvEntityStreamingSupport.scala)
  • Orphaned file (http/src/main/scala/org/apache/pekko/http/scaladsl/common/JsonEntityStreamingSupport.scala)
  • Orphaned knowledge (http-core/src/main/scala/org/apache/pekko/http/impl/model/parser/CommonRules.scala)

New (7)

  • Hotspot: http-core/src/main/scala/org/apache/pekko/http/impl/engine/http2/client/PersistentConnection.scala (http-core/src/main/scala/org/apache/pekko/http/impl/engine/http2/client/PersistentConnection.scala)
  • Off-boarding risk: anonymized user #1
  • Orphaned file (http-core/src/main/java/org/apache/pekko/http/javadsl/model/StatusCodes.java)
  • Orphaned file (http-core/src/main/scala/org/apache/pekko/http/impl/engine/ws/FrameOutHandler.scala)
  • Orphaned file (http-core/src/main/scala/org/apache/pekko/http/scaladsl/model/ContentType.scala)
  • Orphaned file (http-testkit/src/main/scala/org/apache/pekko/http/scaladsl/testkit/RouteTestResultComponent.scala)
  • Workflow holding a long-lived secret is unscoped (.github/workflows/publish-1.5-snapshots.yml)

Changes since last survey

  • 33 commits — 31 feature/other, 2 fixes

By area

  • http-core/src — 20 commits
  • .github/workflows — 3 commits
  • docs/src — 2 commits
  • http/src — 2 commits
  • project/Dependencies.scala — 2 commits
  • (root) — 1 commit
  • project/Common.scala — 1 commit
  • project/PekkoCoreDependency.scala — 1 commit
  • project/build.properties — 1 commit

Notable commits

  • fix: fix: close pool connection after an early response, abort the upload only if rejected (#1350)
  • fix: fix: pull pending response when toNet is pulled during termination (#1400)
  • change: Add HttpMessage.header(name) for case-insensitive header lookup by name (#1366)
  • change: Add WebSocket receive-idle-timeout and send-idle-timeout settings (#1369)
  • change: Emit a failed response for the triggering request when an HTTP/2 persistent connection gives up (#1368)
  • change: Preserve pending responses during server shutdown (#1398)
  • change: Quote Link header parameter values containing a colon (RFC 8288) (#1365)
  • change: Remove ApiMayChange from client transport, request/response association and directive APIs (#1364)
  • change: Update Pekko core to 2.0.0 (#1390)
  • change: Update classgraph to 5.0.1 (#1385)
  • change: Update gson to 2.15.0 (#1372)
  • change: Update sbt, sbt-dependency-tree, ... to 1.13.1 (#1387)
  • change: Update scala3-library to 3.3.9 (#1386)
  • change: accept Iterable<? extends HttpHeader> in Java API header parameters (#1379)
  • change: accept Iterable<? extends SocketOption> in Java API withSocketOptions (#1381)
  • change: accept Message subtype and supertype handlers in Java WebSocket APIs (#1382)
  • change: accept wildcard element types in Java API Rejection factories (#1380)
  • change: accept wildcard result and materialized types in remaining Java APIs (#1384)
  • change: add Java connection pool flows that emit HttpResponseResult instead of Try (#1376)
  • change: add java.lang.Iterable overloads to Trailer.addHeaders and withHeaders (#1374)
  • …and 13 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

apache/pekko-http was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 7 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit e2a4aea439094bdeda4bcefb14a79131061708ee — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-5f8314471808.