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

# De duur van databasetransacties monitoren

> Leer hoe je met Connection::whenTransactionRunsLongerThan in Laravel 13 langlopende transacties detecteert bij commit of rollback.

Als je trage transacties onderzoekt, is de uitvoeringstijd van SQL niet genoeg. Je moet ook kijken naar de applicatiecode die binnen de transactie draait en naar de tijd die wordt gewacht op databaselocks. In Laravel 13.x roept `Connection::whenTransactionRunsLongerThan` een callback aan wanneer de totale verstreken tijd van een transactie de opgegeven drempel overschrijdt.

> [!NOTE]
>
> Deze pagina is gebaseerd op de [implementatie in Laravel Framework 13.x](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Connection.php). Controleer of de Framework-versie die je gebruikt deze methode bevat.

## Een callback registreren

Om de databaseverbindingen van de hele applicatie te monitoren, registreer je de callback in de `boot`-methode van een service provider. De drempel is in **milliseconden**.

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

namespace App\Providers;

use Illuminate\Database\Connection;
use Illuminate\Database\Events\TransactionCommitted;
use Illuminate\Database\Events\TransactionRolledBack;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap any application services.
     */
    public function boot(): void
    {
        DB::connection()->whenTransactionRunsLongerThan(
            500,
            function (
                Connection $connection,
                TransactionCommitted|TransactionRolledBack $event,
                float $duration,
            ): void {
                Log::warning('Long database transaction detected.', [
                    'connection' => $connection->getName(),
                    'duration_ms' => $duration,
                    'event' => $event::class,
                ]);
            },
        );
    }
}
```

De callback ontvangt drie argumenten.

* `Connection`: de gemonitorde databaseverbinding
* `TransactionCommitted|TransactionRolledBack`: het event dat aangeeft of de transactie is gecommit of teruggedraaid
* `float`: de gemeten verstreken tijd (in milliseconden)

Geef je een verbindingsnaam op, zoals `DB::connection('mysql')`, dan monitor je alleen die verbinding. Om meerdere verbindingen te monitoren, registreer je op elke `Connection` een callback.

## Wat er wordt gemeten

De meting begint wanneer de buitenste transactie start en eindigt wanneer de buitenste transactie wordt gecommit of teruggedraaid.

```php theme={null}
DB::transaction(function () {
    // Hier begint de meting

    Order::create($orderData);

    DB::transaction(function () {
        // De binnenste transactie wordt niet apart gemeten
        Inventory::reserve($product);
    });

    // Hier eindigt de meting; bij overschrijding van de drempel wordt de callback aangeroepen
});
```

Laravel slaat de starttijd alleen op wanneer het transaction level van `0` naar `1` gaat. Ook als een binnenste transactie als savepoint werkt, telt de verwerkingstijd ervan dus mee in de verstreken tijd van de buitenste transactie. Met dit mechanisme kun je een binnenste transactie niet met een eigen drempel monitoren.

De callback wordt aangeroepen nadat het transaction level weer `0` is. Als de callback van `DB::transaction` een exception gooit en de transactie wordt teruggedraaid, ontvang je ook het event `TransactionRolledBack` en de gemeten tijd. Dezelfde events treden op wanneer je `beginTransaction` / `commit` / `rollBack` handmatig aanroept.

## De drempel opgeven

Als eerste argument van `whenTransactionRunsLongerThan` kun je de volgende vormen meegeven.

| Waarde | Betekenis |
| - | - |
| `int` of `float` | Milliseconden |
| `CarbonInterval` | Totaal aantal milliseconden van het interval |
| `DateTimeInterface` | Seconden tot het opgegeven tijdstip, omgerekend naar milliseconden |

Meestal volstaat het om milliseconden direct op te geven. Wil je de drempel liever in tijdseenheden uitdrukken, dan kun je `CarbonInterval` gebruiken.

```php theme={null}
use Carbon\CarbonInterval;
use Illuminate\Support\Facades\DB;

DB::connection()->whenTransactionRunsLongerThan(
    CarbonInterval::seconds(1),
    static function (): void {
        // Logs of metrics voor monitoring vastleggen
    },
);
```

Er wordt gecontroleerd of de verstreken tijd groter is dan de drempel. Is de verstreken tijd gelijk aan de drempel, dan wordt de callback niet aangeroepen. Met een drempel van `0` activeert elke gemeten transactie de callback.

## Onderscheiden van trage SQL

Laravel heeft ook `whenQueryingForLongerThan`, dat de cumulatieve tijd van de SQL binnen één request monitort. De twee API's meten verschillende dingen.

| API | Wat er wordt gemeten | Event in de callback |
| - | - | - |
| `whenQueryingForLongerThan` | Cumulatieve SQL-uitvoeringstijd binnen de request | `QueryExecuted` |
| `whenTransactionRunsLongerThan` | Verstreken tijd vanaf de start van de buitenste transactie tot commit of rollback | `TransactionCommitted` of `TransactionRolledBack` |

Als je binnen een transactie een externe API aanroept of op locks wacht, kan de verstreken tijd van de transactie groter zijn dan de cumulatieve SQL-tijd. Door beide vast te leggen, kun je makkelijker onderscheiden of een vertraging door de SQL zelf komt of door ander werk binnen de transactie.

## Aandachtspunten in productie

De callback wordt aangeroepen tijdens de verwerking van de commit of rollback, dus beperk hem tot monitoring. Logs en metrics vastleggen kan, maar voer geen extra schrijfacties uit op dezelfde verbinding en doe geen trage externe aanroepen.

Roep je binnen een transactie een externe API aan, dan wordt ook die wachttijd meegemeten. Kijk of je externe aanroepen buiten de transactie kunt plaatsen. Dat vermindert niet alleen meldingen, maar verkort ook hoe lang locks worden vastgehouden.

## Geraadpleegde primaire bronnen

* [Officiële Laravel-databasedocumentatie](https://github.com/laravel/docs/blob/13.x/database.md)
* [Implementatie van `Connection::whenTransactionRunsLongerThan`](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Connection.php)
* [Commit waarmee het aan Laravel Framework is toegevoegd](https://github.com/laravel/framework/commit/5edfeeed86961983042d0bdbbe7265d5b6dc7bba)


## Related topics

- [Geavanceerde onderwerpen](https://kawax.biz/nl/advanced/index.md)
- [Eigen Pulse-recorders in packages](https://kawax.biz/nl/advanced/package-pulse-recorders.md)
- [Ontwikkelgids voor apps met de engine-API - VOICEVOX for Laravel](https://kawax.biz/nl/packages/laravel-voicevox/app-guide.md)
- [Upgradegids van Laravel 12 naar 13](https://kawax.biz/nl/blog/upgrade-12-to-13.md)
- [Laravel-updates van oktober 2026](https://kawax.biz/nl/blog/changelog/202610.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.