Merge pull request #193 from getsentry/add-options-as-services

Add before_send option

Author: Jean85

composer.json

@@ -35,7 +35,7 @@
         "php-http/mock-client": "^1.0",
         "phpstan/phpstan": "^0.11",
         "phpstan/phpstan-phpunit": "^0.11",
-        "phpunit/phpunit": "^7",
+        "phpunit/phpunit": "^7.5",
         "scrutinizer/ocular": "^1.4",
         "symfony/expression-language": "^3.0||^4.0"
     },

src/DependencyInjection/Configuration.php

@@ -47,7 +47,12 @@ public function getConfigTreeBuilder()
             ->children()
             ->booleanNode('attach_stacktrace')->end()
             // TODO -- before_breadcrumb
-            // TODO -- before_send
+            ->variableNode('before_send')
+                ->validate()
+                    ->ifTrue($this->isNotAValidCallback())
+                    ->thenInvalid('Expecting callable or service reference, got %s')
+                ->end()
+            ->end()
             ->booleanNode('default_integrations')->end()
             ->integerNode('context_lines')
                 ->min(0)
@@ -137,4 +142,19 @@ private function getProjectRoot(): string
 
         return '%kernel.root_dir%/..';
     }
+
+    private function isNotAValidCallback(): \Closure
+    {
+        return function ($value): bool {
+            if (is_callable($value)) {
+                return false;
+            }
+
+            if (is_string($value) && 0 === strpos($value, '@')) {
+                return false;
+            }
+
+            return true;
+        };
+    }
 }

src/DependencyInjection/SentryExtension.php

@@ -10,6 +10,7 @@
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Loader;
+use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\HttpKernel\DependencyInjection\Extension;
 
 /**
@@ -83,5 +84,16 @@ private function passConfigurationToOptions(ContainerBuilder $container, array $
             $parsedValue = (new ErrorTypesParser($processedOptions['error_types']))->parse();
             $options->addMethodCall('setErrorTypes', [$parsedValue]);
         }
+
+        if (\array_key_exists('before_send', $processedOptions)) {
+            $optionValue = $processedOptions['before_send'];
+            if (is_string($optionValue) && 0 === strpos($optionValue, '@')) {
+                $beforeSend = new Reference(substr($optionValue, 1));
+            } else {
+                $beforeSend = $optionValue;
+            }
+
+            $options->addMethodCall('setBeforeSendCallback', [$beforeSend]);
+        }
     }
 }

test/DependencyInjection/ConfigurationTest.php

@@ -11,7 +11,7 @@
 
 class ConfigurationTest extends TestCase
 {
-    public const SUPPORTED_SENTRY_OPTIONS_COUNT = 19;
+    public const SUPPORTED_SENTRY_OPTIONS_COUNT = 20;
 
     public function testDataProviderIsMappingTheRightNumberOfOptions(): void
     {
@@ -84,6 +84,7 @@ public function optionValuesProvider(): array
     {
         return [
             ['attach_stacktrace', true],
+            ['before_send', 'count'],
             ['context_lines', 4],
             ['context_lines', 99],
             ['default_integrations', true],
@@ -125,6 +126,10 @@ public function invalidValuesProvider(): array
     {
         return [
             ['attach_stacktrace', 'string'],
+            ['before_send', 'this is not a callable'],
+            ['before_send', [$this, 'is not a callable']],
+            ['before_send', false],
+            ['before_send', -1],
             ['context_lines', -1],
             ['context_lines', 99999],
             ['context_lines', 'string'],

test/DependencyInjection/SentryExtensionTest.php

@@ -3,13 +3,15 @@
 namespace Sentry\SentryBundle\Test\DependencyInjection;
 
 use PHPUnit\Framework\TestCase;
+use Sentry\Event;
 use Sentry\Options;
 use Sentry\SentryBundle\DependencyInjection\SentryExtension;
 use Sentry\SentryBundle\EventListener\ConsoleListener;
 use Sentry\SentryBundle\EventListener\RequestListener;
 use Symfony\Component\DependencyInjection\Alias;
 use Symfony\Component\DependencyInjection\Container;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\HttpFoundation\RequestStack;
 use Symfony\Component\HttpKernel\Kernel;
@@ -87,6 +89,7 @@ public function optionsValueProvider(): array
     {
         return [
             ['attach_stacktrace', true, 'shouldAttachStacktrace'],
+            ['before_send', __NAMESPACE__ . '\mockBeforeSend', 'getBeforeSendCallback'],
             ['context_lines', 1],
             ['default_integrations', false, 'hasDefaultIntegrations'],
             ['enable_compression', false, 'isCompressionEnabled'],
@@ -146,6 +149,75 @@ public function emptyDsnValueProvider(): array
         ];
     }
 
+    public function testBeforeSendUsingServiceDefinition(): void
+    {
+        $container = $this->getContainer([
+            'options' => [
+                    'before_send' => '@before_send',
+                ],
+        ]);
+
+        $beforeSendCallback = $this->getOptionsFrom($container)->getBeforeSendCallback();
+        $this->assertIsCallable($beforeSendCallback);
+        $defaultOptions = $this->getOptionsFrom($this->getContainer());
+        $this->assertNotEquals(
+            $defaultOptions->getBeforeSendCallback(),
+            $beforeSendCallback,
+            'before_send closure has not been replaced, is the default one'
+        );
+        $this->assertEquals(
+            CallbackMock::createBeforeSendCallback(),
+            $beforeSendCallback
+        );
+    }
+
+    /**
+     * @dataProvider beforeSendDataProvider
+     */
+    public function testBeforeSendUsingScalarCallable($scalarCallable): void
+    {
+        $container = $this->getContainer([
+            'options' => [
+                    'before_send' => $scalarCallable,
+                ],
+        ]);
+
+        $beforeSendCallback = $this->getOptionsFrom($container)->getBeforeSendCallback();
+        $this->assertIsCallable($beforeSendCallback);
+        $defaultOptions = $this->getOptionsFrom($this->getContainer());
+        $this->assertNotEquals(
+            $defaultOptions->getBeforeSendCallback(),
+            $beforeSendCallback,
+            'before_send closure has not been replaced, is the default one'
+        );
+        $this->assertEquals(
+            $scalarCallable,
+            $beforeSendCallback
+        );
+    }
+
+    public function beforeSendDataProvider(): array
+    {
+        return [
+            [[CallbackMock::class, 'beforeSend']],
+            [CallbackMock::class . '::beforeSend'],
+            [__NAMESPACE__ . '\mockBeforeSend'],
+        ];
+    }
+
+    public function testBeforeSendWithInvalidServiceReference(): void
+    {
+        $container = $this->getContainer([
+            'options' => [
+                    'before_send' => '@event_dispatcher',
+                ],
+        ]);
+
+        $this->expectException(\TypeError::class);
+
+        $this->getOptionsFrom($container)->getBeforeSendCallback();
+    }
+
     private function getContainer(array $configuration = []): Container
     {
         $containerBuilder = new ContainerBuilder();
@@ -168,6 +240,10 @@ private function getContainer(array $configuration = []): Container
         $containerBuilder->setAlias(self::REQUEST_LISTENER_TEST_PUBLIC_ALIAS, new Alias(RequestListener::class, true));
         $containerBuilder->setAlias(self::CONSOLE_LISTENER_TEST_PUBLIC_ALIAS, new Alias(ConsoleListener::class, true));
 
+        $beforeSend = new Definition('callable');
+        $beforeSend->setFactory([CallbackMock::class, 'createBeforeSendCallback']);
+        $containerBuilder->setDefinition('before_send', $beforeSend);
+
         $extension = new SentryExtension();
         $extension->load(['sentry' => $configuration], $containerBuilder);
 
@@ -186,3 +262,21 @@ private function getOptionsFrom(Container $container): Options
         return $options;
     }
 }
+
+function mockBeforeSend(Event $event): ?Event
+{
+    return null;
+}
+
+class CallbackMock
+{
+    public static function beforeSend(Event $event): ?Event
+    {
+        return null;
+    }
+
+    public static function createBeforeSendCallback(): callable
+    {
+        return [new self(), 'beforeSend'];
+    }
+}