symfony · joaojacome · Mar 21, 2023 · Mar 21, 2023 · Mar 28, 2023
diff --git a/src/Symfony/Bridge/Monolog/Logger.php b/src/Symfony/Bridge/Monolog/Logger.php
@@ -11,17 +11,83 @@
 
 namespace Symfony\Bridge\Monolog;
 
+use Monolog\Handler\HandlerInterface;
 use Monolog\Logger as BaseLogger;
+use Monolog\Processor\ProcessorInterface;
 use Monolog\ResettableInterface;
+use Psr\Log\LoggerInterface;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpKernel\Log\DebugLoggerInterface;
 use Symfony\Contracts\Service\ResetInterface;
 
 /**
  * @author Fabien Potencier <fabien@symfony.com>
  */
-class Logger extends BaseLogger implements DebugLoggerInterface, ResetInterface
+class Logger extends BaseLogger implements LoggerInterface, DebugLoggerInterface, ResetInterface
 {
+    use MonologApiTrait;
+
+    /**
+     * @see BaseLogger::DEBUG
+     * @deprecated This has been copied over from \Monolog\Logger for compatibility reasons, and might be removed eventually.
+     */
+    public const DEBUG = 100;
+
+    /**
+     * @see BaseLogger::INFO
+     * @deprecated This has been copied over from \Monolog\Logger for compatibility reasons, and might be removed eventually.
+     */
+    public const INFO = 200;
+
+    /**
+     * @see BaseLogger::NOTICE
+     * @deprecated This has been copied over from \Monolog\Logger for compatibility reasons, and might be removed eventually..
+     */
+    public const NOTICE = 250;
+
+    /**
+     * @see BaseLogger::WARNING
+     * @deprecated This has been copied over from \Monolog\Logger for compatibility reasons, and might be removed eventually.
+     */
+    public const WARNING = 300;
+
+    /**
+     * @see BaseLogger::ERROR
+     * @deprecated This has been copied over from \Monolog\Logger for compatibility reasons, and might be removed eventually.
+     */
+    public const ERROR = 400;
+
+    /**
+     * @see BaseLogger::CRITICAL
+     * @deprecated This has been copied over from \Monolog\Logger for compatibility reasons, and might be removed eventually.
+     */
+    public const CRITICAL = 500;
+
+    /**
+     * @see BaseLogger::ALERT
+     * @deprecated This has been copied over from \Monolog\Logger for compatibility reasons, and might be removed eventually.
+     */
+    public const ALERT = 550;
+
+    /**
+     * @see BaseLogger::EMERGENCY
+     * @deprecated This has been copied over from \Monolog\Logger for compatibility reasons, and might be removed eventually.
+     */
+    public const EMERGENCY = 600;
+
+    /**
+     * @see BaseLogger::API
+     * @deprecated This has been copied over from \Monolog\Logger for compatibility reasons, and might be removed eventually.
+     */
+    public const API = 3;
+
+    public function setLogger(BaseLogger $logger): self
+    {
+        $this->logger = $logger;
+
+        return $this;
+    }
+
     public function getLogs(Request $request = null): array
     {
         if ($logger = $this->getDebugLogger()) {
@@ -54,46 +120,80 @@ public function reset(): void
     {
         $this->clear();
 
-        if ($this instanceof ResettableInterface) {
-            parent::reset();
-        }
+        $this->logger->reset();
     }
 
     /**
      * @return void
      */
     public function removeDebugLogger()
     {
-        foreach ($this->processors as $k => $processor) {
-            if ($processor instanceof DebugLoggerInterface) {
-                unset($this->processors[$k]);
-            }
-        }
-
-        foreach ($this->handlers as $k => $handler) {
-            if ($handler instanceof DebugLoggerInterface) {
-                unset($this->handlers[$k]);
-            }
-        }
+        $this->logger->removeProcessor(fn (int $key, ProcessorInterface $processor) => $processor instanceof DebugLoggerInterface);
+        $this->logger->removeHandler(fn (int $key, HandlerInterface $handler) => $handler instanceof DebugLoggerInterface);
     }
 
     /**
      * Returns a DebugLoggerInterface instance if one is registered with this logger.
      */
     private function getDebugLogger(): ?DebugLoggerInterface
     {
-        foreach ($this->processors as $processor) {
+        foreach ($this->logger->getProcessors() as $processor) {
             if ($processor instanceof DebugLoggerInterface) {
                 return $processor;
             }
         }
 
-        foreach ($this->handlers as $handler) {
+        foreach ($this->logger->getHandlers() as $handler) {
             if ($handler instanceof DebugLoggerInterface) {
                 return $handler;
             }
         }
 
         return null;
     }
+
+    public function emergency($message, array $context = []): void
+    {
+        $this->logger->emergency($message, $context);
+    }
+
+    public function alert($message, array $context = []): void
+    {
+        $this->logger->alert($message, $context);
+    }
+
+    public function critical($message, array $context = []): void
+    {
+        $this->logger->critical($message, $context);
+    }
+
+    public function error($message, array $context = []): void
+    {
+        $this->logger->error($message, $context);
+    }
+
+    public function warning($message, array $context = []): void
+    {
+        $this->logger->warning($message, $context);
+    }
+
+    public function notice($message, array $context = []): void
+    {
+        $this->logger->notice($message, $context);
+    }
+
+    public function info($message, array $context = []): void
+    {
+        $this->logger->info($message, $context);
+    }
+
+    public function debug($message, array $context = []): void
+    {
+        $this->logger->debug($message, $context);
+    }
+
+    public function log($level, $message, array $context = []): void
+    {
+        $this->logger->log($level, $message, $context);
+    }
 }