How to Use DB:Monitor on Laravel

Is your Laravel application dealing with too many database connections? Are you worried about your website slowing down or crashing because of database problems?

Laravel has a built-in tool to help you keep an eye on your database connections: the db:monitor command. Think of it as a guard for your database, always watching and alerting you if things get too busy.

Since Laravel version 9.24, this feature is available to help you proactively manage your database connections and avoid problems before they affect your users.

Why is Monitoring Database Connections Important?

Imagine your database as a highway. Database connections are like cars on this highway. If too many cars try to use the highway at the same time, traffic jams happen! In your application, too many database connections can lead to:

• Slow website: Your website takes longer to load, frustrating users.
• Application errors: Your application might start showing errors or stop working correctly.
• Database crashes: In extreme cases, your database could crash, making your entire application unavailable.

By monitoring your database connections, you can see when you're getting close to the "traffic jam" point and take action before it causes problems.

How db:monitor Works

The db:monitor command in Laravel is like a checkup for your database connections. It counts how many connections are currently open and compares it to a limit you set.

If the number of connections gets too close to your limit, db:monitor can send you a notification, letting you know there might be an issue.

Setting up db:monitor

1. Schedule the monitor: You need to tell Laravel to run the db:monitor command regularly. A good starting point is to check every minute. You can do this by adding the following to your App\Console\Kernel.php file:

   PHP

   // App\Console\Kernel.php
   protected function schedule(Schedule $schedule)
   {
       // Monitor the 'mysql' database every minute, alert if connections reach 100
       $schedule->command('db:monitor --database=mysql --max=100')
           ->everyMinute();
   }
   

   • --database=mysql: This specifies which database connection to monitor (in this case, 'mysql'). Change this to the name of your database connection.
   • --max=100: This sets the maximum allowed connections. Adjust this number based on your database server's capacity and your application's needs.

2. Create a Notification: When db:monitor detects too many connections, it triggers a DatabaseBusy event. You need to set up a notification to be sent when this event happens. Create a notification file (if you don't already have one) using:

   Bash

   php artisan make:notification DatabaseApproachingMaxConnections
   

   Then, modify the notification (App\Notifications\DatabaseApproachingMaxConnections.php) to send you an email alert:

   PHP

   // App\Notifications\DatabaseApproachingMaxConnections.php
   use Illuminate\Notifications\Notification;
   use Illuminate\Notifications\Messages\MailMessage;
   
   class DatabaseApproachingMaxConnections extends Notification
   {
       public $connectionName;
       public $connections;
   
       public function __construct(string $connectionName, int $connections)
       {
           $this->connectionName = $connectionName;
           $this->connections = $connections;
       }
   
       public function toMail($notifiable)
       {
           return (new MailMessage)
               ->error() // Use error styling for important alerts
               ->subject('Database Connection Alert!') // Clear subject line
               ->line("The {$this->connectionName} database has {$this->connections} open connections.") // Informative message
               ->line('This is approaching the configured threshold.'); // Explain the alert
       }
   
       public function via($notifiable)
       {
           return ['mail']; // Send notification via email
       }
   }
   

3. Listen for the DatabaseBusy Event: In your App\Providers\AppServiceProvider.php file, tell Laravel to listen for the DatabaseBusy event and send your notification when it occurs:

   PHP

   // App\Providers\AppServiceProvider.php
   use App\Notifications\DatabaseApproachingMaxConnections;
   use Illuminate\Database\Events\DatabaseBusy;
   use Illuminate\Support\Facades\Event;
   use Illuminate\Support\Facades\Notification;
   
   public function boot(): void
   {
       Event::listen(DatabaseBusy::class, function (DatabaseBusy $event) { // Listen for DatabaseBusy event
           Notification::route('mail', 'dev@example.com') // Send email to your development team
               ->notify(new DatabaseApproachingMaxConnections( // Use your notification
                   $event->connectionName, // Pass database connection name
                   $event->connections // Pass current connection count
               ));
       });
   }
   

   • Make sure to replace 'dev@example.com' with the email address where you want to receive alerts.

More Efficient Code Example (Optional):

The provided code is already quite efficient for its purpose. Database connection monitoring is not typically a performance-critical task. However, if you are monitoring multiple databases, you can slightly adjust the scheduled command to monitor them all at once:

PHP

    // App\Console\Kernel.php
    protected function schedule(Schedule $schedule)
    {
        // Monitor multiple databases (mysql and pgsql)
        $schedule->command('db:monitor --databases=mysql,pgsql --max=100')
            ->everyMinute();
    }

This single command will monitor both 'mysql' and 'pgsql' databases, reducing the number of scheduled tasks if you have many databases to monitor.

When is db:monitor Most Useful?

• High User Traffic: Websites with many users accessing the database at the same time.
• Multiple Databases: Applications that connect to several databases.
• Debugging Connection Issues: Helps in understanding and fixing database connection problems.
• Maintaining Stability: Ensures your application runs smoothly and reliably.
• Scaling for Growth: Provides insights when you are planning to handle more users and data.

Conclusion

Don't wait until you reach 100% of your maximum connections to get an alert. Setting the --max value to 80% of your actual database limit gives you time to investigate and react before a real problem occurs.

Laravel's db:monitor command is a simple yet powerful tool to keep your database connections healthy. By proactively monitoring and getting alerts, you can prevent database connection exhaustion and ensure your Laravel applications remain stable and performant.