Running a high-performance Shopware 6.7 storefront in production demands more than just robust infrastructure—it requires continuous, actionable visibility into how your application behaves under real-world load. Shopware 6.7 builds on deeper Symfony foundations, introduces refined messenger queue handling, and exposes additional observability endpoints, but without a structured monitoring strategy, performance degradation often goes unnoticed until it impacts conversion rates or checkout stability.

Effective monitoring isn’t about collecting every possible metric; it’s about tracking the right signals at the right time. Below is a practical, production-ready approach to monitoring Shopware 6.7+, broken down into infrastructure, application, data layer, queue processing, and business-layer observability.

1. Infrastructure & Runtime Metrics

Your base layer must be transparent. Track CPU, memory, disk I/O, network throughput, and uptime using tools like Prometheus with node_exporter or a managed APM provider. For Shopware specifically, pay attention to PHP-FPM pools: monitor max_children, active requests, slow requests, and pool draining metrics. Misconfigured FPM pools are the silent killer of concurrent storefront traffic.

# Example php-fpm pool configuration monitoring hint
# pm.max_children = 150
# pm.max_requests = 5000
# pm.status_path = /fpm-status

Enable FPM’s status endpoint behind authentication, and scrape it with Prometheus. Alert when max_active_processes exceeds 80% of max_children, or when average response time for PHP processes crosses 200ms. These thresholds ensure you scale worker pools before the application starts queuing requests.

2. Application & Symfony Insights

Shopware 6.7 leverages Symfony components heavily. Expose application-level metrics through a custom data collector or by extending Symfony\Component\HttpKernel\DataCollector\DataCollector. Register it in your services.yaml:

services:
  shopware_monitoring.metric_collector:
    class: App\Metrics\MetricCollector
    tags:
      - { name: data_collector, template: '@WebProfiler/Collector/metrics.html.twig', id: shopware_metrics }

Inside the collector, track request durations, Symfony cache hits, event subscriber execution times, and custom business KPIs (e.g., API calls to third-party services). Export these to Prometheus using the promphp/prometheus_client_php library. Create a /api/_internal/metrics endpoint secured via Shopware’s access control rules, exposing APC_USER_CACHE_HITS, SYMFONY_EVENT_DURATION_SECONDS, and SW_REQUEST_LATENCY. This gives your observability stack direct insight into framework bottlenecks without relying solely on third-party agents.

3. Database & Cache Health

Shopware 6.7 relies heavily on MySQL/MariaDB and Redis. Monitor query latency, connection pool utilization, and buffer pool hit ratios. Enable the slow query log with a threshold of 500ms and stream it to your APM or ELK stack. Use pt-query-digest for historical trend analysis.

For Redis, track memory usage, evicted keys, and connected clients. Shopware’s cache layers (storefront, product-search, api) should show hit rates above 95% under normal load. A sudden drop indicates cache invalidation storms or memory pressure. Add a health check script:

#!/bin/bash
REDIS_PING=$(redis-cli -h redis-master ping)
if [[ "$REDIS_PING" != "PONG" ]]; then
  echo "CRITICAL: Redis unreachable"
  exit 2
fi

Integrate this into your monitoring stack to trigger alerts on cache layer failures. Correlate cache miss spikes with traffic surges or deployment rollouts to identify cache stampedes before they cascade into database overload.

4. Queue & Background Processing

Shopware 6.7 uses Symfony Messenger with AMQP, Redis, or database transport for deferred jobs (e.g., data hub sync, email dispatch, indexing). Monitor queue depth, processing latency, and error rates. Use bin/messenger:consume health checks that expose active workers, stalled messages, and retry counts.

Track worker metrics via a lightweight stats endpoint:

// src/Metrics/WorkerMetricCollector.php
public function getMetrics(): array
{
    return [
        'sw_queue_depth' => $this->queueRepository->count(['processorName' => 'default']),
        'sw_worker_uptime' => time() - $this->workerStartTimestamp,
        'sw_error_rate' => $this->errorLogCount / max(1, $this->processedCount),
    ];
}

Alert when queue depth exceeds your processing capacity by 20% or when error rates climb above 5%. Stalled consumers often indicate memory leaks, downstream timeouts, or AMQP consumer crashes. Automate graceful worker restarts and log dead-letter queue contents to prevent silent data loss.

5. Business & UX Performance Metrics

Technical health means nothing if users experience friction. Implement Real User Monitoring (RUM) to track Core Web Vitals: LCP, FID, CLS, and TTFB. For Shopware 6.7, ensure your storefront caching aligns with these metrics. Use synthetic monitoring to simulate checkout flows, search queries, and API calls from multiple geographic locations.

Track conversion funnels, cart abandonment rates, and payment gateway latency. A sudden drop in checkout completion often traces back to slow inventory checks, timeout-prone ERP syncs, or cache stampedes. Correlate these business metrics with your infrastructure alerts to pinpoint root causes quickly and prioritize optimization efforts.

Best Practices for Production Monitoring

  • Define clear thresholds: Avoid alert fatigue by setting actionable baselines tuned to your traffic patterns and SLA requirements.
  • Log aggregation: Centralize Symfony logs, PHP errors, and Shopware debug outputs. Use correlation IDs across requests for traceability.
  • Security & Compliance: Never expose raw metrics or logs publicly. Hash sensitive data, enforce IP whitelisting on monitoring endpoints, and comply with GDPR/CCPA.
  • Automated reporting: Generate daily performance summaries highlighting trends, anomalies, and capacity planning needs to keep stakeholders aligned.

Conclusion

Monitoring Shopware 6.7 in production isn’t a one-time setup—it’s an ongoing discipline. By tracking infrastructure stability, Symfony application health, database/cache efficiency, queue processing, and real user experience, you transform reactive debugging into proactive optimization. Leverage Shopware’s modern observability hooks, integrate them with your existing monitoring ecosystem, and establish clear alerting protocols. When performance issues arise, you’ll already know exactly where to look.

Invest in monitoring early, tune it continuously, and let data guide your scaling, caching, and architecture decisions. Your storefront will thank you—with faster load times, stable checkouts, and higher conversion rates.