1c46667f56
ApiLogger now stores the upstream response body to
`api_logs.response_body` whenever the call failed (non-2xx response or
a RequestException carrying a response). Successful 2xx responses
remain null so the table stays small on busy services like fuel:poll
and oil:fetch.
Truncated at 64 KB. The column is mediumText so a future cap raise
needs no schema change.
Captures:
- 4xx and 5xx response bodies verbatim
- Body extracted from RequestException via `$e->response->body()`
when callers use `Http::throw()`
Does not capture:
- ConnectionException (no response existed)
- Generic Throwable from the closure (same reason)
Motivation: the LLM overlay's "skipped — no verified citations" path
left no forensic trail to debug. With this, the next time anything
routed through ApiLogger fails — Anthropic 429s, FRED 5xx, Fuel
Finder errors — the failed body is queryable directly:
SELECT response_body FROM api_logs
WHERE service = ? AND status_code >= 400
ORDER BY id DESC LIMIT 1;
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
79 lines
2.3 KiB
PHP
79 lines
2.3 KiB
PHP
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Models\ApiLog;
|
|
use Illuminate\Http\Client\RequestException;
|
|
use Illuminate\Http\Client\Response;
|
|
use Illuminate\Support\Str;
|
|
use Throwable;
|
|
|
|
class ApiLogger
|
|
{
|
|
/**
|
|
* Cap the stored response body. MEDIUMTEXT can hold ~16MB, but
|
|
* persisting more than 64KB is rarely useful for debugging and
|
|
* blows up the row size on busy services.
|
|
*/
|
|
private const int RESPONSE_BODY_CAP = 65_536;
|
|
|
|
/**
|
|
* Execute an HTTP request and log it to api_logs.
|
|
*
|
|
* The callable must return an Illuminate\Http\Client\Response.
|
|
* Exceptions are logged and re-thrown so the caller handles them.
|
|
*
|
|
* Persists the response body to `api_logs.response_body` ONLY when
|
|
* the call failed (non-2xx) or threw. Truncates to RESPONSE_BODY_CAP.
|
|
*
|
|
* @param callable(): Response $request
|
|
*/
|
|
public function send(string $service, string $method, string $url, callable $request): Response
|
|
{
|
|
$start = microtime(true);
|
|
$statusCode = null;
|
|
$error = null;
|
|
$responseBody = null;
|
|
|
|
try {
|
|
$response = $request();
|
|
$statusCode = $response->status();
|
|
|
|
if ($response->failed()) {
|
|
$body = $response->body();
|
|
$error = Str::limit($body, 1000);
|
|
$responseBody = $this->truncate($body);
|
|
}
|
|
|
|
return $response;
|
|
} catch (Throwable $e) {
|
|
$error = $e->getMessage();
|
|
|
|
// RequestException carries the response, ConnectionException
|
|
// doesn't. Pull the body when it's available.
|
|
if ($e instanceof RequestException) {
|
|
$responseBody = $this->truncate($e->response->body());
|
|
}
|
|
|
|
throw $e;
|
|
} finally {
|
|
ApiLog::create([
|
|
'service' => $service,
|
|
'method' => strtoupper($method),
|
|
'url' => $url,
|
|
'status_code' => $statusCode,
|
|
'duration_ms' => (int) round((microtime(true) - $start) * 1000),
|
|
'error' => $error,
|
|
'response_body' => $responseBody,
|
|
]);
|
|
}
|
|
}
|
|
|
|
private function truncate(string $body): string
|
|
{
|
|
return strlen($body) > self::RESPONSE_BODY_CAP
|
|
? substr($body, 0, self::RESPONSE_BODY_CAP)
|
|
: $body;
|
|
}
|
|
}
|