Help me een aangepaste logstrategie configureren in mijn Laravel-toepassing voor verbeterde debugging en prestatiemonitoring
description
Door het implementeren van een aangepaste logstrategie krijg je diepere inzichten in de prestaties van je toepassing, identificeer je snel problemen en verbeter je de algehele stabiliteit.
prompt
try_prompt
Ik wil een aangepaste logstrategie instellen in mijn Laravel-toepassing om specifieke toepassingsgebeurtenissen en prestatietools te vastleggen. Leg uit hoe je aangepaste logkanalen en formatteringsopties definieert, en hoe ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Om een aangepaste logstrategie in Laravel in te stellen voor het vastleggen van specifieke gebeurtenissen en prestatietools, volg je deze stappen:
1. Configuratie van aangepaste logkanalen:
a. Open het bestand `config/logging.php`.
b. Voeg een nieuw kanaal toe onder de `channels`-array, bijvoorbeeld voor database logging:
```php
'database' => [
'driver' => 'custom',
'via' => App\Logging\DatabaseLogger::class,
],
```
Voor externe services zoals Logstash, Sentry of Papertrail, kun je gebruik maken van bestaande drivers of aangepaste via een package.
2. Aangepaste formatteringsopties:
a. Laravel gebruikt Monolog onder de motorkap. Je kunt formatteringsopties aanpassen door custom handlers en formatters te definiëren.
b. Maak bijvoorbeeld een custom formatter:
```php
use Monolog\Formatter\LineFormatter;
$formatter = new LineFormatter(null, null, true, true);
$handler->setFormatter($formatter);
```
3. Logs opslaan in een database of externe service:
a. **Database:** Maak een migratie voor een logs-tabel:
```php
Schema::create('application_logs', function (Blueprint $table) {
$table->id();
$table->string('level');
$table->string('message');
$table->json('context')->nullable();
$table->timestamps();
});
```
b. **Custom Logger Klasse:** Maak een logger-klasse die logs in de database opslaat:
```php
namespace App\Logging;
use Monolog\Logger;
use Monolog\Handler\AbstractProcessingHandler;
class DatabaseHandler extends AbstractProcessingHandler
{
protected function write(array $record): void
{
\DB::table('application_logs')->insert([
'level' => $record['level_name'],
'message' => $record['message'],
'context' => json_encode($record['context']),
'created_at' => now(),
'updated_at' => now(),
]);
}
}
class DatabaseLogger
{
public function __invoke(array $config)
{
$logger = new Logger('database');
$logger->pushHandler(new DatabaseHandler());
return $logger;
}
}
```
c. **Externe Service:** Gebruik bestaande Laravel packages (zoals Sentry SDK, Logstash, Papertrail) en configureer volgens hun documentatie.
4. Voorbeelden van gebeurtenissen die je moet loggen:
- Gebruikers login en logout
- Foutmeldingen en uitzonderingen
- Belangrijke bedrijfsacties (bijv. order geplaatst, betaling voltooid)
- Prestatiegegevens (bijv. responsetijden, langlopende processen)
- Security-gerelateerde gebeurtenissen (bijv. mislukte inlogpogingen)
5. Logs analyseren voor prestatieoptimalisatie:
- Gebruik logbestanden of database-logs om responsetijden en foutfrequenties te monitoren.
- Zet alerts op bij uitzonderingen of trage responses.
- Analyseer patronen in gebruikersactiviteit en systeembelasting.
- Gebruik tools als Laravel Telescope, New Relic, of DataDog voor diepgaande inzichten.
- Identificeer knelpunten door logs te filteren op langzame verzoeken, fouten of ongebruikelijk gedrag en optimaliseer de code of infrastructuur op basis hiervan.
Met deze aanpak kun je een effectieve en op maat gemaakte logstrategie opzetten, waardoor je inzicht krijgt in de werking en prestaties van je Laravel-toepassing.
provider: deepseek
model: deepseek-chat
Hier is een uitgebreide uitleg over het instellen van aangepaste logging in Laravel:
## Aangepaste Logkanalen Definiëren
### 1. Configuratie in `config/logging.php`
```php
'channels' => [
'custom_app' => [
'driver' => 'daily',
'path' => storage_path('logs/custom-app.log'),
'level' => 'debug',
'days' => 14,
'formatter' => Monolog\Formatter\JsonFormatter::class,
],
'performance' => [
'driver' => 'daily',
'path' => storage_path('logs/performance.log'),
'level' => 'info',
'formatter' => Monolog\Formatter\LineFormatter::class,
'formatter_with' => [
'format' => "[%datetime%] %channel%.%level_name%: %message% %context%\n"
]
],
'database' => [
'driver' => 'custom',
'via' => App\Logging\DatabaseLogger::class,
],
]
```
### 2. Aangepaste Database Logger
```php
<?php
// app/Logging/DatabaseLogger.php
namespace App\Logging;
use Monolog\Logger;
use App\Models\LogEntry;
class DatabaseLogger
{
public function __invoke(array $config)
{
return new Logger('database', [
new class extends \Monolog\Handler\AbstractProcessingHandler {
protected function write(array $record): void
{
LogEntry::create([
'level' => $record['level_name'],
'message' => $record['message'],
'context' => json_encode($record['context']),
'channel' => $record['channel'],
'created_at' => now(),
]);
}
}
]);
}
}
```
## Database Migratie voor Logs
```php
<?php
// database/migrations/create_log_entries_table.php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateLogEntriesTable extends Migration
{
public function up()
{
Schema::create('log_entries', function (Blueprint $table) {
$table->id();
$table->string('level'); // INFO, ERROR, DEBUG, etc.
$table->text('message');
$table->json('context')->nullable();
$table->string('channel');
$table->string('user_id')->nullable();
$table->string('ip_address')->nullable();
$table->string('user_agent')->nullable();
$table->timestamps();
$table->index(['level', 'created_at']);
$table->index(['user_id', 'created_at']);
});
}
}
```
## Gebeurtenissen Loggen
### 1. Login/Logout Events
```php
<?php
// app/Listeners/LogAuthenticationEvents.php
namespace App\Listeners;
use Illuminate\Auth\Events\Login;
use Illuminate\Auth\Events\Logout;
use Illuminate\Support\Facades\Log;
use Illuminate\Http\Request;
class LogAuthenticationEvents
{
protected $request;
public function __construct(Request $request)
{
$this->request = $request;
}
public function handleLogin(Login $event)
{
$startTime = microtime(true);
// Log de login gebeurtenis
Log::channel('custom_app')->info('Gebruiker ingelogd', [
'user_id' => $event->user->id,
'email' => $event->user->email,
'ip_address' => $this->request->ip(),
'user_agent' => $this->request->userAgent(),
'login_time' => now()->toISOString(),
'session_id' => session()->getId(),
'performance' => [
'login_duration_ms' => round((microtime(true) - $startTime) * 1000, 2)
]
]);
// Performance logging
Log::channel('performance')->info('Login performance', [
'user_id' => $event->user->id,
'duration_ms' => round((microtime(true) - $startTime) * 1000, 2),
'timestamp' => now()->toISOString()
]);
}
public function handleLogout(Logout $event)
{
$user = $event->user;
Log::channel('custom_app')->info('Gebruiker uitgelogd', [
'user_id' => $user ? $user->id : null,
'ip_address' => $this->request->ip(),
'logout_time' => now()->toISOString(),
'session_duration' => $this->calculateSessionDuration(),
]);
}
private function calculateSessionDuration()
{
$loginTime = session('login_time');
if ($loginTime) {
return now()->diffInMinutes($loginTime);
}
return null;
}
}
```
### 2. Event Service Provider Registratie
```php
<?php
// app/Providers/EventServiceProvider.php
protected $listen = [
Login::class => [
LogAuthenticationEvents::class,
],
Logout::class => [
LogAuthenticationEvents::class,
],
];
```
## Aanvullende Gebeurtenissen om te Loggen
```php
<?php
// Voorbeeld van andere belangrijke gebeurtenissen
class ApplicationLogger
{
public static function logUserAction($action, $userId, $details = [])
{
Log::channel('custom_app')->info("Gebruikersactie: {$action}", [
'user_id' => $userId,
'action' => $action,
'details' => $details,
'ip_address' => request()->ip(),
'timestamp' => now()->toISOString()
]);
}
public static function logPerformance($metric, $value, $context = [])
{
Log::channel('performance')->info("Performance metric: {$metric}", [
'metric' => $metric,
'value' => $value,
'unit' => 'ms',
'context' => $context,
'timestamp' => now()->toISOString()
]);
}
}
// Gebruik voorbeelden:
ApplicationLogger::logUserAction('profile_updated', auth()->id(), [
'fields_updated' => ['name', 'email']
]);
ApplicationLogger::logPerformance('database_query', 150, [
'query' => 'SELECT * FROM users',
'rows_returned' => 1000
]);
```
## Log Analyse voor Prestatieoptimalisatie
### 1. Query's voor Login/Logout Analyse
```php
<?php
// app/Services/LogAnalyzer.php
namespace App\Services;
use App\Models\LogEntry;
use Illuminate\Support\Collection;
use Carbon\Carbon;
class LogAnalyzer
{
public function getLoginStats($days = 30): array
{
$startDate = Carbon::now()->subDays($days);
return [
'total_logins' => LogEntry::where('message', 'LIKE', '%ingelogd%')
->where('created_at', '>=', $startDate)
->count(),
'average_login_time' => $this->calculateAverageLoginTime($startDate),
'logins_per_day' => LogEntry::where('message', 'LIKE', '%ingelogd%')
->where('created_at', '>=', $startDate)
->selectRaw('DATE(created_at) as date, COUNT(*) as count')
->groupBy('date')
->get(),
'slow_logins' => LogEntry::where('message', 'LIKE', '%ingelogd%')
->where('context->performance->login_duration_ms', '>', 1000)
->where('created_at', '>=', $startDate)
->count()
];
}
public function getUserSessionAnalytics($userId)
{
return LogEntry::where('user_id', $userId)
->where(function($query) {
$query->where('message', 'LIKE', '%ingelogd%')
->orWhere('message', 'LIKE', '%uitgelogd%');
})
->orderBy('created_at', 'desc')
->get()
->groupBy(function($log) {
return $log->message;
});
}
private function calculateAverageLoginTime($startDate): float
{
$logins = LogEntry::where('message', 'LIKE', '%ingelogd%')
->where('created_at', '>=', $startDate)
->get();
$totalTime = 0;
$count = 0;
foreach ($logins as $login) {
if (isset($login->context['performance']['login_duration_ms'])) {
$totalTime += $login->context['performance']['login_duration_ms'];
$count++;
}
}
return $count > 0 ? round($totalTime / $count, 2) : 0;
}
}
```
### 2. Prestatie Monitoring Dashboard
```php
<?php
// routes/web.php
Route::get('/admin/logs/performance', function () {
$analyzer = new App\Services\LogAnalyzer();
return view('admin.performance-dashboard', [
'loginStats' => $analyzer->getLoginStats(7),
'slowOperations' => $analyzer->getSlowOperations(),
]);
});
```
## Belangrijke Gebeurtenissen om te Loggen
1. **Authenticatie**: Login, logout, failed login attempts
2. **Gebruikersacties**: Profiel updates, wachtwoord wijzigingen
3. **Prestatie metrics**: Database query tijden, API response tijden
4. **Fouten**: Exceptions, validation errors
5. **Beveiliging**: Suspecte activiteiten, rate limiting events
## Externe Services (bijv. Logstash, CloudWatch)
```php
'channels' => [
'logstash' => [
'driver' => 'custom',
'via' => App\Logging\LogstashLogger::class,
'host' => env('LOGSTASH_HOST'),
'port' => env('LOGSTASH_PORT'),
],
'cloudwatch' => [
'driver' => 'custom',
'via' => App\Logging\CloudWatchLogger::class,
'region' => env('AWS_DEFAULT_REGION'),
'group' => env('CLOUDWATCH_LOG_GROUP'),
],
]
```
Deze setup geeft je een complete logging infrastructuur voor het monitoren van gebruikersactiviteiten en prestaties in je Laravel applicatie.