http4s/blaze

This system is the Blaze HTTP engine, a high-performance, asynchronous networking backend for the http4s framework that implements HTTP/1.1 and WebSocket protocols. It provides a configurable client and server architecture featuring connection pooling, strict RFC compliance, and support for SSL/TLS and mutual authentication. The codebase focuses on low-level pipeline management, efficient byte buffering, and robust error handling, while explicitly deprecating its unmaintained HTTP/2 implementation.

22 changes.

This period established the project's foundational infrastructure, including build configuration and development tooling, while introducing the core Blaze HTTP engine. Significant work focused on implementing the NIO1 and NIO2 channel layers, refactoring the pipeline API, and adding a robust HTTP client with connection pooling. The examples were modernized to demonstrate these new capabilities, including SSL authentication and streaming, while legacy Play-based implementations were removed.

15 changes.

This period focused on rewriting the HTTP/1.1 parser in Java for stricter validation and performance, while introducing a new WebSocket implementation with ping/pong support. The work also included refactoring connection handling and response writing utilities, adding comprehensive test coverage for these components, and deprecating the unmaintained HTTP/2 server support.

14 changes.

This period focused on a comprehensive refactoring of the Blaze HTTP client and server modules, introducing improved connection pooling, stricter HTTP/1.1 compliance, and better resource management. The work included adding Scala 2.11, 2.12, and 2.13 compatibility shims, migrating to MUnit for testing, and establishing reproducible build environments via Nix. Extensive test suites were added to verify client concurrency, server security, and utility correctness.

4 changes.

The Blaze HTTP client internals were refactored to leverage Scala 2.13's native parasitic execution context, improving performance for fire-and-forget tasks. Concurrently, comprehensive demo applications were added for both client and server sides, illustrating multipart uploads, streaming, authentication, and OAuth2 integration.

A new Nix package set (nix/pkgs.nix) is introduced that imports a pinned version of Nixpkgs from GitHub and configures the SBT build tool to use a specific Java runtime (passed as an argument). This allows users to build the project using a reproducible, pinned Nix environment with a customizable Java version.

nix · high confidence

The examples now include an SSL client authentication demonstration. A new EchoServer example utilizes a dedicated ExampleKeystore helper to configure an SSLContext that requires client certificates, allowing users to see how to enforce mutual TLS authentication in a Blaze server.

examples/src/main/scala/org/http4s/blaze · high confidence

Introduces a new \ConnectionMonitor\ abstract class and a \BasicConnectionMonitor\ implementation within the \org.http4s.blaze.pipeline.stages.monitors\ package. This allows users to track basic connection metrics, including the number of live connections, inbound bytes, and outbound bytes, by injecting a \ServerStatusStage\ into the socket pipeline builder.

core/src/main/scala/org/http4s/blaze/pipeline/stages/monitors · high confidence

This change introduces a new demo server application in the \examples/src/main/scala/com/example/http4s/blaze/demo/server\ directory. It provides a complete HTTP server implementation using http4s and the Blaze engine, exposing several endpoints: file directory listing and storage, hex-encoded name responses, simulated timeouts, and multipart file uploads. It also includes authentication features via Basic Auth and a GitHub OAuth2 integration flow. The server is wired together via a \Module\ that combines these services with middleware like GZip and AutoSlash, and is launched via \Server.scala\ on port 8080.

examples/src/main/scala/com/example/http4s/blaze/demo/server · high confidence

This change introduces two new utility components in the HTTP server module. The \HeaderLike\ trait provides a generic interface for packing and unpacking header representations, including an implicit implementation for tuple-based headers to simplify header creation and access. Additionally, the \NormalDisconnect\ object is added as a helper to identify and filter out expected disconnection errors, such as EOF and timeouts, allowing the server to handle these cases gracefully without treating them as unexpected failures.

http/src/main/scala/org/http4s/blaze/http/util · high confidence

New demo files have been added to the HTTP4s Blaze client examples: MultipartClient.scala demonstrates how to construct and send multipart form requests (including file uploads) using the Blaze client, while StreamClient.scala shows how to stream HTTP responses and process the body as a character stream. These examples provide reference implementations for common client-side patterns.

examples/src/main/scala/com/example/http4s/blaze/demo/client · high confidence

Added a new shell script (scripts/dowrklocal) and a Lua script (scripts/pipeline.lua) to facilitate local performance testing of the HTTP server. The pipeline script configures the wrk benchmarking tool to send pipelined requests to the /plaintext endpoint, allowing developers to easily measure server throughput and latency locally.

scripts · high confidence

The examples module now includes dedicated Logback configuration files (logback.xml and logback-test.xml) that enable console logging with a detailed timestamp, thread, and level pattern. The production configuration defaults to INFO level, while the test configuration allows the root log level to be overridden via the LOGBACK\_ROOT\_LEVEL environment variable, providing users with consistent and customizable logging output for the example applications.

examples/src/main/resources · high confidence

The repository is initialized with essential project infrastructure, including a Nix flake for development environment provisioning, a .mergify.yml file to automate pull request labeling by module, and comprehensive configuration for code formatting (scalafmt) and linting (scalafix). The project also includes a README describing the blaze HTTP server/client backends, a Code of Conduct, and an Apache 2.0 license file.

(repo-wide) · high confidence

This change adds a new NIO2 implementation for the Blaze channel layer, introducing \ByteBufferHead\ for handling asynchronous socket I/O and \ClientChannelFactory\ for establishing TCP connections. The new client factory supports configurable channel options, a connect timeout (defaulting to infinite), and a custom scheduler, while maintaining binary compatibility with older constructors. This provides an alternative asynchronous networking backend alongside the existing NIO1 implementation.

core/src/main/scala/org/http4s/blaze/channel/nio2 · high confidence

Added a new set of internal utility classes in the \org.http4s.blaze.util\ package to support the Blaze HTTP engine. This includes a lightweight, lock-free \Actor\ model for message passing, a \SerialExecutionContext\ for guaranteed sequential task execution, and a thread-local \trampoline\ execution context to reduce context-switching overhead. The update also introduces \BufferTools\ for efficient \ByteBuffer\ manipulation, \ReadPool\ for inbound data queuing, \BasicThreadFactory\ for thread management, and \GenericSSLContext\ for SSL configuration, alongside supporting types like \Cancelable\ and \ImmutableArray\.

core/src/main/scala/org/http4s/blaze/util · high confidence

This change adds several new components to the \org.http4s.blaze.pipeline.stages\ package to support pipeline construction and management. It introduces \BasicTail\ as a concrete implementation of \TailStage\, \OneMessageStage\ for handling single-element ejection from the pipeline, and \ByteToObjectStage\ as a trait for decoding byte buffers into objects with buffer overflow protection. Additionally, it adds \TimeoutStageBase\ to provide the core logic for timeout-based pipeline shutdowns using a \TickWheelExecutor\, and \QuietTimeoutStage\ which extends this base to reset the timeout on every read or write operation, effectively shutting down the pipeline after a period of inactivity.

core/src/main/scala/org/http4s/blaze/pipeline/stages · high confidence

This change introduces the foundational types for the HTTP model within the \org.http4s.blaze.http\ package. It adds \BodyReader\ to handle asynchronous message body streaming and accumulation, \ALPNTokens\ to define known HTTP protocol strings (HTTP/1.1, h2, h2-14), and \HeaderNames\ to provide standard header constants along with validation logic for HTTP/2 header keys. Additionally, it defines basic type aliases for \Headers\, \Url\, and \Method\ in the package object, and includes a configuration flag \logsensitiveinfo\ to control the logging of sensitive request data.

http/src/main/scala/org/http4s/blaze/http · high confidence

Added a suite of example applications in the com.example.http4s.blaze package demonstrating the Blaze HTTP server and client. These include basic HTTP server setup, SSL/TLS configuration with optional HTTP-to-HTTPS redirection, WebSocket communication (including echo and ping/pong patterns), and various client-side operations such as GET requests, JSON decoding, multipart POST uploads, and standard form POSTs.

examples/src/main/scala/com/example/http4s/blaze · high confidence

The blaze-client module introduces a new HTTP client implementation featuring a \PoolManager\ for connection pooling, \Http1Connection\ for handling HTTP/1.1 requests, and an \IdleTimeoutStage\ to manage connection lifecycles. This change adds support for configuring execution contexts, channel options, and connection monitoring, replacing the previous client architecture with a more robust, stateful connection management system.

repository · high confidence

The examples module now includes a comprehensive ExampleService demonstrating key http4s features, including HTTP Basic Authentication, streaming responses, multipart form handling, and static file serving. The service also provides SSL/TLS configuration examples and demonstrates proper handling of HTTP methods like HEAD, along with content negotiation and error handling patterns.

examples/src/main/scala/com/example/http4s · high confidence

The standalone example applications for the Grizzly and Netty server integrations have been removed from the codebase. Users can no longer run the \SimpleGrizzlyServer\ or \SimpleNettyServer\ entry points provided in these specific example modules, as the \Example.scala\ files for both \org.http4s.examples.grizzly\ and \org.http4s.examples.netty\ have been deleted.

examples/src/main/scala/org/http4s/examples/grizzly · high confidence

The \ExampleRoute.scala\ file, which contained a collection of example HTTP routes (such as ping, echo, stream, and challenge endpoints) built on the older Play Iteratee-based API, has been removed from the examples directory. This deletion reflects a broader refactoring of the http4s examples to migrate away from the deprecated \play.api.libs.iteratee\ dependencies and the \HttpChunk\/\Raw\ body model towards a newer, cleaner API structure.

examples/src/main/scala/org/http4s/examples · high confidence

The standalone example application demonstrating how to run http4s within a Jetty servlet container has been removed. Users relying on this specific file for a reference implementation of embedding http4s in a traditional Java servlet environment will no longer find this code in the examples directory.

examples/src/main/scala/org/http4s/examples/servlet · high confidence

A change to existing behaviour in examples/src/main/resources/clientauth — 1 commit, 5 files.

examples/src/main/resources/clientauth · medium confidence · unverified

Users running http4s on Scala 2.13 can now utilize the blaze HTTP client without compilation errors. A new compatibility object in the blaze internal package provides a bridge to \scala.jdk.CollectionConverters\, ensuring that internal code relying on Java collection interoperability works correctly on the newer Scala version.

core/src/main/scala-2.13 · high confidence

A new compatibility object has been added to the core Blaze HTTP client module to provide a unified access point for Java collection conversions. This shim, located in the internal package, exposes the \scala.collection.JavaConverters\ object, ensuring that code relying on these conversions behaves consistently across Scala 2.11 and 2.12 versions.

core/src/main/scala-2.11-2.12 · high confidence

The Blaze channel layer now sets the default maximum number of active connections to 512 and configures the default thread pool size based on the number of available CPU cores (minimum 4). Additionally, connection error handling has been refined to explicitly recognize and normalize specific 'broken pipe' and 'connection reset' messages from various operating systems and Java versions as standard EOF conditions, ensuring more consistent disconnect behavior for users.

core/src/main/scala/org/http4s/blaze/channel · high confidence

The Blaze HTTP client implementation has been restructured to improve connection management and resource handling. A new \ConnectionManager\ abstraction (including \BasicManager\ and \PoolManager\) now handles connection lifecycle, replacing previous inline pooling logic. Users can now configure \maxIdleDuration\ via \BlazeClientBuilder\ to mitigate stale connections that may be closed while idling in the pool. The client also introduces a \BlazeClientState\ trait for monitoring pool metrics such as allocated connections and queue depths. Additionally, the builder has been updated to deprecate the \executionContext\ parameter in favor of \executionContextConfig\, and the retry logic for \SocketException\ is now explicitly configurable via a \retries\ parameter.

blaze-client/src/main/scala/org/http4s/blaze · high confidence

The Blaze server implementation has been restructured into a new package (org.http4s.blaze.server) and refactored to improve HTTP/1.1 RFC 9112 compliance and security. The HTTP parser now strictly rejects malformed requests, including those with both Transfer-Encoding and Content-Length headers, duplicate Content-Length headers, and obsolete line folding (obs-fold). WebSocket message sizes are now capped by default (4 MiB) to prevent resource exhaustion, with the limit configurable via BlazeServerBuilder. Additionally, the HTTP/2 implementation is deprecated, and the server builder API has been simplified by removing the deprecated withSSL/withSSLContext methods in favor of withSslContext and consolidating execution context configuration.

blaze-server/src/main/scala/org/http4s/blaze · high confidence

The HTTP/2 server components, specifically the ALPN negotiation handler (ALPNServerSelector) and the prior-knowledge handshaker (ServerPriorKnowledgeHandshaker), are now deprecated and will be removed in a future version. Users relying on the built-in HTTP/2 server support should be aware that this functionality is unmaintained.

http/src/main/scala/org/http4s/blaze/http/http2/server · high confidence

The \BlazeClientBuilder\ type alias and companion object in the \org.http4s.client.blaze\ package are now deprecated as of version 0.22. Users should migrate to \org.http4s.blaze.client.BlazeClientBuilder\ to ensure compatibility with future releases.

blaze-client/src/main/scala/org/http4s/client · high confidence

The \org.http4s.server.blaze\ package now includes deprecated type and value aliases for \BlazeServerBuilder\ that point to the new \org.http4s.blaze.server.BlazeServerBuilder\. These aliases are marked for removal in version 0.22, signaling to users that they should migrate their imports and usage to the new package location.

blaze-server/src/main/scala/org/http4s/server · high confidence

The HTTP/2 implementation in the \blaze\ module is now deprecated and will be removed in a future version (0.23.18). All core components in this area—including \ConnectionImpl\, \FrameDecoder\, \FrameEncoder\, \PriorKnowledgeHandshaker\, and related stream and header handling classes—have been annotated with a deprecation notice indicating that HTTP/2 support is unmaintained.

http/src/main/scala/org/http4s/blaze/http/http2 · high confidence

The HTTP/1.1 parser has been rewritten in Java (replacing the previous Scala implementation) within the \org.http4s.blaze.http.parser\ package. This change introduces a new set of parser classes (\Http1ServerParser\, \Http1ClientParser\, \BodyAndHeaderParser\) that handle request and response line parsing, header validation, and chunked transfer encoding. The new parser enforces stricter validation, such as requiring valid tchar characters in header names and ensuring header values are present, and includes a fix for a chunked transfer-encoding bug. Users will experience a native Java parsing layer with updated error handling via \BaseExceptions\.

http/src/main/java · high confidence

The Blaze WebSocket stage has been replaced with a new implementation that introduces a dedicated \Http4sWSStage\ to handle the WebSocket lifecycle. This change adds support for receiving Ping messages from clients (and automatically replying with Pongs) and allows applications to handle Pong messages, which were previously ignored. It also enforces a cap on aggregate WebSocket message sizes, closing the connection with a 1009 status code if the limit is exceeded, and improves protocol compliance by properly handling reserved and unknown opcodes.

blaze-core/src/main/scala/org/http4s/blazecore/websocket · high confidence

The pipeline construction API has been refactored to use explicit builder types. Users now build pipelines using \LeafBuilder\ (starting from a Tail) and \TrunkBuilder\ (starting from a MidStage), which provide methods like \prepend\, \append\, \base\, and \cap\ to assemble stages. This replaces the previous implicit or less structured stage linking mechanism, enforcing that stages are fresh (not already part of a pipeline) when added and providing clearer separation between head, mid, and tail stages.

core/src/main/scala/org/http4s/blaze/pipeline · high confidence

The Blaze HTTP/1.1 implementation now strictly follows RFC 9112 for connection persistence, updating the logic in Http1Stage to correctly interpret Connection headers and manage keep-alive behavior. A new ResponseHeaderTimeoutStage has been introduced to enforce timeouts on incoming response headers, configurable via the builder. Additionally, the BlazeBackendBuilder trait now exposes methods to configure standard socket options (such as SO\_KEEPALIVE, TCP\_NODELAY, and buffer sizes) directly through the builder API.

blaze-core/src/main/scala/org/http4s/blazecore · high confidence

The internal compatibility layer for obtaining a parasitic execution context has been renamed from XCompat to ParasiticExecutionContextCompat. This change updates the implementation in the Scala 2.12 and Scala 3 specific source directories to use the new trait name, ensuring consistent internal naming for the utility that provides a trampolined or parasitic execution context depending on the Scala version.

blaze-core/src/main/scala-2.12, blaze-core/src/main/scala-3 · high confidence

The \blaze-core/src/main/scala/org/http4s/blazecore/util\ package has been restructured to improve the handling of HTTP response bodies. New writer implementations have been introduced, including \BodylessWriter\ for discarding entity bodies, \CachingChunkWriter\ for buffering and optimizing chunked responses, \FlushingChunkWriter\ for immediate flushing, and \IdentityWriter\ for strict content-length enforcement. The \Http1Writer\ trait now coordinates header and body writing with better error handling via \guaranteeCase\, while \Http2Writer\ has been deprecated as HTTP/2 support is unmaintained. Utility objects like \ChunkWriter\ and \EntityBodyWriter\ provide shared logic for encoding chunks and managing stream compilation, and a new \fromFutureNoShift\ helper optimizes internal future handling by avoiding unnecessary execution context shifts.

blaze-core/src/main/scala/org/http4s/blazecore/util · high confidence

The NIO1 networking layer has been restructured to separate acceptor and worker responsibilities into distinct thread pools. A new \FixedSelectorPool\ manages round-robin distribution of \SelectorLoop\ instances, while \NIO1SocketServerGroup\ now accepts these pools to configure server behavior. This change introduces a dedicated acceptor pool (defaulting to a single thread) for handling incoming connections and a configurable worker pool for processing I/O events, improving resource isolation and allowing users to tune thread counts and buffer sizes independently.

core/src/main/scala/org/http4s/blaze/channel/nio1 · high confidence

The Blaze HTTP client now utilizes Scala 2.13's native \ExecutionContext.parasitic\ for internal execution contexts. This change, implemented via a new compatibility trait in the Scala 2.13-specific source directory, replaces previous workarounds to leverage the standard library's optimized, non-forking execution context, improving performance and reducing overhead for fire-and-forget tasks.

blaze-core/src/main/scala-2.13 · high confidence

1 commit adding/updating tests in blaze-server/src/test/resources; Added HTTP/2 mock utilities for testing; Added MUnit-based test suites for blaze-core utilities; Added MUnit-based tests for blaze channel options and lifecycle; Added Scala 2.13-specific Blaze client test suite; Added comprehensive test suite for HTTP/2 implementation; Added comprehensive test suites for the Blaze HTTP client; Added test for ClientChannelFactory timeout behavior; Added test infrastructure and utilities for Blaze core; Added test suite for blaze pipeline stages; Added test suites and benchmarks for HTTP parsers; Added test suites for BodyReader and HeaderNames validation; Added test utilities and specs for HTTP/1 writer implementations; Added tests for Blaze server mTLS support and HTTP/1.1 connection handling; Added unit tests for WebSocket handshake and stage behavior; New BlazeTestSuite base class for HTTP4s Blaze tests.

The project now defines its build structure using a modernized sbt setup (version 1.13.0). This includes a centralized dependency management file specifying core libraries such as async-http-client 3.0.13, logback-classic 1.2.13, and the MUnit testing framework (1.0.0-M6). The build also integrates several sbt plugins, including sbt-buildinfo for generating build metadata, sbt-java-formatter for code style enforcement, sbt-revolver for hot-reload development, and sbt-http4s-org for project organization.

project · high confidence

The build configuration has been updated to use Scala 2.12.21, 2.13.18, and 3.3.8, with 2.13 set as the default version. Key library dependencies have been bumped, including http4s to 0.23.37, circe-generic to 0.14.16, and munit-cats-effect to 2.2.0. The project now targets Java 8 exclusively and adopts the sbt-http4s-org plugin for standardized build settings.

(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 48.

• Code Health 92
• Architecture 79
• Maturity 55
• Readiness 37
• Security 50

• 300 commits — 295 feature/other, 5 fixes

• (repo) — 137 commits
• (root) — 51 commits
• project/build.properties — 37 commits
• project/plugins.sbt — 25 commits
• project/Dependencies.scala — 15 commits
• .github/workflows — 14 commits
• blaze-server/src — 10 commits
• http/src — 6 commits
• blaze-core/src — 4 commits
• blaze-client/src — 1 commit

• fix: Fix Connection persistence according to RFC 9112
• fix: Fix MiMa issues
• fix: Fix Scalafix
• fix: Fix compilation for Scala 2.13.13
• fix: Fix tests to reflect tightened parsers
• change: Address the fs2.io.net.Network API changes
• change: CachingStaticWriter must write the status line and headers before the body
• change: Deprecate HTTP/2 implementation
• change: Merge branch 'series/0.23' into update/series/0.23/scala-library-2.12.20
• change: Merge branch 'series/0.23' into update/series/0.23/scala-library-2.13.12
• change: Merge branch 'series/0.23' into update/series/0.23/scala-library-2.13.13
• change: Merge branch 'series/0.23' into update/series/0.23/scala-library-2.13.13
• change: Merge branch 'series/0.23' into update/series/0.23/scala3-library-3.3.1
• change: Merge pull request #1001 from http4s/update/series/0.23/scala-library-2.12.21
• change: Merge pull request #1003 from http4s/update/series/0.23/async-http-client-3.0.5
• change: Merge pull request #1007 from http4s/update/series/0.23/async-http-client-3.0.6
• change: Merge pull request #1008 from http4s/update/series/0.23/sbt-1.12.0
• change: Merge pull request #1011 from http4s/update/series/0.23/sbt-1.12.1
• change: Merge pull request #1013 from http4s/update/series/0.23/async-http-client-3.0.7
• change: Merge pull request #1015 from http4s/update/series/0.23/sbt-http4s-org-2.0.5
• …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.

http4s/blaze 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.