chore: prepare for PR

app/Jobs/ScheduledJobManager.php

@@ -27,6 +27,10 @@ class ScheduledJobManager implements ShouldQueue
      */
     private ?Carbon $executionTime = null;
 
+    private int $dispatchedCount = 0;
+
+    private int $skippedCount = 0;
+
     /**
      * Create a new job instance.
      */
@@ -61,6 +65,12 @@ class ScheduledJobManager implements ShouldQueue
     {
         // Freeze the execution time at the start of the job
         $this->executionTime = Carbon::now();
+        $this->dispatchedCount = 0;
+        $this->skippedCount = 0;
+
+        Log::channel('scheduled')->info('ScheduledJobManager started', [
+            'execution_time' => $this->executionTime->toIso8601String(),
+        ]);
 
         // Process backups - don't let failures stop task processing
         try {
@@ -91,6 +101,13 @@ class ScheduledJobManager implements ShouldQueue
                 'trace' => $e->getTraceAsString(),
             ]);
         }
+
+        Log::channel('scheduled')->info('ScheduledJobManager completed', [
+            'execution_time' => $this->executionTime->toIso8601String(),
+            'duration_ms' => Carbon::now()->diffInMilliseconds($this->executionTime),
+            'dispatched' => $this->dispatchedCount,
+            'skipped' => $this->skippedCount,
+        ]);
     }
 
     private function processScheduledBackups(): void
@@ -101,8 +118,16 @@ class ScheduledJobManager implements ShouldQueue
 
         foreach ($backups as $backup) {
             try {
-                // Apply the same filtering logic as the original
-                if (! $this->shouldProcessBackup($backup)) {
+                $skipReason = $this->getBackupSkipReason($backup);
+                if ($skipReason !== null) {
+                    $this->skippedCount++;
+                    $this->logSkip('backup', $skipReason, [
+                        'backup_id' => $backup->id,
+                        'database_id' => $backup->database_id,
+                        'database_type' => $backup->database_type,
+                        'team_id' => $backup->team_id ?? null,
+                    ]);
+
                     continue;
                 }
 
@@ -120,6 +145,14 @@ class ScheduledJobManager implements ShouldQueue
 
                 if ($this->shouldRunNow($frequency, $serverTimezone)) {
                     DatabaseBackupJob::dispatch($backup);
+                    $this->dispatchedCount++;
+                    Log::channel('scheduled')->info('Backup dispatched', [
+                        'backup_id' => $backup->id,
+                        'database_id' => $backup->database_id,
+                        'database_type' => $backup->database_type,
+                        'team_id' => $backup->team_id ?? null,
+                        'server_id' => $server->id,
+                    ]);
                 }
             } catch (\Exception $e) {
                 Log::channel('scheduled-errors')->error('Error processing backup', [
@@ -138,7 +171,15 @@ class ScheduledJobManager implements ShouldQueue
 
         foreach ($tasks as $task) {
             try {
-                if (! $this->shouldProcessTask($task)) {
+                $skipReason = $this->getTaskSkipReason($task);
+                if ($skipReason !== null) {
+                    $this->skippedCount++;
+                    $this->logSkip('task', $skipReason, [
+                        'task_id' => $task->id,
+                        'task_name' => $task->name,
+                        'team_id' => $task->server()?->team_id,
+                    ]);
+
                     continue;
                 }
 
@@ -156,6 +197,13 @@ class ScheduledJobManager implements ShouldQueue
 
                 if ($this->shouldRunNow($frequency, $serverTimezone)) {
                     ScheduledTaskJob::dispatch($task);
+                    $this->dispatchedCount++;
+                    Log::channel('scheduled')->info('Task dispatched', [
+                        'task_id' => $task->id,
+                        'task_name' => $task->name,
+                        'team_id' => $server->team_id,
+                        'server_id' => $server->id,
+                    ]);
                 }
             } catch (\Exception $e) {
                 Log::channel('scheduled-errors')->error('Error processing task', [
@@ -166,33 +214,33 @@ class ScheduledJobManager implements ShouldQueue
         }
     }
 
-    private function shouldProcessBackup(ScheduledDatabaseBackup $backup): bool
+    private function getBackupSkipReason(ScheduledDatabaseBackup $backup): ?string
     {
         if (blank(data_get($backup, 'database'))) {
             $backup->delete();
 
-            return false;
+            return 'database_deleted';
         }
 
         $server = $backup->server();
         if (blank($server)) {
             $backup->delete();
 
-            return false;
+            return 'server_deleted';
         }
 
         if ($server->isFunctional() === false) {
-            return false;
+            return 'server_not_functional';
         }
 
         if (isCloud() && data_get($server->team->subscription, 'stripe_invoice_paid', false) === false && $server->team->id !== 0) {
-            return false;
+            return 'subscription_unpaid';
         }
 
-        return true;
+        return null;
     }
 
-    private function shouldProcessTask(ScheduledTask $task): bool
+    private function getTaskSkipReason(ScheduledTask $task): ?string
     {
         $service = $task->service;
         $application = $task->application;
@@ -201,32 +249,32 @@ class ScheduledJobManager implements ShouldQueue
         if (blank($server)) {
             $task->delete();
 
-            return false;
+            return 'server_deleted';
         }
 
         if ($server->isFunctional() === false) {
-            return false;
+            return 'server_not_functional';
         }
 
         if (isCloud() && data_get($server->team->subscription, 'stripe_invoice_paid', false) === false && $server->team->id !== 0) {
-            return false;
+            return 'subscription_unpaid';
         }
 
         if (! $service && ! $application) {
             $task->delete();
 
-            return false;
+            return 'resource_deleted';
         }
 
         if ($application && str($application->status)->contains('running') === false) {
-            return false;
+            return 'application_not_running';
         }
 
         if ($service && str($service->status)->contains('running') === false) {
-            return false;
+            return 'service_not_running';
         }
 
-        return true;
+        return null;
     }
 
     private function shouldRunNow(string $frequency, string $timezone): bool
@@ -248,7 +296,15 @@ class ScheduledJobManager implements ShouldQueue
 
         foreach ($servers as $server) {
             try {
-                if (! $this->shouldProcessDockerCleanup($server)) {
+                $skipReason = $this->getDockerCleanupSkipReason($server);
+                if ($skipReason !== null) {
+                    $this->skippedCount++;
+                    $this->logSkip('docker_cleanup', $skipReason, [
+                        'server_id' => $server->id,
+                        'server_name' => $server->name,
+                        'team_id' => $server->team_id,
+                    ]);
+
                     continue;
                 }
 
@@ -270,6 +326,12 @@ class ScheduledJobManager implements ShouldQueue
                         $server->settings->delete_unused_volumes,
                         $server->settings->delete_unused_networks
                     );
+                    $this->dispatchedCount++;
+                    Log::channel('scheduled')->info('Docker cleanup dispatched', [
+                        'server_id' => $server->id,
+                        'server_name' => $server->name,
+                        'team_id' => $server->team_id,
+                    ]);
                 }
             } catch (\Exception $e) {
                 Log::channel('scheduled-errors')->error('Error processing docker cleanup', [
@@ -296,19 +358,28 @@ class ScheduledJobManager implements ShouldQueue
         return $query->get();
     }
 
-    private function shouldProcessDockerCleanup(Server $server): bool
+    private function getDockerCleanupSkipReason(Server $server): ?string
     {
         if (! $server->isFunctional()) {
-            return false;
+            return 'server_not_functional';
         }
 
         // In cloud, check subscription status (except team 0)
         if (isCloud() && $server->team_id !== 0) {
             if (data_get($server->team->subscription, 'stripe_invoice_paid', false) === false) {
-                return false;
+                return 'subscription_unpaid';
             }
         }
 
-        return true;
+        return null;
+    }
+
+    private function logSkip(string $type, string $reason, array $context = []): void
+    {
+        Log::channel('scheduled')->info(ucfirst(str_replace('_', ' ', $type)).' skipped', array_merge([
+            'type' => $type,
+            'skip_reason' => $reason,
+            'execution_time' => $this->executionTime?->toIso8601String(),
+        ], $context));
     }
 }

app/Livewire/Settings/ScheduledJobs.php

@@ -0,0 +1,211 @@
+<?php
+
+namespace App\Livewire\Settings;
+
+use App\Models\DockerCleanupExecution;
+use App\Models\ScheduledDatabaseBackupExecution;
+use App\Models\ScheduledTaskExecution;
+use App\Services\SchedulerLogParser;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
+use Livewire\Component;
+
+class ScheduledJobs extends Component
+{
+    public string $filterType = 'all';
+
+    public string $filterDate = 'last_24h';
+
+    protected Collection $executions;
+
+    protected Collection $skipLogs;
+
+    protected Collection $managerRuns;
+
+    public function boot(): void
+    {
+        $this->executions = collect();
+        $this->skipLogs = collect();
+        $this->managerRuns = collect();
+    }
+
+    public function mount(): void
+    {
+        if (! isInstanceAdmin()) {
+            redirect()->route('dashboard');
+
+            return;
+        }
+
+        $this->loadData();
+    }
+
+    public function updatedFilterType(): void
+    {
+        $this->loadData();
+    }
+
+    public function updatedFilterDate(): void
+    {
+        $this->loadData();
+    }
+
+    public function refresh(): void
+    {
+        $this->loadData();
+    }
+
+    public function render()
+    {
+        return view('livewire.settings.scheduled-jobs', [
+            'executions' => $this->executions,
+            'skipLogs' => $this->skipLogs,
+            'managerRuns' => $this->managerRuns,
+        ]);
+    }
+
+    private function loadData(?int $teamId = null): void
+    {
+        $this->executions = $this->getExecutions($teamId);
+
+        $parser = new SchedulerLogParser;
+        $this->skipLogs = $parser->getRecentSkips(50, $teamId);
+        $this->managerRuns = $parser->getRecentRuns(30, $teamId);
+    }
+
+    private function getExecutions(?int $teamId = null): Collection
+    {
+        $dateFrom = $this->getDateFrom();
+
+        $backups = collect();
+        $tasks = collect();
+        $cleanups = collect();
+
+        if ($this->filterType === 'all' || $this->filterType === 'backup') {
+            $backups = $this->getBackupExecutions($dateFrom, $teamId);
+        }
+
+        if ($this->filterType === 'all' || $this->filterType === 'task') {
+            $tasks = $this->getTaskExecutions($dateFrom, $teamId);
+        }
+
+        if ($this->filterType === 'all' || $this->filterType === 'cleanup') {
+            $cleanups = $this->getCleanupExecutions($dateFrom, $teamId);
+        }
+
+        return $backups->concat($tasks)->concat($cleanups)
+            ->sortByDesc('created_at')
+            ->values()
+            ->take(100);
+    }
+
+    private function getBackupExecutions(?Carbon $dateFrom, ?int $teamId): Collection
+    {
+        $query = ScheduledDatabaseBackupExecution::with(['scheduledDatabaseBackup.database', 'scheduledDatabaseBackup.team'])
+            ->where('status', 'failed')
+            ->when($dateFrom, fn ($q) => $q->where('created_at', '>=', $dateFrom))
+            ->when($teamId, fn ($q) => $q->whereRelation('scheduledDatabaseBackup.team', 'id', $teamId))
+            ->orderBy('created_at', 'desc')
+            ->limit(100)
+            ->get();
+
+        return $query->map(function ($execution) {
+            $backup = $execution->scheduledDatabaseBackup;
+            $database = $backup?->database;
+            $server = $backup?->server();
+
+            return [
+                'id' => $execution->id,
+                'type' => 'backup',
+                'status' => $execution->status ?? 'unknown',
+                'resource_name' => $database?->name ?? 'Deleted database',
+                'resource_type' => $database ? class_basename($database) : null,
+                'server_name' => $server?->name ?? 'Unknown',
+                'server_id' => $server?->id,
+                'team_id' => $backup?->team_id,
+                'created_at' => $execution->created_at,
+                'finished_at' => $execution->updated_at,
+                'message' => $execution->message,
+                'size' => $execution->size ?? null,
+            ];
+        });
+    }
+
+    private function getTaskExecutions(?Carbon $dateFrom, ?int $teamId): Collection
+    {
+        $query = ScheduledTaskExecution::with(['scheduledTask.application', 'scheduledTask.service'])
+            ->where('status', 'failed')
+            ->when($dateFrom, fn ($q) => $q->where('created_at', '>=', $dateFrom))
+            ->when($teamId, function ($q) use ($teamId) {
+                $q->where(function ($sub) use ($teamId) {
+                    $sub->whereRelation('scheduledTask.application.environment.project.team', 'id', $teamId)
+                        ->orWhereRelation('scheduledTask.service.environment.project.team', 'id', $teamId);
+                });
+            })
+            ->orderBy('created_at', 'desc')
+            ->limit(100)
+            ->get();
+
+        return $query->map(function ($execution) {
+            $task = $execution->scheduledTask;
+            $resource = $task?->application ?? $task?->service;
+            $server = $task?->server();
+            $teamId = $server?->team_id;
+
+            return [
+                'id' => $execution->id,
+                'type' => 'task',
+                'status' => $execution->status ?? 'unknown',
+                'resource_name' => $task?->name ?? 'Deleted task',
+                'resource_type' => $resource ? class_basename($resource) : null,
+                'server_name' => $server?->name ?? 'Unknown',
+                'server_id' => $server?->id,
+                'team_id' => $teamId,
+                'created_at' => $execution->created_at,
+                'finished_at' => $execution->finished_at,
+                'message' => $execution->message,
+                'size' => null,
+            ];
+        });
+    }
+
+    private function getCleanupExecutions(?Carbon $dateFrom, ?int $teamId): Collection
+    {
+        $query = DockerCleanupExecution::with(['server'])
+            ->where('status', 'failed')
+            ->when($dateFrom, fn ($q) => $q->where('created_at', '>=', $dateFrom))
+            ->when($teamId, fn ($q) => $q->whereRelation('server', 'team_id', $teamId))
+            ->orderBy('created_at', 'desc')
+            ->limit(100)
+            ->get();
+
+        return $query->map(function ($execution) {
+            $server = $execution->server;
+
+            return [
+                'id' => $execution->id,
+                'type' => 'cleanup',
+                'status' => $execution->status ?? 'unknown',
+                'resource_name' => $server?->name ?? 'Deleted server',
+                'resource_type' => 'Server',
+                'server_name' => $server?->name ?? 'Unknown',
+                'server_id' => $server?->id,
+                'team_id' => $server?->team_id,
+                'created_at' => $execution->created_at,
+                'finished_at' => $execution->finished_at ?? $execution->updated_at,
+                'message' => $execution->message,
+                'size' => null,
+            ];
+        });
+    }
+
+    private function getDateFrom(): ?Carbon
+    {
+        return match ($this->filterDate) {
+            'last_24h' => now()->subDay(),
+            'last_7d' => now()->subWeek(),
+            'last_30d' => now()->subMonth(),
+            default => null,
+        };
+    }
+}

app/Services/SchedulerLogParser.php

@@ -0,0 +1,188 @@
+<?php
+
+namespace App\Services;
+
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\File;
+
+class SchedulerLogParser
+{
+    /**
+     * Get recent skip events from the scheduled log files.
+     *
+     * @return Collection<int, array{timestamp: string, type: string, reason: string, team_id: ?int, context: array}>
+     */
+    public function getRecentSkips(int $limit = 100, ?int $teamId = null): Collection
+    {
+        $logFiles = $this->getLogFiles();
+
+        $skips = collect();
+
+        foreach ($logFiles as $logFile) {
+            $lines = $this->readLastLines($logFile, 2000);
+
+            foreach ($lines as $line) {
+                $entry = $this->parseLogLine($line);
+                if ($entry === null || ! isset($entry['context']['skip_reason'])) {
+                    continue;
+                }
+
+                if ($teamId !== null && ($entry['context']['team_id'] ?? null) !== $teamId) {
+                    continue;
+                }
+
+                $skips->push([
+                    'timestamp' => $entry['timestamp'],
+                    'type' => $entry['context']['type'] ?? 'unknown',
+                    'reason' => $entry['context']['skip_reason'],
+                    'team_id' => $entry['context']['team_id'] ?? null,
+                    'context' => $entry['context'],
+                ]);
+            }
+        }
+
+        return $skips->sortByDesc('timestamp')->values()->take($limit);
+    }
+
+    /**
+     * Get recent manager execution logs (start/complete events).
+     *
+     * @return Collection<int, array{timestamp: string, message: string, duration_ms: ?int, dispatched: ?int, skipped: ?int}>
+     */
+    public function getRecentRuns(int $limit = 60, ?int $teamId = null): Collection
+    {
+        $logFiles = $this->getLogFiles();
+
+        $runs = collect();
+
+        foreach ($logFiles as $logFile) {
+            $lines = $this->readLastLines($logFile, 2000);
+
+            foreach ($lines as $line) {
+                $entry = $this->parseLogLine($line);
+                if ($entry === null) {
+                    continue;
+                }
+
+                if (! str_contains($entry['message'], 'ScheduledJobManager')) {
+                    continue;
+                }
+
+                $runs->push([
+                    'timestamp' => $entry['timestamp'],
+                    'message' => $entry['message'],
+                    'duration_ms' => $entry['context']['duration_ms'] ?? null,
+                    'dispatched' => $entry['context']['dispatched'] ?? null,
+                    'skipped' => $entry['context']['skipped'] ?? null,
+                ]);
+            }
+        }
+
+        return $runs->sortByDesc('timestamp')->values()->take($limit);
+    }
+
+    private function getLogFiles(): array
+    {
+        $logDir = storage_path('logs');
+        if (! File::isDirectory($logDir)) {
+            return [];
+        }
+
+        $files = File::glob($logDir.'/scheduled-*.log');
+
+        // Sort by modification time, newest first
+        usort($files, fn ($a, $b) => filemtime($b) - filemtime($a));
+
+        // Only check last 3 days of logs
+        return array_slice($files, 0, 3);
+    }
+
+    /**
+     * @return array{timestamp: string, level: string, message: string, context: array}|null
+     */
+    private function parseLogLine(string $line): ?array
+    {
+        // Laravel daily log format: [2024-01-15 10:30:00] production.INFO: Message {"key":"value"}
+        if (! preg_match('/^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] \w+\.(\w+): (.+)$/', $line, $matches)) {
+            return null;
+        }
+
+        $timestamp = $matches[1];
+        $level = $matches[2];
+        $rest = $matches[3];
+
+        // Extract JSON context if present
+        $context = [];
+        if (preg_match('/^(.+?)\s+(\{.+\})\s*$/', $rest, $contextMatches)) {
+            $message = $contextMatches[1];
+            $decoded = json_decode($contextMatches[2], true);
+            if (is_array($decoded)) {
+                $context = $decoded;
+            }
+        } else {
+            $message = $rest;
+        }
+
+        return [
+            'timestamp' => $timestamp,
+            'level' => $level,
+            'message' => $message,
+            'context' => $context,
+        ];
+    }
+
+    /**
+     * Efficiently read the last N lines of a file.
+     *
+     * @return string[]
+     */
+    private function readLastLines(string $filePath, int $lines): array
+    {
+        if (! File::exists($filePath)) {
+            return [];
+        }
+
+        $fileSize = File::size($filePath);
+        if ($fileSize === 0) {
+            return [];
+        }
+
+        // For small files, read the whole thing
+        if ($fileSize < 1024 * 1024) {
+            $content = File::get($filePath);
+
+            return array_filter(explode("\n", $content), fn ($line) => $line !== '');
+        }
+
+        // For large files, read from the end
+        $handle = fopen($filePath, 'r');
+        if ($handle === false) {
+            return [];
+        }
+
+        $result = [];
+        $chunkSize = 8192;
+        $buffer = '';
+        $position = $fileSize;
+
+        while ($position > 0 && count($result) < $lines) {
+            $readSize = min($chunkSize, $position);
+            $position -= $readSize;
+            fseek($handle, $position);
+            $buffer = fread($handle, $readSize).$buffer;
+
+            $bufferLines = explode("\n", $buffer);
+            $buffer = array_shift($bufferLines);
+
+            $result = array_merge(array_filter($bufferLines, fn ($line) => $line !== ''), $result);
+        }
+
+        if ($buffer !== '' && count($result) < $lines) {
+            array_unshift($result, $buffer);
+        }
+
+        fclose($handle);
+
+        return array_slice($result, -$lines);
+    }
+}