> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Logging

> Leer hoe je met het loggingsysteem van Laravel het gedrag van je applicatie vastlegt naar bestanden, Slack en externe services.

## Wat is logging

De logging van Laravel is opgebouwd rond het concept van **channels**.
Een channel is een configuratie-eenheid die bepaalt waar en hoe logs worden weggeschreven; je kunt allerlei uitvoerbestemmingen combineren, zoals bestanden, Slack en syslog.

Intern wordt de bibliotheek [Monolog](https://github.com/Seldaek/monolog) gebruikt, waardoor je toegang hebt tot een breed scala aan handlers en formatters.

<Info>
  Standaard wordt het channel `stack` gebruikt. `stack` is een parent-channel dat meerdere channels bundelt.
</Info>

## Configuratie

De loggingconfiguratie is gecentraliseerd in `config/logging.php`. Met de omgevingsvariabele `LOG_CHANNEL` wissel je het standaardchannel.

```php theme={null}
// config/logging.php
'default' => env('LOG_CHANNEL', 'stack'),
```

### Beschikbare channeldrivers

| Driver     | Beschrijving                                         |
| ---------- | ---------------------------------------------------- |
| `single`   | Schrijft alle logs naar één bestand                  |
| `daily`    | Schrijft naar een bestand per datum (met rotatie)    |
| `slack`    | Stuurt berichten naar een Incoming Webhook van Slack |
| `stack`    | Parent-channel dat meerdere channels bundelt         |
| `syslog`   | Schrijft naar de syslog van het systeem              |
| `errorlog` | Schrijft naar de foutlog van PHP                     |
| `monolog`  | Geeft direct een Monolog-handler op                  |
| `custom`   | Past het channel volledig aan met een factoryklasse  |

### Logniveaus

Laravel ondersteunt de acht logniveaus die zijn gedefinieerd in [RFC 5424](https://tools.ietf.org/html/rfc5424).
Ze staan gerangschikt van hoogste naar laagste ernst.

| Niveau      | Voorbeelden van gebruik                                                                  |
| ----------- | ---------------------------------------------------------------------------------------- |
| `emergency` | Het hele systeem is onbruikbaar. Directe actie vereist                                   |
| `alert`     | Een toestand waarbij direct menselijk ingrijpen nodig is (bijv. verbroken DB-verbinding) |
| `critical`  | Een ernstige storing waarbij kernfunctionaliteit van de app is uitgevallen               |
| `error`     | Runtime-fout. Actie vereist, maar vaak niet direct                                       |
| `warning`   | Potentieel probleem. Gebruik van deprecated API's, onverwachte data enz.                 |
| `notice`    | Normale werking, maar informatie die aandacht verdient                                   |
| `info`      | Normale operationele logs, zoals gebruikerslogins en bevestigde bestellingen             |
| `debug`     | Gedetailleerde debuginformatie tijdens de ontwikkeling                                   |

De instelling `level` van een channel betekent het **minimale logniveau**.
Is `level` bijvoorbeeld `error`, dan wordt alleen `error` en hoger (`critical`, `alert`, `emergency`) weggeschreven.

## Basisgebruik

### De Log-facade

Met de facade `Illuminate\Support\Facades\Log` schrijf je berichten op elk niveau weg.

```php theme={null}
use Illuminate\Support\Facades\Log;

Log::emergency('Het systeem ligt plat.');
Log::alert('De databaseverbinding is verbroken.');
Log::critical('De betaalservice reageert niet.');
Log::error('Het bijwerken van de gebruikersdata is mislukt.');
Log::warning('Er is een deprecated methode aangeroepen.');
Log::notice('Het configuratiebestand is opnieuw geladen.');
Log::info('Een gebruiker is ingelogd.');
Log::debug('Uitvoeringstijd van de query: 42ms');
```

Een voorbeeld in een controller:

```php theme={null}
<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Support\Facades\Log;
use Illuminate\View\View;

class UserController extends Controller
{
    public function show(string $id): View
    {
        Log::info('Gebruikersprofiel wordt weergegeven.', ['user_id' => $id]);

        return view('user.profile', [
            'user' => User::findOrFail($id),
        ]);
    }
}
```

### De log()-helperfunctie

Met de `log()`-helper kun je schrijven zonder de `Log`-facade te importeren.

```php theme={null}
log('Een logbericht vanuit de helper.');

// Je kunt ook een niveau en context opgeven
log('Gebruiker aangemaakt.', 'info', ['user_id' => $user->id]);
```

### Contextinformatie toevoegen

Geef je samen met het bericht context (een array) door, dan leg je gerelateerde informatie in één keer vast.

```php theme={null}
Log::info('Inloggen mislukt.', [
    'user_id' => $user->id,
    'ip'      => $request->ip(),
    'reason'  => 'Wachtwoord komt niet overeen',
]);
```

#### withContext() — gedeelde context toevoegen aan een heel channel

Wil je voor een specifiek channel gemeenschappelijke informatie toevoegen aan alle volgende logentries, gebruik dan `withContext()`.
Dit is geschikt voor informatie die je in alle logs wilt opnemen, zoals een request-ID.

```php theme={null}
Log::withContext(['request-id' => (string) Str::uuid()]);

// Alle volgende logs bevatten automatisch de request-id
Log::info('Verwerking gestart.');
Log::error('Er is een fout opgetreden.');
```

#### shareContext() — gedeelde context toevoegen aan alle channels

Waar `withContext()` alleen effect heeft op het doelchannel, voegt `shareContext()` gemeenschappelijke context toe aan alle channels.

```php theme={null}
Log::shareContext(['app-version' => config('app.version')]);
```

## Channels configureren

### Het stack-channel — tegelijk naar meerdere channels schrijven

Met het `stack`-channel schrijf je met één logaanroep naar meerdere channels.

```php theme={null}
// config/logging.php
'channels' => [
    'stack' => [
        'driver'   => 'stack',
        'channels' => ['daily', 'slack'],
    ],

    'daily' => [
        'driver' => 'daily',
        'path'   => storage_path('logs/laravel.log'),
        'level'  => env('LOG_LEVEL', 'debug'),
        'days'   => 14,
    ],

    'slack' => [
        'driver'   => 'slack',
        'url'      => env('LOG_SLACK_WEBHOOK_URL'),
        'username' => env('LOG_SLACK_USERNAME', 'Laravel Log'),
        'emoji'    => env('LOG_SLACK_EMOJI', ':boom:'),
        'level'    => 'critical',
    ],
],
```

Met deze configuratie worden alle logs vanaf `debug` naar `daily` (bestand) geschreven, en wordt alleen `critical` en hoger ook naar `slack` gestuurd.

<Tip>
  In productie is het aan te raden om het niveau van het `slack`-channel op `error` of `critical` te zetten.
  Stuur je ook lichte logs naar Slack, dan krijg je een stortvloed aan meldingen en raken belangrijke alerts ondergesneeuwd.
</Tip>

### Het daily-channel — logrotatie

Het `daily`-channel splitst de bestanden per datum en verwijdert oude bestanden automatisch.

```php theme={null}
'daily' => [
    'driver' => 'daily',
    'path'   => storage_path('logs/laravel.log'),
    'level'  => env('LOG_LEVEL', 'debug'),
    'days'   => env('LOG_DAILY_DAYS', 14), // 14 dagen bewaren
],
```

<Warning>
  Maak je `days` kleiner, dan worden oude logs eerder verwijderd.
  Zorg voor een voldoende lange bewaartermijn met het oog op het onderzoeken van storingen in productie.
</Warning>

### Foutmeldingen naar Slack

Haal een [Incoming Webhook URL](https://slack.com/apps/A0F7XDUAZ-incoming-webhooks) van Slack op en stel die in in `.env`.

```ini theme={null}
LOG_SLACK_WEBHOOK_URL=https://hooks.slack.com/services/xxx/yyy/zzz
```

```php theme={null}
// config/logging.php
'slack' => [
    'driver'   => 'slack',
    'url'      => env('LOG_SLACK_WEBHOOK_URL'),
    'username' => 'Laravel Error Bot',
    'emoji'    => ':fire:',
    'level'    => 'error',
],
```

Neem `slack` op in het `stack`-channel en stel `LOG_CHANNEL=stack` in; bij fouten krijg je dan automatisch een melding.

### Naar een specifiek channel schrijven

Met `Log::channel()` geef je expliciet het doelchannel op.

```php theme={null}
// Alleen naar het slack-channel schrijven
Log::channel('slack')->error('De betaalservice reageert niet.');

// Tegelijk naar meerdere channels schrijven
Log::stack(['daily', 'slack'])->critical('De verbinding met de database is mislukt.');
```

## On-demand channels

Met `Log::build()` maak je ter plekke een aangepast channel zonder het in het configuratiebestand te definiëren.
Handig voor tests of het schrijven naar een tijdelijke uitvoerbestemming.

```php theme={null}
use Illuminate\Support\Facades\Log;

$channel = Log::build([
    'driver' => 'single',
    'path'   => storage_path('logs/import-' . now()->format('Ymd') . '.log'),
]);

Log::stack([$channel])->info('CSV-import gestart.');
```

## Praktische use-cases

### Een request-ID toevoegen via middleware

Door aan alle logs een gemeenschappelijke request-ID toe te voegen, kun je in de logs eenvoudiger het verloop van een specifiek request volgen.

<Steps>
  <Step title="Maak de middleware aan">
    ```shell theme={null}
    php artisan make:middleware AssignRequestId
    ```
  </Step>

  <Step title="Implementeer de handle()-methode">
    ```php theme={null}
    <?php

    namespace App\Http\Middleware;

    use Closure;
    use Illuminate\Http\Request;
    use Illuminate\Support\Facades\Log;
    use Illuminate\Support\Str;
    use Symfony\Component\HttpFoundation\Response;

    class AssignRequestId
    {
        public function handle(Request $request, Closure $next): Response
        {
            $requestId = (string) Str::uuid();

            Log::withContext(['request-id' => $requestId]);

            $response = $next($request);

            $response->headers->set('X-Request-Id', $requestId);

            return $response;
        }
    }
    ```
  </Step>

  <Step title="Registreer de middleware">
    Registreer de middleware als globale middleware in `bootstrap/app.php`.

    ```php theme={null}
    ->withMiddleware(function (Middleware $middleware) {
        $middleware->append(\App\Http\Middleware\AssignRequestId::class);
    })
    ```
  </Step>
</Steps>

Na deze configuratie krijgen alle logs automatisch een `request-id`.

```
[2026-03-01 12:00:00] local.INFO: Een gebruiker is ingelogd. {"request-id":"550e8400-...","user_id":1}
[2026-03-01 12:00:00] local.INFO: Dashboard wordt weergegeven. {"request-id":"550e8400-..."}
```

### Deprecation-waarschuwingen loggen

Je kunt waarschuwingen loggen wanneer deprecated functionaliteit van PHP of Laravel wordt gebruikt.

```php theme={null}
// config/logging.php
'deprecations' => [
    'channel' => env('LOG_DEPRECATIONS_CHANNEL', 'null'),
    'trace'   => env('LOG_DEPRECATIONS_TRACE', false),
],
```

Geef het channel op in `.env`.

```ini theme={null}
LOG_DEPRECATIONS_CHANNEL=daily
```

## Laravel Pail — logs in realtime volgen

[Laravel Pail](https://github.com/laravel/pail) is een ontwikkeltool waarmee je de logs van je applicatie in realtime in de terminal bekijkt. Anders dan het standaard `tail`-commando is Pail ontworpen om te werken met elke logdriver, waaronder [Laravel Nightwatch](https://nightwatch.laravel.com), Sentry en Flare.

<Info>
  Voor het uitvoeren van Pail is de [PCNTL](https://www.php.net/manual/ja/book.pcntl.php)-extensie van PHP vereist.
</Info>

### Installatie

```shell theme={null}
composer require --dev laravel/pail
```

### Basisgebruik

```shell theme={null}
# Logs live volgen
php artisan pail

# Uitgebreide weergave (zonder inkorten)
php artisan pail -v

# Ook stacktraces tonen
php artisan pail -vv
```

### Logs filteren

```shell theme={null}
# Filteren op trefwoord
php artisan pail --filter="QueryException"

# Alleen filteren op bericht
php artisan pail --message="login"

# Filteren op logniveau
php artisan pail --level=error

# Alleen logs van een specifieke gebruiker tonen
php artisan pail --user=1
```

## Samenvatting

<AccordionGroup>
  <Accordion title="Het juiste logniveau kiezen">
    | Niveau      | Wanneer gebruiken                                                             |
    | ----------- | ----------------------------------------------------------------------------- |
    | `emergency` | Fatale storing waarbij het hele systeem uitvalt                               |
    | `alert`     | Toestand waarbij direct menselijk ingrijpen nodig is                          |
    | `critical`  | Ernstige storing waarbij kernfunctionaliteit niet werkt                       |
    | `error`     | Onverwachte runtime-fout. Actie vereist                                       |
    | `warning`   | Toestanden die aandacht vragen, zoals deprecated gebruik of onverwachte data  |
    | `notice`    | Normaal, maar belangrijke handelingen die je wilt vastleggen                  |
    | `info`      | Vastleggen van gebruikershandelingen en business-events                       |
    | `debug`     | Gedetailleerde debuginformatie tijdens ontwikkeling (niet nodig in productie) |
  </Accordion>

  <Accordion title="Richtlijnen voor het kiezen van channels">
    * **Ontwikkelomgeving**: naar bestand schrijven met `single` of `daily`
    * **Productie**: `stack` met een combinatie van `daily` (bestandsopslag) en `slack` (foutmeldingen)
    * **Logs van specifieke processen**: met `Log::build()` een on-demand channel maken en naar een apart bestand schrijven
    * **Realtime monitoring**: bekijken vanuit de terminal met `php artisan pail`
  </Accordion>

  <Accordion title="Aandachtspunten in productie">
    * `debug`-logs kunnen gevoelige informatie bevatten. In productie wordt `LOG_LEVEL=error` of hoger aanbevolen.
    * Roteer logbestanden regelmatig zodat ze de schijf niet vol laten lopen (de instelling `days` van het `daily`-channel).
    * Let bij meldingen naar externe services zoals Slack op rate limits. Stel het niveau zo in dat alleen ernstige fouten worden gemeld.
  </Accordion>
</AccordionGroup>


## Related topics

- [Laravel-updates van juli 2026](/nl/blog/changelog/202607.md)
- [Collections](/nl/collections.md)
- [Events](/nl/packages/laravel-copilot-sdk/events.md)
- [Laravel Pulse](/nl/pulse.md)
- [Foutafhandeling](/nl/error-handling.md)