All jobs

Add Request ID Logging to a Slim App

Yes. An agent adds a request-id middleware to your Slim 4 app, puts the id on every response, error and Monolog line, tests it with PHPUnit, and opens a PR.

Run this on RushOpens the console with this prompt ready to send, in a Project that has your repository.

What the agent does

The agent reads how a request flows and where the log lines come from. In a Slim app like slimphp/Slim-Skeleton, composer.json requires slim/slim ^4.12, slim/psr7 ^1.6, php-di/php-di ^6.4 and monolog/monolog ^2.9 on PHP ^7.4 or ^8.0, with phpunit/phpunit ^9.6.17, phpstan/phpstan ^1.10 and squizlabs/php_codesniffer ^3.9 for development. app/dependencies.php builds the LoggerInterface as a Monolog Logger named slim-app from app/settings.php, pushes a UidProcessor and a StreamHandler writing to logs/app.log, or php://stdout when the docker environment variable is set as docker-compose.yml sets it. Every action extends src/Application/Actions/Action.php, which takes that logger in its constructor, so the two user actions already have a logger to write to.

It then works out why the existing UidProcessor is not enough. Monolog generates that uid once per logger instance, so it ties lines together within one PHP process, but it never comes from the client, never goes back in the response, and cannot be matched to a load balancer's log. The agent reads public/index.php for the middleware order: app/middleware.php adds SessionMiddleware, then the file adds routing, body parsing and the error middleware, which in Slim 4 means the error middleware runs outermost. A middleware added in app/middleware.php therefore never sees the response the HttpErrorHandler in src/Application/Handlers builds for an exception, which matters because an error response is exactly the one a developer wants to find in the log.

The change is three files. src/Application/Middleware/RequestIdMiddleware.php takes X-Request-Id from the incoming request when present, otherwise makes one from random_bytes, stores it as the request attribute request_id and sets the same header on the response. src/Application/Logging/RequestIdProcessor.php is a small Monolog processor holding the current id and adding it to each record's extra, registered in app/dependencies.php as a shared service that the middleware updates; Monolog's default LineFormatter prints extra as JSON at the end of the line, so request_id appears beside the existing uid. HttpErrorHandler::respond() reads the attribute from $this->request and adds the header to its own response, which covers the error path the middleware order leaves out. The middleware is registered in app/middleware.php, so tests/TestCase.php, whose getAppInstance() loads the same file, picks it up without changes.

Tests use the skeleton's own helpers. tests/Application/Middleware/RequestIdMiddlewareTest.php builds the app with getAppInstance(), sends createRequest('GET', '/users') with an HTTP_X_REQUEST_ID header and asserts it comes back unchanged, then sends one without and asserts the generated header's shape; a third case swaps the container's LoggerInterface for one with Monolog's TestHandler, the way ListUserActionTest.php swaps UserRepository, and asserts the record's extra['request_id'] equals the response header. The agent runs vendor/bin/phpunit, vendor/bin/phpcs and vendor/bin/phpstan, the three commands .github/workflows/tests.yml runs on the PHP 8.1 analysis job, and keeps the new code at PHP 7.4 syntax because that workflow's matrix starts there.

Start it with one API call

POST https://api.phoenix.so/o/{org}/sessions with this body:

{
  "agent": "claude",
  "input": "Add request ID logging to this Slim 4 application. Read composer.json, public/index.php, app/settings.php, app/dependencies.php, app/middleware.php, app/routes.php, src/Application/Actions/Action.php, src/Application/Handlers/HttpErrorHandler.php, src/Application/Middleware/SessionMiddleware.php, tests/TestCase.php, tests/Application/Actions/User/ListUserActionTest.php, phpunit.xml and .github/workflows/tests.yml first. Add src/Application/Middleware/RequestIdMiddleware.php that reuses an incoming X-Request-Id header or generates one with random_bytes, stores it as the request attribute request_id and sets the X-Request-Id response header; register it in app/middleware.php. Add a Monolog processor that adds request_id to every record's extra, register it as a shared service in app/dependencies.php next to the existing UidProcessor, and have the middleware update it. Make HttpErrorHandler::respond() add the header from the request attribute so error responses carry it too. Write tests/Application/Middleware/RequestIdMiddlewareTest.php using getAppInstance() and createRequest() for the echoed header, the generated header and, with Monolog's TestHandler set on the container, the log record's extra. Keep PHP 7.4 syntax. Run vendor/bin/phpunit, vendor/bin/phpcs and vendor/bin/phpstan, and open a pull request that shows one log line before and after.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
  1. Get an API key. In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
  2. Send the request. POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
  3. Read what came back. Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

What comes back

What comes back is a pull request that adds the middleware, the processor and the test, and changes app/middleware.php, app/dependencies.php and src/Application/Handlers/HttpErrorHandler.php. The description shows a line from logs/app.log before and after, with request_id in the extra JSON next to uid, and explains why the error handler needed its own line: in Slim 4 the error middleware runs outside anything added in app/middleware.php.

The run's record keeps the phpunit, phpcs and phpstan output, so a reviewer can see the three new tests pass with the existing user action tests and that the code sniffer and static analysis raised nothing, without running them locally.

Before merging, a reviewer decides whether to trust an incoming X-Request-Id from the public internet or only from the load balancer, and whether the header name should match the one that balancer already sets. The agent accepts any incoming value up to a sane length and says that a stricter rule is a one-line change in the middleware.

Run it on every Linear issue labelled observability

A team that files logging gaps as Linear issues adds an automation on the Project with a linear trigger filtered to the label observability and the prompt above, written for the general case: the trigger adds the issue after the prompt, so the run reads the issue's text for which header name and which services the team wants. Each labelled issue starts one run, and a pull request comes back linked from the run.

The automation runs as the member who last changed it and needs that member's Linear connection, made once under Settings → Connections. Its max_runs_per_hour cap bounds a burst of labelled issues, so a triage session that labels ten at once does not start ten runs in the same minute.

The use case this job follows, with its automation and trigger: Turn a Linear label into a PR.

Why run it on Rush?

Request ids are only worth adding if every path carries them, and the path that matters most, an exception answered by the error handler, is the one a middleware in the usual place misses. The agent finds that from the order in public/index.php and tests the error path in its own sandbox, so the pull request covers it instead of assuming it.

Every command the agent ran stays with the run, from the test output to the static analysis, so the pull request can cite them. Doing the same across every PHP service a team runs at once costs no more attention than one, because each run has its own machine and its own record.

Frequently asked questions

Does the existing UidProcessor already do this?

Not quite. Monolog's UidProcessor makes one random id per logger instance, which under PHP-FPM is one per request, but it is never read from or written to an HTTP header. The new id is accepted from X-Request-Id, returned in the response and logged, so a line can be found from the client's side. The agent keeps the uid in place.

Why does the error handler need a change?

Because of middleware order. public/index.php adds the error middleware after app/middleware.php runs, which in Slim 4 makes it the outermost layer. When a route throws, the response is built by HttpErrorHandler and never passes back through the request-id middleware, so the handler sets the header itself from the request attribute.

Will this work with the Docker setup?

Yes. docker-compose.yml sets the docker environment variable, which app/settings.php reads to send the log to php://stdout instead of logs/app.log. The processor adds request_id to the record either way; only the handler's destination differs.

Does it change the PHP version the project supports?

No. composer.json allows PHP ^7.4 and .github/workflows/tests.yml tests 7.4 through 8.2, so the new classes use typed properties and no enums, readonly properties or first-class callable syntax. The agent runs the suite on the sandbox's PHP and notes the version it used.

More Slim jobs

The same job on other stacks

Keep reading