technik: Aufrufe über ein Ereignis-Log zählen statt im Request

Bisher lief pro Seitenaufruf ein UPDATE press_releases SET hits = hits + 1 im
Request. Auf der über 1 GB großen Tabelle blockiert dieser Schreibzugriff,
sobald dort eine Schemaänderung läuft — die wartenden Requests belegten dabei
PHP-FPM-Worker und DB-Verbindungen, bis die ganze Seite stand.

Der Request schreibt jetzt nur noch in die kleine Append-Tabelle
press_release_events, und selbst dabei wird jeder Fehler geschluckt und
gemeldet: Ein Aufruf-Zähler darf eine Seite niemals langsamer oder kaputt
machen. Die Summierung in press_releases.hits übernimmt gebündelt der
Scheduler.

Der Fortschritt läuft über eine Wasserstandsmarke (höchste bereits verbuchte
Event-ID) statt über einen Zwischenspeicher, damit bei einem Neustart kein
Aufruf verloren geht. Zähler und Marke werden je Durchgang gemeinsam
committet — sonst wäre nur der Durchgang wiederanlaufsicher, nicht der Abbruch
darin, und der nächste Lauf verbuchte dieselben Aufrufe doppelt. Eine Migration
setzt die Marke beim Deploy auf den Ist-Stand; ohne sie würde der erste Lauf
den gesamten Altbestand ein zweites Mal aufaddieren.

Weil das Log damit mit dem Traffic wächst und als einzige Log-Tabelle des
Systems keine Bereinigung hatte, begrenzt press-releases:purge-events es auf
einen Aufbewahrungszeitraum (Default 395 Tage = 13 Monate, damit der
Vorjahresmonats-Vergleich möglich bleibt). Gelöscht wird ausschließlich
unterhalb der Wasserstandsmarke — alles darüber ist noch nicht in hits verbucht
und wäre sonst dauerhaft verloren. Fehlt die Marke, bricht der Lauf ab, statt
zu raten.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

app/Console/Commands/AggregatePressReleaseViews.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Enums\PressReleaseEventType;
+use App\Models\AppSetting;
+use App\Models\PressRelease;
+use App\Models\PressReleaseEvent;
+use App\Scopes\PortalScope;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\DB;
+
+/**
+ * Schreibt die gezählten Aufrufe aus dem Ereignis-Log in den Gesamtzähler
+ * `press_releases.hits`.
+ *
+ * Hintergrund: Früher lief pro Seitenaufruf ein `UPDATE press_releases SET
+ * hits = hits + 1` im Request. Auf der über 1 GB großen Tabelle blockiert
+ * dieser Schreibzugriff, sobald eine Schemaänderung läuft (FULLTEXT-Indizes
+ * erzwingen dort einen COPY-Rebuild) — die wartenden Requests haben dann
+ * PHP-FPM-Worker und MySQL-Verbindungen belegt, bis die ganze Seite stand.
+ * Der Request schreibt jetzt nur noch das Ereignis in die kleine Log-Tabelle;
+ * die Summierung passiert hier gebündelt.
+ *
+ * Fortschritt läuft über eine Wasserstandsmarke (höchste bereits verarbeitete
+ * Event-ID) statt über einen Zwischenspeicher: Das Log ist die dauerhafte
+ * Quelle, dadurch geht bei einem Neustart kein Aufruf verloren und ein
+ * doppelter Lauf zählt nichts doppelt. Zähler und Marke werden je Durchgang
+ * gemeinsam committet — sonst wäre nur der Durchgang selbst, nicht der
+ * einzelne Abbruch darin, wiederanlaufsicher.
+ */
+class AggregatePressReleaseViews extends Command
+{
+    protected $signature = 'press-releases:aggregate-views {--chunk=5000 : Ereignisse je Durchgang}';
+
+    protected $description = 'Überträgt gezählte Aufrufe aus dem Ereignis-Log in press_releases.hits.';
+
+    /**
+     * Wasserstandsmarke: höchste bereits in `hits` verbuchte Event-ID.
+     */
+    public const WatermarkKey = 'press_release_views.aggregated_through_id';
+
+    public function handle(): int
+    {
+        $chunk = max(100, (int) $this->option('chunk'));
+        $watermark = AppSetting::getValue(self::WatermarkKey);
+
+        // Fehlende Marke heißt: noch nie initialisiert. Sie jetzt als 0 zu
+        // lesen wäre fatal — `press_releases.hits` enthält den Bestand bereits,
+        // ein Lauf ab 0 würde jedes Alt-Ereignis ein zweites Mal aufaddieren.
+        // Das kann im Deploy-Fenster passieren, wenn der Scheduler den neuen
+        // Task startet, bevor die Migration gelaufen ist. Also setzen wir die
+        // Marke auf den Ist-Stand und zählen erst ab dem nächsten Aufruf.
+        if ($watermark === null) {
+            $latest = (int) PressReleaseEvent::query()->max('id');
+            AppSetting::setValue(self::WatermarkKey, $latest);
+
+            $this->info("Wasserstandsmarke erstmalig auf Event-ID {$latest} gesetzt — der Bestand steckt bereits in `hits`.");
+
+            return self::SUCCESS;
+        }
+
+        $watermark = (int) $watermark;
+
+        $totalEvents = 0;
+        $totalReleases = 0;
+
+        while (true) {
+            // Obergrenze des Durchgangs zuerst festlegen, damit gleichzeitig
+            // eintreffende Aufrufe die Summe nicht gegen die Marke verschieben.
+            // Bewusst über die IDs statt über max(): eine Aggregatfunktion
+            // ignoriert das limit und lieferte die Marke des GESAMTEN Rests.
+            $ids = PressReleaseEvent::query()
+                ->where('id', '>', $watermark)
+                ->orderBy('id')
+                ->limit($chunk)
+                ->pluck('id');
+
+            if ($ids->isEmpty()) {
+                break;
+            }
+
+            $upperBound = (int) $ids->last();
+
+            $counts = PressReleaseEvent::query()
+                ->where('id', '>', $watermark)
+                ->where('id', '<=', $upperBound)
+                ->where('type', PressReleaseEventType::View->value)
+                ->selectRaw('press_release_id, count(*) as views')
+                ->groupBy('press_release_id')
+                ->pluck('views', 'press_release_id');
+
+            // Zähler und Marke gehören in EINE Transaktion. Ohne sie wäre der
+            // Lauf nur zwischen den Durchgängen wiederanlaufsicher: Bricht der
+            // Prozess mitten im Chunk ab (OOM, Deploy, kill), sind ein Teil der
+            // Zähler schon erhöht, die Marke steht aber noch auf dem alten
+            // Stand — der nächste Lauf verbuchte genau diese Aufrufe ein
+            // zweites Mal.
+            DB::transaction(function () use ($counts, $upperBound, &$totalEvents, &$totalReleases): void {
+                foreach ($counts as $pressReleaseId => $views) {
+                    PressRelease::query()
+                        ->withoutGlobalScope(PortalScope::class)
+                        ->whereKey((int) $pressReleaseId)
+                        ->increment('hits', (int) $views);
+
+                    $totalReleases++;
+                    $totalEvents += (int) $views;
+                }
+
+                AppSetting::setValue(self::WatermarkKey, $upperBound);
+            });
+
+            $watermark = $upperBound;
+        }
+
+        $this->info("Aufrufe verbucht: {$totalEvents} auf {$totalReleases} Pressemitteilungen (Stand Event-ID {$watermark}).");
+
+        return self::SUCCESS;
+    }
+}

app/Console/Commands/PurgePressReleaseEvents.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\AppSetting;
+use App\Models\PressReleaseEvent;
+use Illuminate\Console\Command;
+
+/**
+ * Begrenzt das Ereignis-Log der Pressemitteilungen auf einen
+ * Aufbewahrungszeitraum.
+ *
+ * Seit der Aufruf-Zähler nicht mehr im Request auf `press_releases.hits`
+ * schreibt, ist `press_release_events` die Quelle jedes einzelnen
+ * Seitenaufrufs — die Tabelle wächst also mit dem Traffic und hatte als
+ * einzige Log-Tabelle des Systems keine Bereinigung. Für die Gesamtzahl ist
+ * das Log nach der Aggregation nicht mehr nötig (die steckt in `hits`);
+ * gebraucht wird es nur noch für den zeitlichen Verlauf in der Absenderansicht.
+ *
+ * ZWEI SICHERUNGEN, beide zwingend:
+ *
+ * 1. Gelöscht wird ausschließlich UNTERHALB der Wasserstandsmarke von
+ *    `press-releases:aggregate-views`. Alles darüber ist noch nicht in `hits`
+ *    verbucht — würde es hier verschwinden, wären diese Aufrufe dauerhaft
+ *    verloren. Fehlt die Marke, bricht der Lauf ab, statt zu raten.
+ * 2. Gelöscht wird in Blöcken. Ein einzelnes DELETE über Millionen Zeilen
+ *    hielte die Sperre über die gesamte Laufzeit.
+ */
+class PurgePressReleaseEvents extends Command
+{
+    protected $signature = 'press-releases:purge-events
+        {--days= : Ereignisse älter als X Tage löschen (Standard: config press_releases.events.retention_days)}
+        {--chunk=5000 : Zeilen je Durchgang}
+        {--dry-run : Nur zählen, nichts löschen}';
+
+    protected $description = 'Begrenzt das Ereignis-Log der Pressemitteilungen auf den Aufbewahrungszeitraum.';
+
+    public function handle(): int
+    {
+        $days = (int) ($this->option('days') ?? config('press_releases.events.retention_days'));
+
+        if ($days < 1) {
+            $this->error('Aufbewahrungszeitraum muss mindestens einen Tag betragen.');
+
+            return self::FAILURE;
+        }
+
+        $watermark = AppSetting::getValue(AggregatePressReleaseViews::WatermarkKey);
+
+        if ($watermark === null) {
+            $this->error(
+                'Wasserstandsmarke des Aufruf-Zählers fehlt — es ist unbekannt, welche Ereignisse '
+                .'bereits in `hits` verbucht sind. Erst "php artisan press-releases:aggregate-views" laufen lassen.'
+            );
+
+            return self::FAILURE;
+        }
+
+        $watermark = (int) $watermark;
+        $cutoff = now()->subDays($days);
+        $chunk = max(100, (int) $this->option('chunk'));
+
+        $expired = PressReleaseEvent::query()
+            ->where('id', '<=', $watermark)
+            ->where('created_at', '<', $cutoff);
+
+        if ($this->option('dry-run')) {
+            $this->info(sprintf(
+                '[Dry-Run] %d Ereignisse älter als %s und bereits verbucht (Stand Event-ID %d).',
+                (clone $expired)->count(),
+                $cutoff->format('d.m.Y'),
+                $watermark,
+            ));
+
+            return self::SUCCESS;
+        }
+
+        $deleted = 0;
+
+        while (true) {
+            $removed = (clone $expired)->limit($chunk)->delete();
+
+            if ($removed === 0) {
+                break;
+            }
+
+            $deleted += $removed;
+        }
+
+        $this->info(sprintf(
+            'Ereignis-Log bereinigt: %d Einträge vor dem %s gelöscht (Aufbewahrung %d Tage).',
+            $deleted,
+            $cutoff->format('d.m.Y'),
+            $days,
+        ));
+
+        return self::SUCCESS;
+    }
+}

app/Models/AppSetting.php

@@ -43,6 +43,17 @@ class AppSetting extends Model
     public static function setValue(string $key, mixed $value): void
     {
         static::query()->updateOrCreate(['key' => $key], ['value' => $value]);
+        static::forgetCached($key);
+    }
+
+    /**
+     * Verwirft den zwischengespeicherten Wert. Nötig überall dort, wo an
+     * `app_settings` vorbei geschrieben wird — insbesondere in Migrationen,
+     * die den Query Builder benutzen: `getValue()` cacht dauerhaft
+     * (`rememberForever`), ein Direktschreiber bliebe sonst unsichtbar.
+     */
+    public static function forgetCached(string $key): void
+    {
         Cache::forget("app-setting.{$key}");
     }
 }

app/Models/PressRelease.php

@@ -356,15 +356,24 @@ class PressRelease extends Model
      */
     public static function recordDeferredView(int $pressReleaseId): void
     {
-        static::query()
-            ->withoutGlobalScope(PortalScope::class)
-            ->whereKey($pressReleaseId)
-            ->increment('hits');
-
-        PressReleaseEvent::create([
-            'press_release_id' => $pressReleaseId,
-            'type' => PressReleaseEventType::View,
-        ]);
+        // Bewusst NUR das Ereignis-Log (kleine Append-Tabelle). Der frühere
+        // `increment('hits')` traf die über 1 GB große press_releases-Tabelle
+        // und blockierte dort, sobald eine Schemaänderung lief — die
+        // wartenden Requests belegten PHP-FPM-Worker und DB-Verbindungen, bis
+        // die gesamte Seite stand. Die Summierung übernimmt jetzt gebündelt
+        // der Scheduler (AggregatePressReleaseViews).
+        //
+        // Der Aufruf-Zähler ist eine Nebensache: Er darf eine Seite niemals
+        // langsamer oder kaputt machen, deshalb wird jeder Fehler geschluckt
+        // und nur gemeldet.
+        try {
+            PressReleaseEvent::create([
+                'press_release_id' => $pressReleaseId,
+                'type' => PressReleaseEventType::View,
+            ]);
+        } catch (\Throwable $e) {
+            report($e);
+        }
     }
 
     /**