Logging ¶

Logging a Message ¶

To log a message, inject the default logger in your controller or service:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

use Psr\Log\LoggerInterface;

public function index(LoggerInterface $logger)
{
    $logger->info('I just got the logger');
    $logger->error('An error occurred');

    $logger->critical('I left the oven on!', [
        // include extra "context" info in your logs
        'cause' => 'in_hurry',
    ]);

    // ...
}

The logger service has different methods for different logging levels/priorities. See LoggerInterface for a list of all of the methods on the logger.

Monolog ¶

Symfony integrates seamlessly with Monolog, the most popular PHP logging library, to create and store log messages in a variety of different places and trigger various actions.

For instance, using Monolog you can configure the logger to do different things based on the level of a message (e.g. send an email when an error occurs).

Run this command to install the Monolog based logger before using it:

1

$ composer require symfony/monolog-bundle

The following sections assume that Monolog is installed.

Where Logs are Stored ¶

By default, log entries are written to the var/log/dev.log file when you're in the dev environment.

In the prod environment, logs are written to STDERR PHP stream, which works best in modern containerized applications deployed to servers without disk write permissions.

If you prefer to store production logs in a file, set the path of your log handler(s) to the path of the file to use (e.g. var/log/prod.log).

Handlers: Writing Logs to different Locations ¶

The logger has a stack of handlers, and each can be used to write the log entries to different locations (e.g. files, database, Slack, etc).

Symfony pre-configures some basic handlers in the default monolog.yaml config files. Check these out for some real-world examples.

This example uses two handlers: stream (to write to a file) and syslog to write logs using the syslog function:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# config/packages/prod/monolog.yaml
monolog:
    handlers:
        # this "file_log" key could be anything
        file_log:
            type: stream
            # log to var/log/(environment).log
            path: "%kernel.logs_dir%/%kernel.environment%.log"
            # log *all* messages (debug is lowest level)
            level: debug

        syslog_handler:
            type: syslog
            # log error-level messages and higher
            level: error

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<!-- config/packages/prod/monolog.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:monolog="http://symfony.com/schema/dic/monolog"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/monolog
        https://symfony.com/schema/dic/monolog/monolog-1.0.xsd">

    <monolog:config>
        <!-- this "file_log" key could be anything -->
        <monolog:handler name="file_log"
            type="stream"
            path="%kernel.logs_dir%/%kernel.environment%.log"
            level="debug"/><!-- log *all* messages (debug is lowest level) -->

        <monolog:handler name="syslog_handler"
            type="syslog"
            level="error"/><!-- log error-level messages and higher -->
    </monolog:config>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// config/packages/prod/monolog.php
use Symfony\Config\MonologConfig;

return static function (MonologConfig $monolog) {
    // this "file_log" key could be anything
    $monolog->handler('file_log')
        ->type('stream')
        // log to var/logs/(environment).log
        ->path('%kernel.logs_dir%/%kernel.environment%.log')
        // log *all* messages (debug is lowest level)
        ->level('debug');

    $monolog->handler('syslog_handler')
        ->type('syslog')
        // log error-level messages and higher
        ->level('error');
};

This defines a stack of handlers and each handler is called in the order that it's defined.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# config/packages/prod/monolog.yaml
monolog:
    handlers:
        filter_for_errors:
            type: fingers_crossed
            # if *one* log is error or higher, pass *all* to file_log
            action_level: error
            handler: file_log

        # now passed *all* logs, but only if one log is error or higher
        file_log:
            type: stream
            path: "%kernel.logs_dir%/%kernel.environment%.log"

        # still passed *all* logs, and still only logs error or higher
        syslog_handler:
            type: syslog
            level: error

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

<!-- config/packages/prod/monolog.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:monolog="http://symfony.com/schema/dic/monolog"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/monolog
        https://symfony.com/schema/dic/monolog/monolog-1.0.xsd">

    <monolog:config>
        <!-- if *one* log is error or higher, pass *all* to file_log -->
        <monolog:handler name="filter_for_errors"
            type="fingers_crossed"
            action-level="error"
            handler="file_log"
        />

        <!-- now passed *all* logs, but only if one log is error or higher -->
        <monolog:handler name="file_log"
            type="stream"
            path="%kernel.logs_dir%/%kernel.environment%.log"
            level="debug"
        />

        <!-- still passed *all* logs, and still only logs error or higher -->
        <monolog:handler name="syslog_handler"
            type="syslog"
            level="error"
        />
    </monolog:config>
</container>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// config/packages/prod/monolog.php
use Symfony\Config\MonologConfig;

return static function (MonologConfig $monolog) {
    $monolog->handler('filter_for_errors')
        ->type('fingers_crossed')
        // if *one* log is error or higher, pass *all* to file_log
        ->actionLevel('error')
        ->handler('file_log')
    ;

    // now passed *all* logs, but only if one log is error or higher
    $monolog->handler('file_log')
        ->type('stream')
        ->path('%kernel.logs_dir%/%kernel.environment%.log')
        ->level('debug')
    ;

    // still passed *all* logs, and still only logs error or higher
    $monolog->handler('syslog_handler')
        ->type('syslog')
        ->level('error')
    ;
};

All Built-in Handlers ¶

Monolog comes with many built-in handlers for emailing logs, sending them to Loggly, or notifying you in Slack. These are documented inside of MonologBundle itself. For a full list, see Monolog Configuration.

How to Rotate your Log Files ¶

Over time, log files can grow to be huge, both while developing and on production. One best-practice solution is to use a tool like the logrotate Linux command to rotate log files before they become too large.

Another option is to have Monolog rotate the files for you by using the rotating_file handler. This handler creates a new log file every day and can also remove old files automatically. To use it, set the type option of your handler to rotating_file:

1
2
3
4
5
6
7
8
9
10

# config/packages/prod/monolog.yaml
monolog:
    handlers:
        main:
            type:  rotating_file
            path:  '%kernel.logs_dir%/%kernel.environment%.log'
            level: debug
            # max number of log files to keep
            # defaults to zero, which means infinite files
            max_files: 10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<!-- config/packages/prod/monolog.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:monolog="http://symfony.com/schema/dic/monolog"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/monolog
        https://symfony.com/schema/dic/monolog/monolog-1.0.xsd">

    <monolog:config>
        <!-- "max-files": max number of log files to keep
             defaults to zero, which means infinite files -->
        <monolog:handler name="main"
            type="rotating_file"
            path="%kernel.logs_dir%/%kernel.environment%.log"
            level="debug"
            max-files="10"
        />
    </monolog:config>
</container>

1
2
3
4
5
6
7
8
9
10
11
12

// config/packages/prod/monolog.php
use Symfony\Config\MonologConfig;

return static function (MonologConfig $monolog) {
    $monolog->handler('main')
        ->type('rotating_file')
        ->path('%kernel.logs_dir%/%kernel.environment%.log')
        ->level('debug')
        // max number of log files to keep
        // defaults to zero, which means infinite files
        ->maxFiles(10);
};

Using a Logger inside a Service ¶

If your application uses service autoconfiguration, any service whose class implements Psr\Log\LoggerAwareInterface will receive a call to its method setLogger() with the default logger service passed as a service.

If you want to use in your own services a pre-configured logger which uses a specific channel (app by default), you can either autowire monolog channels or use the monolog.logger tag with the channel property as explained in the Dependency Injection reference.

Adding extra Data to each Log (e.g. a unique request token) ¶

Monolog also supports processors: functions that can dynamically add extra information to your log entries.

See How to Add extra Data to Log Messages via a Processor for details.

Learn more ¶