TenantAtlas/app/Jobs/GenerateDriftFindingsJob.php

<?php

namespace App\Jobs;

use App\Models\OperationRun;
use App\Models\Tenant;
use App\Services\Drift\DriftFindingGenerator;
use App\Services\OperationRunService;
use App\Services\Operations\TargetScopeConcurrencyLimiter;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Log;
use RuntimeException;
use Throwable;

class GenerateDriftFindingsJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public ?OperationRun $operationRun = null;

    /**
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public int $tenantId,
        public int $userId,
        public int $baselineRunId,
        public int $currentRunId,
        public string $scopeKey,
        ?OperationRun $operationRun = null,
        public array $context = [],
    ) {
        $this->operationRun = $operationRun;
    }

    public function handle(
        DriftFindingGenerator $generator,
        OperationRunService $runs,
        TargetScopeConcurrencyLimiter $limiter,
    ): void {
        Log::info('GenerateDriftFindingsJob: started', [
            'tenant_id' => $this->tenantId,
            'baseline_operation_run_id' => $this->baselineRunId,
            'current_operation_run_id' => $this->currentRunId,
            'scope_key' => $this->scopeKey,
        ]);

        if (! $this->operationRun instanceof OperationRun) {
            throw new RuntimeException('OperationRun is required for drift generation.');
        }

        $this->operationRun->refresh();

        if ($this->operationRun->status === 'completed') {
            return;
        }

        $opContext = is_array($this->operationRun->context) ? $this->operationRun->context : [];
        $targetScope = is_array($opContext['target_scope'] ?? null) ? $opContext['target_scope'] : [];

        $lock = $limiter->acquireSlot($this->tenantId, $targetScope);

        if (! $lock) {
            $delay = (int) config('tenantpilot.bulk_operations.poll_interval_seconds', 3);
            $this->release(max(1, $delay));

            return;
        }

        try {
            $tenant = Tenant::query()->find($this->tenantId);
            if (! $tenant instanceof Tenant) {
                throw new RuntimeException('Tenant not found.');
            }

            $baseline = OperationRun::query()
                ->whereKey($this->baselineRunId)
                ->where('tenant_id', $tenant->getKey())
                ->where('type', 'inventory_sync')
                ->first();
            if (! $baseline instanceof OperationRun) {
                throw new RuntimeException('Baseline run not found.');
            }

            $current = OperationRun::query()
                ->whereKey($this->currentRunId)
                ->where('tenant_id', $tenant->getKey())
                ->where('type', 'inventory_sync')
                ->first();
            if (! $current instanceof OperationRun) {
                throw new RuntimeException('Current run not found.');
            }

            $runs->updateRun($this->operationRun, 'running');

            $counts = is_array($this->operationRun->summary_counts ?? null) ? $this->operationRun->summary_counts : [];
            if ((int) ($counts['total'] ?? 0) === 0) {
                $runs->incrementSummaryCounts($this->operationRun, ['total' => 1]);
            }

            $created = $generator->generate(
                tenant: $tenant,
                baseline: $baseline,
                current: $current,
                scopeKey: $this->scopeKey,
            );

            Log::info('GenerateDriftFindingsJob: completed', [
                'tenant_id' => $this->tenantId,
                'baseline_operation_run_id' => $this->baselineRunId,
                'current_operation_run_id' => $this->currentRunId,
                'scope_key' => $this->scopeKey,
                'created_findings_count' => $created,
            ]);

            $runs->incrementSummaryCounts($this->operationRun, [
                'processed' => 1,
                'succeeded' => 1,
                'created' => $created,
            ]);

            $runs->maybeCompleteBulkRun($this->operationRun);
        } catch (Throwable $e) {
            Log::error('GenerateDriftFindingsJob: failed', [
                'tenant_id' => $this->tenantId,
                'baseline_operation_run_id' => $this->baselineRunId,
                'current_operation_run_id' => $this->currentRunId,
                'scope_key' => $this->scopeKey,
                'error' => $e->getMessage(),
            ]);

            $runs->incrementSummaryCounts($this->operationRun, [
                'processed' => 1,
                'failed' => 1,
            ]);

            $runs->appendFailures($this->operationRun, [[
                'code' => 'drift_generate_findings.failed',
                'message' => $e->getMessage(),
            ]]);

            $runs->maybeCompleteBulkRun($this->operationRun);

            throw $e;
        } finally {
            $lock->release();
        }
    }
}