feat(integrations): allow callbacks as integrations

Author: Litarnus

src/DependencyInjection/Configuration.php

@@ -60,8 +60,8 @@ public function getConfigTreeBuilder(): TreeBuilder
                     ->fixXmlConfig('ignore_transaction')
                     ->fixXmlConfig('prefix', 'prefixes')
                     ->children()
-                        ->arrayNode('integrations')
-                            ->scalarPrototype()->end()
+                        ->variableNode('integrations')
+                            ->defaultValue([])
                         ->end()
                         ->booleanNode('default_integrations')->end()
                         ->arrayNode('prefixes')

src/DependencyInjection/SentryExtension.php

@@ -146,9 +146,17 @@ private function registerConfiguration(ContainerBuilder $container, array $confi
             $options['http_client'] = new Reference($options['http_client']);
         }
 
-        $container->getDefinition(IntegrationConfigurator::class)
-            ->setArgument(0, $this->configureIntegrationsOption($options['integrations'], $config))
-            ->setArgument(1, $config['register_error_handler']);
+        if (\is_string($options['integrations']) && '' !== $options['integrations']) {
+            $container->getDefinition(IntegrationConfigurator::class)
+                ->setArgument(0, new Reference($options['integrations']))
+                ->setArgument(1, $config['register_error_handler']);
+        } else {
+            $integrations = \is_array($options['integrations']) ? $options['integrations'] : [];
+
+            $container->getDefinition(IntegrationConfigurator::class)
+                ->setArgument(0, $this->configureIntegrationsOption($integrations, $config))
+                ->setArgument(1, $config['register_error_handler']);
+        }
         $options['integrations'] = new Reference(IntegrationConfigurator::class);
 
         $container

src/Integration/IntegrationConfigurator.php

@@ -21,52 +21,69 @@ final class IntegrationConfigurator
     ];
 
     /**
-     * @var IntegrationInterface[]
+     * @var IntegrationInterface[]|callable
      */
-    private $userIntegrations;
+    private $userConfig;
 
     /**
      * @var bool
      */
     private $registerErrorHandler;
 
     /**
-     * @param IntegrationInterface[] $userIntegrations
+     * @param IntegrationInterface[]|callable $userConfig Array of integrations or a callable that filters/returns integrations
      */
-    public function __construct(array $userIntegrations, bool $registerErrorHandler)
+    public function __construct($userConfig, bool $registerErrorHandler)
     {
-        $this->userIntegrations = $userIntegrations;
+        $this->userConfig = $userConfig;
         $this->registerErrorHandler = $registerErrorHandler;
     }
 
     /**
-     * @see IntegrationRegistry::getIntegrationsToSetup()
-     *
      * @param IntegrationInterface[] $defaultIntegrations
      *
      * @return IntegrationInterface[]
+     *
+     * @see IntegrationRegistry::getIntegrationsToSetup()
      */
     public function __invoke(array $defaultIntegrations): array
     {
-        $integrations = [];
-
-        $userIntegrationsClasses = array_map('get_class', $this->userIntegrations);
-        $pickedIntegrationsClasses = [];
-
+        $filteredDefaults = [];
         foreach ($defaultIntegrations as $defaultIntegration) {
             $integrationClassName = \get_class($defaultIntegration);
 
             if (!$this->registerErrorHandler && isset(self::ERROR_HANDLER_INTEGRATIONS[$integrationClassName])) {
                 continue;
             }
 
+            $filteredDefaults[] = $defaultIntegration;
+        }
+
+        if (\is_callable($this->userConfig)) {
+            $result = ($this->userConfig)($filteredDefaults);
+
+            if (!\is_array($result)) {
+                throw new \UnexpectedValueException(\sprintf('Expected the callable set for the user integrations to return a list of integrations. Got: "%s".', get_debug_type($result)));
+            }
+
+            return $result;
+        }
+
+        $integrations = [];
+        $userIntegrations = \is_array($this->userConfig) ? $this->userConfig : [];
+        $userIntegrationsClasses = array_map('get_class', $userIntegrations);
+        $pickedIntegrationsClasses = [];
+
+        foreach ($filteredDefaults as $defaultIntegration) {
+            $integrationClassName = \get_class($defaultIntegration);
+
             if (!\in_array($integrationClassName, $userIntegrationsClasses, true) && !isset($pickedIntegrationsClasses[$integrationClassName])) {
                 $integrations[] = $defaultIntegration;
                 $pickedIntegrationsClasses[$integrationClassName] = true;
             }
         }
 
-        foreach ($this->userIntegrations as $userIntegration) {
+        foreach ($userIntegrations as $userIntegration) {
             $integrationClassName = \get_class($userIntegration);
 
             if (!isset($pickedIntegrationsClasses[$integrationClassName])) {

tests/End2End/App/KernelWithExtraConfig.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tests\End2End\App;
+
+use Symfony\Component\Config\Loader\LoaderInterface;
+
+class KernelWithExtraConfig extends Kernel
+{
+    /**
+     * @var string[]
+     */
+    private $extraConfigFiles;
+
+    /**
+     * @param string[] $extraConfigFiles
+     */
+    public function __construct(array $extraConfigFiles)
+    {
+        parent::__construct('test', true);
+        $this->extraConfigFiles = $extraConfigFiles;
+    }
+
+    public function registerContainerConfiguration(LoaderInterface $loader): void
+    {
+        parent::registerContainerConfiguration($loader);
+
+        foreach ($this->extraConfigFiles as $file) {
+            $loader->load($file);
+        }
+    }
+}

tests/End2End/Fixtures/FactoryCallback.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tests\End2End\Fixtures;
+
+final class FactoryCallback
+{
+    public static function factory(): callable
+    {
+        return static function (array $integrations): array {
+            $integrations[] = new TestIntegrationForFactory();
+
+            return $integrations;
+        };
+    }
+}

tests/End2End/Fixtures/InvokableCallback.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tests\End2End\Fixtures;
+
+use Sentry\Integration\IntegrationInterface;
+
+final class InvokableCallback
+{
+    /**
+     * @param IntegrationInterface[] $integrations
+     *
+     * @return IntegrationInterface[]
+     */
+    public function __invoke(array $integrations): array
+    {
+        $integrations[] = new TestIntegrationForInvokable();
+
+        return $integrations;
+    }
+}

tests/End2End/Fixtures/TestIntegrationForFactory.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tests\End2End\Fixtures;
+
+class TestIntegrationForFactory implements \Sentry\Integration\IntegrationInterface
+{
+    public function setupOnce(): void
+    {
+    }
+}

tests/End2End/Fixtures/TestIntegrationForInvokable.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tests\End2End\Fixtures;
+
+class TestIntegrationForInvokable implements \Sentry\Integration\IntegrationInterface
+{
+    public function setupOnce(): void
+    {
+    }
+}

tests/End2End/Fixtures/config_factory.yaml

@@ -0,0 +1,7 @@
+services:
+    Sentry\SentryBundle\Tests\End2End\Fixtures\FactoryCallback:
+        factory: ['Sentry\SentryBundle\Tests\End2End\Fixtures\FactoryCallback', 'factory']
+
+sentry:
+    options:
+        integrations: 'Sentry\SentryBundle\Tests\End2End\Fixtures\FactoryCallback'

tests/End2End/Fixtures/config_invokable.yaml

@@ -0,0 +1,6 @@
+services:
+    Sentry\SentryBundle\Tests\End2End\Fixtures\InvokableCallback: ~
+
+sentry:
+    options:
+        integrations: 'Sentry\SentryBundle\Tests\End2End\Fixtures\InvokableCallback'