How to Debug Symfony Services in Shopware 6

Shopware 6 is built on top of the Symfony framework, which means it inherits many powerful debugging capabilities. However, debugging Symfony services within the Shopware ecosystem can be challenging due to its modular architecture and custom service container configuration. This guide will walk you through various techniques and tools to effectively debug Symfony services in Shopware 6.

Understanding Shopware 6 Service Container#

Before diving into debugging techniques, it's crucial to understand how Shopware 6 manages its service container. Unlike standard Symfony applications, Shopware 6 uses a custom configuration system that extends the traditional Symfony DI container with additional features like plugin architecture, service decoration, and configuration inheritance.

The service container in Shopware 6 is configured through config/services.xml files, plugin-specific configurations, and the core framework's service definitions. This complexity means that debugging requires a systematic approach to identify where services are defined, how they're wired, and what dependencies they have.

Method 1: Using Symfony's Built-in Debug Commands#

The most straightforward way to debug services in Shopware 6 is by leveraging Symfony's built-in debugging commands. These commands are available through the Shopware CLI interface and provide comprehensive information about service definitions.

Listing Services#

To list all available services in your Shopware installation, use:

bin/console debug:container

This command displays a comprehensive list of all registered services with their IDs, classes, and scope. For more specific filtering, you can use:

bin/console debug:container --tag=shopware.plugin
bin/console debug:container --tag=kernel.event_subscriber

Service Information#

To get detailed information about a specific service:

bin/console debug:container --service=Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria

This command shows the service's class, public status, autowiring capabilities, and all its dependencies. You can also check if a service is public or private:

bin/console debug:container --service=shopware.core.system_config.repository

Method 2: Using Symfony Profiler#

Shopware 6 integrates seamlessly with Symfony's profiler, which provides an excellent graphical interface for debugging services and understanding the application flow.

Enabling Profiler#

First, ensure that the profiler is enabled in your development environment. Add this to your .env file:

APP_ENV=dev
APP_DEBUG=1

Then access the profiler by appending ?_profiler=1 to any URL in your Shopware installation.

Service Inspection via Profiler#

The profiler provides detailed information about service calls, including:

• Service instantiation timing
• Dependencies between services
• Memory usage per service
• Request lifecycle information

Navigate to the "Container" tab in the profiler to see all services loaded for the current request, their initialization times, and dependency graphs.

Method 3: Custom Debugging with Service Decorators#

For more advanced debugging, you can create custom decorators that wrap existing services to provide additional logging or inspection capabilities.

Creating a Service Decorator#

Create a decorator service in your plugin's config/services.xml:

<service id="MyPlugin\Core\Decorator\OrderServiceDecorator" decorates="shopware.core.order.repository">
    <argument type="service" id="MyPlugin\Core\Decorator\OrderServiceDecorator.inner"/>
</service>

Implementing Debug Logic#

<?php declare(strict_types=1);

namespace MyPlugin\Core\Decorator;

use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
use Psr\Log\LoggerInterface;

class OrderServiceDecorator implements EntityRepositoryInterface
{
    private EntityRepositoryInterface $inner;
    private LoggerInterface $logger;

    public function __construct(
        EntityRepositoryInterface $inner,
        LoggerInterface $logger
    ) {
        $this->inner = $inner;
        $this->logger = $logger;
    }

    public function search($criteria, $context)
    {
        $this->logger->info('OrderServiceDecorator::search called');
        $this->logger->info('Criteria: ' . json_encode($criteria));
        
        $result = $this->inner->search($criteria, $context);
        
        $this->logger->info('Search result count: ' . count($result->getElements()));
        return $result;
    }

    // Implement other methods...
}

Method 4: Using Xdebug for Step-by-Step Debugging#

Xdebug integration with Shopware 6 provides powerful debugging capabilities. Here's how to set it up:

Installation and Configuration#

Install Xdebug via your system package manager or Docker:

# For Ubuntu/Debian
sudo apt-get install php-xdebug

# For Docker, add to your php.ini
zend_extension=xdebug.so
xdebug.remote_enable=1
xdebug.remote_host=host.docker.internal
xdebug.remote_port=9003

Debugging Service Initialization#

Set breakpoints in service constructor methods to understand how services are instantiated:

// In a service class
public function __construct(
    private Repository $repository,
    private LoggerInterface $logger
) {
    // Set breakpoint here to see when service is created
    $this->logger->debug('Service initialized');
}

Method 5: Runtime Service Inspection#

Shopware 6 provides several runtime methods to inspect services programmatically:

Using Container Access#

<?php declare(strict_types=1);

namespace MyPlugin\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Response;

class DebugController extends AbstractController
{
    public function debugServices(ContainerInterface $container): Response
    {
        $services = [];
        
        foreach ($container->getServiceIds() as $serviceId) {
            if ($container->has($serviceId)) {
                try {
                    $service = $container->get($serviceId);
                    $services[$serviceId] = get_class($service);
                } catch (\Exception $e) {
                    $services[$serviceId] = 'Error: ' . $e->getMessage();
                }
            }
        }
        
        return $this->json($services);
    }
}

Service Type Checking#

// Check if a service implements a specific interface
if ($container->has('shopware.core.order.repository')) {
    $service = $container->get('shopware.core.order.repository');
    
    if ($service instanceof \Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface) {
        // Service is properly typed
    }
}

Method 6: Debugging Service Dependencies#

Understanding service dependencies is crucial for debugging. Use the following approach to trace dependency chains:

Dependency Tree Analysis#

bin/console debug:container --service=Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria

This command shows all dependencies of a specific service. You can also dump this information programmatically:

public function dumpDependencies(string $serviceName, ContainerInterface $container): array
{
    $dependencies = [];
    
    if ($container->has($serviceName)) {
        $service = $container->get($serviceName);
        $reflection = new \ReflectionClass($service);
        
        foreach ($reflection->getConstructor()->getParameters() as $parameter) {
            $dependencies[] = [
                'name' => $parameter->getName(),
                'type' => $parameter->getType() ? $parameter->getType()->getName() : 'mixed',
                'required' => !$parameter->isOptional()
            ];
        }
    }
    
    return $dependencies;
}

Method 7: Plugin-Specific Debugging#

When debugging services in plugins, consider the plugin loading order and configuration:

Plugin Service Registration#

<!-- config/services.xml in your plugin -->
<service id="MyPlugin\Core\Service\CustomService">
    <argument type="service" id="Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface"/>
    <tag name="kernel.event_subscriber"/>
</service>

Debugging Plugin Services#

bin/console debug:container --tag=kernel.event_subscriber | grep MyPlugin

Advanced Debugging Techniques#

Service Mocking for Testing#

Create mock services for debugging purposes:

// In your test or debug environment
$mockService = $this->createMock(RepositoryInterface::class);
$mockService->method('search')->willReturn($mockResult);

$container->set('shopware.core.order.repository', $mockService);

Performance Profiling#

Monitor service instantiation times:

public function profileService(string $serviceName, ContainerInterface $container): array
{
    $start = microtime(true);
    
    $service = $container->get($serviceName);
    
    $end = microtime(true);
    
    return [
        'service' => $serviceName,
        'time' => ($end - $start) * 1000, // milliseconds
        'class' => get_class($service)
    ];
}

Best Practices for Service Debugging#

1. Use appropriate environments: Always debug in development mode with APP_ENV=dev
2. Enable logging: Configure proper logging levels for service initialization
3. Profile selectively: Don't profile all services simultaneously, focus on specific areas
4. Clean up: Remove debugging code before production deployment
5. Use caching awareness: Be aware of service caching behavior in different environments

Troubleshooting Common Issues#

Service Not Found Errors#

If you encounter "Service not found" errors:

bin/console debug:container --tag=shopware.plugin
bin/console cache:clear

Circular Dependencies#

Use Symfony's circular dependency detection:

bin/console debug:container --service=YourService

Service Decoration Issues#

Ensure proper decoration syntax in services.xml:

<service id="MyPlugin\Service\DecoratedService" decorates="original.service.id">
    <argument type="service" id="MyPlugin\Service\DecoratedService.inner"/>
</service>

Conclusion#

Debugging Symfony services in Shopware 6 requires a combination of built-in Symfony tools, custom debugging techniques, and understanding of the framework's unique architecture. By leveraging the commands mentioned above, you can effectively trace service instantiation, understand dependency chains, and identify performance bottlenecks.

The key is to start with simple debugging approaches like debug:container and gradually move to more advanced techniques like service decorators or Xdebug integration when dealing with complex service interactions. Remember to always test your debugging solutions in a development environment and clean up any temporary debugging code before deploying to production.

With these techniques, you'll be able to tackle even the most complex service debugging scenarios in Shopware 6, ensuring your applications run smoothly and efficiently.