Skip to content

chore(deps): update dependency org.mock-server:mockserver-netty-no-dependencies to v9.3.0 - #2697

Merged
renovate[bot] merged 1 commit into
mainfrom
renovate/org.mock-server-mockserver-netty-no-dependencies-9.x
Nov 18, 2026
Merged

renovate[bot] merged 1 commit into
mainfrom
renovate/org.mock-server-mockserver-netty-no-dependencies-9.x

Conversation

@renovate

@renovate renovate Bot commented Nov 17, 2026

Copy link
Copy Markdown
Contributor

Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package Change Age Confidence
org.mock-server:mockserver-netty-no-dependencies (source) 9.2.0 → 9.3.0 age confidence

Release Notes

mock-server/mockserver-monorepo (org.mock-server:mockserver-netty-no-dependencies)

v9.3.0

Security
  • Release image and Helm chart signing can no longer be skipped. A release used to publish Docker images and the Helm chart unsigned, without failing, when it could not find the cosign signing key (this is how the 8.0.0 images and chart shipped unsigned). The release now checks the key before it publishes anything and stops if the key is missing or unusable. The mockserver/mockserver-webhook image on ECR Public is now signed too
  • (Release) Every toolchain image the release runs in is now pinned by digest, not only by tag, so re-pushing a tag cannot change what a release runs. This includes the community alpine/helm and maniator/gh images, which receive the signing key and the GitHub token. The pins live in scripts/release/images/Dockerfile, which Dependabot keeps current in one PR that is never merged automatically and only refreshes digests or moves to a patch release on the same line. The VS Code extension is now packaged and published with the @vscode/vsce and ovsx versions locked in its package-lock.json, instead of the latest versions installed globally in the container that holds the marketplace tokens, and the PyPI packages are built and uploaded with build, twine and setuptools installed from a hash-pinned requirements file (scripts/release/requirements-publish.txt) rather than the latest versions. The npm release of mockserver-node and mockserver-client-node now installs from their committed lockfiles (npm ci), updating only the entries the release itself changes, instead of deleting the lockfile, resolving every dependency afresh and running npm audit fix before publishing. The .NET client and Testcontainers packages are now restored in locked mode from committed NuGet lock files (packages.lock.json)
  • With proxyAuthenticationUsername and proxyAuthenticationPassword set, a client could use MockServer as a proxy without credentials by opening its connection the way MockServer's own CONNECT and SOCKS tunnels open theirs internally. MockServer now accepts that opening only on its own internal tunnel connections. The forward allow, deny and private-network rules were not affected, and CONNECT, SOCKS and plain proxy requests sent with credentials work as before. Present since 5.11.0 (fixes GHSA-36c2-h3v8-7w6w)
  • With proxyAuthenticationUsername and proxyAuthenticationPassword set, SOCKS5 clients could proxy without credentials by offering "no authentication", SOCKS4 clients were never asked for credentials, and HTTP/3 CONNECT-UDP tunnels were opened without checking the Proxy-Authorization header. SOCKS5 now selects username/password authentication whenever the client offers it and refuses a client that does not (replying 0xFF and closing the connection), SOCKS4 is refused (it cannot carry a password) with a warning in the log, and HTTP/3 CONNECT-UDP now requires the proxy credentials, answering 407 without them. Without proxy credentials configured, SOCKS4, SOCKS5 and CONNECT-UDP behave as before, except that a SOCKS5 0xFF refusal now also closes the connection. With transparentProxyEnabled also set, MockServer now logs a warning at startup that connections handled as transparent proxying, including those whose destination comes from the Host header or a PROXY protocol header, are not asked for proxy credentials (fixes GHSA-36c2-h3v8-7w6w)
  • With proxyAuthenticationUsername and proxyAuthenticationPassword set, a plain HTTP proxy request for another host (a request line holding a full URL, such as GET http://example.com/path) without the credentials was still answered by a matching expectation, and was asked for them only when nothing matched; a WebSocket upgrade for another host was relayed to it without them; and the proxy WAR (mockserver-proxy-war) never asked for them. Such a request to the standalone server now gets 407 before it is matched against any expectation, a WebSocket upgrade for another host is relayed only with the credentials, and the proxy WAR asks for them before matching a request whose Host names another host. A request sent to MockServer directly (a request line holding only a path, as every HTTP/2 and HTTP/3 request is) is still matched without proxy credentials whatever its Host header says, and needs them only when MockServer would forward it; requests for MockServer's own address never need them. A request refused this way is logged as a failed proxy authentication, as a refused CONNECT is, not as a received request, so it does not count in verify or retrieveRecordedRequests. The WAR (mockserver-war) cannot see whether a request line held a full URL, so there every request is handled like one sent to MockServer directly. Without proxy credentials configured nothing changes
  • Build-time dependency fixes, none shipped in a published package: the Maven plugin's integration-test projects now pin Guava 33.8.0-jre, the version the main build uses (GHSA-xxph-c9ww-hj94 was fixed in 33.7.2), the VS Code extension's development lockfile resolves qs 6.16.1 (GHSA-6pq8-jhm2-2vcw; it reaches the build only through @vscode/vsce → typed-rest-client), and the Rust client's lockfile resolves rustls 0.23.46 (GHSA-vp88-798v-h67f, GHSA-w44r-93j7-qv28, GHSA-c8m5-c952-6cm4, GHSA-h2v8-394m-p7vv; the client uses native TLS, so rustls is listed in its lockfile but not compiled into it). The development lockfiles of the Node client, mockserver-node, the dashboard UI and the VS Code extension now resolve minimatch 11.0.3 (GHSA-g3hv-75wg-m249) for every copy that contains the affected code: under c8 → test-exclude in the Node client, through mockserver-node's glob development dependency (now 14.0.3), for eslint and its plugins in the dashboard UI and under @vscode/vsce in the VS Code extension. All but mockserver-node use npm overrides, because no release of those tools accepts minimatch 11 yet. The minimatch 3.x copies that grunt and jshint still pull in do not contain the affected code. The development lockfiles of the Node client and mockserver-node now also resolve lodash 4.18.1 for the copy under jshint (GHSA-f23m-r3pf-42rh), through an npm overrides entry because jshint accepts only lodash 4.17.x; jshint does not call the affected _.unset, _.omit or _.pullAt
  • The standard image (mockserver/mockserver, built from docker/local), the -aot image and the reference docker/Dockerfile image now run on gcr.io/distroless/java-base-debian13:nonroot instead of java-base-debian12. Distroless stopped building java-base-debian12 in February 2026 (GoogleContainerTools/distroless#2023), so its pinned digest could no longer pick up Debian security fixes; the new base ships libbrotli1 1.1.0-2+deb13u1, fixing CVE-2026-111497 (DSA-6582-1), and is the same Debian release as the other image variants (#​2927)
  • The Node Testcontainers module's lockfile now resolves glob 14.0.3 and minimatch 11.0.3 under archiver, a runtime dependency of the published @mockserver/testcontainers package (GHSA-3g3m-2fjr-6pw4, GHSA-g3hv-75wg-m249). The fix uses npm overrides, which npm does not apply when another project installs the package, so a project that depends on @mockserver/testcontainers resolves these from its own lockfile until archiver moves to the patched releases; it can add the same overrides itself. The module does not reach the affected code: archiver copies a directory without a glob pattern, and the affected glob copy is used only by an archiver-utils helper that archiver does not call
  • The forward-target checks (forwardProxyBlockPrivateNetworks, forwardProxyAllowedHosts, forwardProxyDeniedHosts) could be sidestepped by a destination an upstream proxy reads differently from MockServer. Through forwardHttpProxy the proxy's request line was built from the raw Host header and path, so a Host such as 8.8.8.8:80@169.254.169.254 or allowed?.example.com, a second Host header, or a path not starting with / could send the proxy to a host that was never checked. A plain HTTP request sent through forwardHttpProxy now needs exactly one Host header (without one, the client address is used) that is a host name, IPv4 address or bracketed IPv6 address with an optional port, and is otherwise refused with 502 Bad Gateway even when no check is set; its path always starts with /, spaces and control characters in it, Unicode ones included, are percent-encoded except CR and LF, which are still refused, and OPTIONS * is sent as OPTIONS http://<host>/ rather than with * appended to the host. Through forwardHttpsProxy or forwardSocksProxy, a request whose tunnel destination is not a host of that form is refused before connecting, and so is a binary (non-HTTP) connection tunnelled through any of the three upstream proxies, whose destination previously reached the proxy as given (a forwardProxyAllowedHosts entry *.allowed.com let secret.internal.example/.allowed.com through). A PROXY protocol v1 header whose destination is not an IP address of the family it declares (TCP4 or TCP6), such as a host name, is now ignored as malformed, as the PROXY protocol requires. Where a check is set, a numeric IPv4 host that is not four decimal octets without leading zeros (0177.0.0.1, 0x7f.1, 2130706433), which resolvers may read as another address, is refused, as is a forwarded request whose destination host or port cannot be read, and an IPv6 address whose dotted IPv4 part has a leading zero ([::ffff:017.0.0.1]) is refused too. forwardProxyBlockPrivateNetworks and address entries in forwardProxyAllowedHosts / forwardProxyDeniedHosts now check the IPv4 address inside an IPv4-compatible (::127.0.0.1), IPv4-translated (::ffff:0:a9fe:a9fe) or NAT64 (64:ff9b::a9fe:a9fe) IPv6 address. Within the local-use NAT64 prefix 64:ff9b:1::/48, which an operator may divide into longer prefixes, and for a 6to4 address (2002::/16), an address is refused if any IPv4 address it may carry is blocked or denied, but never matches an allow-list entry through one; other operator-specific NAT64 prefixes and Teredo (2001::/32) addresses are not unwrapped, so egress control on the NAT64 gateway or proxy remains the real protection. forwardProxyBlockPrivateNetworks also now blocks the "this network" range 0.0.0.0/8 (0.1.2.3, ::0.0.0.2), not only 0.0.0.0. A well-formed Host and path are sent as before. The checks use MockServer's own lookup of a name, which an upstream proxy resolves again, so restrict egress on the proxy too
  • The Kafka SSL keystore and truststore can only be set at startup (BREAKING for anyone who sends kafkaSecurity.sslTruststoreLocation, sslTruststorePassword, sslKeystoreLocation, sslKeystorePassword or sslKeyPassword to PUT /mockserver/asyncapi; see upgrading to 9). A request could name any file as the Kafka keystore or truststore, so anyone who could reach MockServer's API could make the Kafka client read any keystore-format file the MockServer process can read. Those fields are now rejected with a 400 that names the startup property to use instead: asyncKafkaSslTruststoreLocation, asyncKafkaSslTruststorePassword, asyncKafkaSslKeystoreLocation, asyncKafkaSslKeystorePassword and asyncKafkaSslKeyPassword (system property, environment variable such as MOCKSERVER_ASYNC_KAFKA_SSL_TRUSTSTORE_LOCATION, properties file or Configuration). MockServer gives them to the Kafka client when a request's securityProtocol is SSL or SASL_SSL. While any of them is set, an SSL request must leave out kafkaBootstrapServers or name the startup asyncKafkaBootstrapServers, as a SASL_* request must, so MockServer's client certificate is only presented to brokers chosen at startup. PUT /mockserver/configuration ignores them with a warning, and GET /mockserver/configuration returns the two locations but never the passwords. The same brokerConfig keys outside kafkaSecurity, or spelt with dots or another case, are rejected too. A PUT /mockserver/configuration that supplies any startup-only secret (these passwords, asyncKafkaSaslJaasConfig, clusterFanInPeerAuthToken, forwardCredentialHeadersByHost or controlPlaneBasicAuthenticationCredentials) now always logs the warning, even when the value matches the one in force, so the warning can no longer be used to confirm a guessed secret
  • The MQTT SSL keystore and truststore can only be set at startup (BREAKING for anyone who sends mqttSecurity.sslProperties to PUT /mockserver/asyncapi, or, once an asyncMqttSsl* property or the JVM's javax.net.ssl.keyStore is set, sends an ssl:///wss:// broker URL other than asyncMqttBrokerUrl or changes asyncMqttBrokerUrl with PUT /mockserver/configuration; see upgrading to 9). The request's sslProperties went to the MQTT client unchanged, so anyone who could reach MockServer's API could name any file as the MQTT keystore or truststore, making the MQTT client read any keystore-format file the MockServer process can read, and could choose its TLS protocol, cipher suites, security provider and key and trust manager. Every sslProperties entry is now rejected with a 400 that never echoes the value. For com.ibm.ssl.keyStore, keyStorePassword, keyStoreType, trustStore, trustStorePassword and trustStoreType it names the startup property to use instead: asyncMqttSslKeystoreLocation, asyncMqttSslKeystorePassword, asyncMqttSslKeystoreType, asyncMqttSslTruststoreLocation, asyncMqttSslTruststorePassword and asyncMqttSslTruststoreType (system property, environment variable such as MOCKSERVER_ASYNC_MQTT_SSL_TRUSTSTORE_LOCATION, properties file or Configuration), which MockServer gives to the MQTT 3 and MQTT 5 clients when the broker URL uses any scheme other than tcp:// or ws:// (such as ssl:// or wss://). The protocol, cipher suites, providers and key and trust manager now come from the JVM's own TLS settings (such as jdk.tls.client.protocols), and com.ibm.ssl.clientAuthentication, which Paho reads only for a TLS server and so never affected the client, is rejected too. The same keys spelt in another case or with dots or underscores, placed directly in mqttSecurity, or placed at the top level of brokerConfig, are rejected the same way. While any asyncMqttSsl* property, or the JVM's javax.net.ssl.keyStore (which Paho falls back to), is set, a request using any scheme other than tcp:// or ws:// must leave out mqttBrokerUrl or name the startup asyncMqttBrokerUrl, so MockServer's client certificate is only presented to the broker chosen at startup, and PUT /mockserver/configuration then ignores a new asyncMqttBrokerUrl with a warning; with none of them set, asyncMqttBrokerUrl can still be changed at runtime as before. PUT /mockserver/configuration always ignores the six asyncMqttSsl* properties with a warning, and GET /mockserver/configuration returns the locations, types and broker URL but never the passwords
  • The template Java class settings can only be set at startup (BREAKING for anyone who changes velocityDisallowClassLoading, javascriptAllowedClasses or javascriptDisallowedClasses with PUT /mockserver/configuration or a client's updateConfiguration; see upgrading to 9). These settings decide whether response and forward templates can load Java classes, but a PUT /mockserver/configuration could change them on a running server, so anyone who could reach the control plane could let templates use any Java class. Before, they were fixed at startup only while forwardCredentialHeadersByHost was set. A PUT that sets a different value is now still answered, but the value is ignored, a warning is logged and GET /mockserver/configuration reports the value in force; a PUT that sends the value already in force logs nothing. Set them before the server starts with a system property, environment variable, mockserver.properties or Configuration. javascriptDisallowedText, velocityDisallowedText and mustacheDisallowedText can still be changed at runtime (fixes GHSA-5xh7-f7gh-prcf)
  • Upgraded Netty from 4.2.19.Final to 4.2.20.Final (bundled dependency; netty-tcnative moves to 2.0.85.Final with it). It fixes GHSA-6xv6-9mgg-mfvc, where a client could get past TLS client-certificate (mTLS) authentication by resuming a TLS session, three out-of-bounds reads in netty-buffer (GHSA-m77g-r4c7-3w77, GHSA-rx4g-qxm6-238r, GHSA-qhw9-p586-v948), control characters not neutralised in the HTTP/1.1 codec (GHSA-42mp-m8rq-6rgj) and several HTTP/2, HTTP/3 and QUIC issues. Two visible changes: with tlsMutualAuthenticationRequired, a client whose certificate MockServer does not trust is now refused with a bad_certificate TLS alert instead of internal_error when MockServer uses OpenSSL (the default when its native library loads); and Netty now decrypts TLS into buffers of at most 16 KiB, too small for a 16 KiB HTTP/2 DATA frame and its header, so MockServer's HTTP/2 server now joins the two pieces of such a frame into a buffer of their own size instead of one twice as large. An HTTP/2 upload over TLS sent in 16 KiB frames therefore holds about 1.0 to 1.3 times its size in memory while it arrives when the client sends each frame in TLS records of its own, and 1.3 to 1.7 times when frames share records (about 1.1 to 1.7 times before, for 1 and 4 MiB uploads); cleartext HTTP/2 uploads in 16 KiB frames hold slightly less too. Also upgraded jsoup to 1.24.1, Guava to 33.8.0-jre and Error Prone annotations to 2.52.0, and, in the optional blob-store modules, the AWS SDK to 2.57.8, Google Cloud Storage to 2.76.0 and Azure Storage Blob to 12.37.1
  • When MockServer (the JAR, Docker image or Helm chart) is a forward proxy, a request a client sends through it to another host is now matched against expectations and, if none matches, forwarded, even when its path looks like one of MockServer's own API routes, such as PUT http://upstream/mockserver/clear or a PUT /clear inside a CONNECT or SOCKS tunnel to another host (this changes behaviour for anyone who sends MockServer API calls through MockServer's own proxy to an address it cannot recognise as its own, as described below, or relies on a MockServer reached as another MockServer's proxyRemoteHost answering API or liveness calls the front MockServer does not serve itself). MockServer used to answer such a request itself, so a proxied request could clear, reconfigure or stop the proxy instead of reaching its destination. Requests addressed to MockServer itself are served as before: sent directly, whatever the host name, or sent through its own proxy to a port it listens on (including ports added with /bind), to localhost or another loopback address at any port (which kubectl port-forward or ssh -L may relay to MockServer), or by host name to one of its ports. No MockServer of this version or later serves an API call that a MockServer forwarded as a proxy (it answers 404, MCP and WebSocket upgrades included), so a client that can only use the proxy cannot reach the API of a MockServer of this version or later with the forwarding MockServer's client certificate (upgrade every MockServer that trusts the proxy's certificate authority before relying on this). So an API call sent through the proxy to an address of MockServer's it cannot recognise as its own, such as a Kubernetes Service port or a Docker host or ClusterIP address, or to another MockServer, now gets 404: send such calls to MockServer directly. Such a call carries x-forwarded-by: MockServer_proxied to its destination, and recorded expectations (and recordings promoted to mocks) no longer keep an x-forwarded-by header, so they match a client calling MockServer directly. The proxy WAR does not classify proxied requests. Contributed by Matthew Hall (@​megahall) in #​2955
  • With proxyAuthenticationUsername and proxyAuthenticationPassword set, the client's Proxy-Authorization header, which holds the proxy password, was kept on the request after MockServer checked it: it was shown in the dashboard, returned by retrieve for requests and logs, written to recordings and recordings saved to disk, could be matched by expectations, and was relayed to the upstream server in a proxied WebSocket handshake. MockServer now removes the header once it has checked it, whether the credential was right or wrong, so it is never recorded, matched or forwarded; the log entries for a refused CONNECT and for a request refused by data-plane authentication (dataPlaneAuthenticationRequired) or for lacking TLS (tlsMutualAuthenticationRequired) no longer hold it either. Without proxy credentials configured, Proxy-Authorization is recorded and matched as before, but, as for every other forwarded request, it is no longer relayed in a proxied WebSocket handshake, and neither is Proxy-Connection. Contributed by Matthew Hall (@​megahall) in #​2954 and #​2955
  • The Go Testcontainers module (mockserver-testcontainers/go) now requires golang.org/x/crypto v0.59.0 and github.com/klauspost/compress v1.20.3 or later, so projects using it no longer resolve versions with known advisories (GO-2026-6303, GO-2026-6354, GO-2026-6355, GO-2026-5932, GO-2026-6865). Because that x/crypto release needs Go 1.26, the module now requires Go 1.26 or later
  • The .NET Testcontainers module (MockServer.Testcontainers) now requires Testcontainers 4.16.0 or later, which depends on SSH.NET 2026.0.0, so projects using it no longer resolve an SSH.NET version with known advisories (GHSA-mggc-4xg6-vcxf, GHSA-q939-rpr3-3284). It still accepts any MockServerClient from 7.1.0
  • The proxy WAR (mockserver-proxy-war) forwarded a request that matched no expectation and whose Host header was the WAR's own address (localhost, 127.0.0.1 or the server's IP address, followed by its port, except on port 80, and on port 443 over HTTPS, where it is written without a port) back to that address, without asking for proxy credentials even when proxyAuthenticationUsername and proxyAuthenticationPassword were set. So a client that could reach the WAR could fetch any other application on the same servlet container, such as its management pages, as a request from the container itself. Such a request, and one with no Host header, is now a request to MockServer itself, as on the JAR, Docker image and Helm chart: it is matched against expectations without credentials and, when nothing matches, answered 404; it is never forwarded to the container, and an extension request filter or response transformer is told it was not a proxy request. With proxyRemoteHost and proxyRemotePort set, an unmatched one is forwarded there, and needs the proxy credentials when they are configured; one whose path matches a proxyPassMappings entry still goes to that entry's target. Requests whose Host names another host are proxied as before
  • Build and test tooling hardening, none shipped in a published package: the API-collection CI gate installs PyYAML from a hash-pinned requirements file, the container-test Dockerfiles are digest-pinned (the curl test client moves from Ubuntu 20.04, now out of standard support, to 24.04), the local dashboard launch scripts install with npm ci, the JetBrains plugin's Gradle wrapper pins its distribution checksum, and a new GitHub Actions workflow checks the committed gradle-wrapper.jar files against Gradle's published checksums
Added
  • A new startup property, proxyProtocolTrustedSources (-Dmockserver.proxyProtocolTrustedSources or MOCKSERVER_PROXY_PROTOCOL_TRUSTED_SOURCES), lists the IP addresses and CIDR blocks (IPv4 or IPv6) a PROXY protocol v1 or v2 header is accepted from when transparentProxyEnabled is on, normally the load balancer that adds it. A PROXY header names where a connection is forwarded and which client address is recorded for it, so until now any client that could reach a transparent-proxy port could choose both; with the property set, a connection from any other address that starts with a PROXY header is closed with a warning, as HAProxy does with a header from a source it does not trust, while connections without a header are unaffected. Empty (the default) keeps today's behaviour. An entry that is not a single IP address or CIDR block (a host name, a block with bits set after its prefix, a block covering every address or every IPv4 address, a zone ID, an IPv4 part with a leading zero, an IPv4 address written as ::a.b.c.d) stops the server starting, each entry being checked on its own, the entries in force are logged at startup, the refusal warning is given at most once a minute, and PUT /mockserver/configuration cannot change it. The startup warning given when transparent proxying and proxy credentials are both set now says whether it is set
  • Release Docker images (mockserver/mockserver and its -graaljs, -clustered, -aot and -http3 tags, and mockserver/mockserver-webhook) now carry an SPDX software bill of materials (SBOM) and SLSA build provenance as image attestations, readable with docker buildx imagetools inspect <image> --format '{{ json .SBOM }}' (or .Provenance); they are covered by the image's cosign signature
  • Every Maven artifact released to Maven Central now has a CycloneDX software bill of materials next to it (<artifactId>-<version>-cyclonedx.json), signed like the jar
  • Dashboard: a workspace tab you are not looking at, on a different server from the workspace you are in, now shows how many items (requests, responses or stream frames) are paused at a breakpoint on its server; click the count to open that workspace's Breakpoints view before the breakpoint timeout continues them
  • A new opt-in property, recordTruncatedStreamTiming (-Dmockserver.recordTruncatedStreamTiming or MOCKSERVER_RECORD_TRUNCATED_STREAM_TIMING), keeps the chunk timing of a streamed forwarded response that is recorded as truncated: one the upstream closes or resets without ending it, that times out (streamIdleTimeoutSeconds), whose upstream fails, or that passes maxStreamingCaptureBytes. Such a recording lost its x-mockserver-chunk-delays-ms, so it could only be replayed as one static response. With the property on it keeps the timing of the chunks captured before the cut and stays marked x-mockserver-stream-truncated: true; nothing is timed after the cut. A fixture made from a truncated text/event-stream recording with that timing (for example by the record_llm_fixtures MCP tool) now replays the events captured before the cut with their delays, leaves out an event cut off part way, and carries an x-mockserver-fixture-warning header; the replay then ends the stream normally rather than reproducing how it broke. Other content types keep the static fallback (#​2929)
  • A new opt-in property, recordOpenStreamsOnStop (-Dmockserver.recordOpenStreamsOnStop or MOCKSERVER_RECORD_OPEN_STREAMS_ON_STOP), records a streamed forwarded response that is still open when MockServer stops, such as a Server-Sent Events push stream the backend never ends. Such a stream was recorded only when it ended, so a stop (PUT /mockserver/stop, or SIGINT / SIGTERM to the command line) lost it: it was missing from the recorded expectations and from persistedRecordedExpectationsPath. With the property on, the stop first ends each open recorded stream (the client gets the normal end of the stream), records it as complete with its x-mockserver-chunk-delays-ms, marks it x-mockserver-stream-closed-by-mockserver-stop: true, and waits for persistedRecordedExpectationsPath to be written; when the property is set at startup the command line also stops MockServer this way on SIGINT / SIGTERM (see the clean-stop entry under Changed for how long to let docker stop wait). Nothing changes with the property off (#​2945)
  • A new startup property, forwardCredentialHeadersByHost (-Dmockserver.forwardCredentialHeadersByHost or MOCKSERVER_FORWARD_CREDENTIAL_HEADERS_BY_HOST), adds credential headers to requests MockServer forwards or proxies to a named upstream host, each valued from an environment variable read once at startup, for example global.example.com=Authorization:GLOBAL_CLUSTER_TOKEN. The value is added only to the copy of the request written to the upstream, so it never appears in expectations, the log, recordings, exports or the dashboard, even with redactSecretsInLog off. Headers are sent only over TLS unless an entry is written http://host:port, and HTTPS entries need forwardProxyTLSX509CertificatesTrustManagerType set to JVM or CUSTOM and forwardProxyTLSHostnameVerificationEnabled set to true; otherwise they are ignored with a warning. A TLS connection that carries a credential is always a new one, never pooled, and trusts only the JVM's root CAs or the CUSTOM file as they were at startup, never MockServer's own CA or a certificate it signed, even when the JVM trust store or the CUSTOM file holds them, and never uses TLS 1.0 or 1.1. A header is added only when the connection target and the request's single Host header name exactly the configured host and port, the path starts with /, and the method is not TRACE or CONNECT. The property can only be set at startup. Requests are no larger when the property is not set. The configuration properties page explains what it does not protect against (#​2930)
  • A new opt-in property, recordClientClosedStreamsComplete (-Dmockserver.recordClientClosedStreamsComplete or MOCKSERVER_RECORD_CLIENT_CLOSED_STREAMS_COMPLETE), keeps the chunk timing when the client closes a streamed forwarded response part-way through. Since 9.0.0 MockServer then closes the upstream, and a chunked stream was recorded as incomplete (x-mockserver-stream-truncated) with no x-mockserver-chunk-delays-ms. With the property on, such a recording ends complete, keeps its chunk delays and is marked x-mockserver-stream-closed-by-client: true. A stream that the upstream ends or breaks, and one MockServer closes itself (a response write stall, an error or chaos action, an HTTP/2 or HTTP/3 connection error, a QUIC transport or TLS error, or a server stop), is recorded as before. The maxStreamingCaptureBytes limit still applies
  • An SSE event can now carry a comment (SseEvent.withComment(...) in Java, comment in JSON and in the Node, Python, Ruby, Go, .NET, Rust and PHP clients, and a Comment field for each event in the dashboard's expectation composer, whose generated code includes it). It is sent before the event's other fields as : followed by each line of the comment exactly as written (keep-alive is sent as :keep-alive, keep-alive as : keep-alive), so an event with only a comment sends a heartbeat and a blank line, which clients ignore. A line break in a comment cannot start a new field or event. With templateType set the comment is rendered like data, and for NDJSON, JSON array and AWS event-stream LLM responses a comment-only event sends nothing but still waits its delay. Events without a comment are sent exactly as before (#​2946)
  • The record_llm_fixtures MCP tool takes keepSseComments (default false). With it set, the comment lines of a recorded SSE stream, such as :heartbeat, are kept: each comment-only chunk becomes an event with only a comment, replayed exactly as recorded (the text after the colon, leading space included) with its recorded delay (#​2946)
  • A recorded streamed response now carries x-mockserver-first-chunk-delay-ms, the time from the start of the forward to the first chunk, measured on the same clock as x-mockserver-response-time-ms. x-mockserver-chunk-delays-ms is unchanged and its first value is still 0. Fixtures made by record_llm_fixtures now replay the first event after that wait, so a backend that waited before its first event is no longer replayed as answering at once. The header is kept out of fixtures like the other recording headers (#​2947)
  • An SSE response can now wait before it ends: closeDelay on httpSseResponse (HttpSseResponse.withCloseDelay(...) in Java, and in the Node, Python, Ruby, Go, .NET, Rust and PHP clients and the dashboard's generated code) is how long the stream stays open after its last event, and keepStreamOpen: true keeps it open until the client leaves or MockServer stops. Before, a stream always ended right after its last event, so SSE clients reconnected at once. Fixtures made by record_llm_fixtures from a stream the backend ended now get a closeDelay, the recorded total time less the time the events replay over, so the replay ends when the recording did; a truncated stream, or one the client or MockServer's stop (recordOpenStreamsOnStop) closed, gets none. record_llm_fixtures also no longer drops an SSE response's delay and primary when it redacts a fixture. Responses without either field behave as before (#​2947)
Changed
  • The Rust client (mockserver-client crate) now needs Rust 1.88 or newer (it declared 1.75), and CI now builds, tests and lints it on exactly Rust 1.88 as well as on the latest stable (BREAKING for Rust client users on an older compiler). It now uses reqwest 0.13, tungstenite 0.30, sha2 0.11 and base64 0.23, and still connects with the platform's native TLS over HTTP/1.1 as before. PausedStreamFrame::body_bytes() now returns the client's own mockserver_client::Result<Vec<u8>>: a body that is not valid Base64 is the new Error::Decode variant, with the decoder's error as its source(), instead of a base64::DecodeError, so later base64 upgrades no longer change the client's API (BREAKING for code that names base64::DecodeError from body_bytes()). Error::Transport still holds a reqwest::Error, now from reqwest 0.13 (BREAKING for code that converts its own reqwest 0.12 errors into mockserver_client::Error or passes the inner error to reqwest 0.12 APIs). The Testcontainers module (testcontainers-mockserver crate) now declares Rust 1.88 too, because it uses the newest mockserver-client
  • The command line and the Docker image now stop cleanly on SIGINT / SIGTERM (Ctrl+C, docker stop, a Kubernetes pod shutdown) whenever persistExpectations, persistRecordedExpectations, persistRecordedRequestsToDisk or recordOpenStreamsOnStop is set at startup, the same way PUT /mockserver/stop does, so its files are written before the process exits. Before, the process exited at once and could lose the last recorded requests still buffered for persistedRecordedRequestsPath and the last write of persistedRecordedExpectationsPath. A clean stop waits up to stopDrainMillis (15 seconds by default) for requests still in progress before it writes the files, and docker stop kills a container after 10 seconds, so give it longer (docker stop -t 30, docker run --stop-timeout 30, Compose stop_grace_period: 30s; the Helm chart already allows 45 seconds) or lower stopDrainMillis. With none of these properties set, nothing changes
  • A CONNECT or SOCKS tunnel through MockServer now carries any TCP protocol, not only HTTP and TLS, to its destination (SOCKS4 only when proxy credentials are not configured, since it is refused otherwise). Where clients you do not trust can reach MockServer, limit where binary connections may go with forwardProxyBlockPrivateNetworks, forwardProxyAllowedHosts and forwardProxyDeniedHosts, which apply to every binary connection. Proxy authentication (proxyAuthenticationUsername and proxyAuthenticationPassword) is asked for before a CONNECT or SOCKS tunnel opens, but not on a transparent-proxy or port-forwarded connection, and dataPlaneAuthenticationRequired does not apply to binary connections. A binary connection's messages, including credentials a protocol sends in the clear (a Redis AUTH, a PostgreSQL password), are kept in the event log, so protect the control plane where MockServer proxies real credentials
  • .NET client (MockServerClient NuGet package): the netstandard2.0 build, used by .NET Framework and by .NET versions before .NET 8, now depends on System.Text.Json 10.0.14 and Microsoft.Bcl.AsyncInterfaces 10.0.14, up from 8.0.6 and 8.0.0, because .NET 8 support ended on 2026-11-10. A project that pins either package, or a package System.Text.Json 10 depends on such as System.Text.Encodings.Web, below the new version must raise its pin, or restore fails with NU1605 (package downgrade). On .NET 6 or 7, System.Text.Json now also prints a build warning that the target framework is unsupported. The net8.0 build, used by .NET 8 and later, has no package dependencies and is unchanged, and the target frameworks (netstandard2.0, net8.0) are unchanged
  • The nightly client conformance sweep (CI) no longer re-runs the seven client pipelines when master has not moved since the last passed sweep
  • Snapshot builds are now published once a night (02:00 UTC) from master instead of after every commit: the mockserver/mockserver:snapshot image and its variant tags on Docker Hub and ECR Public, the SNAPSHOT jars in the Sonatype snapshot repository, and the snapshot binary bundles the client launchers download. A snapshot can be up to a day behind master
  • Dashboard: a link that names a server with ?host=, ?port=, ?secure= or ?basePath= now opens on that server even when the workspace you had open has its own server. The link opens in a workspace that follows it (an existing one without its own server, or a new one), and your workspace keeps its server, view and searches, one tab away. Before, the stored server won and the link was ignored
Removed
  • The http1PipeliningInOrder property (-Dmockserver.http1PipeliningInOrder, MOCKSERVER_HTTP1_PIPELINING_IN_ORDER), the temporary switch added in 9.2.0 to turn off in-order answering of pipelined HTTP/1.1 requests. MockServer now always answers requests pipelined on one connection in the order they were sent. A configuration that still sets it is not an error: the property is ignored, the startup warning and diagnose_config report it as removed, and PUT /mockserver/configuration ignores the field. The perf pipeline's on / off A/B for it (about 5 minutes of each perf-run) is removed with it, and that step's timeout goes back from 90 to 80 minutes
Fixed
  • A streamed forwarded response still in a Content-Encoding MockServer does not decode (such as a custom coding) was recorded as text, which corrupted its bytes, so replaying the recording sent the client different bytes than the upstream had. It is now recorded as its bytes, and an SSE fixture made from it replays those bytes unchanged instead of trying to read events from them
  • An SSE recording whose lines end with a lone carriage return (\r), which the SSE specification allows, was turned into a fixture as one garbled event. Lines may now end with CRLF, LF or CR, and a CRLF is still one line end
  • The trailers that end a streamed forwarded response (an HTTP/1.1 chunked trailer section, such as a checksum) were dropped: the client never received them and the recording did not hold them. They are now relayed to the client and recorded as the response's trailers
  • An SSE fixture made from a recorded stream replayed events at the wrong times when the backend's chunks did not hold one event each: events the backend sent together were spread out over the delays of later chunks, and an event that arrived in pieces was replayed before its last piece arrived. A recording now also carries the bytes each chunk held (x-mockserver-chunk-sizes-bytes, a log-only header like the other recording headers), and each event replays when the chunk that completed it arrived. Recordings made with earlier versions replay as before
  • A forwarded or recorded text/event-stream or application/x-ndjson response that named no charset was read as ISO-8859-1, so non-ASCII text in it (accented letters, emoji, CJK) was garbled in the event log, the dashboard and the recorded expectation, and an SSE fixture made from the recording (such as by record_llm_fixtures) replayed it garbled. Both types are always UTF-8, so MockServer now reads and writes them as UTF-8 when no charset is given. A mocked text/event-stream response with a static body is now also sent as UTF-8, rather than as ISO-8859-1 (with ? for any character outside it)
  • A recorded gRPC call made by a client that sets a deadline did not match the same call when replayed: the recorded expectation required the call's grpc-timeout header, which is the time left before the deadline and so differs on every call, and the replayed call was answered UNIMPLEMENTED (or proxied again). Recorded expectations no longer include grpc-timeout or grpc-previous-rpc-attempts (the retry count). Recordings made with earlier versions hold the header: re-record them, or remove it from their request
  • When MockServer proxied or forwarded a gRPC call, the upstream's trailing metadata (trailers such as x-cost or a -bin key sent with grpc-status) reached the client as response headers, so a client reading it from the trailers did not find it, and the same happened when the recording was replayed. Trailing metadata is now relayed, recorded and replayed as trailers, and redactSecretsInLog and redactSecretsInRecordedExpectations mask a sensitive trailer (such as x-api-key) as they mask that header
  • A gRPC call forwarded by a FORWARD expectation while no gRPC descriptors were loaded was sent to an HTTPS upstream over HTTP/1.1, which a gRPC server refuses, so the client got UNAVAILABLE. It is now sent over HTTP/2 with te: trailers, as with descriptors loaded, and its grpc-status reaches the client in the trailers. A plaintext upstream is still called over HTTP/1.1
  • A grpcStreamResponse sent to a gRPC-Web client (application/grpc-web or application/grpc-web-text) was written as plain gRPC, with the application/grpc content type, unencoded for -text, and its status in HTTP trailers, which a browser cannot read. It is now sent as gRPC-Web: each message in a frame, base64-encoded for -text, followed by the gRPC-Web trailer frame carrying grpc-status and grpc-message
  • A WebSocket reached through MockServer as an HTTP CONNECT or SOCKS proxy, which is how browsers and most HTTP clients send ws:// and wss:// through a proxy, failed at its first message: after the 101 Switching Protocols the tunnel went on reading the WebSocket frames as HTTP, so the connection ended or the client was sent an HTTP error. This broke mocked (httpWebSocketResponse) and proxied WebSockets alike. After a 101 the tunnel now carries the connection's bytes unchanged in both directions
  • A proxied WebSocket handshake no longer forwards hop-by-hop request headers to the upstream: Keep-Alive, TE, Trailer, Transfer-Encoding and any header the request's Connection header names. They describe the client's connection to MockServer, not MockServer's to the upstream
  • A proxied WebSocket whose upstream selected none of the subprotocols the client offered (Sec-WebSocket-Protocol) was answered 502; the upstream's answer is now relayed, with no subprotocol, and the client decides, as RFC 6455 allows. A client that sends each subprotocol on its own Sec-WebSocket-Protocol line now has all of them offered upstream and selectable, not only the first
  • A WebSocket frame larger than 64 KiB was refused with close code 1009 (message too big): by a proxied WebSocket in both directions, and by a mocked one for what the client sent. A frame from the client is now limited by maxRequestBodySize (10 MiB by default) and one from the upstream by maxResponseBodySize (50 MiB by default), as request and response bodies are. With maxRequestBodySize set below 64 KiB, the limit on WebSocket frames from clients is now lower than before
  • A mocked WebSocket's message matchers now see a message the client sends in fragments (a text or binary frame followed by continuation frames) as one message. Before, each fragment was matched on its own, so a matcher for the whole text never matched, and a matcher for any frame answered every fragment. A whole message larger than maxRequestBodySize closes the WebSocket with code 1009
  • A proxied WebSocket closed by either side with a close frame now answers that side with a close frame of the same code and reason, as RFC 6455 requires. Before, the side that started the close got only the end of its connection, so browsers reported an abnormal close (1006, wasClean false) and other clients waited for a close frame that never came
  • A gRPC call that MockServer proxied or forwarded, with gRPC descriptors loaded, and whose response had no messages (such as a server stream that ended straight away) reached the client with one placeholder message, and so did every replay of its recording: the empty response was recorded with no body, which MockServer fills with an example message. It is now recorded as an empty JSON array ([]) and sent, while proxying and on replay, as a stream with no messages and the upstream's grpc-status. Recordings made with earlier versions hold no body for such a call: re-record them, or set the response body to []. A server stream with several messages, recorded as a JSON array of them, is now also sent as those messages over HTTP/1.1, HTTP/2 and HTTP/3; it was answered INTERNAL. A forwarded client-streaming call that sent no messages no longer has an empty message added to it, and a recorded gRPC response no longer lists its grpc-status twice (#​2988)
  • A forwarded or proxied request whose every header is hop-by-hop (such as Connection, Proxy-Connection or Proxy-Authorization) kept all of them, because the filter that drops those headers left a request unchanged when it would have had no headers left. It is now forwarded with none. Contributed by Matthew Hall (@​megahall) in #​2954 and #​2955
  • With persistRecordedExpectations on, a recording made in the last quarter of a second before MockServer stopped could

[!IMPORTANT]
✂ PR body was truncated to here.


Configuration

📅 Schedule: (UTC)

  • Branch creation
    • At any time (no schedule defined)
  • Automerge
    • At any time (no schedule defined)

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.


  • If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

@renovate renovate Bot added the dependencies Pull requests that update a dependency file label Nov 17, 2026
@renovate
renovate Bot enabled auto-merge (squash) November 17, 2026 23:06
@renovate
renovate Bot merged commit 9792218 into main Nov 18, 2026
26 checks passed
@renovate
renovate Bot deleted the renovate/org.mock-server-mockserver-netty-no-dependencies-9.x branch November 18, 2026 18:41
zeitlinger pushed a commit to zeitlinger/client_java that referenced this pull request Nov 19, 2026
…pendencies to v9.3.0 (prometheus#2697)

> [!NOTE]
> This PR body was truncated due to platform limits.

This PR contains the following updates:

| Package | Change |
[Age](https://docs.renovatebot.com/merge-confidence/) |
[Confidence](https://docs.renovatebot.com/merge-confidence/) |
|---|---|---|---|
|
[org.mock-server:mockserver-netty-no-dependencies](https://www.mock-server.com)
([source](https://redirect.github.com/mock-server/mockserver-monorepo))
| `9.2.0` → `9.3.0` |
![age](https://developer.mend.io/api/mc/badges/age/maven/org.mock-server:mockserver-netty-no-dependencies/9.3.0?slim=true)
|
![confidence](https://developer.mend.io/api/mc/badges/confidence/maven/org.mock-server:mockserver-netty-no-dependencies/9.2.0/9.3.0?slim=true)
|

Signed-off-by: Gregor Zeitlinger <gregor.zeitlinger@grafana.com>

---

### Release Notes

<details>
<summary>mock-server/mockserver-monorepo
(org.mock-server:mockserver-netty-no-dependencies)</summary>

###
[`v9.3.0`](https://redirect.github.com/mock-server/mockserver-monorepo/blob/HEAD/changelog.md#930---2026-11-15)

##### Security

- Release image and Helm chart signing can no longer be skipped. A
release used to publish Docker images and the Helm chart unsigned,
without failing, when it could not find the cosign signing key (this is
how the 8.0.0 images and chart shipped unsigned). The release now checks
the key before it publishes anything and stops if the key is missing or
unusable. The `mockserver/mockserver-webhook` image on ECR Public is now
signed too <!-- version-ref:keep -->
- (Release) Every toolchain image the release runs in is now pinned by
digest, not only by tag, so re-pushing a tag cannot change what a
release runs. This includes the community `alpine/helm` and
`maniator/gh` images, which receive the signing key and the GitHub
token. The pins live in `scripts/release/images/Dockerfile`, which
Dependabot keeps current in one PR that is never merged automatically
and only refreshes digests or moves to a patch release on the same line.
The VS Code extension is now packaged and published with the
`@vscode/vsce` and `ovsx` versions locked in its `package-lock.json`,
instead of the latest versions installed globally in the container that
holds the marketplace tokens, and the PyPI packages are built and
uploaded with `build`, `twine` and `setuptools` installed from a
hash-pinned requirements file
(`scripts/release/requirements-publish.txt`) rather than the latest
versions. The npm release of `mockserver-node` and
`mockserver-client-node` now installs from their committed lockfiles
(`npm ci`), updating only the entries the release itself changes,
instead of deleting the lockfile, resolving every dependency afresh and
running `npm audit fix` before publishing. The .NET client and
Testcontainers packages are now restored in locked mode from committed
NuGet lock files (`packages.lock.json`)
- With `proxyAuthenticationUsername` and `proxyAuthenticationPassword`
set, a client could use MockServer as a proxy without credentials by
opening its connection the way MockServer's own `CONNECT` and SOCKS
tunnels open theirs internally. MockServer now accepts that opening only
on its own internal tunnel connections. The forward allow, deny and
private-network rules were not affected, and `CONNECT`, SOCKS and plain
proxy requests sent with credentials work as before. Present since
5.11.0 (fixes
[GHSA-36c2-h3v8-7w6w](https://redirect.github.com/mock-server/mockserver-monorepo/security/advisories/GHSA-36c2-h3v8-7w6w))
- With `proxyAuthenticationUsername` and `proxyAuthenticationPassword`
set, SOCKS5 clients could proxy without credentials by offering "no
authentication", SOCKS4 clients were never asked for credentials, and
HTTP/3 CONNECT-UDP tunnels were opened without checking the
`Proxy-Authorization` header. SOCKS5 now selects username/password
authentication whenever the client offers it and refuses a client that
does not (replying `0xFF` and closing the connection), SOCKS4 is refused
(it cannot carry a password) with a warning in the log, and HTTP/3
CONNECT-UDP now requires the proxy credentials, answering `407` without
them. Without proxy credentials configured, SOCKS4, SOCKS5 and
CONNECT-UDP behave as before, except that a SOCKS5 `0xFF` refusal now
also closes the connection. With `transparentProxyEnabled` also set,
MockServer now logs a warning at startup that connections handled as
transparent proxying, including those whose destination comes from the
`Host` header or a PROXY protocol header, are not asked for proxy
credentials (fixes
[GHSA-36c2-h3v8-7w6w](https://redirect.github.com/mock-server/mockserver-monorepo/security/advisories/GHSA-36c2-h3v8-7w6w))
- With `proxyAuthenticationUsername` and `proxyAuthenticationPassword`
set, a plain HTTP proxy request for another host (a request line holding
a full URL, such as `GET http://example.com/path`) without the
credentials was still answered by a matching expectation, and was asked
for them only when nothing matched; a WebSocket upgrade for another host
was relayed to it without them; and the proxy WAR
(`mockserver-proxy-war`) never asked for them. Such a request to the
standalone server now gets `407` before it is matched against any
expectation, a WebSocket upgrade for another host is relayed only with
the credentials, and the proxy WAR asks for them before matching a
request whose `Host` names another host. A request sent to MockServer
directly (a request line holding only a path, as every HTTP/2 and HTTP/3
request is) is still matched without proxy credentials whatever its
`Host` header says, and needs them only when MockServer would forward
it; requests for MockServer's own address never need them. A request
refused this way is logged as a failed proxy authentication, as a
refused `CONNECT` is, not as a received request, so it does not count in
`verify` or `retrieveRecordedRequests`. The WAR (`mockserver-war`)
cannot see whether a request line held a full URL, so there every
request is handled like one sent to MockServer directly. Without proxy
credentials configured nothing changes
- Build-time dependency fixes, none shipped in a published package: the
Maven plugin's integration-test projects now pin Guava 33.8.0-jre, the
version the main build uses (GHSA-xxph-c9ww-hj94 was fixed in 33.7.2),
the VS Code extension's development lockfile resolves `qs` 6.16.1
(GHSA-6pq8-jhm2-2vcw; it reaches the build only through `@vscode/vsce` →
`typed-rest-client`), and the Rust client's lockfile resolves `rustls`
0.23.46 (GHSA-vp88-798v-h67f, GHSA-w44r-93j7-qv28, GHSA-c8m5-c952-6cm4,
GHSA-h2v8-394m-p7vv; the client uses native TLS, so `rustls` is listed
in its lockfile but not compiled into it). The development lockfiles of
the Node client, `mockserver-node`, the dashboard UI and the VS Code
extension now resolve `minimatch` 11.0.3 (GHSA-g3hv-75wg-m249) for every
copy that contains the affected code: under `c8` → `test-exclude` in the
Node client, through `mockserver-node`'s `glob` development dependency
(now 14.0.3), for `eslint` and its plugins in the dashboard UI and under
`@vscode/vsce` in the VS Code extension. All but `mockserver-node` use
npm `overrides`, because no release of those tools accepts `minimatch`
11 yet. The `minimatch` 3.x copies that `grunt` and `jshint` still pull
in do not contain the affected code. The development lockfiles of the
Node client and `mockserver-node` now also resolve `lodash` 4.18.1 for
the copy under `jshint` (GHSA-f23m-r3pf-42rh), through an npm
`overrides` entry because `jshint` accepts only `lodash` 4.17.x;
`jshint` does not call the affected `_.unset`, `_.omit` or `_.pullAt`
- The standard image (`mockserver/mockserver`, built from
`docker/local`), the `-aot` image and the reference `docker/Dockerfile`
image now run on `gcr.io/distroless/java-base-debian13:nonroot` instead
of `java-base-debian12`. Distroless stopped building
`java-base-debian12` in February 2026
([GoogleContainerTools/distroless#2023](https://redirect.github.com/GoogleContainerTools/distroless/issues/2023)),
so its pinned digest could no longer pick up Debian security fixes; the
new base ships `libbrotli1` 1.1.0-2+deb13u1, fixing CVE-2026-111497
(DSA-6582-1), and is the same Debian release as the other image variants
([#&#8203;2927](https://redirect.github.com/mock-server/mockserver-monorepo/issues/2927))
- The Node Testcontainers module's lockfile now resolves `glob` 14.0.3
and `minimatch` 11.0.3 under `archiver`, a runtime dependency of the
published `@mockserver/testcontainers` package (GHSA-3g3m-2fjr-6pw4,
GHSA-g3hv-75wg-m249). The fix uses npm `overrides`, which npm does not
apply when another project installs the package, so a project that
depends on `@mockserver/testcontainers` resolves these from its own
lockfile until `archiver` moves to the patched releases; it can add the
same `overrides` itself. The module does not reach the affected code:
`archiver` copies a directory without a glob pattern, and the affected
`glob` copy is used only by an `archiver-utils` helper that `archiver`
does not call
- The forward-target checks (`forwardProxyBlockPrivateNetworks`,
`forwardProxyAllowedHosts`, `forwardProxyDeniedHosts`) could be
sidestepped by a destination an upstream proxy reads differently from
MockServer. Through `forwardHttpProxy` the proxy's request line was
built from the raw `Host` header and path, so a `Host` such as
`8.8.8.8:80@169.254.169.254` or `allowed?.example.com`, a second `Host`
header, or a path not starting with `/` could send the proxy to a host
that was never checked. A plain HTTP request sent through
`forwardHttpProxy` now needs exactly one `Host` header (without one, the
client address is used) that is a host name, IPv4 address or bracketed
IPv6 address with an optional port, and is otherwise refused with `502
Bad Gateway` even when no check is set; its path always starts with `/`,
spaces and control characters in it, Unicode ones included, are
percent-encoded except CR and LF, which are still refused, and `OPTIONS
*` is sent as `OPTIONS http://<host>/` rather than with `*` appended to
the host. Through `forwardHttpsProxy` or `forwardSocksProxy`, a request
whose tunnel destination is not a host of that form is refused before
connecting, and so is a binary (non-HTTP) connection tunnelled through
any of the three upstream proxies, whose destination previously reached
the proxy as given (a `forwardProxyAllowedHosts` entry `*.allowed.com`
let `secret.internal.example/.allowed.com` through). A PROXY protocol v1
header whose destination is not an IP address of the family it declares
(`TCP4` or `TCP6`), such as a host name, is now ignored as malformed, as
the PROXY protocol requires. Where a check is set, a numeric IPv4 host
that is not four decimal octets without leading zeros (`0177.0.0.1`,
`0x7f.1`, `2130706433`), which resolvers may read as another address, is
refused, as is a forwarded request whose destination host or port cannot
be read, and an IPv6 address whose dotted IPv4 part has a leading zero
(`[::ffff:017.0.0.1]`) is refused too.
`forwardProxyBlockPrivateNetworks` and address entries in
`forwardProxyAllowedHosts` / `forwardProxyDeniedHosts` now check the
IPv4 address inside an IPv4-compatible (`::127.0.0.1`), IPv4-translated
(`::ffff:0:a9fe:a9fe`) or NAT64 (`64:ff9b::a9fe:a9fe`) IPv6 address.
Within the local-use NAT64 prefix `64:ff9b:1::/48`, which an operator
may divide into longer prefixes, and for a 6to4 address (`2002::/16`),
an address is refused if any IPv4 address it may carry is blocked or
denied, but never matches an allow-list entry through one; other
operator-specific NAT64 prefixes and Teredo (`2001::/32`) addresses are
not unwrapped, so egress control on the NAT64 gateway or proxy remains
the real protection. `forwardProxyBlockPrivateNetworks` also now blocks
the "this network" range `0.0.0.0/8` (`0.1.2.3`, `::0.0.0.2`), not only
`0.0.0.0`. A well-formed `Host` and path are sent as before. The checks
use MockServer's own lookup of a name, which an upstream proxy resolves
again, so restrict egress on the proxy too
- **The Kafka SSL keystore and truststore can only be set at startup**
(BREAKING for anyone who sends `kafkaSecurity.sslTruststoreLocation`,
`sslTruststorePassword`, `sslKeystoreLocation`, `sslKeystorePassword` or
`sslKeyPassword` to `PUT /mockserver/asyncapi`; see [upgrading to
9](https://www.mock-server.com/mock_server/upgrading_to_9.html#kafka_ssl_startup_only)).
A request could name any file as the Kafka keystore or truststore, so
anyone who could reach MockServer's API could make the Kafka client read
any keystore-format file the MockServer process can read. Those fields
are now rejected with a `400` that names the startup property to use
instead: `asyncKafkaSslTruststoreLocation`,
`asyncKafkaSslTruststorePassword`, `asyncKafkaSslKeystoreLocation`,
`asyncKafkaSslKeystorePassword` and `asyncKafkaSslKeyPassword` (system
property, environment variable such as
`MOCKSERVER_ASYNC_KAFKA_SSL_TRUSTSTORE_LOCATION`, properties file or
`Configuration`). MockServer gives them to the Kafka client when a
request's `securityProtocol` is `SSL` or `SASL_SSL`. While any of them
is set, an `SSL` request must leave out `kafkaBootstrapServers` or name
the startup `asyncKafkaBootstrapServers`, as a `SASL_*` request must, so
MockServer's client certificate is only presented to brokers chosen at
startup. `PUT /mockserver/configuration` ignores them with a warning,
and `GET /mockserver/configuration` returns the two locations but never
the passwords. The same `brokerConfig` keys outside `kafkaSecurity`, or
spelt with dots or another case, are rejected too. A `PUT
/mockserver/configuration` that supplies any startup-only secret (these
passwords, `asyncKafkaSaslJaasConfig`, `clusterFanInPeerAuthToken`,
`forwardCredentialHeadersByHost` or
`controlPlaneBasicAuthenticationCredentials`) now always logs the
warning, even when the value matches the one in force, so the warning
can no longer be used to confirm a guessed secret
- **The MQTT SSL keystore and truststore can only be set at startup**
(BREAKING for anyone who sends `mqttSecurity.sslProperties` to `PUT
/mockserver/asyncapi`, or, once an `asyncMqttSsl*` property or the JVM's
`javax.net.ssl.keyStore` is set, sends an `ssl://`/`wss://` broker URL
other than `asyncMqttBrokerUrl` or changes `asyncMqttBrokerUrl` with
`PUT /mockserver/configuration`; see [upgrading to
9](https://www.mock-server.com/mock_server/upgrading_to_9.html#mqtt_ssl_startup_only)).
The request's `sslProperties` went to the MQTT client unchanged, so
anyone who could reach MockServer's API could name any file as the MQTT
keystore or truststore, making the MQTT client read any keystore-format
file the MockServer process can read, and could choose its TLS protocol,
cipher suites, security provider and key and trust manager. Every
`sslProperties` entry is now rejected with a `400` that never echoes the
value. For `com.ibm.ssl.keyStore`, `keyStorePassword`, `keyStoreType`,
`trustStore`, `trustStorePassword` and `trustStoreType` it names the
startup property to use instead: `asyncMqttSslKeystoreLocation`,
`asyncMqttSslKeystorePassword`, `asyncMqttSslKeystoreType`,
`asyncMqttSslTruststoreLocation`, `asyncMqttSslTruststorePassword` and
`asyncMqttSslTruststoreType` (system property, environment variable such
as `MOCKSERVER_ASYNC_MQTT_SSL_TRUSTSTORE_LOCATION`, properties file or
`Configuration`), which MockServer gives to the MQTT 3 and MQTT 5
clients when the broker URL uses any scheme other than `tcp://` or
`ws://` (such as `ssl://` or `wss://`). The protocol, cipher suites,
providers and key and trust manager now come from the JVM's own TLS
settings (such as `jdk.tls.client.protocols`), and
`com.ibm.ssl.clientAuthentication`, which Paho reads only for a TLS
server and so never affected the client, is rejected too. The same keys
spelt in another case or with dots or underscores, placed directly in
`mqttSecurity`, or placed at the top level of `brokerConfig`, are
rejected the same way. While any `asyncMqttSsl*` property, or the JVM's
`javax.net.ssl.keyStore` (which Paho falls back to), is set, a request
using any scheme other than `tcp://` or `ws://` must leave out
`mqttBrokerUrl` or name the startup `asyncMqttBrokerUrl`, so
MockServer's client certificate is only presented to the broker chosen
at startup, and `PUT /mockserver/configuration` then ignores a new
`asyncMqttBrokerUrl` with a warning; with none of them set,
`asyncMqttBrokerUrl` can still be changed at runtime as before. `PUT
/mockserver/configuration` always ignores the six `asyncMqttSsl*`
properties with a warning, and `GET /mockserver/configuration` returns
the locations, types and broker URL but never the passwords
- **The template Java class settings can only be set at startup**
(BREAKING for anyone who changes `velocityDisallowClassLoading`,
`javascriptAllowedClasses` or `javascriptDisallowedClasses` with `PUT
/mockserver/configuration` or a client's `updateConfiguration`; see
[upgrading to
9](https://www.mock-server.com/mock_server/upgrading_to_9.html#template_class_access_startup_only)).
These settings decide whether response and forward templates can load
Java classes, but a `PUT /mockserver/configuration` could change them on
a running server, so anyone who could reach the control plane could let
templates use any Java class. Before, they were fixed at startup only
while `forwardCredentialHeadersByHost` was set. A `PUT` that sets a
different value is now still answered, but the value is ignored, a
warning is logged and `GET /mockserver/configuration` reports the value
in force; a `PUT` that sends the value already in force logs nothing.
Set them before the server starts with a system property, environment
variable, `mockserver.properties` or `Configuration`.
`javascriptDisallowedText`, `velocityDisallowedText` and
`mustacheDisallowedText` can still be changed at runtime (fixes
[GHSA-5xh7-f7gh-prcf](https://redirect.github.com/mock-server/mockserver-monorepo/security/advisories/GHSA-5xh7-f7gh-prcf))
- Upgraded Netty from 4.2.19.Final to 4.2.20.Final (bundled dependency;
netty-tcnative moves to 2.0.85.Final with it). It fixes
GHSA-6xv6-9mgg-mfvc, where a client could get past TLS
client-certificate (mTLS) authentication by resuming a TLS session,
three out-of-bounds reads in `netty-buffer` (GHSA-m77g-r4c7-3w77,
GHSA-rx4g-qxm6-238r, GHSA-qhw9-p586-v948), control characters not
neutralised in the HTTP/1.1 codec (GHSA-42mp-m8rq-6rgj) and several
HTTP/2, HTTP/3 and QUIC issues. Two visible changes: with
`tlsMutualAuthenticationRequired`, a client whose certificate MockServer
does not trust is now refused with a `bad_certificate` TLS alert instead
of `internal_error` when MockServer uses OpenSSL (the default when its
native library loads); and Netty now decrypts TLS into buffers of at
most 16 KiB, too small for a 16 KiB HTTP/2 DATA frame and its header, so
MockServer's HTTP/2 server now joins the two pieces of such a frame into
a buffer of their own size instead of one twice as large. An HTTP/2
upload over TLS sent in 16 KiB frames therefore holds about 1.0 to 1.3
times its size in memory while it arrives when the client sends each
frame in TLS records of its own, and 1.3 to 1.7 times when frames share
records (about 1.1 to 1.7 times before, for 1 and 4 MiB uploads);
cleartext HTTP/2 uploads in 16 KiB frames hold slightly less too. Also
upgraded jsoup to 1.24.1, Guava to 33.8.0-jre and Error Prone
annotations to 2.52.0, and, in the optional blob-store modules, the AWS
SDK to 2.57.8, Google Cloud Storage to 2.76.0 and Azure Storage Blob to
12.37.1
- When MockServer (the JAR, Docker image or Helm chart) is a forward
proxy, a request a client sends through it to another host is now
matched against expectations and, if none matches, forwarded, even when
its path looks like one of MockServer's own API routes, such as `PUT
http://upstream/mockserver/clear` or a `PUT /clear` inside a `CONNECT`
or SOCKS tunnel to another host (this changes behaviour for anyone who
sends MockServer API calls through MockServer's own proxy to an address
it cannot recognise as its own, as described below, or relies on a
MockServer reached as another MockServer's `proxyRemoteHost` answering
API or liveness calls the front MockServer does not serve itself).
MockServer used to answer such a request itself, so a proxied request
could clear, reconfigure or stop the proxy instead of reaching its
destination. Requests addressed to MockServer itself are served as
before: sent directly, whatever the host name, or sent through its own
proxy to a port it listens on (including ports added with `/bind`), to
`localhost` or another loopback address at any port (which `kubectl
port-forward` or `ssh -L` may relay to MockServer), or by host name to
one of its ports. No MockServer of this version or later serves an API
call that a MockServer forwarded as a proxy (it answers `404`, MCP and
WebSocket upgrades included), so a client that can only use the proxy
cannot reach the API of a MockServer of this version or later with the
forwarding MockServer's client certificate (upgrade every MockServer
that trusts the proxy's certificate authority before relying on this).
So an API call sent through the proxy to an address of MockServer's it
cannot recognise as its own, such as a Kubernetes Service port or a
Docker host or ClusterIP address, or to another MockServer, now gets
`404`: send such calls to MockServer directly. Such a call carries
`x-forwarded-by: MockServer_proxied` to its destination, and recorded
expectations (and recordings promoted to mocks) no longer keep an
`x-forwarded-by` header, so they match a client calling MockServer
directly. The proxy WAR does not classify proxied requests. Contributed
by Matthew Hall
([@&#8203;megahall](https://redirect.github.com/megahall)) in
[#&#8203;2955](https://redirect.github.com/mock-server/mockserver-monorepo/pull/2955)
- With `proxyAuthenticationUsername` and `proxyAuthenticationPassword`
set, the client's `Proxy-Authorization` header, which holds the proxy
password, was kept on the request after MockServer checked it: it was
shown in the dashboard, returned by `retrieve` for requests and logs,
written to recordings and recordings saved to disk, could be matched by
expectations, and was relayed to the upstream server in a proxied
WebSocket handshake. MockServer now removes the header once it has
checked it, whether the credential was right or wrong, so it is never
recorded, matched or forwarded; the log entries for a refused `CONNECT`
and for a request refused by data-plane authentication
(`dataPlaneAuthenticationRequired`) or for lacking TLS
(`tlsMutualAuthenticationRequired`) no longer hold it either. Without
proxy credentials configured, `Proxy-Authorization` is recorded and
matched as before, but, as for every other forwarded request, it is no
longer relayed in a proxied WebSocket handshake, and neither is
`Proxy-Connection`. Contributed by Matthew Hall
([@&#8203;megahall](https://redirect.github.com/megahall)) in
[#&#8203;2954](https://redirect.github.com/mock-server/mockserver-monorepo/pull/2954)
and
[#&#8203;2955](https://redirect.github.com/mock-server/mockserver-monorepo/pull/2955)
- The Go Testcontainers module (`mockserver-testcontainers/go`) now
requires `golang.org/x/crypto` v0.59.0 and
`github.com/klauspost/compress` v1.20.3 or later, so projects using it
no longer resolve versions with known advisories (GO-2026-6303,
GO-2026-6354, GO-2026-6355, GO-2026-5932, GO-2026-6865). Because that
`x/crypto` release needs Go 1.26, the module now requires Go 1.26 or
later
- The .NET Testcontainers module (`MockServer.Testcontainers`) now
requires Testcontainers 4.16.0 or later, which depends on SSH.NET
2026.0.0, so projects using it no longer resolve an SSH.NET version with
known advisories (GHSA-mggc-4xg6-vcxf, GHSA-q939-rpr3-3284). It still
accepts any `MockServerClient` from 7.1.0
- The proxy WAR (`mockserver-proxy-war`) forwarded a request that
matched no expectation and whose `Host` header was the WAR's own address
(`localhost`, `127.0.0.1` or the server's IP address, followed by its
port, except on port 80, and on port 443 over HTTPS, where it is written
without a port) back to that address, without asking for proxy
credentials even when `proxyAuthenticationUsername` and
`proxyAuthenticationPassword` were set. So a client that could reach the
WAR could fetch any other application on the same servlet container,
such as its management pages, as a request from the container itself.
Such a request, and one with no `Host` header, is now a request to
MockServer itself, as on the JAR, Docker image and Helm chart: it is
matched against expectations without credentials and, when nothing
matches, answered `404`; it is never forwarded to the container, and an
extension request filter or response transformer is told it was not a
proxy request. With `proxyRemoteHost` and `proxyRemotePort` set, an
unmatched one is forwarded there, and needs the proxy credentials when
they are configured; one whose path matches a `proxyPassMappings` entry
still goes to that entry's target. Requests whose `Host` names another
host are proxied as before
- Build and test tooling hardening, none shipped in a published package:
the API-collection CI gate installs PyYAML from a hash-pinned
requirements file, the container-test Dockerfiles are digest-pinned (the
curl test client moves from Ubuntu 20.04, now out of standard support,
to 24.04), the local dashboard launch scripts install with `npm ci`, the
JetBrains plugin's Gradle wrapper pins its distribution checksum, and a
new GitHub Actions workflow checks the committed `gradle-wrapper.jar`
files against Gradle's published checksums

##### Added

- A new startup property, `proxyProtocolTrustedSources`
(`-Dmockserver.proxyProtocolTrustedSources` or
`MOCKSERVER_PROXY_PROTOCOL_TRUSTED_SOURCES`), lists the IP addresses and
CIDR blocks (IPv4 or IPv6) a PROXY protocol v1 or v2 header is accepted
from when `transparentProxyEnabled` is on, normally the load balancer
that adds it. A PROXY header names where a connection is forwarded and
which client address is recorded for it, so until now any client that
could reach a transparent-proxy port could choose both; with the
property set, a connection from any other address that starts with a
PROXY header is closed with a warning, as HAProxy does with a header
from a source it does not trust, while connections without a header are
unaffected. Empty (the default) keeps today's behaviour. An entry that
is not a single IP address or CIDR block (a host name, a block with bits
set after its prefix, a block covering every address or every IPv4
address, a zone ID, an IPv4 part with a leading zero, an IPv4 address
written as `::a.b.c.d`) stops the server starting, each entry being
checked on its own, the entries in force are logged at startup, the
refusal warning is given at most once a minute, and `PUT
/mockserver/configuration` cannot change it. The startup warning given
when transparent proxying and proxy credentials are both set now says
whether it is set
- Release Docker images (`mockserver/mockserver` and its `-graaljs`,
`-clustered`, `-aot` and `-http3` tags, and
`mockserver/mockserver-webhook`) now carry an SPDX software bill of
materials (SBOM) and SLSA build provenance as image attestations,
readable with `docker buildx imagetools inspect <image> --format '{{
json .SBOM }}'` (or `.Provenance`); they are covered by the image's
cosign signature
- Every Maven artifact released to Maven Central now has a CycloneDX
software bill of materials next to it
(`<artifactId>-<version>-cyclonedx.json`), signed like the jar
- Dashboard: a workspace tab you are not looking at, on a different
server from the workspace you are in, now shows how many items
(requests, responses or stream frames) are paused at a breakpoint on its
server; click the count to open that workspace's Breakpoints view before
the breakpoint timeout continues them
- A new opt-in property, `recordTruncatedStreamTiming`
(`-Dmockserver.recordTruncatedStreamTiming` or
`MOCKSERVER_RECORD_TRUNCATED_STREAM_TIMING`), keeps the chunk timing of
a streamed forwarded response that is recorded as truncated: one the
upstream closes or resets without ending it, that times out
(`streamIdleTimeoutSeconds`), whose upstream fails, or that passes
`maxStreamingCaptureBytes`. Such a recording lost its
`x-mockserver-chunk-delays-ms`, so it could only be replayed as one
static response. With the property on it keeps the timing of the chunks
captured before the cut and stays marked `x-mockserver-stream-truncated:
true`; nothing is timed after the cut. A fixture made from a truncated
`text/event-stream` recording with that timing (for example by the
`record_llm_fixtures` MCP tool) now replays the events captured before
the cut with their delays, leaves out an event cut off part way, and
carries an `x-mockserver-fixture-warning` header; the replay then ends
the stream normally rather than reproducing how it broke. Other content
types keep the static fallback
([#&#8203;2929](https://redirect.github.com/mock-server/mockserver-monorepo/issues/2929))
- A new opt-in property, `recordOpenStreamsOnStop`
(`-Dmockserver.recordOpenStreamsOnStop` or
`MOCKSERVER_RECORD_OPEN_STREAMS_ON_STOP`), records a streamed forwarded
response that is still open when MockServer stops, such as a Server-Sent
Events push stream the backend never ends. Such a stream was recorded
only when it ended, so a stop (`PUT /mockserver/stop`, or `SIGINT` /
`SIGTERM` to the command line) lost it: it was missing from the recorded
expectations and from `persistedRecordedExpectationsPath`. With the
property on, the stop first ends each open recorded stream (the client
gets the normal end of the stream), records it as complete with its
`x-mockserver-chunk-delays-ms`, marks it
`x-mockserver-stream-closed-by-mockserver-stop: true`, and waits for
`persistedRecordedExpectationsPath` to be written; when the property is
set at startup the command line also stops MockServer this way on
`SIGINT` / `SIGTERM` (see the clean-stop entry under Changed for how
long to let `docker stop` wait). Nothing changes with the property off
([#&#8203;2945](https://redirect.github.com/mock-server/mockserver-monorepo/issues/2945))
- A new startup property, `forwardCredentialHeadersByHost`
(`-Dmockserver.forwardCredentialHeadersByHost` or
`MOCKSERVER_FORWARD_CREDENTIAL_HEADERS_BY_HOST`), adds credential
headers to requests MockServer forwards or proxies to a named upstream
host, each valued from an environment variable read once at startup, for
example `global.example.com=Authorization:GLOBAL_CLUSTER_TOKEN`. The
value is added only to the copy of the request written to the upstream,
so it never appears in expectations, the log, recordings, exports or the
dashboard, even with `redactSecretsInLog` off. Headers are sent only
over TLS unless an entry is written `http://host:port`, and HTTPS
entries need `forwardProxyTLSX509CertificatesTrustManagerType` set to
`JVM` or `CUSTOM` and `forwardProxyTLSHostnameVerificationEnabled` set
to `true`; otherwise they are ignored with a warning. A TLS connection
that carries a credential is always a new one, never pooled, and trusts
only the JVM's root CAs or the `CUSTOM` file as they were at startup,
never MockServer's own CA or a certificate it signed, even when the JVM
trust store or the `CUSTOM` file holds them, and never uses TLS 1.0 or
1.1. A header is added only when the connection target and the request's
single `Host` header name exactly the configured host and port, the path
starts with `/`, and the method is not `TRACE` or `CONNECT`. The
property can only be set at startup. Requests are no larger when the
property is not set. The configuration properties page explains what it
does not protect against
([#&#8203;2930](https://redirect.github.com/mock-server/mockserver-monorepo/issues/2930))
- A new opt-in property, `recordClientClosedStreamsComplete`
(`-Dmockserver.recordClientClosedStreamsComplete` or
`MOCKSERVER_RECORD_CLIENT_CLOSED_STREAMS_COMPLETE`), keeps the chunk
timing when the client closes a streamed forwarded response part-way
through. Since 9.0.0 MockServer then closes the upstream, and a chunked
stream was recorded as incomplete (`x-mockserver-stream-truncated`) with
no `x-mockserver-chunk-delays-ms`. With the property on, such a
recording ends complete, keeps its chunk delays and is marked
`x-mockserver-stream-closed-by-client: true`. A stream that the upstream
ends or breaks, and one MockServer closes itself (a response write
stall, an error or chaos action, an HTTP/2 or HTTP/3 connection error, a
QUIC transport or TLS error, or a server stop), is recorded as before.
The `maxStreamingCaptureBytes` limit still applies
- An SSE event can now carry a `comment` (`SseEvent.withComment(...)` in
Java, `comment` in JSON and in the Node, Python, Ruby, Go, .NET, Rust
and PHP clients, and a Comment field for each event in the dashboard's
expectation composer, whose generated code includes it). It is sent
before the event's other fields as `:` followed by each line of the
comment exactly as written (`keep-alive` is sent as `:keep-alive`, `
keep-alive` as `: keep-alive`), so an event with only a comment sends a
heartbeat and a blank line, which clients ignore. A line break in a
comment cannot start a new field or event. With `templateType` set the
comment is rendered like `data`, and for NDJSON, JSON array and AWS
event-stream LLM responses a comment-only event sends nothing but still
waits its delay. Events without a comment are sent exactly as before
([#&#8203;2946](https://redirect.github.com/mock-server/mockserver-monorepo/issues/2946))
- The `record_llm_fixtures` MCP tool takes `keepSseComments` (default
`false`). With it set, the comment lines of a recorded SSE stream, such
as `:heartbeat`, are kept: each comment-only chunk becomes an event with
only a `comment`, replayed exactly as recorded (the text after the
colon, leading space included) with its recorded delay
([#&#8203;2946](https://redirect.github.com/mock-server/mockserver-monorepo/issues/2946))
- A recorded streamed response now carries
`x-mockserver-first-chunk-delay-ms`, the time from the start of the
forward to the first chunk, measured on the same clock as
`x-mockserver-response-time-ms`. `x-mockserver-chunk-delays-ms` is
unchanged and its first value is still 0. Fixtures made by
`record_llm_fixtures` now replay the first event after that wait, so a
backend that waited before its first event is no longer replayed as
answering at once. The header is kept out of fixtures like the other
recording headers
([#&#8203;2947](https://redirect.github.com/mock-server/mockserver-monorepo/issues/2947))
- An SSE response can now wait before it ends: `closeDelay` on
`httpSseResponse` (`HttpSseResponse.withCloseDelay(...)` in Java, and in
the Node, Python, Ruby, Go, .NET, Rust and PHP clients and the
dashboard's generated code) is how long the stream stays open after its
last event, and `keepStreamOpen: true` keeps it open until the client
leaves or MockServer stops. Before, a stream always ended right after
its last event, so SSE clients reconnected at once. Fixtures made by
`record_llm_fixtures` from a stream the backend ended now get a
`closeDelay`, the recorded total time less the time the events replay
over, so the replay ends when the recording did; a truncated stream, or
one the client or MockServer's stop (`recordOpenStreamsOnStop`) closed,
gets none. `record_llm_fixtures` also no longer drops an SSE response's
`delay` and `primary` when it redacts a fixture. Responses without
either field behave as before
([#&#8203;2947](https://redirect.github.com/mock-server/mockserver-monorepo/issues/2947))

##### Changed

- The Rust client (`mockserver-client` crate) now needs Rust 1.88 or
newer (it declared 1.75), and CI now builds, tests and lints it on
exactly Rust 1.88 as well as on the latest stable (BREAKING for Rust
client users on an older compiler). It now uses reqwest 0.13,
tungstenite 0.30, sha2 0.11 and base64 0.23, and still connects with the
platform's native TLS over HTTP/1.1 as before.
`PausedStreamFrame::body_bytes()` now returns the client's own
`mockserver_client::Result<Vec<u8>>`: a body that is not valid Base64 is
the new `Error::Decode` variant, with the decoder's error as its
`source()`, instead of a `base64::DecodeError`, so later base64 upgrades
no longer change the client's API (BREAKING for code that names
`base64::DecodeError` from `body_bytes()`). `Error::Transport` still
holds a `reqwest::Error`, now from reqwest 0.13 (BREAKING for code that
converts its own reqwest 0.12 errors into `mockserver_client::Error` or
passes the inner error to reqwest 0.12 APIs). The Testcontainers module
(`testcontainers-mockserver` crate) now declares Rust 1.88 too, because
it uses the newest `mockserver-client`
- The command line and the Docker image now stop cleanly on `SIGINT` /
`SIGTERM` (Ctrl+C, `docker stop`, a Kubernetes pod shutdown) whenever
`persistExpectations`, `persistRecordedExpectations`,
`persistRecordedRequestsToDisk` or `recordOpenStreamsOnStop` is set at
startup, the same way `PUT /mockserver/stop` does, so its files are
written before the process exits. Before, the process exited at once and
could lose the last recorded requests still buffered for
`persistedRecordedRequestsPath` and the last write of
`persistedRecordedExpectationsPath`. A clean stop waits up to
`stopDrainMillis` (15 seconds by default) for requests still in progress
before it writes the files, and `docker stop` kills a container after 10
seconds, so give it longer (`docker stop -t 30`, `docker run
--stop-timeout 30`, Compose `stop_grace_period: 30s`; the Helm chart
already allows 45 seconds) or lower `stopDrainMillis`. With none of
these properties set, nothing changes
- A CONNECT or SOCKS tunnel through MockServer now carries any TCP
protocol, not only HTTP and TLS, to its destination (SOCKS4 only when
proxy credentials are not configured, since it is refused otherwise).
Where clients you do not trust can reach MockServer, limit where binary
connections may go with `forwardProxyBlockPrivateNetworks`,
`forwardProxyAllowedHosts` and `forwardProxyDeniedHosts`, which apply to
every binary connection. Proxy authentication
(`proxyAuthenticationUsername` and `proxyAuthenticationPassword`) is
asked for before a CONNECT or SOCKS tunnel opens, but not on a
transparent-proxy or port-forwarded connection, and
`dataPlaneAuthenticationRequired` does not apply to binary connections.
A binary connection's messages, including credentials a protocol sends
in the clear (a Redis `AUTH`, a PostgreSQL password), are kept in the
event log, so protect the control plane where MockServer proxies real
credentials
- .NET client (`MockServerClient` NuGet package): the `netstandard2.0`
build, used by .NET Framework and by .NET versions before .NET 8, now
depends on `System.Text.Json` 10.0.14 and
`Microsoft.Bcl.AsyncInterfaces` 10.0.14, up from 8.0.6 and 8.0.0,
because .NET 8 support ended on 2026-11-10. A project that pins either
package, or a package `System.Text.Json` 10 depends on such as
`System.Text.Encodings.Web`, below the new version must raise its pin,
or restore fails with NU1605 (package downgrade). On .NET 6 or 7,
`System.Text.Json` now also prints a build warning that the target
framework is unsupported. The `net8.0` build, used by .NET 8 and later,
has no package dependencies and is unchanged, and the target frameworks
(`netstandard2.0`, `net8.0`) are unchanged
- The nightly client conformance sweep (CI) no longer re-runs the seven
client pipelines when `master` has not moved since the last passed sweep
- Snapshot builds are now published once a night (02:00 UTC) from
`master` instead of after every commit: the
`mockserver/mockserver:snapshot` image and its variant tags on Docker
Hub and ECR Public, the SNAPSHOT jars in the Sonatype snapshot
repository, and the snapshot binary bundles the client launchers
download. A snapshot can be up to a day behind `master`
- Dashboard: a link that names a server with `?host=`, `?port=`,
`?secure=` or `?basePath=` now opens on that server even when the
workspace you had open has its own server. The link opens in a workspace
that follows it (an existing one without its own server, or a new one),
and your workspace keeps its server, view and searches, one tab away.
Before, the stored server won and the link was ignored

##### Removed

- The `http1PipeliningInOrder` property
(`-Dmockserver.http1PipeliningInOrder`,
`MOCKSERVER_HTTP1_PIPELINING_IN_ORDER`), the temporary switch added in
9.2.0 to turn off in-order answering of pipelined HTTP/1.1 requests.
MockServer now always answers requests pipelined on one connection in
the order they were sent. A configuration that still sets it is not an
error: the property is ignored, the startup warning and
`diagnose_config` report it as removed, and `PUT
/mockserver/configuration` ignores the field. The perf pipeline's on /
off A/B for it (about 5 minutes of each `perf-run`) is removed with it,
and that step's timeout goes back from 90 to 80 minutes

##### Fixed

- A streamed forwarded response still in a `Content-Encoding` MockServer
does not decode (such as a custom coding) was recorded as text, which
corrupted its bytes, so replaying the recording sent the client
different bytes than the upstream had. It is now recorded as its bytes,
and an SSE fixture made from it replays those bytes unchanged instead of
trying to read events from them
- An SSE recording whose lines end with a lone carriage return (`\r`),
which the SSE specification allows, was turned into a fixture as one
garbled event. Lines may now end with CRLF, LF or CR, and a CRLF is
still one line end
- The trailers that end a streamed forwarded response (an HTTP/1.1
chunked trailer section, such as a checksum) were dropped: the client
never received them and the recording did not hold them. They are now
relayed to the client and recorded as the response's trailers
- An SSE fixture made from a recorded stream replayed events at the
wrong times when the backend's chunks did not hold one event each:
events the backend sent together were spread out over the delays of
later chunks, and an event that arrived in pieces was replayed before
its last piece arrived. A recording now also carries the bytes each
chunk held (`x-mockserver-chunk-sizes-bytes`, a log-only header like the
other recording headers), and each event replays when the chunk that
completed it arrived. Recordings made with earlier versions replay as
before
- A forwarded or recorded `text/event-stream` or `application/x-ndjson`
response that named no `charset` was read as ISO-8859-1, so non-ASCII
text in it (accented letters, emoji, CJK) was garbled in the event log,
the dashboard and the recorded expectation, and an SSE fixture made from
the recording (such as by `record_llm_fixtures`) replayed it garbled.
Both types are always UTF-8, so MockServer now reads and writes them as
UTF-8 when no charset is given. A mocked `text/event-stream` response
with a static body is now also sent as UTF-8, rather than as ISO-8859-1
(with `?` for any character outside it)
- A recorded gRPC call made by a client that sets a deadline did not
match the same call when replayed: the recorded expectation required the
call's `grpc-timeout` header, which is the time left before the deadline
and so differs on every call, and the replayed call was answered
`UNIMPLEMENTED` (or proxied again). Recorded expectations no longer
include `grpc-timeout` or `grpc-previous-rpc-attempts` (the retry
count). Recordings made with earlier versions hold the header: re-record
them, or remove it from their request
- When MockServer proxied or forwarded a gRPC call, the upstream's
trailing metadata (trailers such as `x-cost` or a `-bin` key sent with
`grpc-status`) reached the client as response headers, so a client
reading it from the trailers did not find it, and the same happened when
the recording was replayed. Trailing metadata is now relayed, recorded
and replayed as trailers, and `redactSecretsInLog` and
`redactSecretsInRecordedExpectations` mask a sensitive trailer (such as
`x-api-key`) as they mask that header
- A gRPC call forwarded by a `FORWARD` expectation while no gRPC
descriptors were loaded was sent to an HTTPS upstream over HTTP/1.1,
which a gRPC server refuses, so the client got `UNAVAILABLE`. It is now
sent over HTTP/2 with `te: trailers`, as with descriptors loaded, and
its `grpc-status` reaches the client in the trailers. A plaintext
upstream is still called over HTTP/1.1
- A `grpcStreamResponse` sent to a gRPC-Web client
(`application/grpc-web` or `application/grpc-web-text`) was written as
plain gRPC, with the `application/grpc` content type, unencoded for
`-text`, and its status in HTTP trailers, which a browser cannot read.
It is now sent as gRPC-Web: each message in a frame, base64-encoded for
`-text`, followed by the gRPC-Web trailer frame carrying `grpc-status`
and `grpc-message`
- A WebSocket reached through MockServer as an HTTP `CONNECT` or SOCKS
proxy, which is how browsers and most HTTP clients send `ws://` and
`wss://` through a proxy, failed at its first message: after the `101
Switching Protocols` the tunnel went on reading the WebSocket frames as
HTTP, so the connection ended or the client was sent an HTTP error. This
broke mocked (`httpWebSocketResponse`) and proxied WebSockets alike.
After a `101` the tunnel now carries the connection's bytes unchanged in
both directions
- A proxied WebSocket handshake no longer forwards hop-by-hop request
headers to the upstream: `Keep-Alive`, `TE`, `Trailer`,
`Transfer-Encoding` and any header the request's `Connection` header
names. They describe the client's connection to MockServer, not
MockServer's to the upstream
- A proxied WebSocket whose upstream selected none of the subprotocols
the client offered (`Sec-WebSocket-Protocol`) was answered `502`; the
upstream's answer is now relayed, with no subprotocol, and the client
decides, as RFC 6455 allows. A client that sends each subprotocol on its
own `Sec-WebSocket-Protocol` line now has all of them offered upstream
and selectable, not only the first
- A WebSocket frame larger than 64 KiB was refused with close code
`1009` (message too big): by a proxied WebSocket in both directions, and
by a mocked one for what the client sent. A frame from the client is now
limited by `maxRequestBodySize` (10 MiB by default) and one from the
upstream by `maxResponseBodySize` (50 MiB by default), as request and
response bodies are. With `maxRequestBodySize` set below 64 KiB, the
limit on WebSocket frames from clients is now lower than before
- A mocked WebSocket's message matchers now see a message the client
sends in fragments (a text or binary frame followed by continuation
frames) as one message. Before, each fragment was matched on its own, so
a matcher for the whole text never matched, and a matcher for any frame
answered every fragment. A whole message larger than
`maxRequestBodySize` closes the WebSocket with code `1009`
- A proxied WebSocket closed by either side with a close frame now
answers that side with a close frame of the same code and reason, as RFC
6455 requires. Before, the side that started the close got only the end
of its connection, so browsers reported an abnormal close (`1006`,
`wasClean` false) and other clients waited for a close frame that never
came
- A gRPC call that MockServer proxied or forwarded, with gRPC
descriptors loaded, and whose response had no messages (such as a server
stream that ended straight away) reached the client with one placeholder
message, and so did every replay of its recording: the empty response
was recorded with no body, which MockServer fills with an example
message. It is now recorded as an empty JSON array (`[]`) and sent,
while proxying and on replay, as a stream with no messages and the
upstream's `grpc-status`. Recordings made with earlier versions hold no
body for such a call: re-record them, or set the response body to `[]`.
A server stream with several messages, recorded as a JSON array of them,
is now also sent as those messages over HTTP/1.1, HTTP/2 and HTTP/3; it
was answered `INTERNAL`. A forwarded client-streaming call that sent no
messages no longer has an empty message added to it, and a recorded gRPC
response no longer lists its `grpc-status` twice
([#&#8203;2988](https://redirect.github.com/mock-server/mockserver-monorepo/issues/2988))
- A forwarded or proxied request whose every header is hop-by-hop (such
as `Connection`, `Proxy-Connection` or `Proxy-Authorization`) kept all
of them, because the filter that drops those headers left a request
unchanged when it would have had no headers left. It is now forwarded
with none. Contributed by Matthew Hall
([@&#8203;megahall](https://redirect.github.com/megahall)) in
[#&#8203;2954](https://redirect.github.com/mock-server/mockserver-monorepo/pull/2954)
and
[#&#8203;2955](https://redirect.github.com/mock-server/mockserver-monorepo/pull/2955)
- With `persistRecordedExpectations` on, a recording made in the last
quarter of a second before MockServer stopped could

> [!IMPORTANT]
> ✂ PR body was truncated to here.


</details>

---

### Configuration

📅 **Schedule**: (UTC)

- Branch creation
  - At any time (no schedule defined)
- Automerge
  - At any time (no schedule defined)

🚦 **Automerge**: Enabled.

♻ **Rebasing**: Whenever PR is behind base branch, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

This PR was generated by [Mend Renovate](https://mend.io/renovate/).
View the [repository job
log](https://developer.mend.io/github/prometheus/client_java).

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiI0NC4yNDkuMSIsInVwZGF0ZWRJblZlciI6IjQ0LjI0OS4xIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6WyJkZXBlbmRlbmNpZXMiXX0=-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

dependencies Pull requests that update a dependency file

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant