0.34.x

[loks0n]

No description provided.

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on base/target branches other than the default branch.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: d29c187e-8381-420b-ab45-9fec0cd3a823

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch 0.34.x

📝 Coding Plan

• Generate coding plan for human review comments

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[greptile-apps]

Greptile Summary

This PR introduces the 0.34.x branch, adding split Swoole/SwooleCoroutine adapters, telemetry (OpenTelemetry-compatible metrics), compression support, and DI container isolation per request. The most significant new finding is in src/Http/Http.php: the onRequest hook error handler catches \Exception only, meaning PHP internal Errors (e.g., TypeError) thrown from request hooks bypass the framework's error handler entirely. The same issue exists in the start() hook handler. The execute() method correctly uses \Throwable — these two catch sites should match it.

• P1 (src/Http/Http.php line 877): catch (\Exception $e) in request hooks lets PHP Errors escape uncaught, bypassing all configured error handlers. Same issue at the start-hook catch (line 646).
• P2 (src/Http/Http.php line 959): elseif (REQUEST_METHOD_OPTIONS == $method) is dead code — the earlier if block at line 915 always handles OPTIONS and returns before this branch is reachable.

Confidence Score: 3/5

Needs fixes before merging — the P1 \Exception-only catch in request hooks lets PHP Errors bypass all error handlers, and prior review threads flagged several additional open issues (activeRequests counter leak, Swoole getSize returning zero, missing port cast).

One confirmed P1 defect (request-hook errors escaping the error handler) plus several open items from previous review threads that appear unresolved. Score reflects that this is a significant architectural PR that is close but needs targeted fixes on Http.php before it is safe to ship.

src/Http/Http.php requires the most attention — P1 catch-block fix, removal of dead OPTIONS branch, and the previously flagged activeRequests try/finally gap.

Important Files Changed

Filename	Overview
src/Http/Http.php	Core HTTP orchestration class — contains a P1 bug where \Exception-only catch in request hooks lets PHP Errors bypass the error handler, dead unreachable OPTIONS branch, and a gap in the isSent() guard for group init hooks.
src/Http/Adapter/Swoole/Server.php	Process-mode Swoole server adapter — correctly casts port to int; sets per-request coroutine container but lacks try/finally cleanup (noted in previous threads).
src/Http/Adapter/SwooleCoroutine/Server.php	Coroutine Swoole adapter — correctly uses try/finally for container cleanup; missing (int) cast for port (noted in previous threads).
src/Http/Adapter/Swoole/Response.php	Swoole response adapter — spurious (string) cast in sendStatus (noted in previous threads); otherwise straightforward delegation to Swoole response object.
src/Http/Request.php	Abstract request base class — getSize() uses php://input which returns empty in Swoole adapters (noted in previous threads); otherwise well-structured abstract interface.
src/Http/Adapter/FPM/Server.php	FPM server adapter — simple synchronous single-request lifecycle; no issues found.

_{Reviews (4): Last reviewed commit: "Skip action if response already sent by ..." | Re-trigger Greptile}

[greptile-apps]

Unnecessary (string) cast in sendStatus

Swoole\Http\Response::status() has the signature status(int $http_status_code, string $reason = ''): bool. $statusCode is already typed as int by the parent abstract method — casting it to string before passing it in is at best a no-op (PHP coerces it back) and could cause a TypeError if Swoole ever enforces strict typing internally. The cast should be removed.

Suggested change

	$this->swoole->status((string) $statusCode);
	$this->swoole->status($statusCode);

[greptile-apps]

Missing try/finally cleanup for coroutine context

The SwooleCoroutine\Server variant wraps the callback invocation in a try/finally to unset(Coroutine::getContext()[self::REQUEST_CONTAINER_CONTEXT_KEY]) after each request, ensuring stale per-request containers don't linger if an exception escapes. The process-mode Swoole\Server does not do this:

Coroutine::getContext()[self::REQUEST_CONTAINER_CONTEXT_KEY] = $requestContainer;
\call_user_func($callback, new Request($request), new Response($response));
// No cleanup

Although Swoole destroys each request coroutine's context automatically when the coroutine exits, adding the matching try/finally here keeps the two adapters consistent and guards against any future change that reuses coroutines across requests:

Suggested change

	$this->server->on('request', function (SwooleRequest $request, SwooleResponse $response) use ($callback) {
	$requestContainer = new Container($this->container);
	$requestContainer->set('swooleRequest', fn () => $request);
	$requestContainer->set('swooleResponse', fn () => $response);
	Coroutine::getContext()[self::REQUEST_CONTAINER_CONTEXT_KEY] = $requestContainer;
	\call_user_func($callback, new Request($request), new Response($response));
	Coroutine::getContext()[self::REQUEST_CONTAINER_CONTEXT_KEY] = $requestContainer;
	try {
	\call_user_func($callback, new Request($request), new Response($response));
	} finally {
	unset(Coroutine::getContext()[self::REQUEST_CONTAINER_CONTEXT_KEY]);
	}

[greptile-apps]

getSize() reads php://input — incorrect for Swoole adapters

The base getSize() calls file_get_contents('php://input') to measure the request body size. This works under PHP-FPM, but in Swoole the request body is only accessible via $swoole->rawContent() — PHP's php://input stream is empty in that context.

Neither Swoole/Request.php nor SwooleCoroutine/Request.php override getSize(). Because Http::run() now calls $this->requestBodySize->record($request->getSize(), ...) for the new telemetry, all Swoole requests will report zero bytes for the body in the http.server.request.body.size metric.

Fix: override getSize() in Swoole/Request.php to use rawContent() for the body component:

public function getSize(): int
{
    $headers = $this->generateHeaders();
    $headerStrings = [];
    foreach ($headers as $key => $value) {
        $headerStrings[] = is_array($value)
            ? $key . ': ' . implode(', ', $value)
            : $key . ': ' . $value;
    }
    return mb_strlen(implode("\n", $headerStrings), '8bit')
         + mb_strlen($this->swoole->rawContent(), '8bit');
}

SwooleCoroutine/Request.php extends Swoole/Request.php, so it will inherit the fix.

[greptile-apps]

activeRequests counter leaks when runInternal throws

run() increments the active-requests counter before calling runInternal(), but the matching decrement sits after the call with no try/finally guard. runInternal can throw — for example, when an error handler itself raises an exception the code explicitly re-throws:

throw new Exception('Error handler had an error: ' . $e->getMessage(), 500, $e);

If that path is taken the add(-1) call on line 842 is skipped, and the http.server.active_requests gauge is permanently over-counted by one for every such request. Over time this makes the metric untrustworthy.

The fix is to wrap the post-call telemetry in a try/finally:

$start = microtime(true);
try {
    $result = $this->runInternal($request, $response);
} finally {
    $requestDuration = microtime(true) - $start;
    $attributes = [
        'url.scheme' => $request->getProtocol(),
        'http.request.method' => $request->getMethod(),
        'http.route' => $this->route?->getPath(),
        'http.response.status_code' => $response->getStatusCode(),
    ];
    $this->requestDuration->record($requestDuration, $attributes);
    $this->requestBodySize->record($request->getSize(), $attributes);
    $this->responseBodySize->record($response->getSize(), $attributes);
    $this->activeRequests->add(-1, [
        'http.request.method' => $request->getMethod(),
        'url.scheme' => $request->getProtocol(),
    ]);
}
return $result;

[greptile-apps]

Request hook errors not caught by error handler

The onRequest hook catch block uses \Exception, but PHP fatal errors (e.g., TypeError, ArithmeticError, Error) extend \Throwable, not \Exception. Any PHP internal error thrown inside a request hook will bypass this catch block entirely, skipping the error handler and propagating to the Swoole/FPM layer uncaught. The execute() method correctly uses \Throwable (line 745) — the same fix is needed here and at the start() hook catch (line 646).

Suggested change

	} catch (\Exception $e) {
	} catch (\Throwable $e) {