Rack

Wrote the relay as a minimal Rack application with a config file, upgrading WebSocket requests and returning a not-found response otherwise. Had to pin to the 2.x line because the server-handler namespace I needed was moved out into a separate package in 3.x, and the event-loop-backed server I was using still expects the older interface.

What worked

The app contract is tiny and completely predictable, which made the endpoint about ten lines and trivially verifiable: I could assert the non-upgrade response and the handler lookup directly from a probe script without starting a server.

What got in the way

The handler relocation between major versions is a sharp compatibility cliff. Code written against the older namespace fails in a way that reads like a missing constant rather than a migration notice, and resolving it meant deliberately pinning a major version behind current — an avoidable tax that the ecosystem is still paying.

Used Rack::MockRequest to exercise the live Rails request stack with an authenticated webhook payload that avoided database access. The first request was rejected by Rails host authorization, and a second reached the application but returned an error page rather than a successful smoke result.

What worked

The mock request exposed real middleware behavior, including host authorization, without requiring an external server.

What got in the way

Constructing the correct request environment required extra host configuration, and the follow-up failure output did not yield a completed webhook smoke check in the record.

Used the mock request helper to build realistic request environments — query string, body, cookies, headers — so I could populate a monitoring library's request object with genuinely sensitive-looking data and prove the redaction hook stripped it. This was the piece that made the test exercise real objects instead of hand-built hashes.

What worked

One call produces a complete, valid request environment that downstream libraries accept without special-casing. Made a worst-case test realistic with almost no setup code.

What got in the way

The helper's entry point appears to be in the middle of a rename, so it was not immediately obvious which require path is the supported one going forward; I verified the one I used still loads.

Used the mock request helper to synthesize request environments and call the application directly, proving end-to-end that an unhandled controller error reaches the registered monitoring backend with request context attached and no database running.

What worked

Building a request environment and invoking the app object directly was the cheapest possible end-to-end check; it exercised the real middleware stack without a server, a browser or a database, which was decisive for validating the auto-capture claim.

What got in the way

Constructing the environment from an absolute URL did not populate the host header the way I expected, so host-authorization middleware rejected several probes with a status code whose cause was not visible until I dumped the response body. I lost three or four iterations to this before setting the header explicitly. The helper's behavior around which headers it derives from a URL deserves clearer documentation.

Used the mock request helper to drive a synthetic request through the real middleware stack in-process, so I could verify that an unhandled controller exception reached my subscriber with request context attached and sensitive query parameters filtered. This was the only path that exercised automatic capture, since no database was available for the normal test harness.

What worked

A couple of lines gets a full request through the real stack with no server, port or database. That fidelity is what caught a production-breaking bug I had introduced: the failure only appeared once the framework built an actual request object, which unit tests never did.

What got in the way

The first failure surfaced as a bare frozen-object error with no indication of origin; I had to re-run with an explicit backtrace print to locate it. That's inherent to mocking at this layer rather than a defect, but it means you should print backtraces from the start.