Defining a custom logger channelfor Drupal 8 , 9 , 10 , and 11

Introduction

Building on our understanding of Drupal's logging system, it's time to explore how to define custom logger channels. Custom channels allow your module to categorize logs effectively based on their specific responsibility or functionality. This makes it easier to filter and monitor logs, improving the overall manageability of your application.

Understanding Custom Logger Channels

Logger channels in Drupal help you segment logging based on context, such as module-specific events, tasks, or features. When you create custom channels, you can classify messages to be tracked individually, allowing for pinpoint data extraction and analysis.

Benefits of Custom Logger Channels

• Enhanced organization of log data, making it easier to sift through large log volumes.
• Streamlined debugging, as different features can log to separate channels for targeted observation.
• Improved monitoring and alerting capabilities based on targeted log content.

Creating a Custom Logger Channel

Let's see how to define a custom logger channel within a custom module. We will be using the mymodule example to demonstrate these concepts.

Step 1: Define the Channel in Services

In your mymodule.services.yml, define a new logger channel service like so:

services:
  logger.channel.mymodule_custom:
    class: Drupal\Core\Logger\LoggerChannel
    arguments: ['mymodule_custom']

Explanation:

This service declaration adds a new custom logger channel with the name mymodule_custom. It's a good practice to use clear and descriptive names that reflect the purpose of the channel to ensure clarity and ease of use.

Step 2: Use the Custom Logger Channel in Your Code

Inject this custom logger channel into your service or controller to start logging messages. Here’s how you can update a controller to utilize the newly defined channel:

namespace Drupal\mymodule\Controller;

use Drupal\Core\Controller\ControllerBase;
use Psr\Log\LoggerInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

class CustomLogController extends ControllerBase {
  
  /**
   * The custom logger service.
   *
   * @var \Psr\Log\LoggerInterface
   */
  protected $customLogger;

  /**
   * Constructs a new CustomLogController object.
   *
   * @param \Psr\Log\LoggerInterface $customLogger
   *   The custom logger service.
   */
  public function __construct(LoggerInterface $customLogger) {
    $this--->customLogger = $customLogger;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container) {
    return new static(
      $container->get('logger.channel.mymodule_custom')
    );
  }

  /**
   * Demonstration of logging using a custom logger channel.
   */
  public function logDemo() {
    $this->customLogger->info('Logging information using a custom channel.', ['channel' => 'mymodule_custom']);
    $this->customLogger->error('Logging an error using a custom channel.', ['channel' => 'mymodule_custom']);
    
    return [
      '#markup' => $this->t('Custom channel log entries have been recorded. Check the logs for details.'),
    ];
  }
}

Explanation:

In this code, the custom logger service, logger.channel.mymodule_custom, is injected into the controller, enabling logs to be recorded specifically under this channel. The controller methods demonstrate the use of different log levels.

Verifying Custom Channel Logs

Once your channel is created and integrated, you can view its logs:

1. Navigate to Reports > Recent log messages (found at /admin/reports/dblog).
2. Here, filter logs specifically by the channel mymodule_custom to view only those entries relevant to your custom logging actions.

Best Practices for Custom Logger Channels

• Descriptive Names: Use descriptive names for channels to clarify their roles within the codebase.
• Consistent Use: Ensure consistent usage of these channels across the related code to maintain organized logs.
• Review and Maintain: Regularly monitor logs and refine your logging strategy as the application evolves.

Conclusion

Defining custom logger channels in Drupal enhances your ability to fine-tune log management within your modules. These custom channels offer a streamlined approach to monitoring, debugging, and maintaining your application by providing structured and categorized logging.

In the next lesson, we will delve into logging to Drupal’s watchdog system, exploring its flexibility and how you can utilize it to extend your logging capabilities further. Continue with us as we unlock more Drupal logging features to strengthen your module development skills!