softwaremill/sttp

This system is the sttp client4 library, a comprehensive HTTP client for Scala that provides a unified API across multiple platforms including JVM, Scala.js, and Scala Native. It supports a wide variety of underlying HTTP engines and effect systems, such as Cats Effect, ZIO, Monix, Fs2, and Pekko, enabling both synchronous and asynchronous request handling. The library offers extensive capabilities for streaming data, WebSocket communication, Server-Sent Events, and request body compression, while also integrating with major JSON libraries and observability tools like OpenTelemetry.

105 changes.

This period covers the major release of sttp client 4.0, involving a complete rewrite of the core API, removal of legacy backends, and the introduction of a modular backend architecture. It features extensive expansion of supported effect systems (ZIO, Cats, Monix, Scalaz) and HTTP libraries (Armeria, OkHttp, Pekko, Finagle, http4s), alongside new platform support for Scala Native and Scala.js.

28 changes.

This period focused on extending the sttp client to support Scala Native across multiple effect systems, including ZIO, Cats, and Ox, while introducing new backends for http4s and curl. Significant work was also done to enhance observability through comprehensive OpenTelemetry tracing and metrics integration, alongside robust support for request compression, caching, and streaming.

A new synchronous-style backend implementation using Scala \Future\ has been added to the Armeria integration. This allows users to make HTTP requests using the Armeria client library with a standard Future-based API, distinct from reactive or ZIO backends. The implementation includes support for following redirects and manages its own connection pool by default, while explicitly not supporting streaming responses.

armeria-backend/src/main/scala/sttp/client4/armeria/future · high confidence

A new Armeria backend implementation for the Scalaz Task effect type is now available, allowing users to make HTTP requests using Scalaz's asynchronous capabilities. This backend integrates with the existing Armeria infrastructure but explicitly does not support streaming, input stream responses, or certain advanced features like host header overrides and cancellation, as indicated by the test configuration.

armeria-backend/scalaz · high confidence

Introduces a new HTTP client backend implementation for ZIO 1, allowing users to make asynchronous HTTP requests using the Armeria library within ZIO effects. The change adds \ArmeriaZioBackend\ which provides factory methods (such as \apply\, \managed\, and \layer\) to create backends with automatic resource management and connection pool handling, and exposes ZIO-specific types like \SttpClient\ and \SttpClientStubbing\ for service definition and testing.

armeria-backend/zio1/src/main · high confidence

New Armeria HTTP backends are now available for both Cats Effect 2 and Cats Effect 3, allowing users to integrate Armeria with their preferred Cats Effect version. The Cats Effect 3 backend (\cats-ce2\ module) uses \Concurrent\ and provides resource-managed creation via \Resource\, while the Cats Effect 2 backend (\cats\ module) uses \Async\. Both implementations wrap the Armeria \WebClient\ and support standard backend options, though they explicitly do not support streaming, host header overrides, cancellation, or auto-decompression disabling.

armeria-backend/cats, armeria-backend/cats-ce2 · high confidence

New backend implementations are available for the Armeria HTTP client, supporting both fs2-ce2 (Cats Effect 2) and Monix streaming libraries. These additions provide \StreamBackend\ instances that integrate Armeria's \WebClient\ with fs2 \Stream\ and Monix \Observable\ types, enabling efficient streaming request and response handling. The backends include factory methods for creating instances with default or custom clients, as well as resource-safe constructors that ensure the underlying Armeria client factory is properly closed when the backend is released.

armeria-backend/fs2-ce2/src/main, armeria-backend/monix/src/main · high confidence

A new \FetchCatsBackend\ implementation is now available for Scala.js, allowing users to utilize the Fetch API with Cats Effect's \Async\ type class. This backend supports standard request customization and options, but explicitly does not support streaming responses or WebSocket pipes, throwing an \IllegalStateException\ if those features are attempted. It also includes a stub backend for testing purposes.

effects/cats/src/main/scalajs · high confidence

A new FetchFs2Backend implementation is introduced for Scala.js, enabling HTTP clients to use the browser's native Fetch API while supporting fs2 streams for both request bodies and response bodies. This change allows users to leverage the Fetch API's capabilities within the sttp client4 library on JavaScript platforms, providing a native alternative to existing backends and supporting WebSocket streaming through the fs2 integration.

effects/fs2/src/main/scalajs · high confidence

Introduces a new Finagle-based backend implementation for the sttp HTTP client library, enabling users to make asynchronous requests using the Finagle framework. This change adds the \FinagleBackend\ class which handles request body compression (GZip and Deflate), supports various body types (file, string, byte array, input stream, multipart), and integrates with sttp's response handling and callback mechanisms.

finagle-backend/src/main · high confidence

The \fs2-ce2\ module now includes implementations for handling WebSocket connections via Fs2 pipes (including proper close-frame handling and text frame reassembly), parsing Server-Sent Events from byte streams, and decompressing GZip and Deflate response bodies using Fs2's compression utilities. These changes enable users to leverage Fs2 streams for real-time communication protocols and compressed data handling within the sttp client.

effects/fs2-ce2/src/main/scala · high confidence

Users can now use the Armeria HTTP client with Fs2 streams, enabling efficient streaming of request and response bodies via the new \ArmeriaFs2Backend\. This backend integrates with the \Fs2Streams\ capability and includes built-in support for GZip and Deflate compression, allowing for compressed data transfer out of the box.

armeria-backend/fs2/src/main · high confidence

The Fs2 integration module now includes new implementations for handling HTTP body compression and decompression (GZip and Deflate) using Fs2 streams, enabling efficient streaming of compressed request and response bodies. It also adds support for parsing Server-Sent Events (SSE) from byte streams and provides a robust mechanism for handling WebSocket connections through Fs2 pipes, including proper handling of close frames, ping/pong, and text frame reassembly. These changes enhance the library's capability to work with streaming protocols and compressed data within the Fs2 ecosystem.

effects/fs2/src/main/scala · high confidence

The json4s module now provides a new \SttpJson4sApi\ trait and package object under the \sttp.client4.json4s\ namespace, enabling users to serialize request bodies and deserialize JSON responses using the JSON4s library. This includes methods for standard JSON handling (\asJson\, \asJsonOrFail\), always-attempting deserialization (\asJsonAlways\), and status-code-aware deserialization with separate error types for success and failure payloads (\asJsonEither\, \asJsonEitherOrFail\), all leveraging JSON4s \Formats\ and \Serialization\ instances.

json/json4s/src/main · high confidence

This change introduces the Monix implementation for the client4 package, adding support for streaming protocols. Users can now use Monix \Observable\ streams with WebSockets via \MonixWebSockets.compilePipe\, which handles frame piping, buffering, and close-frame logic, and with Server-Sent Events via \MonixServerSentEvents.parse\, which handles UTF-8 incomplete byte detection and event parsing. The implementation also includes \MonixSimpleQueue\ for WebSocket buffering and \TaskMonadAsyncError\ to integrate Monix \Task\ with the client's monad transformer stack.

effects/monix/src/main/scala · high confidence

A new example file, WebSocketMonix.scala, has been added to demonstrate how to connect to and interact with a WebSocket using the Monix effect type and the HttpClientMonixBackend. This example shows sending text messages and receiving responses in a synchronous execution context using scala-cli.

examples-ce2/src/main/scala · high confidence

Users can now parse Server-Sent Events (SSE) streams using the Ox effect system. A new \OxServerSentEvents\ object provides a \parse\ method that converts an input stream into a flow of \ServerSentEvent\ objects, enabling SSE integration within Ox-based applications.

effects/ox/src/main · high confidence

Introduces a new HTTP backend for sttp client4 built on Apache Pekko HTTP, replacing the previous Akka HTTP dependency. This implementation provides support for streaming request and response bodies via Pekko Streams, automatic compression and decompression (GZip/Deflate), WebSocket communication, and Server-Sent Events (SSE). It includes specific handling for connection timeouts, proxy authentication, and response body length limits, enabling users to leverage the Pekko ecosystem for high-performance HTTP interactions.

pekko-http-backend/src/main · high confidence

New example files demonstrate how to receive and parse JSON using the Pekko HTTP backend with json4s, and how to perform synchronous JSON requests using the standard HttpClient backend with jsoniter. These additions provide concrete usage patterns for these specific backend and serialization library combinations.

examples/src/main/scala/sttp/client4/examples/json · high confidence

Users can now enable structured logging for HTTP requests and responses using the SLF4J library. This change introduces the Slf4jLogger implementation and the Slf4jLoggingBackend factory, which wraps existing backends (Sync, Async, WebSocket, and Stream) to log activity via SLF4J, including support for MDC context mapping for traceability.

logging/slf4j · high confidence

The Scalaz integration for sttp client4 now includes support for the Scalaz \Task\ effect type. This change introduces a \MonadAsyncError\ implementation for \Task\, enabling asynchronous HTTP requests, and provides implicit conversions to allow mapping between backend effect types using \mapK\. A test helper is also added to convert Scalaz \Task\ instances to Scala \Future\ for testing purposes.

effects/scalaz · high confidence

Users can now use the Tethys library for JSON handling in sttp client requests and responses. This new module provides \asJson\, \asJsonOrFail\, and \asJsonEitherOrFail\ methods to serialize request bodies and deserialize response bodies using Tethys readers and writers. It also includes tests for backend stubs and general JSON encoding/decoding behavior, ensuring compatibility with Tethys Jackson backend.

json/tethys-json · high confidence

The zio-json and zio1-json modules now provide an \asJsonStream\ method within the \SttpZioJsonApiExtensions\ trait, allowing users to decode HTTP responses as a stream of JSON objects using ZIO effects. This feature is available for both ZIO 2 (using \Task\ and \ZPipeline\) and ZIO 1 (using \RIO\[Blocking, \*\]\ and \ZTransducer\), enabling efficient processing of large JSON payloads without loading the entire response into memory.

json/zio-json/src/main, json/zio1-json/src/main · high confidence

Users can now use the Curl HTTP client with ZIO effects on Scala Native. A new \CurlZioBackend\ class and companion object have been added, providing factory methods (\apply\, \layer\, \scoped\) to create a ZIO-based backend that extends the existing abstract sync curl backend.

effects/zio/src/main/scalanative · high confidence

A new Armeria-based backend for ZIO is introduced, providing streaming capabilities via ZIO Streams and enabling automatic compression of request bodies using GZip and Deflate. The implementation includes factory methods for creating backends with default or custom clients, scoped resource management to ensure proper cleanup, and ZIO layers for dependency injection, allowing users to integrate Armeria's HTTP client into ZIO applications with built-in compression support.

armeria-backend/zio/src/main · high confidence

The ZIO backend now supports automatic compression of request bodies using GZip and Deflate via new \GZipZioCompressor\ and \DeflateZioCompressor\ implementations, and handles decompression of responses with corresponding \GZipZioDecompressor\ and \DeflateZioDecompressor\ objects. Additionally, a new \zio\ package object provides \extendEnv\ methods for backend types, allowing users to expand the ZIO environment requirements of existing backends without wrapping them in additional layers.

effects/zio/src/main/scalajvm/sttp/client4/impl · high confidence

A new tracing backend based on the otel4s library is now available, allowing users to integrate sttp client requests with OpenTelemetry. This backend automatically injects tracing headers into outgoing requests and records spans with standard HTTP attributes (such as method, status code, server address, and URL) while redacting sensitive user information from URIs. It supports standard, WebSocket, and streaming backends and includes comprehensive tests to verify correct span creation and attribute recording.

observability/otel4s-tracing-backend · high confidence

This change introduces the extension traits for compressor and decompressor functionality in the sttp client library for both Scala.js and Scala Native platforms. These new files define the default empty lists for compressors and decompressors, serving as the foundational hooks for enabling request body compression and response decompression capabilities in the client.

core/src/main/scalajs/sttp/client4/compression, core/src/main/scalanative/sttp/client4/compression · high confidence

The client now supports compressing outgoing request bodies using GZIP and Deflate algorithms. This change introduces new compressor implementations (GZipDefaultCompressor and DeflateDefaultCompressor) that handle various body types including strings, byte arrays, byte buffers, and input streams. For input streams and file bodies, a custom GZIPCompressingInputStream is used to perform on-the-fly compression. The decompression side also receives updates with default decompressors for GZIP and Deflate, including a safe GZIP input stream wrapper to handle edge cases like empty streams gracefully.

core/src/main/scalajvm/sttp/client4/compression · high confidence

New example files have been added to demonstrate how to stream request and response bodies using the Fs2, ZIO, and Ox effect systems. The StreamFs2.scala file shows how to use fs2 streams with the cats-effect backend, StreamZio.scala demonstrates ZIO-Streams integration, and streamOx.scala illustrates synchronous, blocking stream handling using Ox's Flow API.

examples/src/main/scala/sttp/client4/examples/streaming · high confidence

New example files have been added to demonstrate synchronous HTTP operations using the sttp client4 library with Scala 3. These examples cover posting form data, uploading files, posting multipart forms, and constructing dynamic URIs, all runnable via scala-cli.

examples/src/main/scala/sttp/client4/examples · high confidence

The library now provides a new upickle integration for the sttp client4 package, allowing users to serialize request bodies and deserialize response bodies using the upickle library. This change introduces the \SttpUpickleApi\ trait and a \default\ companion object, enabling methods like \asJson\, \asJsonOrFail\, and \asJsonEither\ for flexible JSON handling with upickle's readers and writers.

json/upickle/src/main · high confidence

A new FetchBackend implementation is now available for Scala.js projects that use Future as their effect type. This backend wraps the browser's native Fetch API and supports standard request customization and options, but explicitly does not support streaming responses or WebSocket piping, throwing an IllegalStateException if those features are attempted. A stub backend for testing is also provided.

core/src/main/scalajs/sttp/client4/fetch · high confidence

A new example file demonstrates how to integrate sttp client4 with OpenTelemetry for distributed tracing and metrics collection. The example shows wrapping the HTTP client backend with OpenTelemetryTracingBackend and OpenTelemetryMetricsBackend, using the auto-configured OpenTelemetry SDK, and sending a request to httpbin.org while waiting for metrics to be exported.

examples/src/main/scala/sttp/client4/examples/observability · high confidence

Users can now integrate the Scribe logging library with sttp client backends. A new ScribeLoggingBackend companion object provides factory methods to wrap existing SyncBackend, Backend, WebSocketBackend, StreamBackend, and WebSocketStreamBackend instances with Scribe-based logging, supporting both default and custom LogConfig configurations.

logging/scribe · high confidence

New example files have been added to demonstrate request resilience patterns, specifically rate limiting and retry logic, using the Ox and ZIO effect systems. The RateLimitOx and RetryOx examples show how to integrate sttp with Ox's built-in rate limiting and retry mechanisms, while RetryZio illustrates retry strategies using ZIO's scheduling capabilities.

examples/src/main/scala/sttp/client4/examples/resilience · high confidence

The Akka HTTP backend implementation has been updated to include request body compression support, allowing clients to compress outgoing payloads using GZip or Deflate. Additionally, a new option has been added to limit the maximum response body length, helping to prevent excessive memory consumption when handling large responses. These changes are implemented through new compressor and decompressor components integrated into the backend's request and response handling pipeline.

akka-http-backend/src/main · high confidence

A new CurlCatsBackend implementation is now available for Scala Native, allowing users to create HTTP backends using the cats-effect Sync type class. This enables asynchronous HTTP requests via curl within Scala Native applications, with optional verbose logging for request and response summaries.

effects/cats/src/main/scalanative · high confidence

The generated documentation for sttp client version 4.0 is now available, covering the new \sttp.client4\ package structure. This release introduces a simplified type system with \PartialRequest\ and \GenericRequest\ replacing \RequestT\, and specialized backend traits like \SyncBackend\ and \StreamBackend\. Key behavioral changes include the removal of implicit \BodySerializer\ (requiring explicit \asJson\ calls), the introduction of \...OrFailed\ response handling methods, and the renaming of \HttpError\ to \UnexpectedStatusCode\. The documentation also details the migration path from version 3, noting the removal of \async-http-client\ backends and the addition of Pekko support.

generated-docs/out · high confidence

This change adds a new backend implementation for sttp client4 using the Armeria library, replacing the previous client3 package structure. The new backend supports request body compression, limits on response length, and authenticated proxies. It also introduces support for the QUERY HTTP method (RFC 10008) and allows input streams as response bodies. The implementation includes proper resource management with cancellation support and integrates with sttp's logging and metrics via onBodyReceived callbacks.

armeria-backend/src/main/scala/sttp/client4/armeria · high confidence

This change adds new backend implementations for the sttp HTTP client that integrate with Cats Effect and fs2 (Cats Effect 2). For Cats Effect, it provides \HttpClientCatsBackend\ along with supporting components like \CatsSequencer\ and \CatsSimpleQueue\ to manage concurrency and WebSocket buffering. For fs2, it introduces \HttpClientFs2Backend\ which enables streaming request and response bodies via \Stream\[F, Byte\]\, handles multipart streaming, and includes \Fs2Sequencer\ and \Fs2BodyFromHttpClient\ to manage execution order and body processing. These backends allow users to use sttp within Cats Effect and fs2 applications with proper resource management and streaming support.

effects/cats/src/main/scalajvm, effects/fs2-ce2/src/main/scalajvm · high confidence

The Circe module now provides a dedicated API trait (\SttpCirceApi\) that enables serializing request bodies to JSON and deserializing response bodies from JSON using the Circe library. Users can leverage methods like \asJson\ for standard successful-response deserialization, \asJsonOrFail\ for strict error-throwing behavior, and \asJsonEither\ to handle both successful payloads and error responses with distinct type decoders, simplifying JSON interaction within the HTTP client.

json/circe/src/main · high confidence

The jsoniter module now provides a dedicated API trait (SttpJsoniterJsonApi) that exposes methods for serializing request bodies and deserializing response bodies using the jsoniter-scala library. This includes utilities for handling JSON in successful responses, failing on errors, and parsing different JSON structures for success versus error status codes, making it easier for users to integrate jsoniter into their HTTP client workflows.

json/jsoniter/src/main · high confidence

Adds the internal implementation for the Scala Native curl-based HTTP backend, including low-level libcurl bindings, API wrappers, and option/info enumerations. This enables users to make HTTP requests using the native curl library on Scala Native platforms.

core/src/main/scalanative/sttp/client4/curl/internal · high confidence

This change adds a new \HttpClientFs2Backend\ implementation for the JVM, enabling users to interact with the HTTP client using fs2 Streams instead of blocking calls. The new backend supports streaming request and response bodies, WebSocket communication via streams, and body compression (GZip/Deflate). It also includes resource-safe construction methods (\resource\, \resourceUsingClient\) and handles multipart streaming, providing a non-blocking, functional-streaming alternative to the existing backend.

effects/fs2/src/main/scalajvm, effects/monix/src/main/scalajvm · high confidence

The http4s backend module now includes a new implementation that supports both JVM and Scala Native platforms. On the JVM, the backend can be initialized using either the Blaze or Ember HTTP clients, while on Scala Native it relies exclusively on the Ember client. A key behavioral improvement is the propagation of cancellation: if a caller cancels a request, the underlying HTTP request fiber is now properly cancelled, preventing resource leaks. This change also introduces the necessary test coverage for these new capabilities across both platforms.

http4s-backend · high confidence

A new \Http4sBackend\ implementation for the \client4\ package has been added, providing support for request body compression, configurable response length limits, and an \onBodyReceived\ callback for logging and metrics. This backend integrates with the http4s CE2 runtime and fs2 streams, handling various body types including streams, multipart forms, and file uploads.

http4s-ce2-backend/src/main · high confidence

The caching module now provides a \CachingBackend\ that wraps an existing HTTP backend to cache responses. It introduces a generic \Cache\[F\]\ trait, allowing users to plug in custom storage implementations (e.g., in-memory, disk, or distributed caches) via dependency injection. The backend automatically caches eligible responses based on configuration (such as cache-control headers) and supports various response types, including JSON deserialization, while correctly handling cache keys that include \Vary\ headers.

caching · high confidence

This change adds a new integration module for spray-json within the sttp client4 package, providing a complete API for serializing request bodies and deserializing response bodies. Users can now use methods like \asJson\, \asJsonOrFail\, and \asJsonEither\ to handle JSON payloads with built-in support for \Option\ and \Either\ types, ensuring that empty responses are correctly mapped to \None\ rather than causing deserialization errors. The module also includes specific response specification helpers (e.g., \showAsJson\) to clarify error messages when JSON parsing fails.

json/spray-json · high confidence

The core HTTP client now supports synchronous WebSocket interactions via the new \SyncWebSocket\ class and the \sttp.client4.ws.sync\ API, allowing users to open and manage WebSocket connections without asynchronous effect types. Additionally, the library introduces a \RetryWhen\ predicate to control request retries based on connection errors, server errors, idempotency, and body retryability, and updates \quickRequest\ to always return the response body as a string regardless of the HTTP status code, simplifying error handling for common use cases.

core/src/main/scala/sttp/client4 · high confidence

This change introduces the foundational types for the client4 library, including the core request and response models (Request, Response, ResponseAs, ResponseException) and a new LoggingBackend for structured request/response logging. It also adds configuration options for backend settings (BackendOptions), request behavior (RequestOptions), and logging details (LogConfig, LoggingOptions), along with internal utilities for digest authentication and WebSocket events.

repository · high confidence

This change introduces the Cats Effect 2 integration for the sttp client4 library. It adds new source files implementing the core monad error handling (\CatsMonadError\, \CatsMonadAsyncError\) and implicit conversions (\implicits.scala\) required to use sttp backends with \cats.effect.Concurrent\ and \Sync\ types. Additionally, it provides a concrete \FetchCatsBackend\ for Scala.js, enabling HTTP requests via the Fetch API backed by Cats Effect 2, including support for request cancellation and testing stubs.

effects/cats-ce2/src/main · high confidence

Added new \FetchMonixBackend\ and \FetchZioBackend\ implementations for Scala.js that utilize the browser's native Fetch API and ReadableStream interface. These backends enable streaming response bodies and WebSocket support for applications using Monix or ZIO 1, allowing users to leverage modern browser networking capabilities while maintaining compatibility with their existing effect types.

effects/monix/src/main/scalajs, effects/zio1/src/main/scalajs · high confidence

Added three new Scala example files demonstrating how to handle HTTP errors, JSON parsing failures, and connection exceptions using the sttp client4 library (version 4.0.26). The examples cover default error handling with Either types, using asStringOrFail and asJsonOrFail for exception-based error handling, and parsing JSON responses with jsoniter.

examples/src/main/scala/sttp/client4/examples/errors · high confidence

A new synchronous backend for the JVM is now available via \HttpURLConnectionBackend\, providing an alternative to existing backends by leveraging the standard Java \HttpURLConnection\ API. This implementation supports request body compression, configurable read and connection timeouts, proxy authentication, and limits on response body length to prevent excessive memory usage. It handles various body types including streams, files, and multipart data, and integrates with the library's existing compression and error-handling mechanisms.

core/src/main/scalajvm/sttp/client4/httpurlconnection · high confidence

A new OkHttp backend implementation for the Monix runtime is now available, allowing users to make HTTP requests using Monix's Task and Observable types. This backend supports streaming request and response bodies via MonixStreams, enables WebSocket communication, and includes built-in support for request body compression. It provides both standard factory methods and resource-safe constructors (Resource) to ensure proper cleanup of the underlying OkHttp client.

okhttp-backend/monix/src/main · high confidence

The observability/opentelemetry-backend module now provides dedicated backend wrappers for OpenTelemetry integration. Users can wrap their existing HTTP backends with OpenTelemetryTracingBackend to automatically create client spans that include request details, response status codes, and error information, while OpenTelemetryMetricsBackend exposes standard HTTP client metrics such as request latency, size, and success/error counters. These components are configured via OpenTelemetryTracingConfig and OpenTelemetryMetricsConfig, allowing customization of span names, attribute sets, and metric collectors.

observability/opentelemetry-backend · high confidence

The Scala Native module now provides a dedicated \sttp.client4\ package featuring a \quick\ object for immediate use without manual backend configuration, a \DefaultSyncBackend\ that wraps the cURL-based implementation, and convenience extensions for handling file bodies and responses. This includes new methods to send requests directly via \quick.backend\, save files from responses, and map file paths to request bodies, streamlining the setup for synchronous HTTP operations in Scala Native.

core/src/main/scalanative/sttp/client4 · high confidence

This release introduces a new HTTP client backend for Scala Native, implemented using the libcurl library. The change adds \AbstractCurlBackend\ as the core implementation, \CurlBackends\ providing synchronous execution via \IdentityMonad\ and \TryMonad\, and \CurlMultiInputStream\ to support streaming responses by lazily driving curl multi-transfers. Users can now instantiate the backend via \CurlBackend()\ for standard synchronous requests or \CurlTryBackend()\ for Try-based error handling, with automatic follow-redirects support and proper resource cleanup for headers and native buffers.

core/src/main/scalanative/sttp/client4/curl · high confidence

Added five new example files in the WebSocket examples directory demonstrating how to connect to and interact with WebSockets using various backends and effect types: Pekko HTTP with Future, HttpClient with Fs2 streaming, synchronous HttpClient, ZIO, and Ox channels for streaming.

examples/src/main/scala/sttp/client4/examples/ws · high confidence

This change introduces the \HttpClientZioBackend\ and supporting components (body handling, decompression, sequencing) for the ZIO 1.x effect system within the \sttp.client4.httpclient.zio\ package. Users can now create HTTP backends that integrate with ZIO 1's \Task\ and \ZStream\ capabilities, enabling features like request body compression, response length limiting, and WebSocket streaming using ZIO's native stream types. The implementation provides factory methods (\apply\, \managed\, \layer\) to instantiate the backend, handling resource management and ZIO-specific conversions for HTTP client interactions.

effects/zio1/src/main/scalajvm · high confidence

This change introduces the ZIO 1.x implementation for the sttp client4 package, adding support for WebSockets and Server-Sent Events (SSE). It includes \ZioWebSockets\ to handle continuous WebSocket frame streams via ZIO streams, \ZioServerSentEvents\ for parsing SSE data, and \ZioSimpleQueue\ for WebSocket buffering. Additionally, it provides \ExtendedEnvBackend\ and implicit extension methods that allow backends to extend their ZIO environment requirements (e.g., from \RIO\[R0, \\]\ to \RIO\[R0 with R1, \\]\), enabling more flexible resource management in ZIO-based applications.

effects/zio1/src/main/scala · high confidence

A new \OpenTelemetryTracingZioBackend\ is introduced for the \client4\ package, enabling distributed tracing for ZIO-based HTTP clients by wrapping existing backends and injecting trace context into outgoing requests. The default tracer now correctly populates the \url.full\ OpenTelemetry semantic convention attribute using the \UrlAttributes\ class, ensuring accurate request URL recording in observability tools.

observability/opentelemetry-tracing-zio-backend/src/main · high confidence

A new \FetchZioBackend\ implementation for Scala.js is introduced, enabling HTTP requests via the browser's Fetch API with ZIO effects. This backend supports streaming responses and WebSockets, and provides \scoped\ and \layer\ constructors for proper resource management and integration with ZIO's environment system. Additionally, the package exposes \extendEnv\ implicit classes and \send\/\sendR\ helper methods, allowing users to seamlessly integrate the HTTP client into ZIO environments and handle requests with custom effect types.

effects/zio/src/main/scalajs · high confidence

This change introduces the \HttpClientZioBackend\, a new backend implementation that integrates the Java HttpClient with ZIO effects. It enables users to make HTTP requests and handle responses using ZIO's \Task\ and \ZStream\ types, supporting features like request body compression (GZip/Deflate), multipart streaming, and WebSocket communication. The backend is provided as a ZIO layer and companion methods (\apply\, \scoped\, \scopedUsingClient\) for easy integration into ZIO applications, replacing or supplementing previous backend options with a native ZIO experience.

effects/zio/src/main/scalajvm/sttp/client4/httpclient · high confidence

Added example implementations for several backend wrappers in the sttp client4 library, demonstrating how to integrate resilience4j for circuit-breaking and rate-limiting, how to add custom headers to all requests, how to implement simple retry logic, and how to use a Redis-backed caching backend. These examples cover both synchronous and asynchronous (cats-effect, Future) execution models, providing users with concrete patterns for extending the HTTP client with common production concerns.

examples/src/main/scala/sttp/client4/examples/wrapper · high confidence

The library now provides \DefaultSyncBackend\ and \DefaultFutureBackend\ objects that create ready-to-use HTTP backends (currently based on the JDK HTTP client) with minimal configuration. Additionally, a \quick\ object is introduced to allow fire-and-forget synchronous requests via a \send()\ extension method on \Request\, simplifying common use cases where a full backend instance is not needed.

core/src/main/scalajvm/sttp/client4 · high confidence

The Scala.js client now provides a \quick\ object that exposes a \send()\ extension method for immediate, parameterless requests using a default \Future\-based backend (backed by Fetch). A new \DefaultFutureBackend\ object offers a factory for creating this default websocket-capable backend and a testing stub. Additionally, \SttpExtensions\ and \PartialRequestExtensions\ add platform-specific helpers for handling DOM \File\ objects in multipart uploads and response body saving, while \SttpClientExceptionExtensions\ standardizes the mapping of low-level JavaScript exceptions to sttp client exceptions.

core/src/main/scalajs/sttp/client4 · high confidence

This change introduces a suite of internal components that enable new capabilities in the client. It adds a \Compressor\ and \Decompressor\ framework to support request body compression and response decompression. It introduces a \BodyFromResponseAs\ handler and a \LimitedInputStream\ to allow limiting response body length and supporting input streams as response bodies. It also provides \SttpFile\ for platform-agnostic file handling, \ToCurlConverter\ and \ToRfc2616Converter\ for request rendering (including multipart details), and \SimpleQueue\/\FutureSimpleQueue\/\SyncQueue\ to manage WebSocket message buffering.

core/src/main/scala/sttp/client4/internal · high confidence

The library now provides a \ListenerBackend\ wrapper and a \RequestListener\ trait that allow users to hook into specific stages of the HTTP request lifecycle. By wrapping an existing backend, users can receive notifications when a request starts (\before\), when the response body is fully received (\responseBodyReceived\), when the response is handled (\responseHandled\), and when exceptions occur (\exception\). This enables easier integration of logging, metrics, and tracing without modifying individual request code.

core/src/main/scala/sttp/client4/listener · high confidence

Added two new Scala example files in the logging directory: \logAsStringBackend.scala\ demonstrates a custom backend wrapper that prints the response body as a string to the console, and \logRequestsSlf4j.scala\ shows how to use the \Slf4jLoggingBackend\ to log both request and response bodies using SLF4J. These examples illustrate practical ways to inspect HTTP traffic when using the sttp client4 library.

examples/src/main/scala/sttp/client4/examples/logging · high confidence

Added four new Scala examples in the 'other' category: GetRawResponseBodySynchronous demonstrates handling both parsed JSON and raw string responses simultaneously using circe; cmdOutputStreamingWithOsLib, downloadFileWitOsLib, and uploadFileWithOsLib showcase file and stream operations integrated with the os-lib library for command output streaming, file downloading, and file uploading respectively.

examples/src/main/scala/sttp/client4/examples/other · high confidence

Users of the JVM HttpClient backend can now track upload progress by setting a \BodyProgressCallback\ attribute on requests, which receives \onInit\, \onNext\, \onComplete\, and \onError\ events as the request body is sent. Additionally, a new \maxResponseBodyLength\ option allows limiting the size of downloaded response bodies to prevent excessive memory usage. These changes are implemented in the new \BodyProgressCallback\ trait and integrated into the refactored \HttpClientAsyncBackend\ and \HttpClientSyncBackend\ classes.

core/src/main/scalajvm/sttp/client4/httpclient · high confidence

The play-json module has been added to the sttp client 4 package, providing JSON serialization and deserialization support using the Play JSON library. This includes the \asJson\ and \asJsonOrFail\ response handlers for parsing JSON bodies into Scala types, as well as body serialization for sending JSON requests. The implementation handles content-type headers correctly and supports complex types including nested objects, options, and either types.

json/play-json · high confidence

The repository has been initialized with essential configuration files and documentation. This includes a new Apache 2.0 license, a comprehensive README with quickstart examples for Scala CLI, Ammonite, and sbt, and a \CLAUDE.md\ file detailing build commands and project structure. Configuration for the build tool (\.sbtopts\), code formatting (\.scalafmt.conf\), and dependency management (\.scala-steward.conf\) has been added. Additionally, documentation infrastructure is set up with a \.readthedocs.yaml\ file and a \context7.json\ file providing AI-assisted coding rules for the sttp client library.

(repo-wide) · high confidence

The library now allows users to change the effect type (e.g., from \IO\ to \Task\) used by a request's response specification. This is achieved through the new \MapEffect\ utility, which takes a \FunctionK\ to transform between effect types \F\ and \G\, along with the corresponding \MonadError\ instances. This capability applies to response bodies that require the \Effect\ capability, specifically supporting stream responses and WebSocket interactions, enabling seamless integration with different effect systems without rewriting request logic.

core/src/main/scala/sttp/client4/monad · high confidence

The OpenTelemetry metrics backend now records a \url.template\ attribute on HTTP metrics, replacing numeric IDs and UUIDs in request paths and query parameters with \{id}\ to group similar requests together. Additionally, users can attach custom attributes to all recorded metrics via the \extraAttributes\ configuration option, while ensuring that these custom values cannot override standard semantic convention attributes like HTTP method or status code.

observability/otel4s-metrics-backend · high confidence

The Akka HTTP handler implementation has been removed from the library. This deletion eliminates the ability to use Akka HTTP as a backend for making HTTP requests, requiring users to switch to a supported handler if they were relying on this specific integration.

akka-http-handler · high confidence

The \core/src/main/scala/com/softwaremill/sttp\ package has been removed, deleting the legacy HTTP client implementation and its associated model classes. This includes the deletion of \HttpConnectionSttpHandler\ (the \java.net.HttpURLConnection\ backend), the \SttpHandler\ trait, the \Response\ case class, the \UriInterpolator\ object, and the main \package.scala\ which defined the request/response models, body types, and fluent API. Users relying on these specific classes for direct HTTP interactions or URI interpolation will need to migrate to the new backend structure.

core/src/main/scala/com · high confidence

A new C source file (ffi.c) has been added to the Scala Native resources to provide Foreign Function Interface bindings for the curl-based HTTP backend. This file implements helper functions for setting curl options and retrieving version information, and specifically includes a wrapper for curl\_multi\_info\_read to safely handle CURLMsg unions that cannot be directly represented in Scala Native's type system, enabling streaming support and proper operation on ARM architectures.

core/src/main/resources · high confidence

The library now includes internal support for MD5 message digests and enhanced file operations specifically for the Scala Native backend. This change introduces a native MD5 implementation via the system crypto library and a compatibility wrapper, alongside new extension methods for SttpFile that allow reading file contents as strings or byte arrays, opening input streams, and creating SttpFile instances from standard Java NIO paths or files.

core/src/main/scalanative/sttp/client4/internal · high confidence

This change introduces several internal utilities and fixes for the sttp client4 core. It adds SafeGZIPInputStream to gracefully handle empty GZIP streams, preventing EOFException errors when servers omit Content-Length headers for empty responses. New FileHelpers and SttpFileExtensions provide robust file I/O operations with proper resource management. MessageDigestCompatibility offers a wrapper for secure hashing, while SttpToJavaConverters facilitates interoperability with Java functional interfaces. These internal classes are package-private and support the broader client4 functionality.

core/src/main/scalajvm/sttp/client4/internal · high confidence

This change adds several internal implementation details specific to the Scala.js target for the sttp client4 library. It includes a \ConvertFromFuture\ trait to handle future conversions, a \JSSimpleQueue\ for WebSocket message handling, and compatibility shims for \MessageDigest\ (using SparkMD5) and file operations (\SttpFileExtensions\). These components support the underlying mechanics of the client4 API on JavaScript platforms.

core/src/main/scalajs/sttp/client4/internal · high confidence

The build system has been upgraded from sbt 0.13.15 to 1.13.0, replacing the legacy scalariform and coursier plugins with the SoftwareMill sbt plugin suite (including sbt-softwaremill-common, publish, and browser-test-js), sbt-projectmatrix, sbt-mdoc, and sbt-mima. New build utilities were added to support this migration: FileUtils and GenerateListOfExamples now automate the generation of the examples documentation list, PollingUtils assists with server availability checks, and VerifyExamplesCompileUsingScalaCli ensures examples compile via scala-cli.

project · high confidence

The Cats effect integration has been re-implemented in the client4 package with new \CatsMonadError\ and \CatsMonadAsyncError\ classes that map sttp's monad interfaces to Cats Effect's \Sync\ and \Async\ types. This includes updated implicits for backend mapping and a fix to the \blocking\ operation, which now correctly delegates to \F.blocking\ to ensure proper effect handling.

effects/cats/src/main/scala · high confidence

The OkHttp backend has been migrated to the client4 package (sttp.client4.okhttp), introducing new entry points OkHttpFutureBackend and OkHttpSyncBackend. This implementation adds support for request body compression, allows limiting the response body length via maxResponseBodyLength, and exposes an onBodyReceived callback for logging and metrics. It also implements WebSocket support with a configurable buffer capacity and ensures proper resource cleanup on cancellation.

okhttp-backend/src/main · high confidence

The internal implementation for the Java HttpClient-based backends has been restructured to support new capabilities and improve reliability. Request bodies now support compression via the new Compressor integration, and multipart requests can be streamed for large payloads. Users can now receive response bodies as input streams and track upload progress through request body progress callbacks. WebSocket communication has been refactored to use a sequencer (FutureSequencer/IdSequencer) to ensure thread-safe, sequential execution of send operations, and a DelegatingWebSocketListener handles connection lifecycle events more robustly. Additionally, resource leaks on cancellation are addressed by properly cancelling publishers.

core/src/main/scalajvm/sttp/client4/internal/httpclient · high confidence

The backend wrapper implementations in the \wrappers\ package have been restructured to use a new \DelegateBackend\ base class, which centralizes \close\ and \monad\ delegation so subclasses only need to implement \send\. This refactor introduces \MappedEffectBackend\ to handle effect-type transformations (used by the new \TryBackend\ and \EitherBackend\ wrappers to safely capture exceptions in \Try\ and \Either\ types) and updates \DigestAuthenticationBackend\ and \ResolveRelativeUrisBackend\ to extend the new delegation pattern. This change improves code reuse and consistency across synchronous, streaming, and WebSocket backend wrappers.

core/src/main/scala/sttp/client4/wrappers · high confidence

The logging backend now provides structured log context that includes HTTP method, URI (with sensitive query parameters masked), request/response headers (when enabled), status code, and request duration. It also supports detailed timing information, distinguishing between body received and body handled durations, and integrates with sensitive header/query parameter filtering to ensure secure logging.

core/src/main/scala/sttp/client4/logging · high confidence

The ZIO backend implementation has been updated to align with the ZIO 2.x effect model, replacing the previous \ZIO\[R, E, A\]\ signature with \RIO\[R, A\]\ (which combines environment and error handling). This change introduces new internal components in the \sttp.client4.impl.zio\ package, including \RIOMonadAsyncError\ for effect mapping, \ZioWebSockets\ for stream-based WebSocket handling, and \ZioServerSentEvents\ for SSE parsing. Users relying on the ZIO effect type will need to ensure their code is compatible with the \RIO\ type alias, as the underlying monad structure has shifted to leverage ZIO 2.x's improved environment and error management capabilities.

effects/zio/src/main/scala · high confidence

Add HTTP test server for client4; Added Armeria Future backend test suite; Added DeflateNoWrap coding class for testing; Added JVM-specific test infrastructure and extensions for sttp client4; Added Scala Native curl backend tests; Added Scala Native test infrastructure for sttp client 4; Added Scala Native test stubs for ScalaTest FreeSpec traits; Added Scala Native test suite for Cats-based Curl backend; Added Scala examples for testing with stub backends; Added ZIO 1.x integration tests for the HTTP client backend; Added ZIO and ZIO 1.0 test suites for the Armeria HTTP backend; Added ZIO backend tests for stubbing, streaming, and WebSockets; Added ZIO test base utilities for client4; Added compile-time tests for WebSocket and request validation; Added comprehensive test suite for WebSocket functionality; Added comprehensive test suite for sttp-client4 testing utilities; Added streaming test suite for sttp client4; Added test coverage for Circe JSON serialization and deserialization; Added test coverage for Fs2 WebSocket and streaming capabilities; Added test coverage for Fs2 streaming and WebSocket backends; Added test coverage for OkHttp backend; Added test coverage for jsoniter integration; Added test coverage for sttp-client4 core functionality; Added test infrastructure for Cats retry and base utilities; Added test infrastructure for the Fetch backend in Scala.js; Added test suite for Monix HTTP client backend; Added test suites for Armeria backends; Added test suites for Fetch-based HTTP, WebSocket, and streaming backends; Added test suites for http4s CE2 backend; Added testing utilities for stubbing and recording HTTP interactions; Added tests for Cats integration in the client4 package; Added tests for CookieStorage behavior; Added tests for CurlZioBackend on Scala Native; Added tests for Finagle backend in client4 package; Added tests for OpenTelemetry tracing in ZIO backend; Added tests for Ox-based WebSocket and Server-Sent Events integration; Added tests for PrometheusBackend metric configuration; Added tests for SafeGZIPInputStream error handling; Added tests for Upickle JSON integration in sttp client4; Added tests for ZIO WebSocket pipe frame handling; Added tests for internal HTTP client utilities; Added tests for json4s JSON serialization and deserialization; Added tests for proxy configuration, redirect handling, logging, and request conversion; Added tests for zio-json integration.

Added a new \docs/requirements.txt\ file (and its copy in \generated-docs/out/\) specifying pinned versions for Sphinx documentation tools: \sphinx\ 7.3.7, \sphinx\_rtd\_theme\ 2.0.0, \sphinx-autobuild\ 2024.4.16, \myst-parser\ 2.0.0, and \sphinx-llms-txt\.

(dependencies) · high confidence

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

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

• Code Health 100 → 93 (-6.6)
• Architecture 69 → 98 (+29.4)
• Maturity 64 → 73 (+9.3)
• Readiness 30 → 55 (+25.3)
• Security 32 → 81 (+49.7)

• Dimension evaluation failed
• Duplicated block (9 lines × 2) (core/src/main/scalajvm/sttp/client4/internal/httpclient/MultiPartBodyPublisher.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No artifact signing
• No automated tests
• No consequences/trade-offs section (e.g. loss of unsafeApply's exception-handling safety) (generated-docs/out/adr/0002-http-model-conventions.md)
• No exposed public API
• No tests found
• Rotate the exposed credentials — git history can't be un-committed
• Secret: etsy-access-token (core/src/main/scala/sttp/client4/testing/WebSocketBackendStub.scala)
• Secret: etsy-access-token (core/src/main/scalajvm/sttp/client4/DefaultSyncBackend.scala)
• Secret: etsy-access-token (core/src/main/scalajvm/sttp/client4/httpclient/HttpClientSyncBackend.scala)
• Secret: etsy-access-token (okhttp-backend/src/main/scala/sttp/client4/okhttp/OkHttpSyncBackend.scala)
• Test reliability not included
• The requirements file lists only the Sphinx themes (sphinx_rtd_theme==2.0.0, sphinx==7.3.7) and a few other packages; it does not show which sttp modules or backends are supported. (docs/requirements.txt)

• AbstractBackendStub.adjustResponseBody (cognitive 20) (core/src/main/scala/sttp/client4/testing/AbstractBackendStub.scala)
• AbstractBackendStub.adjustResponseBody (cyclomatic 29) (core/src/main/scala/sttp/client4/testing/AbstractBackendStub.scala)
• BodyFromAkka.webSocketAndFlow (cognitive 31) (akka-http-backend/src/main/scala/sttp/client4/akkahttp/BodyFromAkka.scala)
• BodyFromAkka.webSocketAndFlow (cyclomatic 16) (akka-http-backend/src/main/scala/sttp/client4/akkahttp/BodyFromAkka.scala)
• BodyFromPekko.webSocketAndFlow (cognitive 31) (pekko-http-backend/src/main/scala/sttp/client4/pekkohttp/BodyFromPekko.scala)
• BodyFromPekko.webSocketAndFlow (cyclomatic 16) (pekko-http-backend/src/main/scala/sttp/client4/pekkohttp/BodyFromPekko.scala)
• Boundary-crossing change coupling: AkkaHttpBackend.scala ↔ Http4sBackendBase.scala (akka-http-backend/src/main/scala/sttp/client4/akkahttp/AkkaHttpBackend.scala)
• Duplicated block (10 lines × 2) (akka-http-backend/src/main/scala/sttp/client4/akkahttp/AkkaHttpBackend.scala)
• Duplicated block (10 lines × 2) (akka-http-backend/src/main/scala/sttp/client4/akkahttp/AkkaHttpClient.scala)
• Duplicated block (10 lines × 2) (effects/cats/src/main/scalajvm/sttp/client4/httpclient/cats/CatsSimpleQueue.scala)
• Duplicated block (10 lines × 2) (effects/zio/src/main/scala/sttp/client4/impl/zio/ZioWebSockets.scala)
• Duplicated block (10 lines × 2) (http4s-backend/src/main/scala/sttp/client4/http4s/Http4sBackendBase.scala)
• Duplicated block (11 lines × 2) (http4s-backend/src/main/scala/sttp/client4/http4s/Http4sBackendBase.scala)
• Duplicated block (12 lines × 2) (akka-http-backend/src/main/scala/sttp/client4/akkahttp/AkkaHttpBackend.scala)
• Duplicated block (12 lines × 2) (akka-http-backend/src/main/scala/sttp/client4/akkahttp/ToAkka.scala)
• Duplicated block (12 lines × 2) (http4s-backend/src/main/scala/sttp/client4/http4s/Http4sBackendBase.scala)
• Duplicated block (12–13 lines × 2) (core/src/main/scalanative/sttp/client4/curl/AbstractCurlBackend.scala)
• Duplicated block (12–15 lines × 2) (effects/zio/src/main/scalajvm/sttp/client4/httpclient/zio/ZioBodyFromHttpClient.scala)
• Duplicated block (13 lines × 2) (effects/fs2-ce2/src/main/scala/sttp/client4/impl/fs2/Fs2WebSockets.scala)
• Duplicated block (13 lines × 2) (http4s-backend/src/main/scala/sttp/client4/http4s/Http4sBackendBase.scala)
• …and 108 more

• 38 commits — 38 feature/other, 0 fixes

• (root) — 26 commits
• examples/src — 4 commits
• project/build.properties — 2 commits
• core/src — 1 commit
• docs/backends — 1 commit
• generated-docs/out — 1 commit
• http4s-backend/src — 1 commit
• observability/otel4s-metrics-backend — 1 commit
• project/plugins.sbt — 1 commit

• change: Add missing resource variants that close a user-provided client (#2978)
• change: Add support for RFC 10008 (QUERY HTTP method) (#2948)
• change: Propagate cancellation for http4s backend (#2984)
• change: Release 4.0.27
• change: Update armeria to 1.41.0 (#2964)
• change: Update armeria to 1.41.1 (#2987)
• change: Update cats-effect, cats-effect-kernel, ... to 3.7.1 (#2980)
• change: Update fs2-core, fs2-reactive-streams to 3.14.0 (#2991)
• change: Update http4s-client, http4s-ember-client to 0.23.37 (#2994)
• change: Update jedis to 8.0.1 (#2983)
• change: Update jsoniter-scala-core, ... to 2.40.1 (#2961)
• change: Update jsoniter-scala-core, ... to 2.41.0 (#3005)
• change: Update logback-classic to 1.6.2 (#2973)
• change: Update logback-classic to 1.6.3 (#2974)
• change: Update mdoc, sbt-mdoc to 2.9.2 (#2990)
• change: Update model:core to 1.8.0 (#3000)
• change: Update model:core to 1.8.1 (#3002)
• change: Update model:core to 1.8.2 (#3007)
• change: Update okhttp-jvm to 5.5.0 (#2975)
• change: Update opentelemetry-api, ... to 1.65.0 (#2965)
• …and 18 more

• Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed

• repository

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

softwaremill/sttp 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.