Interaktives Debuggen mit der Symfony-Konsole

Eines der wichtigsten Systeme, die wir bei RoundingWell haben, ist die Evaluation Engine, oder „Bewertungen“, wie wir sie allgemein nennen. Dieses System ist für die Verarbeitung kundenspezifisch konfigurierter Ereignis-Listener verantwortlich, was es uns ermöglicht, jeder Organisation ein einzigartiges Benutzererlebnis zu bieten. Es versteht sich von selbst, dass dieses System für unsere Anwendung unglaublich wichtig ist und dass es von entscheidender Bedeutung ist, genau zu wissen, was es bei einem bestimmten Ereignis getan hat oder tun wird .

Heute arbeitete ich an der Umstellung eines unserer Kunden von einigen alten Ereignissen auf neuere Ereignisse und musste sicherstellen, dass einer der Schritte darin bestand, das Ereignis korrekt zu verarbeiten. Wir führen viele Protokolle rund um die Auswertungen durch und ich wusste, dass die Informationen, die ich brauchte, in den Protokollen enthalten waren. Das Problem bei vielen Protokollen besteht jedoch darin, dass es viele Protokolle gibt. Außerdem musste ich nur den ersten Teil jedes Triggers ausführen, um zu überprüfen, ob die Migration funktionierte.

Ich dachte mir: „Wäre es nicht clever, wenn wir einen Xdebug-ähnlichen Step-Debugger für die Evaluierungs-Engine hätten? Ich weiß, dass die Symfony-Konsole alle Funktionen hat, die ich dafür brauche …“

Und genau das habe ich getan. Da unsere Anwendung vollständig abhängigkeitsinjiziert ist, konnte ich eine neue Klasse erstellen, um die StepFactory zu umschließen, die für das Lesen der Konfiguration und das Erstellen der „Schritte“ verantwortlich ist, aus denen die Auswertung besteht.

use RoundingWell\Framework\DebugVar;
use RuntimeException;
use Symfony\Component\Console\Style\SymfonyStyle;

readonly class StepFactoryWithConsoleConfirmation implements StepFactory
{
    public function __construct(
        private StepFactory $stepFactory,
        private SymfonyStyle $style,
        private bool $confirmCreatedStep = true,
        private bool $showCreatedStep = true,
        private bool $showStepDefinition = false,
    ) {
    }

    public function create(object $subject, StepDefinition $definition): Step
    {
        if ($this->showStepDefinition) {
            $debug = new DebugVar($definition->parameters);

            $this->style->info(
                message: <<<TEXT
                Next step is $definition->name with parameters:

                $debug
                TEXT,
            );
        }

        $step = $this->stepFactory->create($subject, $definition);

        if ($this->showCreatedStep) {
            $debug = new DebugVar($step);

            $this->style->info(
                message: <<<TEXT
                Step $definition->name created as:

                $debug
                TEXT,
            );
        }

        if ($this->confirmCreatedStep && ! $this->style->confirm(question: "Continue with evaluation?")) {
            throw new RuntimeException(
                message: "Evaluation aborted at step {$definition->name}",
            );
        }

        return $step;
    }
}

Und mit ein wenig Containermanipulation in meinem Konsolenbefehl haben wir einen interaktiven Evaluierungsdebugger:

use DI\Container;
use RoundingWell\Common\Command\CommandBus;
use RoundingWell\Common\Command\CommandBusComposed;
use RoundingWell\Common\Command\Middleware\LoggingMiddleware;
use RoundingWell\Evaluation\Command\EvaluateEvent;
use RoundingWell\Evaluation\Command\EvaluateEventHandler;
use RoundingWell\Evaluation\Step\StepFactory;
use RoundingWell\Evaluation\Step\StepFactoryWithConsoleConfirmation;
use Symfony\Component\Console\Style\SymfonyStyle;

readonly class EvaluationDebug
{
    public function __construct(
        private Container $container,
    ) {
    }

    public function __invoke(
        SymfonyStyle $symfonyStyle,
        string $eventType,
        string $eventId,
        string|null $evaluationId = null,
    ): void {
        // The command bus MUST ONLY log executed commands.
        $commandBus = new CommandBusComposed(
            $this->container->get(LoggingMiddleware::class),
        );

        // The step factory MUST be wrapped to step through the evaluation.
        $stepFactory = new StepFactoryWithConsoleConfirmation(
            stepFactory: $this->container->get(StepFactory::class),
            style: $symfonyStyle,
        );

        $this->container->set(CommandBus::class, $commandBus);
        $this->container->set(StepFactory::class, $stepFactory);

        $command = new EvaluateEvent(
            eventClass: $eventType,
            eventId: $eventId,
            evaluationId: $evaluationId,
        );

        $this->container->get(EvaluateEventHandler::class)->handle($command);

        $symfonyStyle->success('Evaluation complete');
    }
}

Das war's für heute!

Das obige ist der detaillierte Inhalt vonInteraktives Debuggen mit der Symfony-Konsole. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!