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
This commit is contained in:
@@ -1,14 +0,0 @@
|
||||
# Analytics-Framework
|
||||
|
||||
> **Dokumentationshinweis:** Die vollständige Dokumentation für das Analytics-Framework finden Sie im Ordner [/docs/framework/analytics](/docs/framework/analytics/).
|
||||
|
||||
## Schnellzugriff
|
||||
|
||||
- [Übersicht und Einstieg](/docs/framework/analytics/index.md)
|
||||
- [Detaillierte Architektur](/docs/framework/analytics/architecture.md)
|
||||
- [Anwendungsbeispiele](/docs/framework/analytics/usage.md)
|
||||
- [Migrationsleitfaden](/docs/framework/analytics/migration.md)
|
||||
|
||||
## Implementierungsdetails
|
||||
|
||||
Die Code-Dokumentation befindet sich in der [README-Datei des Frameworks](/Framework/Analytics1/README.md).
|
||||
@@ -1,200 +0,0 @@
|
||||
# Erweiterungsmuster im Framework
|
||||
|
||||
## Übersicht
|
||||
|
||||
Dieses Dokument beschreibt die verschiedenen Muster und Techniken, um das Framework zu erweitern oder anzupassen, ohne den Kern-Code zu verändern.
|
||||
|
||||
## Event-basierte Erweiterungen
|
||||
|
||||
### Event-Listener
|
||||
|
||||
Die primäre Methode zur Erweiterung des Frameworks ist das Lauschen auf System-Events:
|
||||
|
||||
```php
|
||||
// Event-Listener registrieren
|
||||
public function __construct(private readonly EventDispatcher $eventDispatcher)
|
||||
{
|
||||
$this->eventDispatcher->addHandler(
|
||||
'App\Framework\Core\Events\ApplicationBooted',
|
||||
[$this, 'onApplicationBooted']
|
||||
);
|
||||
}
|
||||
|
||||
// Event-Handler-Methode
|
||||
public function onApplicationBooted(ApplicationBooted $event): void
|
||||
{
|
||||
// Erweiterungslogik implementieren
|
||||
}
|
||||
```
|
||||
|
||||
### Eigene Events
|
||||
|
||||
Benutzerdefinierte Events erstellen:
|
||||
|
||||
```php
|
||||
final readonly class UserRegistered
|
||||
{
|
||||
public function __construct(
|
||||
public string $userId,
|
||||
public string $email,
|
||||
public \DateTimeImmutable $timestamp
|
||||
) {}
|
||||
}
|
||||
|
||||
// Event auslösen
|
||||
$this->eventDispatcher->dispatch(new UserRegistered(
|
||||
$user->getId(),
|
||||
$user->getEmail(),
|
||||
new \DateTimeImmutable()
|
||||
));
|
||||
```
|
||||
|
||||
## Middleware
|
||||
|
||||
HTTP-Anfragen können durch Middleware-Klassen erweitert werden:
|
||||
|
||||
```php
|
||||
final readonly class CustomMiddleware implements Middleware
|
||||
{
|
||||
public function process(Request $request, callable $next): Response
|
||||
{
|
||||
// Vor der Anfrageverarbeitung
|
||||
$modifiedRequest = $this->modifyRequest($request);
|
||||
|
||||
// Anfrage weiterleiten
|
||||
$response = $next($modifiedRequest);
|
||||
|
||||
// Nach der Anfrageverarbeitung
|
||||
return $this->modifyResponse($response);
|
||||
}
|
||||
}
|
||||
|
||||
// Middleware registrieren
|
||||
$app->addMiddleware(CustomMiddleware::class);
|
||||
```
|
||||
|
||||
## Service-Erweiterungen
|
||||
|
||||
### Service-Ersetzen
|
||||
|
||||
Standardimplementierungen durch eigene ersetzen:
|
||||
|
||||
```php
|
||||
#[Initializer]
|
||||
final readonly class CustomStorageInitializer
|
||||
{
|
||||
public function __invoke(Container $container): StorageInterface
|
||||
{
|
||||
return new CustomStorage();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Service-Decorator
|
||||
|
||||
Bestehende Services erweitern ohne Änderung der Original-Implementierung:
|
||||
|
||||
```php
|
||||
#[Initializer]
|
||||
final readonly class LoggingAnalyticsInitializer
|
||||
{
|
||||
public function __construct(
|
||||
private readonly Configuration $config,
|
||||
private readonly LoggerInterface $logger
|
||||
) {}
|
||||
|
||||
public function __invoke(Container $container): Analytics
|
||||
{
|
||||
// Original-Analytics-Service erstellen
|
||||
$originalAnalytics = new Analytics(
|
||||
new AnalyticsManager($this->config->get('analytics'), new FileStorage($path)),
|
||||
$container->get(EventDispatcher::class)
|
||||
);
|
||||
|
||||
// Mit Logging-Decorator umhüllen
|
||||
return new LoggingAnalyticsDecorator($originalAnalytics, $this->logger);
|
||||
}
|
||||
}
|
||||
|
||||
// Decorator-Implementierung
|
||||
final readonly class LoggingAnalyticsDecorator implements AnalyticsInterface
|
||||
{
|
||||
public function __construct(
|
||||
private Analytics $analytics,
|
||||
private LoggerInterface $logger
|
||||
) {}
|
||||
|
||||
public function track(string $event, array $properties = [], ?string $userId = null): void
|
||||
{
|
||||
$this->logger->debug("Tracking event: {$event}", [
|
||||
'properties' => $properties,
|
||||
'user_id' => $userId
|
||||
]);
|
||||
|
||||
$this->analytics->track($event, $properties, $userId);
|
||||
}
|
||||
|
||||
// Andere Methoden implementieren
|
||||
}
|
||||
```
|
||||
|
||||
## Plugin-System
|
||||
|
||||
### Plugin-Interface
|
||||
|
||||
```php
|
||||
interface PluginInterface
|
||||
{
|
||||
public function register(Application $app): void;
|
||||
public function boot(Application $app): void;
|
||||
}
|
||||
|
||||
// Plugin-Implementierung
|
||||
final readonly class CustomPlugin implements PluginInterface
|
||||
{
|
||||
public function register(Application $app): void
|
||||
{
|
||||
// Services registrieren
|
||||
}
|
||||
|
||||
public function boot(Application $app): void
|
||||
{
|
||||
// Nach Initialisierung der Anwendung
|
||||
}
|
||||
}
|
||||
|
||||
// Plugin registrieren
|
||||
$app->registerPlugin(new CustomPlugin());
|
||||
```
|
||||
|
||||
## Konfigurationserweiterungen
|
||||
|
||||
### Konfigurationsquellen
|
||||
|
||||
Benutzerdefinierte Konfigurationsquellen implementieren:
|
||||
|
||||
```php
|
||||
final readonly class EnvironmentConfigSource implements ConfigSourceInterface
|
||||
{
|
||||
public function load(string $key, mixed $default = null): mixed
|
||||
{
|
||||
$envKey = strtoupper(str_replace('.', '_', $key));
|
||||
return $_ENV[$envKey] ?? $default;
|
||||
}
|
||||
}
|
||||
|
||||
// Konfigurationsquelle registrieren
|
||||
$config->addSource(new EnvironmentConfigSource());
|
||||
```
|
||||
|
||||
## Zusammenfassung
|
||||
|
||||
Die bevorzugten Erweiterungsmuster sind:
|
||||
|
||||
1. **Event-Listener** für reaktive Erweiterungen
|
||||
2. **Middleware** für HTTP-Anfrageverarbeitung
|
||||
3. **Service-Initializer** zum Ersetzen oder Dekorieren von Services
|
||||
4. **Plugins** für umfassendere Funktionalitätserweiterungen
|
||||
5. **Konfigurationsquellen** für benutzerdefinierte Konfigurationen
|
||||
|
||||
Diese Muster ermöglichen es, das Framework zu erweitern, ohne den Kern zu modifizieren, was zu einer besseren Wartbarkeit und einfacheren Updates führt.
|
||||
@@ -1,73 +0,0 @@
|
||||
# Framework-Modul Checkliste
|
||||
|
||||
## Übersicht
|
||||
|
||||
Diese Checkliste dient als Leitfaden für die Erstellung neuer Module im Framework. Sie hilft sicherzustellen, dass alle Module den Projektstandards entsprechen und konsistent implementiert werden.
|
||||
|
||||
## Strukturelle Anforderungen
|
||||
|
||||
- [ ] Modul in eigenem Verzeichnis unter `/src/Framework/`
|
||||
- [ ] Konsistente Namensgebung im PascalCase (z.B. `CacheManager` statt `Cache_manager`)
|
||||
- [ ] README.md mit Modul-Dokumentation
|
||||
- [ ] Interface(s) für öffentliche API
|
||||
- [ ] Implementierungsklassen als `final readonly`
|
||||
- [ ] Initializer-Klasse mit `#[Initializer]`-Attribut
|
||||
|
||||
## Abhängigkeiten
|
||||
|
||||
- [ ] Minimale externe Abhängigkeiten (idealerweise keine)
|
||||
- [ ] Klar definierte Abhängigkeiten zu anderen Framework-Modulen
|
||||
- [ ] Keine zirkulären Abhängigkeiten
|
||||
- [ ] Verwendung des DI-Containers für Abhängigkeiten
|
||||
|
||||
## Konfiguration
|
||||
|
||||
- [ ] Konfigurationsdatei unter `/src/Config/{modul-name}.php`
|
||||
- [ ] Standardkonfiguration in der Initializer-Klasse
|
||||
- [ ] Dokumentierte Konfigurationsoptionen
|
||||
|
||||
## Code-Qualität
|
||||
|
||||
- [ ] Vollständige Typisierung (Parameter, Rückgabewerte, Properties)
|
||||
- [ ] PHPDoc für öffentliche Methoden und Klassen
|
||||
- [ ] Keine abstrakten Klassen oder Vererbung (außer Interfaces)
|
||||
- [ ] Immutable Objekte wo möglich
|
||||
- [ ] Spezifische Exceptions für Fehlerbehandlung
|
||||
|
||||
## Tests
|
||||
|
||||
- [ ] Unit-Tests mit Pest für alle öffentlichen Methoden
|
||||
- [ ] Integrationstests für Modul-Interaktionen
|
||||
- [ ] Testabdeckung für Fehlerfälle
|
||||
|
||||
## Integration
|
||||
|
||||
- [ ] Event-Listener für relevante System-Events
|
||||
- [ ] Erweiterungspunkte für andere Module
|
||||
- [ ] Keine direkten Abhängigkeiten zu Domain-Klassen
|
||||
|
||||
## Dokumentation
|
||||
|
||||
- [ ] Beispiele für Verwendung
|
||||
- [ ] Architektur-Beschreibung
|
||||
- [ ] API-Dokumentation
|
||||
- [ ] Konfigurationsreferenz
|
||||
|
||||
## Performance
|
||||
|
||||
- [ ] Lazy-Loading für ressourcenintensive Operationen
|
||||
- [ ] Caching-Strategie (falls relevant)
|
||||
- [ ] Performancekritische Teile identifiziert und optimiert
|
||||
|
||||
## Sicherheit
|
||||
|
||||
- [ ] Validierung aller externen Eingaben
|
||||
- [ ] Keine sensiblen Daten in Logs
|
||||
- [ ] Schutz vor bekannten Sicherheitslücken
|
||||
|
||||
## Wartbarkeit
|
||||
|
||||
- [ ] Kleine, fokussierte Klassen
|
||||
- [ ] Klare Trennung von Verantwortlichkeiten
|
||||
- [ ] Konsistente Fehlerbehandlung
|
||||
- [ ] Logging an strategischen Stellen
|
||||
@@ -1,158 +0,0 @@
|
||||
# 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));
|
||||
}
|
||||
}
|
||||
```
|
||||
@@ -1,102 +0,0 @@
|
||||
# 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
|
||||
@@ -1,114 +0,0 @@
|
||||
# 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)
|
||||
@@ -1,160 +0,0 @@
|
||||
# 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.
|
||||
@@ -1,269 +0,0 @@
|
||||
# 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);
|
||||
}
|
||||
}
|
||||
```
|
||||
@@ -1,45 +0,0 @@
|
||||
# Core-Modul Dokumentation
|
||||
|
||||
## Übersicht
|
||||
|
||||
Das Core-Modul bildet das Herzstück des Frameworks und stellt grundlegende Funktionalitäten bereit, die von anderen Modulen genutzt werden.
|
||||
|
||||
## Hauptkomponenten
|
||||
|
||||
### Events und EventDispatcher
|
||||
|
||||
Das Event-System ermöglicht die Kommunikation zwischen Komponenten über einen zentralen Event-Bus.
|
||||
|
||||
**Kernklassen:**
|
||||
- `EventDispatcher`: Zentraler Service zum Registrieren und Auslösen von Events
|
||||
- Bekannte Events:
|
||||
- `ApplicationBooted`
|
||||
- `ErrorOccurred`
|
||||
- `BeforeHandleRequest`
|
||||
- `AfterHandleRequest`
|
||||
|
||||
**Beispielverwendung:**
|
||||
```php
|
||||
// Event-Handler registrieren
|
||||
$eventDispatcher->addHandler('App\Framework\Core\Events\ApplicationBooted', function($event) {
|
||||
// Event verarbeiten
|
||||
});
|
||||
```
|
||||
|
||||
### PathProvider
|
||||
|
||||
Stellt Pfadinformationen für verschiedene Bereiche der Anwendung bereit.
|
||||
|
||||
**Hauptfunktionen:**
|
||||
- `getDataPath()`: Liefert Pfade zu Datenverzeichnissen
|
||||
|
||||
## Integration mit anderen Modulen
|
||||
|
||||
Das Core-Modul wird von vielen anderen Modulen verwendet, wie z.B.:
|
||||
|
||||
- **Analytics-Modul**: Nutzt den EventDispatcher zum Tracking von Systemereignissen
|
||||
- **DI-Container**: Nutzt Core-Komponenten für die Initialisierung von Services
|
||||
|
||||
## Architektur
|
||||
|
||||
Das Core-Modul folgt einer ereignisgesteuerten Architektur, bei der Komponenten über Events miteinander kommunizieren können, anstatt direkte Abhängigkeiten zu haben.
|
||||
@@ -1,89 +0,0 @@
|
||||
# Dependency Injection Modul
|
||||
|
||||
## Übersicht
|
||||
|
||||
Das DI-Modul implementiert ein Dependency-Injection-Container-System, das die automatische Auflösung und Verwaltung von Abhängigkeiten ermöglicht.
|
||||
|
||||
## Hauptkomponenten
|
||||
|
||||
### Container
|
||||
|
||||
Der zentrale Service-Container, der Instanzen erstellt und verwaltet.
|
||||
|
||||
**Hauptfunktionen:**
|
||||
- Service-Erstellung und -Auflösung
|
||||
- Singleton-Verwaltung
|
||||
- Rekursive Abhängigkeitsauflösung
|
||||
|
||||
### Initializer-Attribut
|
||||
|
||||
Das `#[Initializer]`-Attribut kennzeichnet Klassen, die Services im Container registrieren können.
|
||||
|
||||
**Beispiel:**
|
||||
```php
|
||||
#[Initializer]
|
||||
readonly class AnalyticsInitializer
|
||||
{
|
||||
public function __invoke(Container $container): Analytics
|
||||
{
|
||||
// Service erstellen und konfigurieren
|
||||
return $analytics;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Verwendung
|
||||
|
||||
### Service definieren
|
||||
|
||||
```php
|
||||
// Service-Interface
|
||||
interface MyServiceInterface
|
||||
{
|
||||
public function doSomething(): void;
|
||||
}
|
||||
|
||||
// Konkrete Implementierung
|
||||
class MyService implements MyServiceInterface
|
||||
{
|
||||
public function doSomething(): void
|
||||
{
|
||||
// Implementierung
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Service registrieren
|
||||
|
||||
```php
|
||||
#[Initializer]
|
||||
class MyServiceInitializer
|
||||
{
|
||||
public function __invoke(Container $container): MyServiceInterface
|
||||
{
|
||||
return new MyService();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Service verwenden
|
||||
|
||||
```php
|
||||
class MyController
|
||||
{
|
||||
public function __construct(
|
||||
private readonly MyServiceInterface $myService
|
||||
) {}
|
||||
|
||||
public function action(): void
|
||||
{
|
||||
$this->myService->doSomething();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Prinzipien
|
||||
|
||||
- **Automatische Auflösung**: Abhängigkeiten werden anhand von Typ-Hints automatisch aufgelöst
|
||||
- **Lazy Loading**: Services werden erst erstellt, wenn sie benötigt werden
|
||||
- **Singleton-Modus**: Standardmäßig werden Services als Singletons verwaltet
|
||||
@@ -1,92 +0,0 @@
|
||||
# HTTP-Modul Dokumentation
|
||||
|
||||
## Übersicht
|
||||
|
||||
Das HTTP-Modul stellt Komponenten für die Verarbeitung von HTTP-Anfragen und -Antworten bereit.
|
||||
|
||||
## Hauptkomponenten
|
||||
|
||||
### Request
|
||||
|
||||
Repräsentiert eine HTTP-Anfrage mit Methoden zum Zugriff auf:
|
||||
- HTTP-Methode (`getMethod()`)
|
||||
- Pfad (`getPath()`)
|
||||
- Query-Parameter (`getQueryParams()`)
|
||||
- Request-Body
|
||||
- Headers
|
||||
|
||||
### Response
|
||||
|
||||
Repräsentiert eine HTTP-Antwort mit:
|
||||
- Status-Code (`getStatusCode()`)
|
||||
- Headers
|
||||
- Body
|
||||
|
||||
### Middleware
|
||||
|
||||
Ein Interface für HTTP-Middleware-Komponenten, die die Request-Verarbeitung verändern können:
|
||||
|
||||
```php
|
||||
interface Middleware
|
||||
{
|
||||
public function process(Request $request, callable $next): Response;
|
||||
}
|
||||
```
|
||||
|
||||
**Beispiel-Middleware:**
|
||||
```php
|
||||
class AnalyticsMiddleware implements Middleware
|
||||
{
|
||||
public function __construct(
|
||||
private readonly Analytics $analytics
|
||||
) {}
|
||||
|
||||
public function process(Request $request, callable $next): Response
|
||||
{
|
||||
// Request tracken
|
||||
$this->analytics->track('http_request', [
|
||||
'method' => $request->getMethod(),
|
||||
'path' => $request->getPath(),
|
||||
]);
|
||||
|
||||
// Request weiterleiten
|
||||
$response = $next($request);
|
||||
|
||||
// Response tracken
|
||||
$this->analytics->track('http_response', [
|
||||
'status_code' => $response->getStatusCode(),
|
||||
]);
|
||||
|
||||
return $response;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Integration mit anderen Modulen
|
||||
|
||||
- **Router**: Routing von HTTP-Requests zu Controllers
|
||||
- **Analytics**: Tracking von HTTP-Requests und -Responses
|
||||
- **Validation**: Validierung von Request-Daten
|
||||
|
||||
## Middlewares registrieren
|
||||
|
||||
In der Anwendungsklasse:
|
||||
|
||||
```php
|
||||
$this->addMiddleware(LoggingMiddleware::class);
|
||||
$this->addMiddleware(AnalyticsMiddleware::class);
|
||||
$this->addMiddleware(AuthenticationMiddleware::class);
|
||||
```
|
||||
|
||||
## Responses erzeugen
|
||||
|
||||
```php
|
||||
// JSON-Response
|
||||
return new JsonResponse(['success' => true]);
|
||||
|
||||
// HTML-Response
|
||||
return new HtmlResponse('<html><body>Hello World</body></html>');
|
||||
|
||||
// Redirect
|
||||
return new RedirectResponse('/dashboard');
|
||||
```
|
||||
@@ -1,42 +0,0 @@
|
||||
# Framework-Dokumentation
|
||||
|
||||
## Übersicht
|
||||
|
||||
Diese Dokumentation beschreibt die Architektur, Komponenten und Verwendung des Framework-Kerns des Projekts.
|
||||
|
||||
## Hauptmodule
|
||||
|
||||
- [Analytics](/framework/analytics/README.md) - System zur Erfassung und Analyse von Anwendungsdaten
|
||||
- [Core](/framework/core/README.md) - Kernkomponenten und Event-System
|
||||
- [DI (Dependency Injection)](/framework/di/README.md) - Container und Service-Management
|
||||
- [HTTP](/framework/http/README.md) - HTTP-Request/Response-Handling
|
||||
|
||||
## Richtlinien und Muster
|
||||
|
||||
- [Modul-Checkliste](/framework/MODUL-CHECKLISTE.md) - Leitfaden für die Erstellung neuer Module
|
||||
- [Erweiterungsmuster](/framework/ERWEITERUNGSPATTERN.md) - Muster zur Erweiterung des Frameworks
|
||||
|
||||
## Modulare Architektur
|
||||
|
||||
Das Framework ist modular aufgebaut, mit klaren Verantwortlichkeiten für jedes Modul. Module kommunizieren über klar definierte Interfaces und den Event-Dispatcher.
|
||||
|
||||
### Neues Modul erstellen
|
||||
|
||||
Um ein neues Modul zu erstellen, folgen Sie der [Modul-Checkliste](/framework/MODUL-CHECKLISTE.md) und beachten Sie die folgenden Kernprinzipien:
|
||||
|
||||
1. Klare Verantwortlichkeiten definieren
|
||||
2. Dependency Injection verwenden
|
||||
3. Interface-basiertes Design umsetzen
|
||||
4. Event-basierte Kommunikation nutzen
|
||||
5. Externe Abhängigkeiten minimieren
|
||||
|
||||
### Framework erweitern
|
||||
|
||||
Es gibt verschiedene Möglichkeiten, das Framework zu erweitern:
|
||||
|
||||
1. **Middleware**: HTTP-Request-Pipeline erweitern
|
||||
2. **Event-Listener**: Auf System-Events reagieren
|
||||
3. **Service-Provider**: Eigene Services registrieren
|
||||
4. **Plugin-System**: Umfangreichere Erweiterungen implementieren
|
||||
|
||||
Weitere Details finden Sie im Dokument [Erweiterungsmuster](/framework/ERWEITERUNGSPATTERN.md).
|
||||
Reference in New Issue
Block a user