---
title: "Elastic APM für Shopware: Performance-Monitoring richtig gemacht"
url: https://coding9.de/blog/elastic-apm-shopware-performance-monitoring
author: "Felix Astner"
datePublished: 2025-11-26T08:00:00.000Z
dateModified: 2025-11-26T08:00:00.000Z
description: "Elastic APM für Shopware 6 einrichten: Installation, RUM-Integration, Transaction Tracking und das Aufspüren von Performance-Bottlenecks."
---

# Elastic APM für Shopware: Performance-Monitoring richtig gemacht

Ihr Shopware-Shop ist live, die Verkäufe laufen, doch plötzlich häufen sich Beschwerden: „Der Checkout ist so langsam!", „Die Produktsuche hängt sich auf!". Ohne Monitoring fehlen Ihnen die Antworten: Welche Seiten sind betroffen? Liegt es am PHP-Code, der Datenbank oder an externen APIs? Diese Fragen beantwortet **Elastic APM (Application Performance Monitoring)**. Das Tool ist Teil des Elastic Stack (früher ELK-Stack) und misst Ihre Shopware-Anwendung durchgehend: Backend-Transaktionen ebenso wie das Rendering im Browser. Bei CODING 9 gehört dieses Monitoring standardmäßig zu Shopware-Projekten. Dieser Guide zeigt Installation, Konfiguration und Auswertung, damit Sie Performance-Probleme sehen, bevor Kunden sich melden.

## Was ist Elastic APM und warum für Shopware?

Elastic APM ist ein Open-Source-Tool für **Application Performance Monitoring** und **Distributed Tracing**. Als Performance-Monitoring-System misst es Ihre Anwendungen im laufenden Betrieb in Echtzeit und erfasst:

- **Backend-Transaktionen**: eingehende HTTP-Requests, Database Queries, API-Calls
- **Frontend-Performance (RUM)**: Page Load, Core Web Vitals, JavaScript-Fehler
- **Fehler & Exceptions**: Stack Traces, Error Rates, Impact-Analyse
- **Service Maps**: Visualisierung der Abhängigkeiten zwischen Shopware, MySQL, Redis und Payment-Gateway

Die Messung übernehmen Agents. Sie hängen sich in die Laufzeit der Anwendung ein und instrumentieren eingehende Requests automatisch: Jeder HTTP-Request wird zu einer Transaktion, jede Database Query darunter zu einem Span. Was ein Agent von sich aus erkennt, ist agent-spezifisch. Der PHP-Agent kennt Symfony, Doctrine und Guzzle, der JavaScript-Agent kennt Navigation Timing und Fetch-Aufrufe im Browser. Eigener Code kommt über manuelle Spans dazu, dazu später mehr.

### Warum sich das Tool speziell für Shopware 6 eignet

- **Native PHP-Integration**: Elastic bietet einen offiziellen PHP-Agent, der Symfony/Shopware automatisch instrumentiert
- **Open Source & Self-Hosted**: Volle Datenkontrolle (wichtig für DSGVO)
- **RUM für Storefront**: Misst echte User-Erfahrung (nicht nur synthetische Tests)
- **Kosteneffizient**: Free Tier für kleine Shops, ~€50-200/Monat für mittelgroße Shops (vs. €500+ bei New Relic/Datadog)

## Setup Teil 1: Elastic APM Server installieren

Sie haben zwei Optionen: Self-Hosted oder Elastic Cloud.

### Option 1: Self-Hosted (Docker Compose)

Ideal für volle Kontrolle und DSGVO-Compliance:

```yaml
# docker-compose.yml
version: '3.8'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.11.0
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
    ports:
      - "9200:9200"
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data

  apm-server:
    image: docker.elastic.co/apm/apm-server:8.11.0
    ports:
      - "8200:8200"
    environment:
      - output.elasticsearch.hosts=["elasticsearch:9200"]
    depends_on:
      - elasticsearch

  kibana:
    image: docker.elastic.co/kibana/kibana:8.11.0
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    depends_on:
      - elasticsearch

volumes:
  elasticsearch-data:
```

```bash
docker compose up -d
# Kibana erreichbar unter: http://localhost:5601
```

### Option 2: Elastic Cloud (Managed)

1. Account erstellen auf cloud.elastic.co
2. Deployment erstellen (14-Tage Free Trial)
3. APM-Server aktivieren (unter "Integrations")
4. Secret Token & Server URL notieren

## Setup Teil 2: PHP Agent für Shopware installieren

Der Elastic PHP Agent instrumentiert Ihre Shopware-Anwendung automatisch:

### Schritt 1: Agent-Installation

```bash
# Download & Installation (Debian/Ubuntu)
curl -L -O https://github.com/elastic/apm-agent-php/releases/download/v1.10.0/apm-agent-php_1.10.0_all.deb
sudo dpkg -i apm-agent-php_1.10.0_all.deb

# PHP-Extension aktivieren
sudo phpenmod elastic_apm

# PHP-FPM neustarten
sudo systemctl restart php8.2-fpm
```

### Schritt 2: Konfiguration (.env)

Fügen Sie zu Ihrer Shopware `.env` hinzu:

```bash
# Elastic APM Configuration
ELASTIC_APM_SERVER_URL=http://localhost:8200
ELASTIC_APM_SECRET_TOKEN=your-secret-token
ELASTIC_APM_SERVICE_NAME=shopware-production
ELASTIC_APM_ENVIRONMENT=production
ELASTIC_APM_LOG_LEVEL=info
ELASTIC_APM_ENABLED=true
```

### Schritt 3: Symfony Integration (optional aber empfohlen)

Für bessere Transaction-Namen und Custom Spans:

```bash
composer require elastic/apm-agent-php
```

```php
// config/packages/elastic_apm.yaml
elastic_apm:
    app_name: '%env(ELASTIC_APM_SERVICE_NAME)%'
    server_url: '%env(ELASTIC_APM_SERVER_URL)%'
    secret_token: '%env(ELASTIC_APM_SECRET_TOKEN)%'
    environment: '%env(ELASTIC_APM_ENVIRONMENT)%'
    enabled: '%env(bool:ELASTIC_APM_ENABLED)%'
```

Nach Deploy sehen Sie bereits erste Transaktionen in Kibana APM!

## Setup Teil 3: RUM (Real User Monitoring) für Storefront

RUM trackt Frontend-Performance direkt im Browser Ihrer Kunden:

### JavaScript-Agent einbinden

Erstellen Sie ein Shopware-Plugin oder nutzen Sie ein Theme-Override:

```twig
{# Resources/views/storefront/layout/meta.html.twig #}
{% sw_extends '@Storefront/storefront/layout/meta.html.twig' %}

{% block layout_head_javascript_tracking %}
    {{ parent() }}

    <script src="https://unpkg.com/@elastic/apm-rum@5.15.0/dist/bundles/elastic-apm-rum.umd.min.js"></script>
    <script>
        elasticApm.init({
            serviceName: 'shopware-storefront',
            serverUrl: '{{ elasticApmServerUrl }}',
            environment: '{{ app.environment }}',
            distributedTracingOrigins: ['{{ app.request.host }}'],

            // Performance Budgets
            breakdownMetrics: true,

            // Privacy: Keine sensiblen Daten tracken
            ignoreTransactions: ['/account/login', '/checkout/payment'],

            // Sampling für hohen Traffic (20% der Sessions)
            transactionSampleRate: 0.2
        });
    </script>
{% endblock %}
```

### Custom Tracking für E-Commerce-Events

```javascript
// Custom Transaction für Checkout
const checkoutTransaction = elasticApm.startTransaction('Checkout Flow', 'user-interaction');

// Span für Payment Gateway
const paymentSpan = checkoutTransaction.startSpan('PayPal Payment', 'external');
// ... PayPal API Call
paymentSpan.end();

checkoutTransaction.end();

// Error Tracking
try {
    await addToCart(productId);
} catch (error) {
    elasticApm.captureError(error);
}
```

## Daten analysieren: Kibana APM Dashboard

Öffnen Sie in Kibana den Bereich APM. Die wichtigsten Views:

### 1. Services Overview

- Zeigt alle Services (shopware-production, shopware-storefront, mysql, redis)
- Metriken: Durchschnittliche Response Time, Throughput (Requests/Min), Error Rate

### 2. Transactions

Filtern Sie nach langsamen Endpoints:

- Beispiel: `POST /checkout/confirm` braucht im Schnitt 2.3s, deutlich zu langsam
- Drill-Down: Zeigt **Spans** (Sub-Operationen) an:
  - SQL Query: 850ms (BOTTLENECK!)
  - PayPal API: 400ms
  - Email Versand: 200ms

### 3. Errors

- Stack Traces für jede Exception
- Gruppierung nach Error-Type
- Beispiel: "PDOException: SQLSTATE[HY000] Too many connections" → DB-Pool zu klein

### 4. Service Map

Visualisiert Abhängigkeiten:

```text
[Browser] --> [Shopware Storefront] --> [Shopware Backend]
                                    |
                         [MySQL] + [Redis] + [Elasticsearch]
                                    |
                              [PayPal API]
```

## Performance-Optimierung: Praxis-Beispiele aus CODING 9-Projekten

### Fall 1: Langsamer Checkout, von 2.3s auf 0.4s

**Problem:** APM zeigte 850ms für eine SQL-Query im Checkout

**Lösung:**

- Query analysiert: N+1-Problem (lädt jedes Line Item einzeln)
- Fix: Eager Loading mit Doctrine Associations
- Resultat: 50ms statt 850ms, Checkout 82% schneller

### Fall 2: Hohe Error Rate bei Product Listing, von 12% auf 0.3%

**Problem:** 12% aller Listing-Requests werfen Timeouts

**Lösung:**

- APM Error-Details: Elasticsearch-Timeout bei komplexen Filtern
- Fix: Elasticsearch Query-Optimierung + Index-Tuning
- Resultat: Error Rate von 12% auf 0.3%

### Fall 3: Schlechte Core Web Vitals, LCP von 4.2s auf 1.8s

**Problem:** RUM zeigte Largest Contentful Paint (LCP) von 4.2s

**Lösung:**

- RUM Transaction-Details: Hero-Image (2MB) unkomprimiert
- Fix: WebP-Conversion + CDN + Lazy Loading
- Resultat: LCP von 4.2s auf 1.8s, im Google-Bereich „Good"

## Best Practices & Tipps

### 1. Sampling für hohen Traffic

Bei >100.000 Requests/Tag samplen Sie nur 10-20% der Transaktionen, um Kosten zu senken:

```bash
ELASTIC_APM_TRANSACTION_SAMPLE_RATE=0.1  # 10%
```

### 2. Alerts einrichten

In Kibana unter Alerts:

- Error Rate über 5%: Benachrichtigung nach Slack oder per E-Mail
- Avg. Response Time über 3s: Alert an das DevOps-Team
- LCP über 2.5s: SEO-Team informieren

### 3. Custom Spans für Business-Logik

```php
use Elastic\Apm\ElasticApm;

public function calculateShippingCost(Order $order): float
{
    $transaction = ElasticApm::getCurrentTransaction();
    $span = $transaction->beginCurrentSpan('Calculate Shipping', 'app.shipping');

    // ... complex shipping logic

    $span->end();
    return $cost;
}
```

### 4. DSGVO-Compliance

- Anonymisieren Sie User-IDs in Custom Context
- Filtern Sie sensitive URLs (`/account/login`, `/checkout/payment`)
- Self-Hosting in EU für volle Datenkontrolle

## Kosten & ROI

### Self-Hosted (Docker)

- Server: €30-80/Monat (2-4 vCPU, 8-16 GB RAM)
- Wartung: ~4h/Monat (Updates, Backups)

### Elastic Cloud

- Standard: $95/Monat (bis 50GB Daten)
- Enterprise: ab $175/Monat (unbegrenzt + Support)

### ROI-Beispiel

Ein mittelgroßer Shopware-Shop (€500k/Monat Umsatz):

- Investition: €100/Monat (Elastic Cloud)
- Gewinn durch 1% Conversion-Steigerung (bessere Performance): €5.000/Monat
- ROI: 5.000%

## Was APM im laufenden Shopware-Betrieb bringt

In jedem Shopware-Projekt mit nennenswertem Umsatz gehört Elastic APM zur Grundausstattung, so wie Backups und Server-Monitoring. Für uns ist es ein **Must-Have** im Betrieb. Was es konkret einbringt:

- Proaktive Fehlerbehebung senkt Downtime und die Zahl der Support-Tickets
- Performance-Optimierung an den gemessenen Bottlenecks hebt die Conversion Rate
- Datengetriebene Entscheidungen richten die Entwicklungszeit auf gemessene Probleme statt auf Vermutungen

Wir richten Elastic APM in neuen Shopware-Projekten ein und rüsten es in bestehenden Shops nach, inklusive RUM-Einbindung und Alerts. Wer das Monitoring nicht selbst betreiben will, bekommt es als Teil der laufenden [Shopware-Wartung mit Support und Pflege](https://coding9.de/leistungen/e-commerce/shopware/wartung); die daraus abgeleiteten Optimierungen laufen über unsere [Performance-Optimierung für Web und Datenbanken](https://coding9.de/leistungen/performance). **Kontaktieren Sie uns** für ein kostenloses Performance-Audit Ihres Shops!

Nutzen Sie bereits ein APM-Tool in Ihrem E-Commerce-Projekt? Schreiben Sie uns, welche Erfahrungen Sie damit gemacht haben.

---

Quelle: [Elastic APM für Shopware: Performance-Monitoring richtig gemacht](https://coding9.de/blog/elastic-apm-shopware-performance-monitoring)