apache/pekko-http

This system is Apache Pekko HTTP, a high-performance, asynchronous HTTP server and client library for building reactive applications in Scala and Java. It provides a comprehensive DSL for defining routes, handling marshalling and unmarshalling of various data formats (JSON, XML, SSE), and managing caching, CORS, and compression. The codebase includes extensive tooling for benchmarking, testing, and migrating from previous Akka HTTP versions, ensuring binary compatibility and robust performance tracking.

87 changes.

This period focused on migrating the entire codebase from Akka to Apache Pekko, including namespace updates, dependency upgrades, and the introduction of a Scalafix migration tool. It also involved expanding the library's capabilities by adding new modules for CORS and HTTP caching, enhancing Java DSL support, and implementing comprehensive test coverage and performance benchmarks.

8 changes.

This period focused on preparing the Pekko HTTP codebase for the 2.0.x release by managing binary compatibility breaks in the Java DSL and updating MiMa filters. It introduced new features including Jackson 3 marshalling support, Munit-based route testing, and configurable handling for oversized Server-Sent Events.

A new abstract base class, CommonBenchmark, has been added to the http-bench-jmh module to standardize JMH benchmark configurations. This class sets up common JVM arguments (such as parallel GC and memory settings) and defines default warmup and measurement iterations, providing a consistent foundation for HTTP performance benchmarks.

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

A new Jackson 3-based JSON marshaller and unmarshaller is now available for Pekko HTTP Java applications. This component allows you to serialize and deserialize JSON payloads using the Jackson 3 library, with support for custom ObjectMapper instances and configuration-driven stream constraints (such as nesting depth and string length limits) via the standard reference configuration. It also includes a dedicated exception type for unmarshalling failures and configurable buffer recycler pools to manage memory usage during JSON processing.

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

The Java DSL server directives now include a new \ContentTypeResolver\ functional interface, allowing users to provide custom mappings from file names to content types, along with a helper method to bridge to the Scala DSL. Additionally, an internal \@CorrespondsTo\ annotation has been added to help consistency spec implementations map Java DSL methods to their Scala DSL counterparts.

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

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 API using familiar Java types.

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

The http-testkit-munit module now provides a new testing integration using the Munit framework. Users can mix in the MunitRouteTest trait to write HTTP route tests using Munit's assertion style, supporting standard route testing features like header manipulation, response checking, and handling of rejections and exceptions.

http-testkit-munit · high confidence

The parsing module now includes a new internal logging helper (LogHelper) that provides debug, info, and warning methods guarded by level checks to avoid eager evaluation. The implementation is split by Scala version: Scala 2 uses macro-based reification in LogHelperMacro, while Scala 3 uses inline methods and quoted macros, ensuring efficient logging across both versions.

parsing · high confidence

A new reference configuration file (reference.conf) has been added to the http-caching module, defining default settings for the LfuCache. This includes a default maximum capacity of 512 entries, an initial capacity of 16, and infinite time-to-live and time-to-idle values, allowing users to override these defaults in their application.conf.

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

A new configuration file for the site-link-validator tool has been added to the scripts directory. This configuration defines how the documentation build process validates hyperlinks, including mappings to resolve external API prefixes (such as Pekko HTTP and Java APIs) to local generated documentation paths. It also specifies rules to ignore specific external sites that frequently cause CI failures due to rate limiting, forbidden errors, or certificate issues (e.g., GitHub, Stack Overflow, javadoc.io), and whitelists certain non-HTTPS URLs required for documentation examples.

scripts · high confidence

A new Scalafix rule, MigrateToServerBuilder, is introduced to automatically migrate Akka HTTP code to the new Pekko HTTP server builder API. This rule detects calls to deprecated methods such as bindAndHandle, bindAndHandleAsync, bindAndHandleSync, and bind on the Http object, and rewrites them to use the new fluent builder pattern (e.g., newServerAt(...).bind(...)). It also handles optional arguments like connectionContext, settings, and log, and issues a warning if a custom materializer is detected, suggesting that the system materializer may be used instead.

http-scalafix/scalafix-rules · high confidence

A new JMH benchmark class (CorsBenchmark) has been added to the http-bench-jmh module to measure the performance of Pekko HTTP's CORS directives. The benchmark establishes a local HTTP server and runs throughput tests comparing a baseline request against requests processed with 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

New JMH benchmarks have been added to measure HTTP/2 performance, specifically \H2ClientServerBenchmark\ for end-to-end request/response processing and \H2ServerProcessingBenchmark\ for server-side frame handling. These benchmarks allow users to evaluate throughput and latency under various configurations, including different request body types (empty, single-frame) and response types (strict, chunked, closed-delimited).

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

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 sorted results. Additionally, BenchTestSource classes were added to provide efficient, pre-allocated integer and generic element streams for benchmarking purposes.

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

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 a \RequestEntity\ for HTTP responses.

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

New example applications have been added to the http-tests module to demonstrate Pekko HTTP server capabilities. SimpleServerApp illustrates a calculator service supporting HTTP and HTTPS modes, utilizing Java 15+ string formatting and standard Pekko HTTP directives. SimpleServerHttpHttpsApp demonstrates running both HTTP and HTTPS servers simultaneously on the same host using different ports. These examples serve as reference implementations for setting up routes, handling parameters, and configuring SSL contexts in Java.

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

A new Java-based example application demonstrating Pekko HTTP routing with Jackson marshalling has been added to the http-tests module. This includes a PetStoreController for managing pet data and a PetStoreExample entry point that starts an HTTP server on localhost:8080, showcasing various routing directives such as GET, PUT, and DELETE operations using both synchronous and asynchronous patterns.

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

A new JMH benchmark has been added for the Server-Sent Events (SSE) line parser in the http-bench-jmh module. This benchmark measures the performance of parsing SSE events across various event sizes (1 KB to 1 MB) and chunk sizes (512 to 8192 bytes), allowing users to evaluate the throughput and latency characteristics of the parser under different load conditions.

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

Users can now easily marshal a stream of Server-Sent Events into an HTTP response. A new \EventStreamMarshalling\ trait provides an implicit marshaller that converts a \Source\[ServerSentEvent, Any\]\ into an \HttpEntity\ with the \text/event-stream\ content type, allowing SSE streams to be sent directly as HTTP responses.

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

The Java Jackson marshaller now supports configuring Jackson's buffer recycler pools and stream read/write constraints via the \pekko.http.marshallers.jackson\ configuration section. Users can select from several recycler pool implementations (thread-local, concurrent-deque, shared-concurrent-deque, bounded, or non-recycling) and define limits for nesting depth, string/number/name length, document length, and token count to control memory usage and prevent denial-of-service risks during JSON processing.

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

This change establishes the foundational repository structure for Apache Pekko HTTP, introducing essential governance and development configuration files. It adds \.asf.yaml\ to define GitHub repository settings, including protected branches (main, 1.0.x–1.4.x), required status checks (Code is formatted, Check headers), and notification routing. It introduces \.gitattributes\ to enforce Unix line endings, \.gitignore\ for build artifacts, and \.jvmopts\/\.jvmopts-ci\ to configure JVM memory and encoding for local and CI builds. Developer tooling is configured via \.scala-steward.conf\ (pinning Scala 3.3 LTS and sbt 1.x, excluding Pekko core updates), \.scalafmt.conf\ (setting version 3.11.5 and Scala 2.13/3 dialects), and \.scalafix.conf\ (defining cleanup rules). Additionally, it adds \AGENTS.md\ and \CLAUDE.md\ to provide specific rules for AI coding agents, alongside standard project files like \CONTRIBUTING.md\, \LICENSE\, \NOTICE\, \README.md\, and \SECURITY.md\.

(repo-wide) · high confidence

The new \pekko-http-cors\ module adds Java DSL model classes (\HttpHeaderRange\, \HttpHeaderRanges\, \HttpOriginMatcher\) to support CORS header and origin matching, alongside a \reference.conf\ that defines default CORS settings such as allowed origins, headers, methods, credentials, and cache age.

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

The marshalling package now provides a complete set of predefined marshallers for converting common Scala types into HTTP entities, requests, and responses. This includes support for primitive types (String, Array\[Byte\], Array\[Char\]), collections (Option, Either, Future, Try), and HTTP-specific structures (HttpResponse, HttpRequest, Multipart). New type aliases (ToEntityMarshaller, ToResponseMarshaller, etc.) simplify the API, while traits like GenericMarshallers and PredefinedToResponseMarshallers offer out-of-the-box serialization for typical use cases, such as returning status codes with optional entities or streaming sources.

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

The http-caching module now provides an LfuCache implementation backed by Caffeine and a set of CachingDirectives for Pekko HTTP routes. Users can wrap routes with cache support using the \cache\ or \alwaysCache\ directives, which respect \Cache-Control\ headers like \no-cache\ and \max-age=0\. The \routeCache\ helper simplifies creating caches with default or custom settings, enabling efficient caching of route results while avoiding locking issues through asynchronous processing.

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

The Java HTTP 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, enabling more granular control over error handling in HTTP routes.

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

A new Java DSL interface, \org.apache.pekko.http.caching.javadsl.Cache\, has been added to the http-caching module. This interface defines the contract for caching operations, providing methods to retrieve or generate cached \CompletionStage\ values (\getFuture\, \getOrFulfil\, \getOrCreateStrict\), manage cache entries (\remove\, \clear\), and inspect cache state (\getOptional\, \getKeys\, \size\). This allows Java users to integrate with the Pekko HTTP caching system using standard Java asynchronous patterns.

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

The Java HTTP testkit now includes 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. The legacy \JUnitRouteTest\ and \ActorSystemResource\ classes remain available but are deprecated in favor of the new Jupiter-based approach.

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

The Java DSL now includes \EventStreamUnmarshalling\ in the \http/javadsl/unmarshalling/sse\ package, providing \fromEventsStream\ methods to unmarshal \HttpEntity\ objects with a \text/event-stream\ media type into a \Source\ of \ServerSentEvent\s. This allows Java applications to consume Server-Sent Events streams using the standard unmarshalling infrastructure, bridging the Scala implementation to the Java API.

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

Added the CachingDirectives class in the Java DSL, providing Java-facing wrappers for caching route directives. This includes methods to cache route results using a provided cache implementation and keyer, to enforce caching prohibition via Cache-Control headers, to force caching, and to create a default LfuCache with configurable settings.

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

The Java DSL now exposes the \org.apache.pekko.http.javadsl.coding.Coder\ enum, providing Java users with access to predefined HTTP compression coders (Gzip, Deflate) and their variants, along with methods to encode/decode HTTP messages and raw byte strings. Additionally, \RegexConverters\ is introduced to allow seamless conversion of Java \Pattern\ objects to Scala \Regex\ instances within the HTTP module.

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

The Java HTTP DSL now exposes a dedicated \Unmarshallers\ interface for creating unmarshallers via synchronous or asynchronous functions, as well as chaining multiple unmarshallers with \firstOf\. Additionally, a new \StringUnmarshallers\ utility 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.

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

This change introduces two new files to the \org.apache.pekko.http.javadsl.common\ package. \EntityStreamingSupport.scala\ provides the Java API for entity streaming, including the abstract \EntityStreamingSupport\ trait and its \JsonEntityStreamingSupport\ and \CsvEntityStreamingSupport\ implementations, along with companion object methods to create default JSON and CSV streaming configurations. \PartialApplication.scala\ adds a utility object with a \bindParameter\ method to help Java users partially apply functions by binding the first argument of a \BiFunction\.

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

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

The \http-cors\ module is now available, providing Scala DSL directives (\CorsDirectives\) and settings (\CorsSettings\) to handle Cross-Origin Resource Sharing. This implementation enforces strict origin validation: a request is rejected if any origin listed in the \Origin\ header is not explicitly allowed, rather than accepting the request if at least one origin matches. The module supports configuration for allowed methods, headers, credentials, and preflight caching via the Actor System configuration.

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

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 size), and \DeadLetter\ (sends the message to dead letters). This provides Java users with explicit control over error handling for oversized SSE payloads, mirroring the existing Scala implementation.

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

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

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

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

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

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

The build system has been fully migrated from Akka to Apache Pekko, including renaming the package to org.apache.pekko and updating copyright headers to reflect the Apache Software Foundation license. The project now targets Java 17 and Scala 2.13.18 (with Scala 3.3.8 support), and upgrades key dependencies such as Jackson Databind to 2.22.2 and 3.2.2, Caffeine to 3.2.4, and Specs2 to 4.23.0. New sbt plugins and settings handle license file inclusion in META-INF, automatic module names, and enhanced Scaladoc generation with diagram validation.

project · high confidence

The migration compatibility filters for the HTTP CORS module have been updated to reflect API changes in version 2.0.x. Specifically, the filters now exclude checks for the new \concat\ method added to \HttpHeaderRange\ in both the Java and Scala DSLs, allowing seamless upgrades for users adopting this new capability. Additionally, the filters exclude checks for the removal of the deprecated \defaultSettings\ method from \CorsSettings\ in both DSLs, ensuring that existing code relying on this deprecated API continues to function without triggering binary compatibility errors during the transition.

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

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

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

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

The http-core module's Java DSL model classes (such as HttpEntity, HttpMessage, Authority, and DateTime) have been migrated from the Akka namespace to Apache Pekko. This change updates the package names to org.apache.pekko.http and aligns the Java API with the broader project rebranding, ensuring that Java users interact with the Pekko-branded types while maintaining the same functional interfaces.

http-core · high confidence

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

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

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

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

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

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

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

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

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

The server-side routing DSL now uses the \org.apache.pekko\ package namespace instead of the previous \akka\ namespace. This change introduces the foundational types for the Scala DSL, including the \Directive\ abstraction for route composition, the \Route\ type alias, and the \RequestContext\ for request handling. It also provides the \Directives\ trait for importing all default directives, \ExceptionHandler\ for error handling, and utility classes for tuple operations and route concatenation.

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

The HTTP client request building logic and transformer pipeline support have been migrated from the Akka namespace to Apache Pekko. This change updates the package structure to \org.apache.pekko.http.scaladsl.client\ and adapts the codebase to Scala 3 syntax, ensuring that existing client-side request construction and header transformation capabilities continue to function under the new project identity.

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

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

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.

http-marshallers-scala/http-spray-json · high confidence

This update configures the MiMa (Migration Manager) binary compatibility checks for the Pekko HTTP 2.0.x release by adding and refining exclusion filters. The changes accommodate breaking API changes in the Java DSL, specifically the switch of \Duration\ return types to Java \java.time.Duration\ and refactoring of the \ExceptionHandlerBuilder\. It also excludes internal implementation details (such as synthetic case-class members and static forwarders in \RoutingSettingsImpl\) that are not part of the public API surface. Furthermore, the filters account for the removal of various deprecated methods (including \HttpApp\, \Coder.encode\, and specific route directives) and adjust for bytecode differences in Scala 3 builds caused by the \-Yfuture-lazy-vals\ compiler flag.

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

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

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

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

Added HTTP/2 integration and unit test suites; Added HTTP/2 server manual test application; 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 Pekko HTTP engine benchmarks; 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; Java DSL documentation examples updated for Pekko and JUnit 5.

The build system has been migrated from Akka to Apache Pekko, renaming the root project to 'pekko-http' and updating all internal module dependencies (such as pekko-actor and pekko-stream) to use the new 'pekko' namespace. Additionally, the JUnit Jupiter test framework has been upgraded to version 6.1.3.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 64.

• Code Health 84
• Architecture 74
• Maturity 50
• Readiness 84
• Security 76

• 300 commits — 259 feature/other, 41 fixes

• http-core/src — 70 commits
• .github/workflows — 53 commits
• project/Dependencies.scala — 42 commits
• (root) — 25 commits
• docs/src — 22 commits
• project/plugins.sbt — 21 commits
• http/src — 16 commits
• project/build.properties — 16 commits
• http-tests/src — 14 commits
• http-testkit/src — 4 commits
• http2-tests/src — 4 commits
• http-cors/src — 3 commits
• project/PekkoCoreDependency.scala — 2 commits
• (repo) — 1 commit
• http-bench-jmh/src — 1 commit
• http-caching/src — 1 commit
• http-compatibility-tests/src — 1 commit
• http-marshallers-java/http-jackson — 1 commit
• http-scalafix/scalafix-rules — 1 commit
• project/Common.scala — 1 commit

• fix: DeflateDecompressor: fix inflater memory leak (#1137)
• fix: Fix byte string transformer cleanup on stage stop (#1154)
• fix: Fix integer/long overflow in content-length parsing, timestamp ordering, and HTTP/2 flow control (#1049)
• fix: GzipDecompressor: fix inflater memory leak (#1134)
• fix: build: fix sbt lint warnings by excluding unused keys (#1071)
• fix: fix broken Google link (#1006)
• fix: fix compiler warnings for implicit array to seq conversions (#1102)
• fix: fix: Scala 3.9 compatibility fixes (#1074)
• fix: fix: avoid unmoored doc comments (#1115)
• fix: fix: cancel open request timeouts when the server connection stage stops (#1284)
• fix: fix: cancel the pending slot state timeout when a pool slot is shut down (#1283)
• fix: fix: correct Content-Length rendering based on method+status (#962)
• fix: fix: count repeated Connection headers towards max-header-count (#1255)
• fix: fix: do not send a response body to HTTP/2 HEAD requests (#1239)
• fix: fix: drop HTTP/2 header fields containing CR, LF or NUL (#1258)
• fix: fix: drop removed UseBiasedLocking option from benchmark JVM args (#1227)
• fix: fix: drop rendered headers containing NUL as well as CR and LF (#1260)
• fix: fix: fail instead of throw when a transform on a completed FastFuture throws (#1305)
• fix: fix: fail requests still queued in a pool interface that stops (#1282)
• fix: fix: filter the ParserSettingsImpl accessors shifted by max-part-count (#1293)
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

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

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.