Help me een loggingstrategie implementeren voor het monitoren van API-prestaties in mijn Laravel-toepassing
description
Door het implementeren van een aangepaste loggingstrategie krijg je inzicht in de prestaties van je API, kun je snel knelpunten identificeren en de algehele gebruikerservaring verbeteren door optimale responsetijden te garanderen.
prompt
try_prompt
Ik wil een loggingstrategie ontwerpen die prestatietokens vastlegt voor mijn API-routes in Laravel. Leg uit hoe je aangepaste logvermeldingen definieert die responsetijden, requestgroottes en ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Het ontwerpen van een loggingstrategie voor prestatietokens in Laravel vereist het maken van aangepaste logvermeldingen die belangrijke metrics zoals responsetijden, requestgroottes en statuscodes vastleggen. Hier is een stapsgewijze aanpak:
1. Middleware voor Logging:
Maak een middleware die elke API-aanvraag afhandelt en de relevante gegevens verzamelt.
```php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Request;
class LogApiMetrics
{
public function handle($request, Closure $next)
{
$startTime = microtime(true);
$requestSize = strlen($request->getContent());
$response = $next($request);
$endTime = microtime(true);
$responseTime = ($endTime - $startTime) * 1000; // in milliseconden
$statusCode = $response->getStatusCode();
$responseSize = strlen($response->getContent());
// Loggegevens verzamelen
Log::info('API Request', [
'route' => $request->path(),
'status_code' => $statusCode,
'response_time_ms' => $responseTime,
'request_size_bytes' => $requestSize,
'response_size_bytes' => $responseSize,
]);
return $response;
}
}
```
2. Middleware registreren:
Voeg de middleware toe aan je API-routes in `app/Http/Kernel.php`.
```php
protected $middlewareGroups = [
'api' => [
// andere middleware
\App\Http\Middleware\LogApiMetrics::class,
],
];
```
3. Logs analyseren:
Gebruik loganalysesoftware of scripts om de logs te verwerken en de gevraagde KPI’s te berekenen:
- **Gemiddelde responsetijd**:
Bereken het gemiddelde van alle `response_time_ms` waarden over een bepaald tijdsbestek.
- **Totale requestgrootte**:
Tel alle `request_size_bytes` op binnen dezelfde periode.
Gebruik bijvoorbeeld tools als ELK Stack (Elasticsearch, Logstash, Kibana), Grafana of eenvoudige scripts in bijvoorbeeld Python om deze analyses uit te voeren.
4. Knelpunten identificeren en optimaliseren:
- **Langzame responsetijden**: Kijk naar routes of patronen met hogere responsetijden en optimaliseer databasequeries, caching of code.
- **Grote request- of responsegrootte**: Overweeg compressie, paginering of het minimaliseren van onnodige data.
- **Statuscodes**: Let op een hoog aantal foutstatussen (4xx, 5xx) en onderzoek de oorzaken.
Door deze gegevens systematisch te verzamelen en te analyseren, kun je gerichte verbeteringen doorvoeren die de algehele API-prestatie verbeteren.
provider: deepseek
model: deepseek-chat
Hier is een uitgebreide uitleg voor het implementeren van een loggingstrategie in Laravel:
## 1. Middleware voor Logging
Maak eerst een aangepaste middleware:
```php
<?php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Symfony\Component\HttpFoundation\Response;
class PerformanceLogging
{
public function handle(Request $request, Closure $next): Response
{
$startTime = microtime(true);
$response = $next($request);
$endTime = microtime(true);
$responseTime = round(($endTime - $startTime) * 1000, 2); // in milliseconden
$this->logPerformance($request, $response, $responseTime);
return $response;
}
protected function logPerformance(Request $request, Response $response, float $responseTime): void
{
$logData = [
'method' => $request->method(),
'url' => $request->fullUrl(),
'status_code' => $response->getStatusCode(),
'response_time_ms' => $responseTime,
'request_size' => $this->getRequestSize($request),
'response_size' => $this->getResponseSize($response),
'user_agent' => $request->userAgent(),
'ip' => $request->ip(),
'timestamp' => now()->toISOString(),
];
// Log op verschillende niveaus gebaseerd op responsetijd
if ($responseTime > 1000) {
Log::warning('Trage API response', $logData);
} elseif ($responseTime > 500) {
Log::notice('Matige API response', $logData);
} else {
Log::info('API request', $logData);
}
}
protected function getRequestSize(Request $request): int
{
return strlen($request->getContent());
}
protected function getResponseSize(Response $response): int
{
return strlen($response->getContent());
}
}
```
## 2. Middleware Registreren
Registreer de middleware in `app/Http/Kernel.php`:
```php
protected $middlewareGroups = [
'web' => [
// ... bestaande middleware
],
'api' => [
\App\Http\Middleware\PerformanceLogging::class,
// ... andere API middleware
],
];
```
## 3. Geavanceerde Logging met Events
Voor meer gedetailleerde logging kun je Events gebruiken:
```php
<?php
namespace App\Listeners;
use Illuminate\Http\Client\Events\ResponseReceived;
use Illuminate\Support\Facades\Log;
class LogApiPerformance
{
public function handle(ResponseReceived $event): void
{
$response = $event->response;
$performanceData = [
'url' => $response->effectiveUri(),
'status' => $response->status(),
'response_time' => $response->transferStats->getTransferTime(),
'total_time' => $response->handlerStats['total_time'] ?? 0,
];
Log::channel('performance')->info('Externe API call', $performanceData);
}
}
```
## 4. Log Configuration
Configureer een apart logkanaal in `config/logging.php`:
```php
'channels' => [
'performance' => [
'driver' => 'daily',
'path' => storage_path('logs/performance.log'),
'level' => 'info',
'days' => 30,
],
'slow_queries' => [
'driver' => 'daily',
'path' => storage_path('logs/slow-queries.log'),
'level' => 'debug',
'days' => 14,
],
],
```
## 5. Log Analyse Richtlijnen
### Gemiddelde Responsetijd Berekenen
```bash
# Analyseer logs voor gemiddelde responsetijd
grep "API request" storage/logs/performance.log | \
awk -F'response_time_ms' '{print $2}' | \
awk -F',' '{sum += $1; count++} END {print "Gemiddelde: " sum/count "ms"}'
```
### Totale Requestgrootte Analyseren
```bash
# Totale request grootte per endpoint
grep "API request" storage/logs/performance.log | \
awk -F'request_size' '{print $2}' | \
awk -F':' '{print $2}' | \
awk -F',' '{sum += $1} END {print "Totale request grootte: " sum " bytes"}'
```
## 6. Performance Analyse Script
Maak een analyse script:
```php
<?php
namespace App\Console\Commands;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\DB;
class AnalyzePerformance extends Command
{
protected $signature = 'log:analyze-performance';
protected $description = 'Analyseer performance logs';
public function handle()
{
$logFile = storage_path('logs/performance.log');
$logs = file($logFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
$stats = [
'total_requests' => 0,
'total_response_time' => 0,
'total_request_size' => 0,
'endpoints' => [],
'status_codes' => [],
];
foreach ($logs as $logLine) {
if (str_contains($logLine, 'response_time_ms')) {
$this->parseLogLine($logLine, $stats);
}
}
$this->displayStats($stats);
}
protected function parseLogLine(string $logLine, array &$stats): void
{
preg_match('/"url":"([^"]+)"/', $logLine, $urlMatch);
preg_match('/"response_time_ms":([\d.]+)/', $logLine, $timeMatch);
preg_match('/"request_size":(\d+)/', $logLine, $sizeMatch);
preg_match('/"status_code":(\d+)/', $logLine, $statusMatch);
if ($urlMatch && $timeMatch && $sizeMatch && $statusMatch) {
$url = $urlMatch[1];
$responseTime = (float) $timeMatch[1];
$requestSize = (int) $sizeMatch[1];
$statusCode = $statusMatch[1];
$stats['total_requests']++;
$stats['total_response_time'] += $responseTime;
$stats['total_request_size'] += $requestSize;
// Endpoint statistieken
if (!isset($stats['endpoints'][$url])) {
$stats['endpoints'][$url] = [
'count' => 0,
'total_time' => 0,
'total_size' => 0,
];
}
$stats['endpoints'][$url]['count']++;
$stats['endpoints'][$url]['total_time'] += $responseTime;
$stats['endpoints'][$url]['total_size'] += $requestSize;
// Status code statistieken
$stats['status_codes'][$statusCode] = ($stats['status_codes'][$statusCode] ?? 0) + 1;
}
}
protected function displayStats(array $stats): void
{
$this->info("=== PERFORMANCE ANALYSE ===");
$this->info("Totaal requests: " . $stats['total_requests']);
$this->info("Gemiddelde responsetijd: " .
round($stats['total_response_time'] / $stats['total_requests'], 2) . "ms");
$this->info("Totale request grootte: " .
round($stats['total_request_size'] / 1024 / 1024, 2) . " MB");
$this->info("\n=== TRAAGSTE ENDPOINTS ===");
foreach ($stats['endpoints'] as $url => $endpointStats) {
$avgTime = $endpointStats['total_time'] / $endpointStats['count'];
$this->info("{$url}: {$avgTime}ms ({$endpointStats['count']} requests)");
}
}
}
```
## 7. Knelpunten Identificeren
### Veelvoorkomende Knelpunten:
1. **Trage database queries** - Gebruik Laravel's query log
2. **Grote response payloads** - Implementeer paginering
3. **N+1 query problemen** - Gebruik eager loading
4. **Externe API calls** - Cache resultaten waar mogelijk
### Optimalisatie Acties:
```php
// Database performance monitoring
DB::listen(function ($query) {
if ($query->time > 100) { // queries langer dan 100ms
Log::channel('slow_queries')->warning('Trage query', [
'sql' => $query->sql,
'bindings' => $query->bindings,
'time' => $query->time,
]);
}
});
```
Deze strategie geeft je complete inzichten in je API-prestaties en helpt bij het identificeren en oplossen van knelpunten.