Add attribute/tag for command status tracking

src/Attribute/SentryMonitorCommand.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Attribute;
+
+#[\Attribute(\Attribute::TARGET_CLASS)]
+class SentryMonitorCommand
+{
+    /**
+     * @var string
+     */
+    private $slug;
+
+    public function __construct(string $slug)
+    {
+        $this->slug = $slug;
+    }
+
+    public function getSlug(): string
+    {
+        return $this->slug;
+    }
+}

src/DependencyInjection/Compiler/CronMonitorPass.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\DependencyInjection\Compiler;
+
+use Sentry\SentryBundle\EventListener\CronMonitorListener;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Compiler\PriorityTaggedServiceTrait;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class CronMonitorPass implements CompilerPassInterface
+{
+    use PriorityTaggedServiceTrait;
+
+    public function process(ContainerBuilder $container): void
+    {
+        if (!$container->getParameter('sentry.cron.enabled')) {
+            return;
+        }
+
+        $commands = $this->findAndSortTaggedServices('sentry.monitor_command', $container);
+
+        $commandSlugMapping = [];
+        foreach ($commands as $reference) {
+            $id = $reference->__toString();
+            foreach ($container->getDefinition($id)->getTag('sentry.monitor_command') as $attributes) {
+                $commandSlugMapping[$id] = $attributes['slug'];
+            }
+        }
+
+        $container->getDefinition(CronMonitorListener::class)->setArgument(1, $commandSlugMapping);
+    }
+}

src/DependencyInjection/Configuration.php

@@ -46,6 +46,7 @@ public function getConfigTreeBuilder(): TreeBuilder
                 ->end()
                 ->booleanNode('register_error_listener')->defaultTrue()->end()
                 ->booleanNode('register_error_handler')->defaultTrue()->end()
+                ->booleanNode('register_cron_monitor')->defaultTrue()->end()
                 ->scalarNode('logger')
                     ->info('The service ID of the PSR-3 logger used to log messages coming from the SDK client. Be aware that setting the same logger of the application may create a circular loop when an event fails to be sent.')
                     ->defaultNull()

src/DependencyInjection/SentryExtension.php

@@ -13,7 +13,9 @@
 use Sentry\Integration\RequestFetcherInterface;
 use Sentry\Integration\RequestIntegration;
 use Sentry\Options;
+use Sentry\SentryBundle\Attribute\SentryMonitorCommand;
 use Sentry\SentryBundle\EventListener\ConsoleListener;
+use Sentry\SentryBundle\EventListener\CronMonitorListener;
 use Sentry\SentryBundle\EventListener\ErrorListener;
 use Sentry\SentryBundle\EventListener\LoginListener;
 use Sentry\SentryBundle\EventListener\MessengerListener;
@@ -29,6 +31,7 @@
 use Symfony\Bundle\TwigBundle\TwigBundle;
 use Symfony\Component\Cache\CacheItem;
 use Symfony\Component\Config\FileLocator;
+use Symfony\Component\DependencyInjection\ChildDefinition;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Definition;
 use Symfony\Component\DependencyInjection\Loader;
@@ -77,6 +80,7 @@ protected function loadInternal(array $mergedConfig, ContainerBuilder $container
         $this->registerTwigTracingConfiguration($container, $mergedConfig['tracing']);
         $this->registerCacheTracingConfiguration($container, $mergedConfig['tracing']);
         $this->registerHttpClientTracingConfiguration($container, $mergedConfig['tracing']);
+        $this->registerCronMonitoringConfiguration($container, $mergedConfig);
 
         if (!interface_exists(TokenStorageInterface::class)) {
             $container->removeDefinition(LoginListener::class);
@@ -285,6 +289,32 @@ private function registerHttpClientTracingConfiguration(ContainerBuilder $contai
         $container->setParameter('sentry.tracing.http_client.enabled', $isConfigEnabled);
     }
 
+    /**
+     * @param array<string, mixed> $config
+     */
+    private function registerCronMonitoringConfiguration(ContainerBuilder $container, array $config): void
+    {
+        $container->setParameter('sentry.cron.enabled', (bool) $config['register_cron_monitor']);
+
+        if (!$config['register_cron_monitor']) {
+            $container->removeDefinition(CronMonitorListener::class);
+
+            return;
+        }
+
+        if (\PHP_VERSION > 8.1) {
+            $container->registerAttributeForAutoconfiguration(
+                SentryMonitorCommand::class,
+                static function (
+                    ChildDefinition $definition,
+                    SentryMonitorCommand $attribute
+                ) {
+                    $definition->addTag('sentry.monitor_command', ['slug' => $attribute->getSlug()]);
+                }
+            );
+        }
+    }
+
     /**
      * @param string[]             $integrations
      * @param array<string, mixed> $config

src/EventListener/CronMonitorListener.php

@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\EventListener;
+
+use Sentry\CheckInStatus;
+use Sentry\State\HubInterface;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Event\ConsoleCommandEvent;
+use Symfony\Component\Console\Event\ConsoleErrorEvent;
+use Symfony\Component\Console\Event\ConsoleTerminateEvent;
+
+class CronMonitorListener
+{
+    /**
+     * @var HubInterface
+     */
+    private $hub;
+
+    /**
+     * @var array<string>
+     */
+    private $registeredCommands;
+
+    /**
+     * @var string|null
+     */
+    private $checkinId;
+
+    /**
+     * @param HubInterface  $hub
+     * @param array<string> $registeredCommands
+     */
+    public function __construct(HubInterface $hub, array $registeredCommands = [])
+    {
+        $this->hub = $hub;
+        $this->registeredCommands = $registeredCommands;
+    }
+
+    public function handleConsoleCommandEvent(ConsoleCommandEvent $event): void
+    {
+        $command = $event->getCommand();
+
+        if (false === $this->isValid($command)) {
+            return;
+        }
+
+        $this->checkinId = $this->hub->captureCheckIn(
+            $this->registeredCommands[$this->getCommandIndex($command)],
+            CheckInStatus::inProgress()
+        );
+    }
+
+    public function handleConsoleTerminateEvent(ConsoleTerminateEvent $event): void
+    {
+        $command = $event->getCommand();
+
+        if (false === $this->isValid($command)) {
+            return;
+        }
+
+        $this->hub->captureCheckIn(
+            $this->registeredCommands[$this->getCommandIndex($command)],
+            Command::SUCCESS === $event->getExitCode()
+                ? CheckInStatus::ok()
+                : CheckInStatus::error(),
+            null,
+            null,
+            $this->checkinId
+        );
+    }
+
+    public function handleConsoleErrorEvent(ConsoleErrorEvent $event): void
+    {
+        $command = $event->getCommand();
+
+        if (false === $this->isValid($command)) {
+            return;
+        }
+
+        $this->hub->captureCheckIn(
+            $this->registeredCommands[$this->getCommandIndex($command)],
+            CheckInStatus::error(),
+            null,
+            null,
+            $this->checkinId
+        );
+    }
+
+    private function isValid(?Command $command): bool
+    {
+        return $command instanceof Command && isset($this->registeredCommands[$this->getCommandIndex($command)]);
+    }
+
+    private function getCommandIndex(?Command $command): string
+    {
+        if (null === $command) {
+            return '';
+        }
+
+        return \get_class($command);
+    }
+}

src/Resources/config/schema/sentry-1.0.xsd

@@ -16,6 +16,7 @@
 
         <xsd:attribute name="register-error-listener" type="xsd:boolean" />
         <xsd:attribute name="register-error-handler" type="xsd:boolean" />
+        <xsd:attribute name="register-cron-monitor" type="xsd:boolean" />
         <xsd:attribute name="transport-factory" type="xsd:string" />
         <xsd:attribute name="dsn" type="xsd:string" />
         <xsd:attribute name="logger" type="xsd:string" />

src/Resources/config/services.xml

@@ -26,6 +26,14 @@
             <tag name="kernel.event_listener" event="console.error" method="handleConsoleErrorEvent" priority="-64" />
         </service>
 
+        <service id="Sentry\SentryBundle\EventListener\CronMonitorListener" class="Sentry\SentryBundle\EventListener\CronMonitorListener">
+            <argument type="service" id="Sentry\State\HubInterface" />
+
+            <tag name="kernel.event_listener" event="console.command" method="handleConsoleCommandEvent" priority="128" />
+            <tag name="kernel.event_listener" event="console.terminate" method="handleConsoleTerminateEvent" priority="-64" />
+            <tag name="kernel.event_listener" event="console.error" method="handleConsoleErrorEvent" priority="-64" />
+        </service>
+
         <service id="Sentry\SentryBundle\EventListener\ErrorListener" class="Sentry\SentryBundle\EventListener\ErrorListener">
             <argument type="service" id="Sentry\State\HubInterface" />
 

src/SentryBundle.php

@@ -6,6 +6,7 @@
 
 use Sentry\SentryBundle\DependencyInjection\Compiler\AddLoginListenerTagPass;
 use Sentry\SentryBundle\DependencyInjection\Compiler\CacheTracingPass;
+use Sentry\SentryBundle\DependencyInjection\Compiler\CronMonitorPass;
 use Sentry\SentryBundle\DependencyInjection\Compiler\DbalTracingPass;
 use Sentry\SentryBundle\DependencyInjection\Compiler\HttpClientTracingPass;
 use Symfony\Component\DependencyInjection\Compiler\PassConfig;
@@ -26,5 +27,6 @@ public function build(ContainerBuilder $container): void
         $container->addCompilerPass(new CacheTracingPass());
         $container->addCompilerPass(new HttpClientTracingPass());
         $container->addCompilerPass(new AddLoginListenerTagPass());
+        $container->addCompilerPass(new CronMonitorPass());
     }
 }

tests/DependencyInjection/Compiler/CronMonitorPassTest.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tests\DependencyInjection\Compiler;
+
+use PHPUnit\Framework\TestCase;
+use Sentry\SentryBundle\Command\SentryTestCommand;
+use Sentry\SentryBundle\DependencyInjection\Compiler\CronMonitorPass;
+use Sentry\SentryBundle\EventListener\CronMonitorListener;
+use Sentry\State\HubInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+
+class CronMonitorPassTest extends TestCase
+{
+    public function testProcess(): void
+    {
+        $container = $this->createContainerBuilder(true);
+
+        $container->setDefinition(
+            SentryTestCommand::class,
+            (new Definition(SentryTestCommand::class))
+                ->setPublic(false)
+                ->addTag('console.command')
+                ->addTag('sentry.monitor_command', ['slug' => 'test-command'])
+        );
+
+        $container->compile();
+
+        $insertedCronMonitorListenerArgument = $container->getDefinition(CronMonitorListener::class)->getArgument(1);
+
+        $this->assertIsArray($insertedCronMonitorListenerArgument);
+        $this->assertArrayHasKey(SentryTestCommand::class, $insertedCronMonitorListenerArgument);
+        $this->assertEquals('test-command', $insertedCronMonitorListenerArgument[SentryTestCommand::class]);
+    }
+
+    public function testProcessDoesNothingIfConditionsForEnablingCronIsFalse(): void
+    {
+        $container = $this->createContainerBuilder(false);
+        $container->compile();
+
+        $this->assertFalse($container->getDefinition(CronMonitorListener::class)->getArgument(1));
+    }
+
+    private function createContainerBuilder(bool $isCronActive): ContainerBuilder
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new CronMonitorPass());
+        $container->setParameter('sentry.cron.enabled', $isCronActive);
+
+        $cronMonitorListenerMock = $this->createMock(CronMonitorListener::class);
+
+        $container->setDefinition(CronMonitorListener::class, (new Definition(\get_class($cronMonitorListenerMock)))
+            ->setPublic(true))
+            ->setArgument(0, HubInterface::class)
+            ->setArgument(1, false);
+
+        return $container;
+    }
+}

tests/DependencyInjection/ConfigurationTest.php

@@ -22,6 +22,7 @@ public function testProcessConfigurationWithDefaultConfiguration(): void
         $expectedBundleDefaultConfig = [
             'register_error_listener' => true,
             'register_error_handler' => true,
+            'register_cron_monitor' => true,
             'logger' => null,
             'options' => [
                 'integrations' => [],

tests/DependencyInjection/Fixtures/php/cron_monitor_disabled.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/** @var ContainerBuilder $container */
+$container->loadFromExtension('sentry', [
+    'register_cron_monitor' => false,
+]);

tests/DependencyInjection/Fixtures/php/cron_monitor_enabled.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/** @var ContainerBuilder $container */
+$container->loadFromExtension('sentry', [
+    'register_cron_monitor' => true,
+]);

tests/DependencyInjection/Fixtures/xml/cron_monitor_disabled.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" ?>
+
+<container xmlns="http://symfony.com/schema/dic/services"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xmlns:sentry="https://sentry.io/schema/dic/sentry-symfony"
+           xsi:schemaLocation="http://symfony.com/schema/dic/services https://symfony.com/schema/dic/services/services-1.0.xsd
+                               https://sentry.io/schema/dic/sentry-symfony https://sentry.io/schema/dic/sentry-symfony/sentry-1.0.xsd">
+
+    <sentry:config register-cron-monitor="false" />
+</container>

tests/DependencyInjection/Fixtures/xml/cron_monitor_enabled.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" ?>
+
+<container xmlns="http://symfony.com/schema/dic/services"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xmlns:sentry="https://sentry.io/schema/dic/sentry-symfony"
+           xsi:schemaLocation="http://symfony.com/schema/dic/services https://symfony.com/schema/dic/services/services-1.0.xsd
+                               https://sentry.io/schema/dic/sentry-symfony https://sentry.io/schema/dic/sentry-symfony/sentry-1.0.xsd">
+
+    <sentry:config register-cron-monitor="true" />
+</container>

tests/DependencyInjection/Fixtures/yml/cron_monitor_disabled.yml

@@ -0,0 +1,2 @@
+sentry:
+    register_cron_monitor: false

tests/DependencyInjection/Fixtures/yml/cron_monitor_enabled.yml

@@ -0,0 +1,2 @@
+sentry:
+    register_cron_monitor: true