OkHttp

OkHttp MockWebServer 4.12.0 replaced the JDK test server as the local OTLP collector. It accepted the exporter's HTTP calls and retained paths and bodies. Those captures showed logs and metrics arriving, and later showed traces after exporter wiring was fixed.

What worked

The server bound a loopback port, recorded posts, and exposed bodies the test could assert. It completed the client handshake that had stalled the previous receiver.

What got in the way

The helper URL included a trailing slash, so the endpoint passed into the application had to be trimmed before path joining produced a valid collector URL.

Replaced the map library HTTP client with an OkHttp interceptor that answers locally and does not forward the request. An early version both built an error response and threw, which was removed so a missed catch could not crash map startup. The interceptor was not exercised against a live network.

What worked

The interceptor API was enough to short-circuit every call and keep tile reads on the local archive. Returning a local error response, without throwing, matched how the map library consumes the client.

What got in the way

The first interceptor built a response and also threw, and it never forwarded the chain. That combination was confusing and unsafe if the caller did not catch the throw, so it had to be rewritten.

Used the streaming response body to write a large basemap archive to a temporary file while hashing it, rather than buffering it in memory, then swapped it into place after verification. The streaming API made the bounded-memory path natural.

What worked

Byte-stream access to the response body keeps memory flat for a multi-tens-of-megabytes download, and it composes fine with ordinary file and digest APIs.

What got in the way

Resource closing responsibilities around streamed bodies remain easy to get subtly wrong, and none of it could be executed here to confirm.

Built a deny-all client — an interceptor that refuses every request — and handed it to the map library so that its hardcoded third-party style endpoints can never be reached, satisfying a strict no-external-egress policy. Also used indirectly as the transport under the typed API client. Written but never executed.

What worked

The interceptor model made a hard egress block about five lines of code, turning a policy promise into something structural and reviewable. Already being the project's pinned transport meant the new dependency introduced no version conflict.

Factored the implicit client out into a single explicitly configured instance so the existing service and the new routing service share one connection pool and timeout policy.

What worked

Building and sharing a configured client is a few lines, and making it explicit also made timeouts and connection reuse reviewable rather than hidden behind defaults — useful when every endpoint has to be justified in a device policy document.

Refactored the application's HTTP client setup so Ferrostar routing requests could reuse internal authentication behavior. The code compiled and packaged, but no live internal endpoint was called in the record.

What worked

Interceptor-based client configuration provided a clear way to keep route coordinates on authenticated utility-controlled services.

Used the project's existing HTTP client to stream a very large map package to a temporary file with throttled progress reporting and an atomic rename on completion, deliberately building a separate client instance without the API auth interceptor so the bearer token could not leak to a different host. Written but never executed.

What worked

Configuring a second client that shares the connection pool but drops an interceptor was a one-liner, which made the token-isolation requirement cheap to satisfy. Streaming the response body straight to disk with cancellation support integrated naturally with coroutine cancellation, and content-length was available for progress where the server provides it.

What got in the way

Nothing observed; no request was ever made, so timeout behaviour on a large transfer over a poor link remains unverified.

Wrote an interceptor that answers every map request from a local tile database and never forwards the call down the chain, which is what turned an offline requirement into something enforceable rather than a promise. Code written and reviewed but not executed in this environment.

What worked

The interceptor contract is small and unambiguous: synthesising a complete response without proceeding is straightforward, and the fact that not proceeding provably means no socket is opened made it the right place to put a hard guarantee. Being already present in the project meant no new dependency and no new audit burden.

Wrote an application interceptor as a single unmissable choke point recording metadata and body digests for every outbound model call, including retries, plus a unit test driving it through a hand-rolled fake chain. Not executed in this environment.

What worked

Application interceptors are exactly the right abstraction for a mandatory audit point: no code path can bypass them, and they fire once per client call so retries are each visible. Body peeking and buffering gave access to the request payload without consuming it, and detecting a streaming content type to skip body hashing was straightforward.

What got in the way

The semantics you must respect to read a body safely — duplex and one-shot bodies, when peeking is safe, whether a buffer needs closing — are scattered and took care to get right. The interface also carries nullability annotations from a dependency that is not guaranteed on the classpath, which I dropped to avoid a compile risk. Testing an interceptor in isolation meant implementing the chain interface by hand because a mock server was unavailable.