Der folgende Befehl ist also kein Magento Standardbefehl, sondern wird durch das nachfolgende Beispiel implementiert:

bin/magento dev:plugin-chain \
'Magento\Catalog\Api\ProductRepositoryInterface' \
save

Der Command wird zunächst in der etc/di.xml des eigenen Moduls registriert:

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">

    <type name="Magento\Framework\Console\CommandListInterface">
        <arguments>
            <argument name="commands" xsi:type="array">
                <item name="plugin_chain" xsi:type="object">
                    Vendor\Module\Console\Command\PluginChain
                </item>
            </argument>
        </arguments>
    </type>

</config>

Die eigentliche Command Klasse greift anschließend direkt auf Magentos PluginListInterface zu:

<?php

declare(strict_types=1);

namespace Vendor\Module\Console\Command;

use Magento\Framework\Config\ScopeInterface;
use Magento\Framework\Interception\DefinitionInterface;
use Magento\Framework\Interception\PluginListInterface;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class PluginChain extends Command
{
    private const ARG_TYPE = 'type';
    private const ARG_METHOD = 'method';
    private const OPT_AREA = 'area';

    public function __construct(
        private readonly PluginListInterface $pluginList,
        private readonly ScopeInterface $configScope
    ) {
        parent::__construct();
    }

    protected function configure(): void
    {
        $this->setName('dev:plugin-chain')
            ->setDescription('Shows the effective Magento plugin chain')
            ->addArgument(
                self::ARG_TYPE,
                InputArgument::REQUIRED,
                'Class or interface'
            )
            ->addArgument(
                self::ARG_METHOD,
                InputArgument::REQUIRED,
                'Method name'
            )
            ->addOption(
                self::OPT_AREA,
                null,
                InputOption::VALUE_REQUIRED,
                'Magento area',
                'frontend'
            );

        parent::configure();
    }

    protected function execute(
        InputInterface $input,
        OutputInterface $output
    ): int {
        $type = ltrim(
            (string) $input->getArgument(self::ARG_TYPE),
            '\\'
        );

        $method = (string) $input->getArgument(self::ARG_METHOD);
        $area = (string) $input->getOption(self::OPT_AREA);

        $this->configScope->setCurrentScope($area);

        $pluginInfo = $this->pluginList->getNext(
            $type,
            $method
        );

        if (!$pluginInfo) {
            $output->writeln('<comment>No plugins found.</comment>');

            return Command::SUCCESS;
        }

        $output->writeln(
            sprintf(
                '<info>%s::%s() [%s]</info>',
                $type,
                $method,
                $area
            )
        );

        $this->renderChain(
            $output,
            $type,
            $method,
            $pluginInfo
        );

        return Command::SUCCESS;
    }

    private function renderChain(
        OutputInterface $output,
        string $type,
        string $method,
        array $pluginInfo,
        int $level = 0
    ): void {
        $indent = str_repeat('  ', $level);

        foreach (
            $pluginInfo[DefinitionInterface::LISTENER_BEFORE] ?? []
            as $code
        ) {
            $this->writePlugin(
                $output,
                $type,
                $code,
                'BEFORE',
                $indent
            );
        }

        $around = $pluginInfo[
            DefinitionInterface::LISTENER_AROUND
        ] ?? null;

        if ($around) {
            $this->writePlugin(
                $output,
                $type,
                $around,
                'AROUND',
                $indent
            );

            $next = $this->pluginList->getNext(
                $type,
                $method,
                $around
            );

            if ($next) {
                $this->renderChain(
                    $output,
                    $type,
                    $method,
                    $next,
                    $level + 1
                );
            }
        }

        foreach (
            $pluginInfo[DefinitionInterface::LISTENER_AFTER] ?? []
            as $code
        ) {
            $this->writePlugin(
                $output,
                $type,
                $code,
                'AFTER',
                $indent
            );
        }
    }

    private function writePlugin(
        OutputInterface $output,
        string $type,
        string $code,
        string $position,
        string $indent
    ): void {
        $plugin = $this->pluginList->getPlugin(
            $type,
            $code
        );

        $output->writeln(
            sprintf(
                '%s%-6s %s => %s',
                $indent,
                $position,
                $code,
                get_class($plugin)
            )
        );
    }
}

Nach Einbau des Commands lässt sich beispielsweise die Plugin Kette für ProductRepositoryInterface::save() ausgeben:

bin/magento dev:plugin-chain \
'Magento\Catalog\Api\ProductRepositoryInterface' \
save

Auch der Magento Admin Bereich kann berücksichtigt werden:

bin/magento dev:plugin-chain \
'Magento\Catalog\Api\ProductRepositoryInterface' \
save \
--area=adminhtml

Interessant wird die Ausgabe vor allem bei mehreren Extensions, die dieselbe Methode verändern. Besonders around Plugins können die Ausführung beeinflussen, da ein Plugin durch den Aufruf oder eben Nichtaufruf des nächsten Callables bestimmt, ob die weitere Plugin Kette und die eigentliche Methode noch erreicht werden.

Damit lässt sich ziemlich genau nachvollziehen, welche Plugins Magento für eine bestimmte Methode tatsächlich hintereinander ausführt.