Using Feature Flags in Shopware 6 Development

Introduction#

Feature flags, also known as feature toggles, have become an essential tool in modern software development practices. In the context of Shopware 6 development, feature flags provide developers with a powerful mechanism to control feature visibility, manage rollouts, and enable safe experimentation without affecting production environments. As Shopware 6 continues to evolve with each release, understanding how to effectively implement and utilize feature flags becomes increasingly important for maintaining code quality and enabling flexible deployment strategies.

What Are Feature Flags?#

Feature flags are conditional statements that allow developers to enable or disable specific features in an application without modifying the codebase or redeploying the entire system. They act as runtime switches that can be controlled through configuration files, database entries, or external services, providing granular control over feature availability across different environments and user groups.

In Shopware 6, feature flags serve multiple purposes:

• Controlled feature rollouts
• A/B testing capabilities
• Environment-specific feature management
• Safe deployment practices
• Gradual feature adoption

Implementation in Shopware 6#

Registering Feature Flags#

Shopware 6 provides a built-in mechanism for managing feature flags through the Feature class. To register a new feature flag, you need to add it to the features configuration in your plugin's config.xml file:

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="https://raw.githubusercontent.com/shopware/platform/master/src/Core/Framework/Plugin/schema/config-1.0.xsd">
    <plugins>
        <plugin name="MyFeaturePlugin" version="1.0.0">
            <features>
                <feature name="MY_FEATURE_FLAG" active="false"/>
            </features>
        </plugin>
    </plugins>
</config>

Checking Feature Flag Status#

Once a feature flag is registered, you can check its status in your code using the Feature class:

use Shopware\Core\Framework\Feature;

// Check if a feature is active
if (Feature::isActive('MY_FEATURE_FLAG')) {
    // Execute feature-specific logic
    $result = $this->executeNewFeature();
}

// Alternative approach using the FeatureService
use Shopware\Core\Framework\Feature\FeatureService;
$featureService = $this->container->get(FeatureService::class);
if ($featureService->isActive('MY_FEATURE_FLAG')) {
    // Execute feature logic
}

Dynamic Feature Flag Management#

Shopware 6 allows for dynamic management of feature flags through the FeatureConfig service, enabling runtime configuration changes without requiring a system restart:

use Shopware\Core\Framework\Feature\FeatureConfig;

// Get all active features
$activeFeatures = FeatureConfig::getAll();

// Check specific feature status
$featureStatus = FeatureConfig::get('MY_FEATURE_FLAG');

// Set feature status programmatically (for development/testing)
FeatureConfig::set('MY_FEATURE_FLAG', true);

Advanced Usage Patterns#

Environment-Specific Configuration#

One of the most powerful aspects of feature flags in Shopware 6 is their ability to work seamlessly with different environments. You can configure feature flags differently based on the environment:

// config/packages/shopware.yaml
shopware:
    features:
        MY_FEATURE_FLAG: '%env(bool:FEATURE_MY_FEATURE)%'

Then define environment variables in your .env files:

# .env.development
FEATURE_MY_FEATURE=true

# .env.production
FEATURE_MY_FEATURE=false

User Group Targeting#

Feature flags can be configured to target specific user groups, enabling personalized feature experiences:

use Shopware\Core\Framework\Feature\FeatureContext;

class FeatureService
{
    public function isFeatureAvailableForUser(string $featureName, string $userId): bool
    {
        // Check if user belongs to a special group that should see the feature
        $userGroup = $this->getUserGroup($userId);
        
        if ($userGroup === 'early_adopter') {
            return true;
        }
        
        return Feature::isActive($featureName);
    }
}

A/B Testing Implementation#

Feature flags are particularly useful for implementing A/B testing scenarios in Shopware 6:

class ABTestService
{
    public function getFeatureVariant(string $userId): string
    {
        // Simple hash-based user segmentation
        $hash = crc32($userId);
        $variant = ($hash % 100) < 50 ? 'A' : 'B';
        
        return $variant;
    }
    
    public function getFeatureForUser(string $userId): array
    {
        $variant = $this->getFeatureVariant($userId);
        
        if ($variant === 'A') {
            return ['feature' => 'old_behavior'];
        } else {
            return ['feature' => 'new_behavior'];
        }
    }
}

Integration with Shopware 6 Core#

Plugin Development Considerations#

When developing plugins in Shopware 6, it's crucial to follow best practices for feature flag implementation:

<?php declare(strict_types=1);

namespace MyCompany\MyPlugin;

use Shopware\Core\Framework\Plugin;
use Shopware\Core\Framework\Feature\FeatureConfig;

class MyPlugin extends Plugin
{
    public function install(): void
    {
        // Set default feature flag state during installation
        FeatureConfig::set('MY_PLUGIN_FEATURE', false);
        
        parent::install();
    }
    
    public function activate(): void
    {
        // Enable features when plugin is activated
        FeatureConfig::set('MY_PLUGIN_FEATURE', true);
        
        parent::activate();
    }
}

Admin Panel Integration#

For enhanced usability, feature flags can be integrated into the Shopware 6 administration panel:

// src/Administration/Resources/app/administration/src/module/my-plugin/component/feature-flag-switch/index.js
import template from './feature-flag-switch.html.twig';

Shopware.Component.register('my-plugin-feature-flag-switch', {
    template,
    
    props: {
        featureName: {
            type: String,
            required: true
        }
    },
    
    data() {
        return {
            isActive: false
        };
    },
    
    mounted() {
        this.checkFeatureStatus();
    },
    
    methods: {
        async checkFeatureStatus() {
            const response = await this.$http.get(
                `/api/_action/feature/${this.featureName}`
            );
            this.isActive = response.data.active;
        },
        
        async toggleFeature() {
            await this.$http.post(
                `/api/_action/feature/${this.featureName}`,
                { active: !this.isActive }
            );
            this.isActive = !this.isActive;
        }
    }
});

Best Practices and Considerations#

Performance Impact#

While feature flags provide significant benefits, they should be implemented with performance in mind. The overhead of checking feature flag status should be minimal:

// Good: Cache feature flag checks
class OptimizedFeatureService
{
    private static $cache = [];
    
    public function isFeatureActive(string $featureName): bool
    {
        if (!isset(self::$cache[$featureName])) {
            self::$cache[$featureName] = Feature::isActive($featureName);
        }
        
        return self::$cache[$featureName];
    }
}

Testing Strategy#

Feature flags require a comprehensive testing approach:

// Test feature flag behavior
class FeatureFlagTest extends TestCase
{
    public function testFeatureFlagActivation(): void
    {
        // Set up test environment
        FeatureConfig::set('TEST_FEATURE', true);
        
        $this->assertTrue(Feature::isActive('TEST_FEATURE'));
        
        // Test with different configurations
        FeatureConfig::set('TEST_FEATURE', false);
        $this->assertFalse(Feature::isActive('TEST_FEATURE'));
    }
}

Cleanup and Maintenance#

Regular maintenance of feature flags is essential to prevent technical debt:

// Remove unused features after deprecation period
class FeatureCleanupService
{
    public function cleanupOldFeatures(): void
    {
        // Log usage statistics
        $usageStats = $this->getFeatureUsage();
        
        foreach ($usageStats as $feature => $stats) {
            if ($stats['last_used'] < (time() - 30 * 24 * 3600)) { // 30 days
                // Mark feature for removal
                $this->markFeatureForRemoval($feature);
            }
        }
    }
}

Conclusion#

Feature flags represent a critical component in modern Shopware 6 development practices, enabling teams to implement controlled rollouts, conduct A/B testing, and maintain flexible deployment strategies. By properly implementing feature flags in your Shopware 6 projects, you can significantly improve your development workflow, reduce risk, and provide better user experiences through gradual feature adoption.

The integration of feature flags with Shopware 6's existing architecture provides developers with powerful tools for managing complex feature lifecycles while maintaining system stability. As you implement feature flags in your projects, remember to follow best practices for performance optimization, comprehensive testing, and regular maintenance to ensure long-term success.

With proper planning and implementation, feature flags can transform how you approach development and deployment in Shopware 6, enabling more agile and responsive software delivery processes that adapt to changing business requirements while maintaining the stability and reliability that Shopware 6 users expect.