Logging

Edit this page

Symfony comes with two minimalist PSR-3 loggers: Logger for the HTTP context and ConsoleLogger for the CLI context. In conformance with the twelve-factor app methodology, they send messages starting from the WARNING level to stderr.

The minimal log level can be changed by setting the SHELL_VERBOSITY environment variable:

SHELL_VERBOSITY value Minimum log level
-1 ERROR
1 NOTICE
2 INFO
3 DEBUG

The minimum log level, the default output and the log format can also be changed by passing the appropriate arguments to the constructor of Logger and ConsoleLogger.

The Logger class is available through the logger service. To pass your configuration, you can override the "logger" service definition.

For more information about ConsoleLogger, see Using the Logger.

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 15 16 17 18 19 20 21
use Psr\Log\LoggerInterface; // ... public function index(LoggerInterface $logger): Response { $logger->info('I just got the logger'); $logger->error('An error occurred'); // log messages can also contain placeholders, which are variable names // wrapped in braces whose values are passed as the second argument $logger->debug('User {userId} has logged in', [ 'userId' => $this->getUserId(), ]); $logger->critical('I left the oven on!', [ // include extra "context" info in your logs 'cause' => 'in_hurry', ]); // ... }

Adding placeholders to log messages is recommended because:

  • It's easier to check log messages because many logging tools group log messages that are the same except for some variable values inside them;
  • It's much easier to translate those log messages;
  • It's better for security, because escaping can then be done by the implementation in a context-aware fashion.

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).

Tip

You can also configure logging "channels", which are like categories. Each channel can have its own handlers, which means you can store different log messages in different places. See How to Log Messages to different Files.

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

This defines a stack of handlers. Each handler can define a priority (default 0) to control its position in the stack. Handlers with a higher priority are called first, while those with the same priority keep the order in which they are defined:

1 2 3 4 5 6 7 8 9 10
# config/packages/prod/monolog.yaml monolog: handlers: file_log: type: stream path: "%kernel.logs_dir%/%kernel.environment%.log" syslog_handler: type: syslog priority: 10 # called first

Note

When adding handlers in other configuration files, it's recommended to set an explicit priority to ensure they are ordered as expected.

Handlers that Modify Log Entries

Instead of writing log files somewhere, some handlers are used to filter or modify log entries before sending them to other handlers. One powerful, built-in handler called fingers_crossed is used in the prod environment by default. It stores all log messages during a request but only passes them to a second handler if one of the messages reaches an action_level. Take this example:

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

Now, if even one log entry has an LogLevel::ERROR level or higher, then all log entries for that request are saved to a file via the file_log handler. That means that your log file will contain all the details about the problematic request - making debugging much easier!

Tip

The handler named "file_log" will not be included in the stack itself as it is used as a nested handler of the fingers_crossed handler.

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

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.

Handling Logs in Long Running Processes

During long running processes, logs can be accumulated into Monolog and cause some buffer overflow, memory increase or even non logical logs. Monolog in-memory data can be cleared using the reset() method on a Monolog\Logger instance. This should typically be called between every job or task that a long running process is working through.

Learn more

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.
TOC
    Version