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/guidelines/PERFORMANCE-GUIDELINES.md
+++ b/backups/docs-backup-20250731125004/guidelines/PERFORMANCE-GUIDELINES.md
@@ -0,0 +1,169 @@
+# Performance-Richtlinien
+
+## Übersicht
+
+Diese Richtlinien beschreiben Best Practices für die Optimierung der Anwendungsleistung im Framework.
+
+## Grundprinzipien
+
+### 1. Frühe Optimierung vermeiden
+
+- Code zuerst korrekt und lesbar schreiben
+- Optimierungen auf Basis von Messungen durchführen
+- Performance-Engpässe mit dem Profiler identifizieren
+
+### 2. Caching strategisch einsetzen
+
+- Ergebnisse teurer Operationen cachen
+- Geeignete Cache-Invalidierungsstrategien implementieren
+- Cache-Hierarchie nutzen (Memory → Filesystem → Datenbank)
+
+```php
+// Beispiel: Strategisches Caching
+public function getExpensiveData(string $key): array
+{
+    $cacheKey = "data_{$key}";
+
+    // Prüfen, ob Daten im Cache sind
+    if ($this->cache->has($cacheKey)) {
+        return $this->cache->get($cacheKey);
+    }
+
+    // Teure Operation durchführen
+    $result = $this->performExpensiveOperation($key);
+
+    // Ergebnis cachen mit angemessener TTL
+    $this->cache->set($cacheKey, $result, 3600);
+
+    return $result;
+}
+```
+
+### 3. Lazy Loading
+
+- Ressourcen erst bei Bedarf laden
+- Schwere Abhängigkeiten verzögert initialisieren
+
+```php
+// Beispiel: Lazy Loading
+private ?ExpensiveService $expensiveService = null;
+
+private function getExpensiveService(): ExpensiveService
+{
+    if ($this->expensiveService === null) {
+        $this->expensiveService = new ExpensiveService($this->config);
+    }
+
+    return $this->expensiveService;
+}
+```
+
+### 4. Datenstrukturen optimieren
+
+- Passende Datenstrukturen für den Anwendungsfall wählen
+- Große Arrays vermeiden, wenn möglich Iteratoren oder Generatoren nutzen
+- Bei großen Datenmengen paginieren
+
+```php
+// Beispiel: Generator statt Array
+public function processLargeDataset(): Generator
+{
+    $handle = fopen($this->largeFile, 'r');
+
+    while (($line = fgets($handle)) !== false) {
+        yield $this->processLine($line);
+    }
+
+    fclose($handle);
+}
+```
+
+## Spezifische Optimierungen
+
+### Datenbankzugriffe
+
+- Anzahl der Datenbankabfragen minimieren
+- Indizes für häufige Abfragen
+- N+1 Problem vermeiden durch Eager Loading
+- Datenbankverbindungen poolen
+
+### HTTP-Anfragen
+
+- Statische Assets komprimieren und cachen
+- HTTP/2 nutzen, wenn möglich
+- Content-Kompression aktivieren
+- Browser-Caching durch geeignete Header
+
+### Speichernutzung
+
+- Große Objekte nach Gebrauch freigeben (`unset()`)
+- Zirkuläre Referenzen vermeiden
+- Bei Dateiberarbeitung auf Streaming-Ansätze setzen
+
+### Autoloading
+
+- Composer-Autoloader in Produktionsumgebung optimieren
+- Preloading für häufig verwendete Klassen nutzen
+
+```php
+// preload.php Beispiel
+<?php
+
+declare(strict_types=1);
+
+// Häufig verwendete Klassen vorladen
+require_once __DIR__ . '/Framework/Core/Application.php';
+require_once __DIR__ . '/Framework/DI/Container.php';
+require_once __DIR__ . '/Framework/Http/Request.php';
+require_once __DIR__ . '/Framework/Http/Response.php';
+```
+
+## Monitoring und Profiling
+
+### Performance messen
+
+- Kritische Code-Pfade instrumentieren
+- End-to-End Zeitmessungen durchführen
+
+```php
+// Beispiel: Performance-Messung
+$startTime = microtime(true);
+
+// Operation durchführen
+$result = $this->performOperation();
+
+$duration = microtime(true) - $startTime;
+$this->logger->debug("Operation ausgeführt in {$duration}s");
+```
+
+### Automatisiertes Monitoring
+
+- Performance-Regressions automatisch erkennen
+- Regelmäßige Lasttests durchführen
+- Kritische Pfade überwachen
+
+## Umgebungsspezifische Optimierungen
+
+### Entwicklung
+
+- Debug-Tools aktivieren
+- Performance-Optimierungen deaktivieren, die Debugging erschweren
+
+### Produktion
+
+- Opcache aktivieren und optimieren
+- Fehlerbehandlung optimieren (keine Stack Traces)
+- Logging auf nötige Informationen beschränken
+
+```php
+// Umgebungsspezifische Einstellungen
+if ($environment === 'production') {
+    ini_set('opcache.validate_timestamps', 0);
+    ini_set('display_errors', 0);
+    error_reporting(E_ERROR | E_WARNING | E_PARSE);
+} else {
+    ini_set('opcache.validate_timestamps', 1);
+    ini_set('display_errors', 1);
+    error_reporting(E_ALL);
+}
+```
--- a/backups/docs-backup-20250731125004/guidelines/TESTING-GUIDELINES.md
+++ b/backups/docs-backup-20250731125004/guidelines/TESTING-GUIDELINES.md
@@ -0,0 +1,181 @@
+# Testing-Richtlinien
+
+## Übersicht
+
+Diese Richtlinien beschreiben die Standards und Best Practices für Tests im Framework.
+
+## Grundprinzipien
+
+### 1. Testarten
+
+- **Unit Tests**: Testen einzelner Komponenten isoliert
+- **Integrationstests**: Testen des Zusammenspiels mehrerer Komponenten
+- **Funktionstests**: Testen ganzer Funktionalitäten aus Benutzersicht
+
+### 2. Pest-Framework
+
+Alle Tests werden mit dem Pest-Framework geschrieben:
+
+```php
+test('Analytics::track zeichnet Events korrekt auf', function () {
+    // Arrange
+    $manager = new AnalyticsManager(['enabled' => true], new InMemoryStorage());
+    $analytics = new Analytics($manager, new EventDispatcher());
+
+    // Act
+    $analytics->track('test_event', ['key' => 'value']);
+
+    // Assert
+    expect($manager->getStorage()->retrieve())->toHaveCount(1);
+    expect($manager->getStorage()->retrieve()[0]['event'])->toBe('test_event');
+});
+```
+
+### 3. Teststruktur
+
+- Jeder Test folgt dem AAA-Prinzip: Arrange, Act, Assert
+- Tests sollten unabhängig voneinander sein
+- Tests sollten deterministisch sein (keine zufälligen Ergebnisse)
+
+## Best Practices
+
+### 1. Testabdeckung
+
+- Jede öffentliche Methode sollte getestet werden
+- Edge Cases und Fehlersituationen explizit testen
+- Fokus auf Business-Logik und kritische Pfade
+
+### 2. Mocking
+
+- Externe Abhängigkeiten mocken
+- Eigene Test-Implementierungen für Interfaces erstellen
+- Mock-Objekte nur für die spezifischen Testfälle konfigurieren
+
+```php
+// Beispiel: Test mit Mock
+test('Fehlerbehandlung bei Storage-Ausfall', function () {
+    // Arrange
+    $storage = new class implements StorageInterface {
+        public function store(array $events): void
+        {
+            throw new \RuntimeException('Storage-Fehler');
+        }
+
+        public function retrieve(array $filters = []): array
+        {
+            return [];
+        }
+
+        public function clear(): void
+        {
+        }
+    };
+
+    $manager = new AnalyticsManager(['enabled' => true], $storage);
+
+    // Act & Assert
+    expect(fn() => $manager->flush())->toThrow(\RuntimeException::class);
+});
+```
+
+### 3. Fixtures und Factories
+
+- Testdaten mit Factories erstellen
+- Komplexe Objekte über Helpers aufbauen
+- Wiederverwendbare Fixtures für ähnliche Tests
+
+```php
+// Beispiel: Test-Factory
+function createAnalyticsManager(array $config = []): AnalyticsManager
+{
+    $defaultConfig = ['enabled' => true, 'auto_flush' => false];
+    return new AnalyticsManager(
+        array_merge($defaultConfig, $config),
+        new InMemoryStorage()
+    );
+}
+
+test('Auto-Flush funktioniert korrekt', function () {
+    // Arrange
+    $manager = createAnalyticsManager(['auto_flush' => true, 'batch_size' => 2]);
+
+    // Act
+    $manager->track('event1', []);
+    $manager->track('event2', []);
+
+    // Assert
+    expect($manager->getStorage()->retrieve())->toHaveCount(2);
+});
+```
+
+### 4. Datenbankzugriffe
+
+- In Unit-Tests Datenbankzugriffe vermeiden oder mocken
+- In Integrationstests separate Testdatenbank verwenden
+- Testdatenbank nach Tests zurücksetzen
+
+### 5. Asynchrone Tests
+
+- Timeouts für asynchrone Tests setzen
+- Auf Async-Events warten, statt feste Wartezeiten
+
+## Testorganisation
+
+### 1. Dateistruktur
+
+- Tests in `/tests`-Verzeichnis mit gleicher Struktur wie `/src`
+- Dateinamen mit `Test`-Suffix
+
+### 2. Testgruppen
+
+- Tests mit Attributen in Gruppen einteilen
+- Langsame Tests markieren
+
+```php
+#[Group('analytics')]
+#[Group('slow')]
+test('große Datenmenge verarbeiten', function () {
+    // Test mit vielen Daten
+});
+```
+
+## CI/CD-Integration
+
+- Tests in CI-Pipeline automatisiert ausführen
+- Testabdeckung messen und überwachen
+- Pull Requests nur mit erfolgreichen Tests mergen
+
+## Fehlersuche
+
+### 1. Debugging-Techniken
+
+- Pest-Debugging aktivieren mit `->dump()`
+- PHPUnit-Assertions für detaillierte Fehlermeldungen
+
+```php
+test('komplexes Objekt validieren', function () {
+    $result = processData();
+
+    // Bei Fehlern Kontext ausgeben
+    if (!expect($result->isValid())->toBeTrue()->isSuccess()) {
+        dump($result->getErrors());
+    }
+});
+```
+
+### 2. Problematische Tests
+
+- Flaky Tests identifizieren und beheben
+- Tests isolieren mit `only` oder `skip`
+
+```php
+test('problematischer Test', function () {
+    // Test-Code
+})->skip('Wird untersucht');
+```
+
+## Zusammenfassung
+
+- Tests sind ein integraler Bestandteil der Codebase
+- Qualität und Wartbarkeit der Tests sind genauso wichtig wie die des Produktionscodes
+- Tests dienen als lebende Dokumentation der Funktionalität
--- a/backups/docs-backup-20250731125004/guidelines/index.md
+++ b/backups/docs-backup-20250731125004/guidelines/index.md
@@ -0,0 +1,43 @@
+# Entwicklungsrichtlinien
+
+## Übersicht
+
+Diese Richtlinien bieten Best Practices und Standards für die Entwicklung innerhalb des Projekts. Sie helfen, qualitativ hochwertigen, wartbaren und leistungsfähigen Code zu schreiben.
+
+## Verfügbare Richtlinien
+
+- [Performance-Richtlinien](/guidelines/PERFORMANCE-GUIDELINES.md) - Optimierung der Anwendungsleistung
+- [Testing-Richtlinien](/guidelines/TESTING-GUIDELINES.md) - Standards und Best Practices für Tests
+
+## Performance-Optimierung
+
+Leistungsoptimierung ist ein wichtiger Aspekt der Anwendungsentwicklung. Die [Performance-Richtlinien](/guidelines/PERFORMANCE-GUIDELINES.md) bieten Einblicke in:
+
+- Strategisches Caching
+- Lazy Loading
+- Optimierung von Datenbankabfragen
+- Effiziente Datenstrukturen
+- Speichernutzung
+
+## Teststrategien
+
+Testen ist ein integraler Bestandteil des Entwicklungsprozesses. Die [Testing-Richtlinien](/guidelines/TESTING-GUIDELINES.md) decken folgende Themen ab:
+
+- Unit Tests mit Pest-Framework
+- Integrationstests
+- Test-Fixtures und Factories
+- Mocking-Strategien
+- Testorganisation und -struktur
+
+## Anwendung der Richtlinien
+
+Diese Richtlinien sollten in allen Phasen der Entwicklung berücksichtigt werden:
+
+1. **Planungsphase**: Frühzeitige Berücksichtigung von Performance und Testbarkeit
+2. **Implementierungsphase**: Anwendung der Best Practices während der Entwicklung
+3. **Review-Phase**: Überprüfung des Codes anhand der Richtlinien
+4. **Refactoring**: Verbesserung bestehenden Codes gemäß den Richtlinien
+
+## Continuous Improvement
+
+Diese Richtlinien werden kontinuierlich verbessert und aktualisiert. Wenn Sie Vorschläge zur Verbesserung haben, zögern Sie nicht, diese einzubringen.