Enable Discovery debug logging for production troubleshooting

- Add DISCOVERY_LOG_LEVEL=debug - Add DISCOVERY_SHOW_PROGRESS=true - Temporary changes for debugging InitializerProcessor fixes on production
2025-08-11 20:13:26 +02:00
parent 59fd3dd3b1
commit 55a330b223
3683 changed files with 2956207 additions and 16948 deletions
--- a/backups/docs-backup-20250731125004/framework/analytics/README.md
+++ b/backups/docs-backup-20250731125004/framework/analytics/README.md
@@ -0,0 +1,158 @@
+# Analytics-Modul Dokumentation
+
+## Übersicht
+
+Das Analytics-Modul ist ein internes Tracking- und Analysesystem, das ohne externe Abhängigkeiten Benutzeraktivitäten, Systemereignisse und Leistungsdaten erfasst und analysiert.
+
+## Kernkomponenten
+
+### Analytics (Analytics.php)
+
+Die Hauptklasse, die als zentraler Einstiegspunkt für das Tracking von Events dient.
+
+**Hauptfunktionen:**
+- `track()`: Zeichnet ein generisches Event auf
+- `page()`: Spezifisch für Seitenaufrufe
+- `user()`: Verfolgt Benutzeridentifikation
+- `performance()`: Erfasst Leistungsmetriken
+- `error()`: Protokolliert Fehler und Ausnahmen
+
+### AnalyticsManager (AnalyticsManager.php)
+
+Verwaltet die Verarbeitung und Speicherung von Events.
+
+**Hauptfunktionen:**
+- `track()`: Verarbeitet Events und wendet Middleware an
+- `addMiddleware()`: Fügt Verarbeitungsfunktionen hinzu
+- `flush()`: Schreibt gepufferte Events in den Speicher
+
+### StorageInterface und FileStorage
+
+Das Interface definiert die Speichermethoden, FileStorage implementiert die Speicherung in Dateien.
+
+**Hauptoperationen:**
+- `store()`: Speichert Events
+- `retrieve()`: Ruft Events mit Filtern ab
+- `clear()`: Löscht alle gespeicherten Daten
+
+### AnalyticsInitializer (AnalyticsInitializer.php)
+
+Konfiguriert und initialisiert den Analytics-Service beim Anwendungsstart.
+
+**Konfigurationsoptionen:**
+- Aktivierung/Deaktivierung
+- Auto-Flush und Batch-Größe
+- Storage-Typ und Pfad
+
+### AnalyticsMiddleware (AnalyticsMiddleware.php)
+
+HTTP-Middleware zum automatischen Tracking von Requests und Responses.
+
+### AnalyticsDashboard (AnalyticsDashboard.php)
+
+Stellt Methoden für Datenanalyse und -aggregation bereit:
+- `getEventStats()`: Ereignisstatistiken
+- `getTopPages()`: Meistbesuchte Seiten
+- `getUserStats()`: Benutzerstatistiken
+- `getErrorStats()`: Fehlerstatistiken
+- `getPerformanceStats()`: Leistungsmetriken
+
+### Events
+
+Vordefinierte Event-Typen:
+- `AnalyticsEvent`: Basis-Event-Klasse
+- `PageViewEvent`: Speziell für Seitenaufrufe
+
+### Controllers
+
+`AdminAnalyticsController`: Stellt das Admin-Dashboard bereit mit:
+- Übersichtsseite
+- Seitenstatistiken
+- Fehlerstatistiken
+- Leistungsstatistiken
+
+### Console
+
+`AnalyticsClearCommand`: Konsolenbefehl zum Löschen von Analytics-Daten.
+
+## Konfiguration
+
+Die Konfiguration erfolgt in `src/Config/analytics.php` mit folgenden Optionen:
+
+```php
+return [
+    'enabled' => true,           // Aktiviert/deaktiviert das Tracking
+    'auto_flush' => true,         // Automatisches Speichern nach Batch-Größe
+    'batch_size' => 50,           // Anzahl Events pro Batch
+    'storage' => 'file',          // Storage-Backend
+    'storage_path' => '...',      // Speicherpfad
+    'anonymize_ip' => true,       // IP-Anonymisierung
+    'track_events' => [...]       // Zu trackende Events
+];
+```
+
+## Verwendung
+
+### Basis-Tracking
+
+```php
+// Event tracken
+$analytics->track('button_click', ['button' => 'signup']);
+
+// Seitenaufruf tracken
+$analytics->page('/dashboard', ['section' => 'analytics']);
+
+// Benutzer identifizieren
+$analytics->user('user123', ['plan' => 'premium']);
+```
+
+### Middleware einrichten
+
+```php
+$this->addMiddleware(App\Framework\Analytics\AnalyticsMiddleware::class);
+```
+
+### Eigene Middleware hinzufügen
+
+```php
+$analyticsManager->addMiddleware(function(array $event) {
+    // Daten verarbeiten oder filtern
+    return $event;
+});
+```
+
+## Datenschutz
+
+Das System bietet integrierte Funktionen zur Anonymisierung personenbezogener Daten:
+- IP-Adressen-Anonymisierung (letztes Oktett wird entfernt)
+- Konfigurierbare Filterung sensibler Daten durch Middleware
+
+## Erweiterbarkeit
+
+### Eigene Storage-Provider
+
+Implementieren Sie das `StorageInterface` für benutzerdefinierte Speicherlösungen:
+
+```php
+class CustomStorage implements StorageInterface
+{
+    public function store(array $events): void { /* ... */ }
+    public function retrieve(array $filters = []): array { /* ... */ }
+    public function clear(): void { /* ... */ }
+}
+```
+
+### Event-Typen erweitern
+
+Erstellen Sie benutzerdefinierte Event-Klassen, die von `AnalyticsEvent` erben:
+
+```php
+class CustomEvent extends AnalyticsEvent
+{
+    public function __construct(string $customData, array $additionalProps = [])
+    {
+        parent::__construct('custom_event', 
+            array_merge(['custom_data' => $customData], $additionalProps));
+    }
+}
+```
--- a/backups/docs-backup-20250731125004/framework/analytics/architecture.md
+++ b/backups/docs-backup-20250731125004/framework/analytics/architecture.md
@@ -0,0 +1,102 @@
+# Analytics-Framework: Architektur
+
+## Überblick
+
+Das Analytics-Framework verwendet eine Schichtenarchitektur mit klaren Verantwortlichkeiten:
+
+```
+┌─────────────────────────────────────────────────────┐
+│                 Öffentliche API                      │
+│                  (Analytics)                         │
+└───────────────────────┬─────────────────────────────┘
+                        │
+┌───────────────────────▼─────────────────────────────┐
+│              Event-Verarbeitung                      │
+│             (AnalyticsManager)                       │
+└───────────────────────┬─────────────────────────────┘
+                        │
+         ┌──────────────┴──────────────┐
+         │                             │
+┌────────▼─────────┐         ┌─────────▼────────┐
+│   Middleware     │         │  Storage-Layer   │
+│   (Pipeline)     │         │ (StorageInterface)│
+└──────────────────┘         └──────────────────┘
+```
+
+## Komponenten im Detail
+
+### Analytics (Frontend)
+
+Bietet eine benutzerfreundliche API für Tracking-Operationen. Diese Klasse ist der primäre Einstiegspunkt für Anwendungscode und abstrahiert die Komplexität der Eventverarbeitung.
+
+Verantwortlichkeiten:
+- Bereitstellung der öffentlichen API (`track`, `page`, `user`, `error`)
+- Integration mit dem Event-Dispatcher des Frameworks
+- Typ-Konvertierung zwischen benutzerdefinierten Ereignissen und dem internen Datenformat
+
+### AnalyticsManager (Verarbeitung)
+
+Der Manager ist das Herzstück des Systems und verantwortlich für:
+- Anwendung von Middleware-Transformationen auf Events
+- Eventpufferung für effiziente Speicherung
+- Verwaltung der Konfiguration
+- Steuerung des Storage-Layers
+
+Der Manager implementiert einen Event-Buffer, der Daten sammelt und bei Erreichen einer konfigurierbaren Größe automatisch speichert.
+
+### Middleware-System
+
+Eine Kette von Verarbeitungsfunktionen, die auf jedes Event angewendet werden:
+- Datenfilterung und -transformation
+- Anonymisierung persönlicher Daten
+- Validierung und Anreicherung von Events
+
+Jede Middleware kann Events modifizieren oder komplett verwerfen.
+
+### Storage-Layer
+
+Abstraktion für verschiedene Speichermethoden durch das `StorageInterface`:
+
+```php
+interface StorageInterface
+{
+    public function store(array $events): void;
+    public function retrieve(array $filters = []): array;
+    public function clear(): void;
+}
+```
+
+Implementierungen:
+- `FileStorage`: Speichert Events in JSON-Dateien mit täglicher Rotation
+- Erweiterbar für andere Backends (Datenbank, Redis, etc.)
+
+### HTTP-Integration
+
+`AnalyticsMiddleware` integriert Analytics in den HTTP-Request-Lifecycle:
+- Tracking von eingehenden Requests
+- Erfassung von Antwortzeiten und Statuscodes
+- Fehlererfassung bei Exceptions
+
+### Admin-Dashboard
+
+`AnalyticsDashboard` und `AdminAnalyticsController` bieten:
+- Datenaggregation und -analyse
+- Visualisierung von Metriken
+- Filterung nach Zeiträumen
+- Verschiedene spezialisierte Ansichten (Seiten, Fehler, Performance)
+
+## Datenfluss
+
+1. Event wird durch `Analytics::track()` oder ähnliche Methoden erstellt
+2. `AnalyticsManager` wendet Middleware-Pipeline an
+3. Event wird zum Buffer hinzugefügt
+4. Bei Buffer-Füllung oder explizitem `flush()` werden Events an Storage übergeben
+5. Storage speichert Events im konfigurierten Backend
+6. `AnalyticsDashboard` ruft Daten bei Bedarf vom Storage ab und aggregiert sie
+
+## Erweiterungspunkte
+
+- **Storage-Provider**: Neue Implementierungen von `StorageInterface`
+- **Middleware**: Funktionen für Filterung/Transformation
+- **Event-Typen**: Spezialisierte Event-Klassen für typsicheres Tracking
+- **Dashboard-Views**: Zusätzliche Visualisierungen und Berichte
--- a/backups/docs-backup-20250731125004/framework/analytics/index.md
+++ b/backups/docs-backup-20250731125004/framework/analytics/index.md
@@ -0,0 +1,114 @@
+# Analytics-Framework
+
+> **Dokumentationshinweis:** Diese Dokumentation ist vollständig aktualisiert und stellt die aktuelle Implementierung des Analytics-Frameworks korrekt dar.
+
+## Übersicht
+
+Das Analytics-Framework ist ein eigenständiges Tracking- und Analysesystem, das vollständig in die Anwendung integriert ist und ohne externe Dienste auskommt. Es ermöglicht die Erfassung, Speicherung und Analyse von:
+
+- Benutzeraktivitäten (Seitenaufrufe, Interaktionen)
+- Systemereignissen (Anwendungsstart, Fehler)
+- Leistungsdaten (Speicherverbrauch, Ausführungszeit, Datenbankabfragen)
+
+## Hauptkomponenten
+
+### Analytics-Klasse
+
+Die zentrale API für Tracking-Operationen:
+
+```php
+// Klasse initialisieren
+$analytics = new Analytics($analyticsManager, $eventDispatcher);
+
+// Event tracken
+$analytics->track('event_name', ['property' => 'value']);
+
+// Seite tracken
+$analytics->page('/pfad/zur/seite', ['eigenschaft' => 'wert']);
+
+// Benutzer identifizieren
+$analytics->user('user_id', ['eigenschaft' => 'wert']);
+
+// Fehler tracken
+$analytics->error($exception);
+```
+
+### AnalyticsManager
+
+Verarbeitet und speichert Events:
+
+- Wendet Middleware auf Events an
+- Puffert Events für effiziente Speicherung
+- Verwaltet die Konfiguration
+- Steuert die Speicherung in verschiedenen Backends
+
+### Storage-System
+
+Basierend auf dem `StorageInterface` mit verschiedenen Implementierungen:
+
+- `FileStorage`: Speichert Events in Dateien
+- Erweiterbar für Datenbank, Redis oder andere Backends
+
+### Middleware-System
+
+```php
+$analyticsManager->addMiddleware(function(array $event) {
+    // Event verarbeiten oder filtern
+    return $event; // oder null um zu verwerfen
+});
+```
+
+### HTTP-Middleware
+
+Automatisches Tracking von HTTP-Requests und -Responses:
+
+```php
+// In Bootstrap oder Application-Klasse
+$app->addMiddleware(AnalyticsMiddleware::class);
+```
+
+### Dashboard und Berichterstattung
+
+Das `AnalyticsDashboard` bietet Methoden zur Datenanalyse:
+
+- `getEventStats()`: Statistiken zu Events
+- `getTopPages()`: Meistbesuchte Seiten
+- `getUserStats()`: Benutzerstatistiken
+- `getErrorStats()`: Fehlerstatistiken
+- `getPerformanceStats()`: Leistungsmetriken
+
+Das Admin-Dashboard ist unter `/admin/analytics` verfügbar.
+
+### Konsolen-Befehle
+
+```bash
+# Analytics-Daten löschen
+php console analytics:clear [--force]
+```
+
+## Integration
+
+### Service-Container
+
+Der Analytics-Service wird automatisch registriert und kann per Dependency Injection verwendet werden:
+
+```php
+public function __construct(private readonly Analytics $analytics) {}
+```
+
+### Event-Integration
+
+Standardmäßig werden folgende Anwendungsereignisse getrackt:
+
+- Anwendungsstart (`application_booted`)
+- Fehlerbehandlung (`error_occurred`)
+- Request-Verarbeitung (`request_started`, `request_completed`)
+
+## Konfiguration
+
+Detaillierte Konfigurationsoptionen finden Sie in der [Framework-README](/Framework/Analytics1/README.md).
+
+## Weitere Informationen
+
+- [Framework-Erweiterungsmuster](/docs/framework/ERWEITERUNGSPATTERN.md)
+- [Modul-Checkliste](/docs/framework/MODUL-CHECKLISTE.md)
--- a/backups/docs-backup-20250731125004/framework/analytics/migration.md
+++ b/backups/docs-backup-20250731125004/framework/analytics/migration.md
@@ -0,0 +1,160 @@
+# Analytics-Framework: Migrationsleitfaden
+
+## Von Version 1.x zu 2.x
+
+### Überblick der Änderungen
+
+Die Version 2.x des Analytics-Frameworks führt mehrere wichtige Verbesserungen und Änderungen ein:
+
+- **Typsicherheit**: Neue Event-Klassen statt Arrays
+- **Dependency Injection**: Verbesserte Integration mit dem Container
+- **Storage-Abstraktion**: Flexiblere Speichermethoden
+- **Fehlerbehandlung**: Robustere Exception-Handling
+- **Middleware-System**: Standardisierte Middleware-Pipeline
+
+### Notwendige Migrationsschritte
+
+#### 1. Konfiguration aktualisieren
+
+**Alt (1.x):**
+```php
+return [
+    'enabled' => true,
+    'auto_flush' => true,
+    'batch_size' => 50,
+    'storage' => 'file',
+    'storage_path' => '/pfad/zum/speicher',
+];
+```
+
+**Neu (2.x):**
+```php
+return [
+    'enabled' => true,
+    'auto_flush' => true,
+    'batch_size' => 50,
+    'storage_driver' => 'file',  // Umbenannt
+    'storage_config' => [        // Neue Struktur
+        'path' => '/pfad/zum/speicher',
+    ],
+    'excluded_paths' => [],      // Neue Option
+    'excluded_user_agents' => [], // Neue Option
+    'max_file_size' => 10 * 1024 * 1024, // Neue Option
+];
+```
+
+#### 2. Event-Objekte (falls genutzt)
+
+**Alt (1.x):**
+```php
+$analytics->track('custom_event', ['property' => 'value']);
+```
+
+**Neu (2.x) - Option 1 (abwärtskompatibel):**
+```php
+// Weiterhin unterstützt
+$analytics->track('custom_event', ['property' => 'value']);
+```
+
+**Neu (2.x) - Option 2 (typsicher):**
+```php
+use App\Framework\Analytics\Events\CustomEvent;
+
+$event = new CustomEvent('wert', ['weitere' => 'daten']);
+$analytics->trackEvent($event);
+```
+
+#### 3. Eigene Storage-Provider
+
+**Alt (1.x):**
+```php
+class CustomStorage implements StorageInterface
+{
+    public function store(array $events): void
+    {
+        // Implementation
+    }
+
+    public function retrieve(array $filters = []): array
+    {
+        // Implementation
+    }
+
+    public function clear(): void
+    {
+        // Implementation
+    }
+}
+```
+
+**Neu (2.x):**
+```php
+use Psr\Log\LoggerInterface;
+
+class CustomStorage implements StorageInterface
+{
+    public function __construct(
+        private readonly array $config,
+        private readonly LoggerInterface $logger
+    ) {}
+
+    public function store(array $events): void
+    {
+        try {
+            // Implementation mit Fehlerbehandlung
+        } catch (\Exception $e) {
+            $this->logger->error('Storage error', ['exception' => $e]);
+            throw new StorageException('Failed to store events', 0, $e);
+        }
+    }
+
+    // Andere Methoden analog
+}
+```
+
+#### 4. Middleware anpassen
+
+**Alt (1.x):**
+```php
+$analyticsManager->addMiddleware(function(array $event) {
+    // Verarbeitung
+    return $event;
+});
+```
+
+**Neu (2.x) - Option 1 (abwärtskompatibel):**
+```php
+// Weiterhin unterstützt
+$analyticsManager->addMiddleware(function(array $event) {
+    // Verarbeitung
+    return $event;
+});
+```
+
+**Neu (2.x) - Option 2 (typsicher):**
+```php
+use App\Framework\Analytics\Middleware\AnalyticsMiddleware;
+use App\Framework\Analytics\Events\AnalyticsEvent;
+
+class CustomMiddleware implements AnalyticsMiddleware
+{
+    public function process(AnalyticsEvent $event): ?AnalyticsEvent
+    {
+        // Verarbeitung
+        return $event;
+    }
+}
+
+// Registrierung
+$analyticsManager->addMiddleware(new CustomMiddleware());
+```
+
+### Automatisierte Tests
+
+Führen Sie die folgenden Tests durch, um sicherzustellen, dass die Migration erfolgreich war:
+
+```bash
+php console test:run --group=analytics
+```
+
+Weitere Informationen zur Migration finden Sie in den Änderungsprotokollen im Quellcode-Repository.
--- a/backups/docs-backup-20250731125004/framework/analytics/usage.md
+++ b/backups/docs-backup-20250731125004/framework/analytics/usage.md
@@ -0,0 +1,269 @@
+# Analytics-Framework: Anwendungsbeispiele
+
+## Grundlegende Verwendung
+
+### Events tracken
+
+```php
+// Über Dependency Injection
+public function __construct(private readonly Analytics $analytics) {}
+
+// Einfaches Event tracken
+$this->analytics->track('login_attempt', [
+    'success' => true,
+    'user_type' => 'admin',
+    'method' => 'password'
+]);
+
+// Seitenaufruf tracken
+$this->analytics->page('/produkte/kategorie/elektronik', [
+    'referrer' => 'homepage',
+    'search_query' => 'smartphones'
+]);
+
+// Benutzer identifizieren
+$this->analytics->user($user->getId(), [
+    'email' => $user->getEmail(),
+    'plan' => $user->getSubscriptionPlan(),
+    'registered_since' => $user->getCreatedAt()->format('Y-m-d')
+]);
+```
+
+### Fehler tracken
+
+```php
+try {
+    // Fehleranfälliger Code
+    $result = $this->riskyOperation();
+    return $result;
+} catch (\Exception $e) {
+    // Fehler tracken
+    $this->analytics->error($e);
+
+    // Fehler behandeln
+    $this->logger->error($e->getMessage());
+    return $this->fallbackOperation();
+}
+```
+
+### Performance tracken
+
+```php
+// Manuelles Performance-Tracking
+$startTime = microtime(true);
+$startMemory = memory_get_usage();
+
+// Operation durchführen
+$result = $this->heavyOperation();
+
+// Performance-Metriken tracken
+$this->analytics->performance([
+    'operation' => 'heavy_operation',
+    'execution_time' => microtime(true) - $startTime,
+    'memory_used' => memory_get_usage() - $startMemory,
+    'result_size' => is_countable($result) ? count($result) : 0
+]);
+```
+
+## Erweiterte Anwendungsfälle
+
+### Benutzerdefinierte Middleware
+
+```php
+// In einem Service Provider oder Initializer
+public function initialize(AnalyticsManager $manager): void
+{
+    // DSGVO-Middleware zur Anonymisierung personenbezogener Daten
+    $manager->addMiddleware(function(array $event) {
+        // E-Mail-Adressen anonymisieren
+        if (isset($event['properties']['email'])) {
+            $parts = explode('@', $event['properties']['email']);
+            if (count($parts) === 2) {
+                $event['properties']['email'] = substr($parts[0], 0, 1) . 
+                    '***@' . $parts[1];
+            }
+        }
+
+        // Passwörter und Tokens entfernen
+        foreach (['password', 'token', 'api_key', 'secret'] as $key) {
+            if (isset($event['properties'][$key])) {
+                $event['properties'][$key] = '[redacted]';
+            }
+        }
+
+        return $event;
+    });
+
+    // Spam-Filter
+    $manager->addMiddleware(function(array $event) {
+        // Zu viele Events von einem Benutzer filtern
+        static $userCounts = [];
+        $userId = $event['user_id'] ?? $event['session_id'] ?? null;
+
+        if ($userId) {
+            $userCounts[$userId] = ($userCounts[$userId] ?? 0) + 1;
+
+            // Mehr als 100 Events pro Session ist verdächtig
+            if ($userCounts[$userId] > 100) {
+                return null; // Event verwerfen
+            }
+        }
+
+        return $event;
+    });
+}
+```
+
+### Integration mit dem Domain-Layer
+
+```php
+// In einem Domain-Service
+namespace App\Domain\Shop\Services;
+
+use App\Framework\Analytics\Analytics;
+
+class ProductService
+{
+    public function __construct(private readonly Analytics $analytics) {}
+
+    public function viewProduct(string $productId, ?string $userId): Product
+    {
+        $product = $this->productRepository->find($productId);
+
+        if (!$product) {
+            throw new ProductNotFoundException($productId);
+        }
+
+        // Produktansicht tracken
+        $this->analytics->track('product_view', [
+            'product_id' => $product->getId(),
+            'product_name' => $product->getName(),
+            'product_price' => $product->getPrice(),
+            'product_category' => $product->getCategory()->getName(),
+            'in_stock' => $product->isInStock()
+        ], $userId);
+
+        return $product;
+    }
+
+    public function addToCart(string $productId, int $quantity, ?string $userId): Cart
+    {
+        // Implementation...
+
+        // Event tracken
+        $this->analytics->track('add_to_cart', [
+            'product_id' => $productId,
+            'quantity' => $quantity,
+            'cart_value' => $cart->getTotalValue()
+        ], $userId);
+
+        return $cart;
+    }
+}
+```
+
+### Verwendung im Controller
+
+```php
+namespace App\Application\Controllers;
+
+use App\Framework\Analytics\Analytics;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+use App\Framework\Attributes\Route;
+
+class CheckoutController
+{
+    public function __construct(
+        private readonly Analytics $analytics,
+        private readonly CheckoutService $checkoutService
+    ) {}
+
+    #[Route('/checkout/complete', method: 'POST')]
+    public function completeCheckout(Request $request): Response
+    {
+        $userId = $request->getSession()->get('user_id');
+        $cartId = $request->getSession()->get('cart_id');
+
+        try {
+            $order = $this->checkoutService->completeCheckout($cartId, $userId);
+
+            // Erfolgreichen Checkout tracken
+            $this->analytics->track('checkout_complete', [
+                'order_id' => $order->getId(),
+                'order_value' => $order->getTotalValue(),
+                'items_count' => count($order->getItems()),
+                'payment_method' => $order->getPaymentMethod(),
+                'shipping_method' => $order->getShippingMethod()
+            ], $userId);
+
+            return new Response([
+                'success' => true,
+                'order_id' => $order->getId()
+            ], 200);
+        } catch (\Exception $e) {
+            // Fehler beim Checkout tracken
+            $this->analytics->track('checkout_error', [
+                'error' => $e->getMessage(),
+                'cart_id' => $cartId
+            ], $userId);
+
+            // Auch den Exception-Stack tracken
+            $this->analytics->error($e);
+
+            return new Response([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], 400);
+        }
+    }
+}
+```
+
+## Analyse der Daten
+
+### Dashboard-Controller
+
+```php
+namespace App\Application\Controllers;
+
+use App\Framework\Analytics\AnalyticsDashboard;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+use App\Framework\View\ViewRenderer;
+use App\Framework\Attributes\Route;
+
+class AnalyticsDashboardController
+{
+    public function __construct(
+        private readonly AnalyticsDashboard $dashboard,
+        private readonly ViewRenderer $viewRenderer
+    ) {}
+
+    #[Route('/admin/analytics/conversion')]
+    public function conversionReport(Request $request): Response
+    {
+        $from = $request->getQueryParam('from');
+        $to = $request->getQueryParam('to');
+
+        // Benutzerdefinierte Analyse für Conversion-Funnel
+        $pageViews = $this->dashboard->getEventCountByType('page_view', $from, $to);
+        $productViews = $this->dashboard->getEventCountByType('product_view', $from, $to);
+        $addToCarts = $this->dashboard->getEventCountByType('add_to_cart', $from, $to);
+        $checkouts = $this->dashboard->getEventCountByType('checkout_complete', $from, $to);
+
+        // Conversion-Raten berechnen
+        $data = [
+            'total_visitors' => $pageViews,
+            'product_view_rate' => $pageViews > 0 ? $productViews / $pageViews : 0,
+            'add_to_cart_rate' => $productViews > 0 ? $addToCarts / $productViews : 0,
+            'checkout_rate' => $addToCarts > 0 ? $checkouts / $addToCarts : 0,
+            'overall_conversion' => $pageViews > 0 ? $checkouts / $pageViews : 0,
+            'from_date' => $from,
+            'to_date' => $to
+        ];
+
+        return $this->viewRenderer->render('admin/analytics/conversion', $data);
+    }
+}
+```