Add Monolog handler configuration

Author: HypeMC

README.md

@@ -103,17 +103,20 @@ the [PHP specific](https://docs.sentry.io/platforms/php/#php-specific-options) o
 #### Optional: use monolog handler provided by `sentry/sentry`
 *Note: this step is optional*
 
-If You're using `monolog` for logging e.g. in-app errors, You
+If you're using `monolog` for logging e.g. in-app errors, you
 can use this handler in order for them to show up in Sentry. 
 
-First, define `Sentry\Monolog\Handler` as a service in `config/services.yaml`
+First, enable & configure the `Sentry\Monolog\Handler`; you'll also need
+to disable the `Sentry\SentryBundle\EventListener\ErrorListener` to
+avoid having duplicate events in Sentry:
 
 ```yaml
-services:
-    sentry.monolog.handler:
-        class: Sentry\Monolog\Handler
-        arguments:
-            $level: 'error'
+sentry:
+    register_error_listener: false # Disables the ErrorListener
+    monolog:
+        error_handler:
+            enabled: true
+            level: error
 ```
 
 Then enable it in `monolog` config:
@@ -123,8 +126,7 @@ monolog:
     handlers:
         sentry:
             type: service
-            id: sentry.monolog.handler
-            level: error 
+            id: Sentry\Monolog\Handler
 ```
 
 ## Maintained versions

composer.json

@@ -32,20 +32,24 @@
     "require-dev": {
         "friendsofphp/php-cs-fixer": "^2.8",
         "jangregor/phpstan-prophecy": "^0.3.0",
+        "monolog/monolog": "^1.11||^2.0",
         "php-http/mock-client": "^1.0",
         "phpstan/phpstan": "^0.11",
         "phpstan/phpstan-phpunit": "^0.11",
         "phpunit/phpunit": "^7.5",
         "scrutinizer/ocular": "^1.4",
         "symfony/expression-language": "^2.8||^3.0||^4.0"
     },
+    "suggest": {
+        "monolog/monolog": "Required to use the Monolog handler"
+    },
     "autoload": {
-        "psr-4" : {
+        "psr-4": {
             "Sentry\\SentryBundle\\": "src/"
         }
     },
     "autoload-dev": {
-        "psr-4" : {
+        "psr-4": {
             "Sentry\\SentryBundle\\Test\\": "test"
         }
     },

src/DependencyInjection/Configuration.php

@@ -143,6 +143,24 @@ public function getConfigTreeBuilder(): TreeBuilder
         $listenerPriorities->scalarNode('console_error')
             ->defaultValue(128);
 
+        // Monolog handler configuration
+        $monologConfiguration = $rootNode->children()
+            ->arrayNode('monolog')
+            ->addDefaultsIfNotSet()
+            ->children();
+
+        $errorHandler = $monologConfiguration
+            ->arrayNode('error_handler')
+            ->addDefaultsIfNotSet()
+            ->children();
+        $errorHandler->booleanNode('enabled')
+            ->defaultFalse();
+        $errorHandler->scalarNode('level')
+            ->defaultValue('DEBUG')
+            ->cannotBeEmpty();
+        $errorHandler->booleanNode('bubble')
+            ->defaultTrue();
+
         return $treeBuilder;
     }
 

src/DependencyInjection/SentryExtension.php

@@ -2,7 +2,9 @@
 
 namespace Sentry\SentryBundle\DependencyInjection;
 
+use Monolog\Logger as MonologLogger;
 use Sentry\ClientBuilderInterface;
+use Sentry\Monolog\Handler;
 use Sentry\Options;
 use Sentry\SentryBundle\Command\SentryTestCommand;
 use Sentry\SentryBundle\ErrorTypesParser;
@@ -14,6 +16,7 @@
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\Console\ConsoleEvents;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Exception\LogicException;
 use Symfony\Component\DependencyInjection\Loader;
 use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\HttpKernel\DependencyInjection\Extension;
@@ -49,6 +52,7 @@ public function load(array $configs, ContainerBuilder $container): void
 
         $this->configureErrorListener($container, $processedConfiguration);
         $this->setLegacyVisibilities($container);
+        $this->configureMonologHandler($container, $processedConfiguration['monolog']);
     }
 
     private function passConfigurationToOptions(ContainerBuilder $container, array $processedConfiguration): void
@@ -185,4 +189,32 @@ private function setLegacyVisibilities(ContainerBuilder $container): void
             }
         }
     }
+
+    private function configureMonologHandler(ContainerBuilder $container, array $monologConfiguration): void
+    {
+        $errorHandler = $monologConfiguration['error_handler'];
+
+        if (! $errorHandler['enabled']) {
+            $container->removeDefinition(Handler::class);
+
+            return;
+        }
+
+        if (! class_exists(Handler::class)) {
+            throw new LogicException(
+                sprintf('Missing class "%s", try updating "sentry/sentry" to a newer version.', Handler::class)
+            );
+        }
+
+        if (! class_exists(MonologLogger::class)) {
+            throw new LogicException(
+                sprintf('You cannot use "%s" if Monolog is not available.', Handler::class)
+            );
+        }
+
+        $container
+            ->getDefinition(Handler::class)
+            ->replaceArgument('$level', MonologLogger::toMonologLevel($errorHandler['level']))
+            ->replaceArgument('$bubble', $errorHandler['bubble']);
+    }
 }

src/Resources/config/services.xml

@@ -51,5 +51,11 @@
         <service id="Sentry\SentryBundle\Command\SentryTestCommand" class="Sentry\SentryBundle\Command\SentryTestCommand" public="false">
             <tag name="console.command" />
         </service>
+
+        <service id="Sentry\Monolog\Handler" class="Sentry\Monolog\Handler" public="false">
+            <argument type="service" id="Sentry\State\HubInterface" />
+            <argument key="$level" />
+            <argument key="$bubble" />
+        </service>
     </services>
 </container>

test/DependencyInjection/ConfigurationTest.php

@@ -68,6 +68,13 @@ public function testConfigurationDefaults(): void
                 'project_root' => '%kernel.root_dir%/..',
                 'tags' => [],
             ],
+            'monolog' => [
+                'error_handler' => [
+                    'enabled' => false,
+                    'level' => 'DEBUG',
+                    'bubble' => true,
+                ],
+            ],
         ];
 
         if (method_exists(Kernel::class, 'getProjectDir')) {

test/DependencyInjection/SentryExtensionTest.php

@@ -3,17 +3,23 @@
 namespace Sentry\SentryBundle\Test\DependencyInjection;
 
 use Jean85\PrettyVersions;
+use Monolog\Logger as MonologLogger;
 use Sentry\Breadcrumb;
+use Sentry\ClientInterface;
 use Sentry\Event;
 use Sentry\Integration\IntegrationInterface;
+use Sentry\Monolog\Handler;
 use Sentry\Options;
 use Sentry\SentryBundle\DependencyInjection\SentryExtension;
 use Sentry\SentryBundle\EventListener\ErrorListener;
 use Sentry\SentryBundle\Test\BaseTestCase;
+use Sentry\Severity;
+use Sentry\State\Scope;
 use Symfony\Component\DependencyInjection\Alias;
 use Symfony\Component\DependencyInjection\Container;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\LogicException;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\HttpFoundation\RequestStack;
 use Symfony\Component\HttpKernel\Kernel;
@@ -22,6 +28,7 @@ class SentryExtensionTest extends BaseTestCase
 {
     private const OPTIONS_TEST_PUBLIC_ALIAS = 'sentry.options.public_alias';
     private const ERROR_LISTENER_TEST_PUBLIC_ALIAS = 'sentry.error_listener.public_alias';
+    private const MONOLOG_HANDLER_TEST_PUBLIC_ALIAS = 'sentry.monolog_handler.public_alias';
 
     public function testDataProviderIsMappingTheRightNumberOfOptions(): void
     {
@@ -346,7 +353,7 @@ public function testErrorListenerIsRegistered(bool $registerErrorListener): void
             'register_error_listener' => $registerErrorListener,
         ]);
 
-        $this->assertEquals($registerErrorListener, $container->has(self::ERROR_LISTENER_TEST_PUBLIC_ALIAS));
+        $this->assertSame($registerErrorListener, $container->has(self::ERROR_LISTENER_TEST_PUBLIC_ALIAS));
     }
 
     public function errorListenerConfigurationProvider(): array
@@ -357,6 +364,56 @@ public function errorListenerConfigurationProvider(): array
         ];
     }
 
+    /**
+     * @dataProvider monologHandlerConfigurationProvider
+     */
+    public function testMonologHandlerIsConfiguredProperly($level, bool $bubble, int $monologLevel): void
+    {
+        $this->expectExceptionIfMonologHandlerDoesNotExist();
+
+        $container = $this->getContainer([
+            'monolog' => [
+                'error_handler' => [
+                    'enabled' => true,
+                    'level' => $level,
+                    'bubble' => $bubble,
+                ],
+            ],
+        ]);
+
+        $this->assertTrue($container->has(self::MONOLOG_HANDLER_TEST_PUBLIC_ALIAS));
+
+        /** @var Handler $handler */
+        $handler = $container->get(self::MONOLOG_HANDLER_TEST_PUBLIC_ALIAS);
+        $this->assertEquals($monologLevel, $handler->getLevel());
+        $this->assertEquals($bubble, $handler->getBubble());
+    }
+
+    public function monologHandlerConfigurationProvider(): array
+    {
+        return [
+            ['DEBUG', true, MonologLogger::DEBUG],
+            ['debug', false, MonologLogger::DEBUG],
+            ['ERROR', true, MonologLogger::ERROR],
+            ['error', false, MonologLogger::ERROR],
+            [MonologLogger::ALERT, true, MonologLogger::ALERT],
+            [MonologLogger::EMERGENCY, false, MonologLogger::EMERGENCY],
+        ];
+    }
+
+    public function testMonologHandlerIsNotRegistered(): void
+    {
+        $container = $this->getContainer([
+            'monolog' => [
+                'error_handler' => [
+                    'enabled' => false,
+                ],
+            ],
+        ]);
+
+        $this->assertFalse($container->has(self::MONOLOG_HANDLER_TEST_PUBLIC_ALIAS));
+    }
+
     private function getContainer(array $configuration = []): Container
     {
         $containerBuilder = new ContainerBuilder();
@@ -385,10 +442,17 @@ private function getContainer(array $configuration = []): Container
         $extension = new SentryExtension();
         $extension->load(['sentry' => $configuration], $containerBuilder);
 
+        $client = new Definition(ClientMock::class);
+        $containerBuilder->setDefinition(ClientInterface::class, $client);
+
         if ($containerBuilder->hasDefinition(ErrorListener::class)) {
             $containerBuilder->setAlias(self::ERROR_LISTENER_TEST_PUBLIC_ALIAS, new Alias(ErrorListener::class, true));
         }
 
+        if ($containerBuilder->hasDefinition(Handler::class)) {
+            $containerBuilder->setAlias(self::MONOLOG_HANDLER_TEST_PUBLIC_ALIAS, new Alias(Handler::class, true));
+        }
+
         $containerBuilder->compile();
 
         return $containerBuilder;
@@ -403,6 +467,16 @@ private function getOptionsFrom(Container $container): Options
 
         return $options;
     }
+
+    private function expectExceptionIfMonologHandlerDoesNotExist(): void
+    {
+        if (! class_exists(Handler::class)) {
+            $this->expectException(LogicException::class);
+            $this->expectExceptionMessage(
+                sprintf('Missing class "%s", try updating "sentry/sentry" to a newer version.', Handler::class)
+            );
+        }
+    }
 }
 
 function mockBeforeSend(Event $event): ?Event
@@ -439,3 +513,36 @@ public function setupOnce(): void
     {
     }
 }
+
+class ClientMock implements ClientInterface
+{
+    public function getOptions(): Options
+    {
+        return new Options();
+    }
+
+    public function captureMessage(string $message, ?Severity $level = null, ?Scope $scope = null): ?string
+    {
+        return null;
+    }
+
+    public function captureException(\Throwable $exception, ?Scope $scope = null): ?string
+    {
+        return null;
+    }
+
+    public function captureLastError(?Scope $scope = null): ?string
+    {
+        return null;
+    }
+
+    public function captureEvent(array $payload, ?Scope $scope = null): ?string
+    {
+        return null;
+    }
+
+    public function getIntegration(string $className): ?IntegrationInterface
+    {
+        return null;
+    }
+}