Git-Deploy per Tag, Betriebsüberwachung und Release-Seeder für den Livegang

- dev/betrieb/deploy.sh: Deploy nur per Tag, mit --seed (Seeder im Wartungsmodus)
  und --initial (Vorschau/Live einmalig an Ort und Stelle auf Git umstellen)
- dev/betrieb/vorschau-auffrischen.sh: Live-DB und Live-Medien in die Vorschau (Generalprobe)
- InteriorReleaseSeeder: alle Inhaltsschritte des Relaunchs in einem Lauf, idempotent;
  Displays, Playlists und Mediathek bleiben unberührt
- DisplayInteriorBrandingSeeder überschreibt keinen inzwischen gepflegten Claim mehr
- Monitoring: GlitchTip (Server + Browser), /health mit Token, Scheduler-Herzschlag,
  Alarme per Mail und ntfy, Version in about und /health
- public/build versioniert; .gitignore: macOS-Muster Icon traf resources/views/flux/icon/
- Runbook: dev/betrieb/README.md

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

app/Console/Commands/MonitoringHeartbeat.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Services\Monitoring\HealthProbe;
+use Illuminate\Console\Command;
+
+/**
+ * Minütlicher Herzschlag des Schedulers. Bleibt er aus,
+ * melden `/health` und der Systemstatus den Scheduler als ausgefallen —
+ * `onFailure` der einzelnen Tasks greift in diesem Fall nicht mehr.
+ */
+class MonitoringHeartbeat extends Command
+{
+    protected $signature = 'monitoring:heartbeat';
+
+    protected $description = 'Schreibt den Herzschlag des Schedulers (Grundlage für /health und den Systemstatus).';
+
+    public function handle(HealthProbe $probe): int
+    {
+        $probe->recordHeartbeat();
+
+        return self::SUCCESS;
+    }
+}

app/Console/Commands/MonitoringQueueProbe.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Jobs\Monitoring\QueueProbe;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Sleep;
+use Illuminate\Support\Str;
+
+/**
+ * Prüft, ob ein Queue-Worker läuft: stellt einen Test-Job ein und wartet,
+ * bis er abgeholt ist (Aufruf am Ende von dev/betrieb/deploy.sh).
+ *
+ * Hintergrund: `queue:restart` beendet den Worker, neu starten muss ihn
+ * Supervisor. Läuft Supervisor nicht, bleibt die Queue still stehen.
+ */
+class MonitoringQueueProbe extends Command
+{
+    protected $signature = 'monitoring:queue-probe
+                            {--wait=60 : Sekunden, die auf den Worker gewartet wird}';
+
+    protected $description = 'Prüft mit einem Test-Job, ob ein Queue-Worker läuft.';
+
+    public function handle(): int
+    {
+        $token = Str::random(16);
+        $wait = max(0, (int) $this->option('wait'));
+
+        QueueProbe::dispatch($token);
+
+        for ($second = 0; $second <= $wait; $second++) {
+            if (Cache::has(QueueProbe::cacheKey($token))) {
+                Cache::forget(QueueProbe::cacheKey($token));
+                $this->info(sprintf('Queue-Worker läuft (Test-Job nach %d s abgeholt).', $second));
+
+                return self::SUCCESS;
+            }
+
+            if ($second < $wait) {
+                Sleep::for(1)->second();
+            }
+        }
+
+        $this->error(sprintf('Kein Queue-Worker hat den Test-Job innerhalb von %d s abgeholt.', $wait));
+        $this->line('Worker prüfen: läuft Supervisor (bzw. der Worker im Server-Panel)? Notfalls: nohup php artisan queue:work --tries=3 --max-time=3600 &');
+
+        return self::FAILURE;
+    }
+}

app/Http/Controllers/HealthController.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Services\Monitoring\HealthProbe;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+/**
+ * Tiefer Health-Check für den externen Monitor.
+ *
+ * `/up` zeigt nur, dass die App bootet. `/health` prüft zusätzlich DB,
+ * Cache, Queue-Rückstau, Scheduler-Herzschlag und Plattenplatz: 200 solange
+ * nichts kritisch ist, sonst 503. Zugang nur mit MONITORING_HEALTH_TOKEN
+ * (Bearer oder `?token=`); ohne konfiguriertes Token gibt es den Endpunkt nicht.
+ */
+class HealthController extends Controller
+{
+    public function __invoke(Request $request, HealthProbe $probe): JsonResponse
+    {
+        $token = (string) config('monitoring.health.token');
+        $given = (string) ($request->bearerToken() ?? $request->query('token', ''));
+
+        abort_if($token === '' || ! hash_equals($token, $given), 404);
+
+        $checks = $probe->checks();
+        $status = HealthProbe::worstStatus($checks);
+
+        return response()->json([
+            'status' => $status,
+            'version' => config('app.version'),
+            'checked_at' => now()->toIso8601String(),
+            'checks' => collect($checks)->mapWithKeys(fn (array $check): array => [
+                $check['key'] => ['status' => $check['status'], 'detail' => $check['detail']],
+            ]),
+        ], $status === HealthProbe::StatusCritical ? 503 : 200)
+            ->header('Cache-Control', 'no-store');
+    }
+}

app/Http/Middleware/BasicAuthMiddleware.php

@@ -32,6 +32,12 @@ class BasicAuthMiddleware
             return $next($request);
         }
 
+        // Skip Basic Auth für den Health-Check: Uptime Kuma schickt seinen eigenen
+        // Authorization-Header (Bearer-Token), /health prüft ihn selbst.
+        if ($path === 'health' || $path === 'up') {
+            return $next($request);
+        }
+
         // Skip Basic Auth für Flux UI Assets (flux.js, flux.min.js, editor.js, etc.)
         if (str_starts_with($path, 'flux/')) {
             return $next($request);

app/Http/Middleware/ReportErrorSignals.php

@@ -0,0 +1,96 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use App\Support\Monitoring\ErrorReportScrubber;
+use App\Support\Monitoring\ErrorSignal;
+use Closure;
+use Illuminate\Http\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+use function Illuminate\Support\defer;
+
+/**
+ * Meldet Antworten, hinter denen ein Bedien- oder Programmierfehler steckt,
+ * obwohl keine Exception gemeldet wird:
+ *
+ * - 404 mit Referrer der eigenen Domain — irgendwo bei uns steht ein toter Link
+ * - 403/429 für angemeldete Nutzer — die Oberfläche führt sie dorthin
+ * - 419 — Formular oder Livewire-Komponente abgelaufen, Eingaben sind verloren
+ *
+ * Gesendet wird nach der Antwort (`defer()`), der Nutzer wartet nicht auf GlitchTip.
+ */
+class ReportErrorSignals
+{
+    public function __construct(private readonly ErrorSignal $errorSignal) {}
+
+    public function handle(Request $request, Closure $next): Response
+    {
+        $response = $next($request);
+
+        $signal = $this->signalFor($request, $response->getStatusCode());
+
+        if ($signal !== null) {
+            $location = $this->locationOf($request);
+            $context = [
+                'status' => $response->getStatusCode(),
+                'method' => $request->method(),
+                'path' => '/'.ltrim($request->path(), '/'),
+                'referer' => $this->refererPath($request),
+                'livewire' => $request->hasHeader('X-Livewire'),
+            ];
+
+            defer(fn () => $this->errorSignal->report($signal, $location, $context));
+        }
+
+        return $response;
+    }
+
+    private function signalFor(Request $request, int $status): ?string
+    {
+        return match (true) {
+            $status === 404 && $this->hasInternalReferer($request) => ErrorSignal::DeadInternalLink,
+            $status === 403 && $request->user() !== null => ErrorSignal::AccessDenied,
+            $status === 419 => ErrorSignal::PageExpired,
+            $status === 429 && $request->user() !== null => ErrorSignal::Throttled,
+            default => null,
+        };
+    }
+
+    /**
+     * Livewire-Requests laufen alle über denselben Update-Endpunkt — der Ort
+     * ist dort die Seite, auf der der Nutzer stand.
+     */
+    private function locationOf(Request $request): string
+    {
+        if ($request->hasHeader('X-Livewire')) {
+            return 'livewire '.($this->refererPath($request) ?? '/');
+        }
+
+        $routeName = $request->route()?->getName();
+
+        return $routeName !== null
+            ? $routeName
+            : '/'.ltrim($request->path(), '/');
+    }
+
+    private function hasInternalReferer(Request $request): bool
+    {
+        $referer = $request->headers->get('referer');
+
+        return is_string($referer) && parse_url($referer, PHP_URL_HOST) === $request->getHost();
+    }
+
+    private function refererPath(Request $request): ?string
+    {
+        $referer = $request->headers->get('referer');
+
+        if (! is_string($referer) || $referer === '') {
+            return null;
+        }
+
+        $path = parse_url($referer, PHP_URL_PATH);
+
+        return is_string($path) ? ErrorReportScrubber::scrubPath($path) : null;
+    }
+}

app/Jobs/Monitoring/QueueProbe.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Jobs\Monitoring;
+
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Queue\Queueable;
+use Illuminate\Support\Facades\Cache;
+
+/**
+ * Test-Job für `monitoring:queue-probe`: tut nichts außer zu quittieren,
+ * dass ein Worker ihn abgeholt hat. Läuft auf der Standard-Queue —
+ * der Worker muss sie bedienen.
+ */
+class QueueProbe implements ShouldQueue
+{
+    use Queueable;
+
+    public int $tries = 1;
+
+    public function __construct(public string $token) {}
+
+    public static function cacheKey(string $token): string
+    {
+        return 'monitoring:queue-probe:'.$token;
+    }
+
+    public function handle(): void
+    {
+        Cache::put(self::cacheKey($this->token), now()->toIso8601String(), now()->addMinutes(10));
+    }
+}

app/Providers/AppServiceProvider.php

@@ -2,6 +2,10 @@
 
 namespace App\Providers;
 
+use App\Support\OperationalAlert;
+use Illuminate\Foundation\Console\AboutCommand;
+use Illuminate\Queue\Events\JobFailed;
+use Illuminate\Support\Facades\Queue;
 use Illuminate\Support\Facades\URL;
 use Illuminate\Support\ServiceProvider;
 
@@ -29,5 +33,17 @@ class AppServiceProvider extends ServiceProvider
         if ($scheme === 'https') {
             URL::forceScheme('https');
         }
+
+        // Betriebs-Alert bei endgültig fehlgeschlagenem Queue-Job
+        Queue::failing(function (JobFailed $event): void {
+            OperationalAlert::send("Queue-Job fehlgeschlagen: {$event->job->resolveName()}", [
+                'connection' => $event->connectionName,
+                'queue' => $event->job->getQueue(),
+                'exception' => $event->exception->getMessage(),
+            ]);
+        });
+
+        // Ausgelieferte Version in `php artisan about` (ABOUT_SECTION in dev/betrieb/deploy.sh)
+        AboutCommand::add('B2in', fn (): array => ['Version' => config('app.version') ?? '—']);
     }
 }

app/Services/Monitoring/HealthProbe.php

@@ -0,0 +1,198 @@
+<?php
+
+namespace App\Services\Monitoring;
+
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Str;
+use Throwable;
+
+/**
+ * Die Prüfungen, die ein externer Monitor jede Minute abfragt
+ *: Datenbank, Cache, Queue-Rückstau,
+ * Scheduler-Herzschlag, Plattenplatz. Bewusst billig — keine Zählungen über
+ * große Tabellen, damit `/health` selbst keine Last erzeugt.
+ *
+ * Ein Admin-Systemstatus kann `scheduler()` und `disk()` mitbenutzen.
+ */
+class HealthProbe
+{
+    public const StatusOk = 'ok';
+
+    public const StatusWarn = 'warn';
+
+    public const StatusCritical = 'critical';
+
+    /**
+     * Datei statt Datenbank/Cache: übersteht `cache:clear`, braucht keine
+     * Migration. Bei mehreren App-Servern stattdessen eine DB-Zeile nehmen.
+     */
+    public static function heartbeatPath(): string
+    {
+        return (string) (config('monitoring.scheduler.heartbeat_path') ?: storage_path('framework/scheduler-heartbeat'));
+    }
+
+    public function recordHeartbeat(): void
+    {
+        file_put_contents(self::heartbeatPath(), now()->toIso8601String(), LOCK_EX);
+    }
+
+    public function lastHeartbeat(): ?Carbon
+    {
+        $value = @file_get_contents(self::heartbeatPath());
+
+        return is_string($value) && trim($value) !== '' ? Carbon::parse(trim($value)) : null;
+    }
+
+    /**
+     * @return list<array{key: string, label: string, status: string, detail: string}>
+     */
+    public function checks(): array
+    {
+        return [
+            $this->database(),
+            $this->cache(),
+            $this->queue(),
+            $this->scheduler(),
+            $this->disk(),
+        ];
+    }
+
+    /**
+     * @param  list<array{status: string}>  $checks
+     */
+    public static function worstStatus(array $checks): string
+    {
+        $statuses = array_column($checks, 'status');
+
+        return match (true) {
+            in_array(self::StatusCritical, $statuses, true) => self::StatusCritical,
+            in_array(self::StatusWarn, $statuses, true) => self::StatusWarn,
+            default => self::StatusOk,
+        };
+    }
+
+    /**
+     * @return array{key: string, label: string, status: string, detail: string}
+     */
+    public function scheduler(): array
+    {
+        $lastBeat = $this->lastHeartbeat();
+        $warnMinutes = (int) config('monitoring.scheduler.heartbeat_warn_minutes');
+        $criticalMinutes = (int) config('monitoring.scheduler.heartbeat_critical_minutes');
+        $minutesAgo = $lastBeat !== null ? (int) $lastBeat->diffInMinutes(now(), absolute: true) : null;
+
+        return $this->check(
+            'scheduler',
+            'Scheduler',
+            match (true) {
+                $minutesAgo === null, $minutesAgo >= $criticalMinutes => self::StatusCritical,
+                $minutesAgo >= $warnMinutes => self::StatusWarn,
+                default => self::StatusOk,
+            },
+            $lastBeat === null
+                ? 'Noch kein Herzschlag — läuft `schedule:run` per Cron (bzw. `schedule:work`)?'
+                : 'Letzter Herzschlag '.$lastBeat->format('d.m.Y H:i:s').' (vor '.$minutesAgo.' Min.).',
+        );
+    }
+
+    /**
+     * @return array{key: string, label: string, status: string, detail: string}
+     */
+    public function disk(): array
+    {
+        $path = storage_path();
+        $free = @disk_free_space($path);
+        $total = @disk_total_space($path);
+
+        if ($free === false || $total === false || $total <= 0) {
+            return $this->check('disk', 'Plattenplatz', self::StatusWarn, 'Plattenplatz nicht ermittelbar.');
+        }
+
+        $freePercent = round($free / $total * 100, 1);
+        $minPercent = (float) config('monitoring.health.disk_min_free_percent');
+
+        return $this->check(
+            'disk',
+            'Plattenplatz',
+            match (true) {
+                $freePercent < $minPercent => self::StatusCritical,
+                $freePercent < $minPercent * 2 => self::StatusWarn,
+                default => self::StatusOk,
+            },
+            sprintf('%s %% frei (%s GB von %s GB).', $freePercent, round($free / 1024 ** 3, 1), round($total / 1024 ** 3, 1)),
+        );
+    }
+
+    /**
+     * @return array{key: string, label: string, status: string, detail: string}
+     */
+    private function database(): array
+    {
+        try {
+            DB::select('select 1');
+
+            return $this->check('database', 'Datenbank', self::StatusOk, 'Verbindung steht.');
+        } catch (Throwable $exception) {
+            return $this->check('database', 'Datenbank', self::StatusCritical, 'Keine Verbindung: '.Str::limit($exception->getMessage(), 120));
+        }
+    }
+
+    /**
+     * @return array{key: string, label: string, status: string, detail: string}
+     */
+    private function cache(): array
+    {
+        try {
+            $value = Str::random(8);
+            Cache::put('monitoring:health-probe', $value, 60);
+
+            return Cache::get('monitoring:health-probe') === $value
+                ? $this->check('cache', 'Cache', self::StatusOk, 'Schreiben und Lesen funktionieren.')
+                : $this->check('cache', 'Cache', self::StatusCritical, 'Geschriebener Wert kommt nicht zurück.');
+        } catch (Throwable $exception) {
+            return $this->check('cache', 'Cache', self::StatusCritical, 'Nicht erreichbar: '.Str::limit($exception->getMessage(), 120));
+        }
+    }
+
+    /**
+     * @return array{key: string, label: string, status: string, detail: string}
+     */
+    private function queue(): array
+    {
+        if (config('queue.default') !== 'database') {
+            return $this->check('queue', 'Queue', self::StatusOk, 'Treiber '.config('queue.default').' — Rückstau hier nicht prüfbar.');
+        }
+
+        try {
+            $now = now()->getTimestamp();
+            $oldestAvailable = DB::table('jobs')
+                ->whereNull('reserved_at')
+                ->where('available_at', '<=', $now)
+                ->min('available_at');
+        } catch (Throwable $exception) {
+            return $this->check('queue', 'Queue', self::StatusCritical, 'Jobs-Tabelle nicht lesbar: '.Str::limit($exception->getMessage(), 120));
+        }
+
+        $waitingSeconds = $oldestAvailable !== null ? max(0, $now - (int) $oldestAvailable) : 0;
+        $criticalSeconds = (int) config('monitoring.health.queue_backlog_critical_seconds');
+
+        return $this->check(
+            'queue',
+            'Queue',
+            $waitingSeconds >= $criticalSeconds ? self::StatusCritical : self::StatusOk,
+            $oldestAvailable === null
+                ? 'Kein wartender Job.'
+                : 'Ältester wartender Job seit '.$waitingSeconds.' s.'.($waitingSeconds >= $criticalSeconds ? ' Worker gestoppt?' : ''),
+        );
+    }
+
+    /**
+     * @return array{key: string, label: string, status: string, detail: string}
+     */
+    private function check(string $key, string $label, string $status, string $detail): array
+    {
+        return ['key' => $key, 'label' => $label, 'status' => $status, 'detail' => $detail];
+    }
+}

app/Support/Monitoring/ErrorReportScrubber.php

@@ -0,0 +1,159 @@
+<?php
+
+namespace App\Support\Monitoring;
+
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Str;
+use Sentry\Event;
+use Sentry\EventHint;
+use Sentry\UserDataBag;
+use Throwable;
+
+/**
+ * Letzte Station vor GlitchTip (`before_send` in config/sentry.php).
+ *
+ * Personenbezug nur über die interne User-ID. Tokens und Signaturen stecken
+ * in Query-Strings (signierte Links) und in Pfaden
+ * (`/reset-password/{token}`, Magic Links) — beides wird ersetzt, bevor das
+ * Ereignis den Server verlässt. E-Mail-Adressen in Fehlermeldungen (z. B.
+ * QueryException mit eingesetzten Bindings) ebenso.
+ */
+class ErrorReportScrubber
+{
+    public const Filtered = '[Filtered]';
+
+    /**
+     * Query-Parameter, die unverändert mitgehen dürfen (`utm_*` immer).
+     * Je Projekt anpassen — dieselbe Liste steht in error-reporting.js.
+     *
+     * @var list<string>
+     */
+    public const AllowedQueryParameters = ['page', 'q', 'tab', 'sort'];
+
+    private const EmailPattern = '/[A-Z0-9._%+\-]+@[A-Z0-9.\-]+\.[A-Z]{2,}/i';
+
+    /** Pfadsegmente, die wie ein Token aussehen (Magic Links, Reset-Links). */
+    private const TokenSegmentPattern = '#(?<=/)[A-Za-z0-9_\-]{32,}(?=/|$)#';
+
+    public static function beforeSend(Event $event, ?EventHint $hint = null): ?Event
+    {
+        $userId = self::authenticatedUserId();
+
+        $event->setUser($userId !== null ? UserDataBag::createFromUserIdentifier($userId) : null);
+        $event->setRequest(self::scrubRequest($event->getRequest()));
+
+        foreach ($event->getExceptions() as $exception) {
+            $exception->setValue(self::scrubText($exception->getValue()));
+        }
+
+        if ($event->getMessage() !== null) {
+            $formatted = $event->getMessageFormatted();
+
+            $event->setMessage(
+                self::scrubText($event->getMessage()),
+                $event->getMessageParams(),
+                $formatted !== null ? self::scrubText($formatted) : null,
+            );
+        }
+
+        return $event;
+    }
+
+    /**
+     * @param  array<string, mixed>  $request
+     * @return array<string, mixed>
+     */
+    public static function scrubRequest(array $request): array
+    {
+        if (isset($request['url']) && is_string($request['url'])) {
+            $request['url'] = self::scrubUrl($request['url']);
+        }
+
+        if (isset($request['query_string']) && is_string($request['query_string'])) {
+            $request['query_string'] = self::scrubQuery($request['query_string']);
+        }
+
+        unset($request['data'], $request['cookies']);
+
+        foreach ($request['headers'] ?? [] as $name => $values) {
+            if (strtolower((string) $name) === 'referer') {
+                $request['headers'][$name] = array_map(
+                    static fn (mixed $value): string => self::scrubUrl((string) $value),
+                    (array) $values,
+                );
+            }
+        }
+
+        return $request;
+    }
+
+    public static function scrubUrl(string $url): string
+    {
+        $query = parse_url($url, PHP_URL_QUERY);
+        $withoutQuery = $query !== null && $query !== false ? Str::before($url, '?') : $url;
+        $scrubbedPath = self::scrubPath(self::scrubPathTokens($withoutQuery));
+
+        return $query !== null && $query !== false && $query !== ''
+            ? $scrubbedPath.'?'.self::scrubQuery($query)
+            : $scrubbedPath;
+    }
+
+    public static function scrubQuery(string $query): string
+    {
+        parse_str($query, $parameters);
+
+        $scrubbed = [];
+        foreach ($parameters as $name => $value) {
+            $isAllowed = in_array((string) $name, self::AllowedQueryParameters, true)
+                || str_starts_with((string) $name, 'utm_');
+
+            $scrubbed[$name] = $isAllowed && is_string($value) ? $value : self::Filtered;
+        }
+
+        return http_build_query($scrubbed, '', '&', PHP_QUERY_RFC3986);
+    }
+
+    public static function scrubPath(string $path): string
+    {
+        return self::scrubText((string) preg_replace(self::TokenSegmentPattern, self::Filtered, $path));
+    }
+
+    public static function scrubText(string $text): string
+    {
+        return (string) preg_replace(self::EmailPattern, '[email]', $text);
+    }
+
+    /**
+     * Ersetzt Routenparameter, deren Name auf ein Geheimnis hindeutet
+     * (`token`, `hash`, `signature`), im Pfad der aktuellen Route.
+     */
+    private static function scrubPathTokens(string $url): string
+    {
+        try {
+            $route = request()->route();
+        } catch (Throwable) {
+            return $url;
+        }
+
+        if ($route === null) {
+            return $url;
+        }
+
+        foreach ($route->parameters() as $name => $value) {
+            if (is_string($value) && $value !== '' && Str::contains(strtolower((string) $name), ['token', 'hash', 'signature'])) {
+                $url = str_replace(rawurlencode($value), self::Filtered, str_replace($value, self::Filtered, $url));
+            }
+        }
+
+        return $url;
+    }
+
+    private static function authenticatedUserId(): int|string|null
+    {
+        try {
+            return Auth::id();
+        } catch (Throwable) {
+            return null;
+        }
+    }
+}

app/Support/Monitoring/ErrorSignal.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace App\Support\Monitoring;
+
+use Illuminate\Support\Facades\RateLimiter;
+use Illuminate\Support\Str;
+use Sentry\Severity;
+use Sentry\State\Scope;
+
+use function Sentry\captureMessage;
+use function Sentry\withScope;
+
+/**
+ * Fehler ohne Exception als GlitchTip-Warnung: tote
+ * interne Links, verweigerte Zugriffe, abgelaufene Seiten. Gruppiert wird je
+ * Signal und Ort; je Gruppe gehen höchstens fünf Meldungen in zehn Minuten
+ * raus, damit ein Crawler mit gefälschtem Referrer GlitchTip nicht flutet.
+ */
+class ErrorSignal
+{
+    public const DeadInternalLink = 'dead_internal_link';
+
+    public const AccessDenied = 'access_denied';
+
+    public const PageExpired = 'page_expired';
+
+    public const Throttled = 'throttled';
+
+    private const Labels = [
+        self::DeadInternalLink => 'Toter interner Link',
+        self::AccessDenied => 'Zugriff verweigert (angemeldet)',
+        self::PageExpired => 'Seite abgelaufen (419)',
+        self::Throttled => 'Drosselung trifft angemeldeten Nutzer',
+    ];
+
+    private const MaxReportsPerWindow = 5;
+
+    private const WindowSeconds = 600;
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public function report(string $signal, string $location, array $context = []): bool
+    {
+        $location = Str::limit($location, 200, '');
+
+        $reported = RateLimiter::attempt(
+            'error-signal:'.sha1($signal.'|'.$location),
+            self::MaxReportsPerWindow,
+            static fn (): bool => true,
+            self::WindowSeconds,
+        );
+
+        if ($reported === false) {
+            return false;
+        }
+
+        withScope(function (Scope $scope) use ($signal, $location, $context): void {
+            $scope->setFingerprint(['error-signal', $signal, $location]);
+            $scope->setTag('signal', $signal);
+            $scope->setContext('signal', $context);
+
+            captureMessage((self::Labels[$signal] ?? $signal).': '.$location, Severity::warning());
+        });
+
+        return true;
+    }
+}

app/Support/Monitoring/Release.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Support\Monitoring;
+
+/**
+ * Versionskennung des ausgelieferten Stands — `config('app.version')` und
+ * Release in GlitchTip. Vorrang hat der konfigurierte Wert (APP_VERSION bzw.
+ * SENTRY_RELEASE); sonst die Datei `RELEASE` im Projektwurzelverzeichnis, die
+ * beim Deploy entsteht (`git describe --tags --always --dirty > RELEASE`) —
+ * der Live-Server hat kein Git, solange per SFTP deployt wird.
+ *
+ * Versionen sind Git-Tags nach SemVer: Feature-Deploy erhöht die mittlere,
+ * Hotfix die letzte Stelle. Auf dem Tag ergibt das „v1.1.0“, mit späteren
+ * Commits „v1.1.0-2-gabc1234“, mit uncommitteten Änderungen „…-dirty“.
+ */
+class Release
+{
+    public static function current(?string $configured, ?string $basePath = null): ?string
+    {
+        $configured = trim((string) $configured);
+
+        if ($configured !== '') {
+            return $configured;
+        }
+
+        $file = rtrim($basePath ?? base_path(), '/').'/RELEASE';
+
+        if (! is_file($file)) {
+            return null;
+        }
+
+        $release = trim((string) file_get_contents($file));
+
+        return preg_match('/^[A-Za-z0-9._\-]{1,64}$/', $release) === 1 ? $release : null;
+    }
+}

app/Support/OperationalAlert.php

@@ -0,0 +1,96 @@
+<?php
+
+namespace App\Support;
+
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Mail;
+use Illuminate\Support\Str;
+use Throwable;
+
+/**
+ * Zentrale Betriebs-Alerts: meldet fehlgeschlagene Scheduler-Tasks und
+ * Queue-Jobs (Verdrahtung: siehe 03-betriebsueberwachung.md). Der Log-Eintrag (`critical`) ist die verlässliche Ebene und läuft
+ * immer; Mail und ntfy-Push sind Best-Effort, unabhängig
+ * voneinander, und dürfen den auslösenden Prozess nie mit in den Abgrund
+ * reißen (Mailserver down, ntfy nicht erreichbar o. ä.).
+ */
+class OperationalAlert
+{
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public static function send(string $summary, array $context = []): void
+    {
+        Log::channel('monitoring')->critical('[monitoring] '.$summary, $context);
+
+        if (! config('monitoring.alerts.enabled')) {
+            return;
+        }
+
+        self::mail($summary, $context);
+        self::push($summary, $context);
+    }
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    private static function mail(string $summary, array $context): void
+    {
+        $recipient = config('monitoring.alerts.mail_to');
+
+        if (empty($recipient)) {
+            return;
+        }
+
+        try {
+            Mail::raw(
+                $summary."\n\n".json_encode($context, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES),
+                fn ($message) => $message->to($recipient)->subject('['.config('app.name').'] Betriebs-Alert: '.Str::limit($summary, 80)),
+            );
+        } catch (Throwable $e) {
+            Log::channel('monitoring')->error('[monitoring] Alert-Mail konnte nicht versendet werden.', [
+                'summary' => $summary,
+                'error' => $e->getMessage(),
+            ]);
+        }
+    }
+
+    /**
+     * JSON-Publish an die ntfy-Basis-URL (UTF-8-sicher, anders als Header).
+     *
+     * @param  array<string, mixed>  $context
+     */
+    private static function push(string $summary, array $context): void
+    {
+        $url = (string) config('monitoring.alerts.ntfy.url');
+        $topic = (string) config('monitoring.alerts.ntfy.topic');
+
+        if ($url === '' || $topic === '') {
+            return;
+        }
+
+        $details = collect($context)
+            ->map(fn (mixed $value, string $key): string => $key.': '.(is_scalar($value) || $value === null ? (string) $value : json_encode($value)))
+            ->implode("\n");
+
+        try {
+            Http::timeout(5)
+                ->connectTimeout(3)
+                ->when(filled(config('monitoring.alerts.ntfy.token')), fn ($request) => $request->withToken((string) config('monitoring.alerts.ntfy.token')))
+                ->post(rtrim($url, '/'), [
+                    'topic' => $topic,
+                    'title' => config('app.name').' ('.app()->environment().'): Betriebs-Alert',
+                    'message' => Str::limit(trim($summary."\n\n".$details), 3500),
+                    'priority' => (int) config('monitoring.alerts.ntfy.priority'),
+                    'tags' => ['rotating_light'],
+                ])
+                ->throw();
+        } catch (Throwable $e) {
+            Log::channel('monitoring')->error('[monitoring] ntfy-Push konnte nicht versendet werden.', [
+                'summary' => $summary,
+                'error' => $e->getMessage(),
+            ]);
+        }
+    }
+}