Merge branch 'master' into WIP-add-restify-api - Resolve merge conflicts

Author: Yoyasp

.github/workflows/lint.yml

@@ -53,6 +53,7 @@ jobs:
       - name: Checkout Code
         uses: actions/checkout@v6
         with:
+          fetch-depth: 2
           sparse-checkout-cone-mode: false
           sparse-checkout: |
             /*
@@ -78,6 +79,21 @@ jobs:
       - name: Composer dump
         run: composer dump --strict-psr --strict-ambiguous --no-interaction --no-scripts
 
+      - name: Find new PHP files
+        if: github.event_name == 'pull_request'
+        id: new-php-files
+        run: |
+          # HEAD is the PR merge commit, HEAD~1 is its first parent (base branch tip)
+          NEW_PHP_FILES=$(git diff -z --diff-filter=A --name-only HEAD~1 HEAD -- 'app/**.php' 'bootstrap/**.php' 'config/**.php' 'database/**.php' 'LibreNMS/**.php' 'resources/**.php' 'routes/**.php' 'tests/**.php' | xargs -0)
+          echo "Discovered new PHP files: $NEW_PHP_FILES"
+          echo "files=$NEW_PHP_FILES" >> "$GITHUB_OUTPUT"
+
+      - name: Run PHPStan (New files, level 6)
+        if: github.event_name == 'pull_request' && steps.new-php-files.outputs.files != ''
+        env:
+          NEW_PHP_FILES: ${{ steps.new-php-files.outputs.files }}
+        run: ./vendor/bin/phpstan analyze --no-interaction --memory-limit=4G --level=6 -- $NEW_PHP_FILES
+
       - name: Run PHPStan
         run: ./vendor/bin/phpstan analyze --no-interaction --memory-limit=4G
 

LibreNMS/Alert/AlertUtil.php

@@ -27,12 +27,18 @@
 namespace LibreNMS\Alert;
 
 use App\Facades\LibrenmsConfig;
+use App\Models\Alert;
+use App\Models\AlertOperationSegment;
+use App\Models\AlertRule;
 use App\Models\Device;
 use App\Models\DeviceGroup;
 use App\Models\User;
 use DeviceCache;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Support\Arr;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+use LibreNMS\Enum\AlertRuleOperationPhase;
 use LibreNMS\Enum\MaintenanceStatus;
 use PHPMailer\PHPMailer\PHPMailer;
 
@@ -46,23 +52,203 @@ class AlertUtil
      */
     private static function getRuleId($alert_id)
     {
-        $query = 'SELECT `rule_id` FROM `alerts` WHERE `id`=?';
+        return Alert::find($alert_id)?->rule_id;
+    }
+
+    /**
+     * Map the alert state to the operation phase
+     *
+     * @param  int  $state  The alert state
+     * @return string The operation phase
+     */
+    public static function mapAlertStateToOperationPhase(int $state): string
+    {
+        // UI-defined operations currently use problem phase only.
+        // Keep all states mapped to problem until dedicated phase config is reintroduced.
+        unset($state);
+
+        return AlertRuleOperationPhase::PROBLEM;
+    }
+
+    /**
+     * True when the rule has at least one operation row (notifications are configured at the operation level).
+     */
+    public static function ruleHasAlertOperations(int $ruleId): bool
+    {
+        return AlertRule::find($ruleId)?->alert_operation_id !== null;
+    }
+
+    /**
+     * Merge timing for the problem phase from alert_rule_operations into $rextra
+     * (delay, interval, count) so RunAlerts can reuse existing scheduling logic.
+     * When the rule has no operations at all, notifications are treated as suppressed (mute).
+     *
+     * @param  array<string, mixed>  $details  alert_log details (decoded)
+     * @param  array<string, mixed>  $rextra  rule extra (decoded)
+     */
+    public static function mergeProblemPhaseTimingFromOperations(int $ruleId, array &$details, array &$rextra): void
+    {
+        unset($rextra['_stop_notifications']);
+
+        $ruleRow = AlertRule::query()
+            ->with('alertOperation:id,default_operation_step_duration_seconds,notifications_suppressed')
+            ->whereKey($ruleId)
+            ->first(['id', 'alert_operation_id']);
+        if ($ruleRow === null || $ruleRow->alert_operation_id === null) {
+            $rextra['mute'] = true;
+
+            return;
+        }
+
+        $ops = AlertOperationSegment::where('alert_operation_id', $ruleRow->alert_operation_id)
+            ->where('operation_phase', AlertRuleOperationPhase::PROBLEM)
+            ->orderBy('position')
+            ->orderBy('id')
+            ->get();
+
+        if ($ops->isEmpty()) {
+            return;
+        }
+
+        $opDefault = $ruleRow->alertOperation?->default_operation_step_duration_seconds;
+        if ($opDefault === null) {
+            $opDefault = max(0, 60 * (int) LibrenmsConfig::get('alert_rule.default_operation_step_duration', LibrenmsConfig::get('alert_rule.interval')));
+        }
+        $defaultStep = max(0, (int) $opDefault);
+
+        $notificationCount = (int) ($details['count'] ?? 0);
+        $nextStep = $notificationCount + 1;
+
+        $op = self::selectOperationForEscalationStep($ops, $nextStep);
+        if ($op === null) {
+            $rextra['_stop_notifications'] = true;
 
-        return dbFetchCell($query, [$alert_id]);
+            return;
+        }
+
+        if ($ruleRow->alertOperation === null || (bool) $ruleRow->alertOperation->notifications_suppressed) {
+            $rextra['mute'] = true;
+
+            return;
+        }
+
+        $rextra['delay'] = $notificationCount === 0 ? (int) $op->start_in_seconds : 0;
+        $stepDur = (int) $op->step_duration_seconds;
+        $rextra['interval'] = $stepDur > 0 ? $stepDur : $defaultStep;
+        // Keep legacy runAlerts() counter incrementing for escalation tracking.
+        $rextra['count'] = PHP_INT_MAX;
+    }
+
+    public static function selectOperationForEscalationStep(Collection $operations, int $escalationStep): ?AlertOperationSegment
+    {
+        foreach ($operations as $op) {
+            $from = (int) $op->escalation_step_from;
+            $to = $op->escalation_step_to === null ? null : (int) $op->escalation_step_to;
+            if ($escalationStep < $from) {
+                continue;
+            }
+            if ($to !== null && $escalationStep > $to) {
+                continue;
+            }
+
+            if ($op instanceof AlertOperationSegment) {
+                return $op;
+            }
+        }
+
+        return null;
     }
 
     /**
-     * Get the transport for a given alert_id
+     * Get transports for a given alert (per operation phase and escalation step).
      *
      * @param  int  $alert_id
-     * @return array
+     * @param  string|null  $operation_phase  problem|recovery|update; inferred from alerts.state if null
+     * @param  int  $escalation_step  1-based escalation step for problem operations
+     * @return array<int, array<string, mixed>>
      */
-    public static function getAlertTransports($alert_id)
+    public static function getAlertTransports($alert_id, ?string $operation_phase = null, int $escalation_step = 1)
     {
-        $query = "SELECT b.transport_id, b.transport_type, b.transport_name FROM alert_transport_map AS a LEFT JOIN alert_transports AS b ON b.transport_id=a.transport_or_group_id WHERE a.target_type='single' AND a.rule_id=? UNION DISTINCT SELECT d.transport_id, d.transport_type, d.transport_name FROM alert_transport_map AS a LEFT JOIN alert_transport_groups AS b ON a.transport_or_group_id=b.transport_group_id LEFT JOIN transport_group_transport AS c ON b.transport_group_id=c.transport_group_id LEFT JOIN alert_transports AS d ON c.transport_id=d.transport_id WHERE a.target_type='group' AND a.rule_id=?";
         $rule_id = self::getRuleId($alert_id);
+        if ($rule_id === null) {
+            return [];
+        }
+
+        if ($operation_phase === null) {
+            // Use Eloquent instead of raw SQL for the alert state lookup.
+            $state = (int) (Alert::query()->where('id', $alert_id)->value('state') ?? 0);
+            $operation_phase = self::mapAlertStateToOperationPhase($state);
+        }
+
+        if (! self::ruleHasAlertOperations((int) $rule_id)) {
+            return [];
+        }
+
+        $rule = AlertRule::query()->whereKey($rule_id)->first(['alert_operation_id']);
+        if ($rule === null || $rule->alert_operation_id === null) {
+            return [];
+        }
+
+        $operationId = $rule->alert_operation_id;
+        // Prefer the alert's phase; if no segments exist for recovery/update, fall back to problem
+        // (UI-defined operations store segments as problem-only).
+        $phasesToTry = $operation_phase === AlertRuleOperationPhase::PROBLEM
+            ? [AlertRuleOperationPhase::PROBLEM]
+            : [$operation_phase, AlertRuleOperationPhase::PROBLEM];
+
+        $single = collect();
+        $group = collect();
+        foreach ($phasesToTry as $phase) {
+            // “Single” transports mapped per segment.
+            $single = DB::table('alert_operation_segments')
+                ->join('alert_operation_transport_map as m', 'm.segment_id', '=', 'alert_operation_segments.id')
+                ->join('alert_transports as b', 'b.transport_id', '=', 'm.transport_or_group_id')
+                ->where('m.target_type', '=', 'single')
+                ->where('alert_operation_segments.alert_operation_id', '=', $operationId)
+                ->where('alert_operation_segments.operation_phase', '=', $phase)
+                ->where('alert_operation_segments.escalation_step_from', '<=', $escalation_step)
+                ->where(function ($q) use ($escalation_step): void {
+                    $q->whereNull('alert_operation_segments.escalation_step_to')
+                        ->orWhereRaw('? <= alert_operation_segments.escalation_step_to', [$escalation_step]);
+                })
+                ->select(['b.transport_id', 'b.transport_type', 'b.transport_name'])
+                ->distinct()
+                ->get();
+
+            // Transport groups: expand group membership via transport_group_transport.
+            $group = DB::table('alert_operation_segments')
+                ->join('alert_operation_transport_map as m', 'm.segment_id', '=', 'alert_operation_segments.id')
+                ->join('alert_transport_groups as g', 'g.transport_group_id', '=', 'm.transport_or_group_id')
+                ->join('transport_group_transport as c', 'c.transport_group_id', '=', 'g.transport_group_id')
+                ->join('alert_transports as d', 'd.transport_id', '=', 'c.transport_id')
+                ->where('m.target_type', '=', 'group')
+                ->where('alert_operation_segments.alert_operation_id', '=', $operationId)
+                ->where('alert_operation_segments.operation_phase', '=', $phase)
+                ->where('alert_operation_segments.escalation_step_from', '<=', $escalation_step)
+                ->where(function ($q) use ($escalation_step): void {
+                    $q->whereNull('alert_operation_segments.escalation_step_to')
+                        ->orWhereRaw('? <= alert_operation_segments.escalation_step_to', [$escalation_step]);
+                })
+                ->select(['d.transport_id', 'd.transport_type', 'd.transport_name'])
+                ->distinct()
+                ->get();
+
+            if ($single->isNotEmpty() || $group->isNotEmpty()) {
+                break;
+            }
+        }
 
-        return dbFetchRows($query, [$rule_id, $rule_id]);
+        return $single
+            ->concat($group)
+            // Keep result stable and prevent duplicates when the same transport appears via both mappings.
+            ->unique('transport_id')
+            ->values()
+            ->map(static fn ($row) => [
+                'transport_id' => (int) $row->transport_id,
+                'transport_type' => (string) $row->transport_type,
+                'transport_name' => (string) $row->transport_name,
+            ])
+            ->all();
     }
 
     /**

LibreNMS/Alert/RunAlerts.php

@@ -35,12 +35,14 @@
 use App\Facades\LibrenmsConfig;
 use App\Facades\Rrd;
 use App\Models\Alert;
+use App\Models\AlertLog;
 use App\Models\AlertTransport;
 use App\Models\ApplicationMetric;
 use App\Models\Eventlog;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Log;
 use LibreNMS\Alerting\QueryBuilderParser;
+use LibreNMS\Enum\AlertRuleOperationPhase;
 use LibreNMS\Enum\AlertState;
 use LibreNMS\Enum\MaintenanceStatus;
 use LibreNMS\Enum\Severity;
@@ -228,6 +230,13 @@ public function describeAlert($alert)
         $obj['alerted'] = $alert['alerted'];
         $obj['template'] = $template;
 
+        $obj['operation_phase'] = AlertUtil::mapAlertStateToOperationPhase((int) $alert['state']);
+        $detailCount = (int) ($extra['count'] ?? 0);
+        $obj['escalation_step'] = max(1, $detailCount);
+        if ($obj['operation_phase'] !== AlertRuleOperationPhase::PROBLEM) {
+            $obj['escalation_step'] = 1;
+        }
+
         return $obj;
     }
 
@@ -507,6 +516,17 @@ public function runAlerts()
                 $rextra['recovery'] = true;
             }
 
+            if (in_array($alert['state'], [AlertState::ACTIVE, AlertState::WORSE, AlertState::BETTER, AlertState::CHANGED], true)) {
+                AlertUtil::mergeProblemPhaseTimingFromOperations((int) $alert['rule_id'], $alert['details'], $rextra);
+            }
+
+            if (! empty($rextra['_stop_notifications'])) {
+                unset($rextra['_stop_notifications']);
+                echo 'Max escalation steps reached for Alert-UID #' . $alert['id'] . "\r\n";
+
+                continue;
+            }
+
             if (! isset($alert['details']['count'])) {
                 // make sure count is set for below code, in legacy code null would get type juggled to 0
                 $alert['details']['count'] = 0;
@@ -518,7 +538,7 @@ public function runAlerts()
 
             if ($status_check === null) {
                 Log::warning("Alert #{$alert['id']} references non-existent device {$alert['device_id']}, cleaning up");
-                Alert::query()->where('id', $alert['id'])->delete();
+                AlertLog::query()->where('id', $alert['id'])->delete();
 
                 continue;
             }
@@ -633,10 +653,23 @@ public function extTransports($obj)
         $type = new Template;
 
         // If alert transport mapping exists, override the default transports
-        $transport_maps = AlertUtil::getAlertTransports($obj['alert_id']);
+        $transport_maps = AlertUtil::getAlertTransports(
+            $obj['alert_id'],
+            $obj['operation_phase'] ?? null,
+            (int) ($obj['escalation_step'] ?? 1)
+        );
 
+        $ruleId = (int) ($obj['rule_id'] ?? 0);
         if (! $transport_maps) {
-            $transport_maps = AlertUtil::getDefaultAlertTransports();
+            $reason = 'No mapped transport for this operation';
+            if ($ruleId > 0 && ! AlertUtil::ruleHasAlertOperations($ruleId)) {
+                $reason = 'No operations configured for this rule';
+            }
+
+            Eventlog::log($reason . ' (notification skipped)', $obj['device_id'], 'alert', Severity::Notice);
+            c_echo(" :: Skipped => $reason");
+
+            return;
         }
 
         // alerting for default contacts, etc

LibreNMS/ComposerHelper.php

@@ -183,7 +183,7 @@ private static function execComposerCommand(array $command, array $env = []): in
             $cli[] = "$key=$value";
         }
         $cli[] = PHP_BINARY;
-        $cli[] = realpath(__DIR__ . '/../../scripts/composer_wrapper.php');
+        $cli[] = realpath(__DIR__ . '/../scripts/composer_wrapper.php');
         foreach ($command as $word) {
             $cli[] = escapeshellarg($word);
         }

LibreNMS/Discovery/Yaml/YamlDiscoveryField.php

@@ -51,7 +51,7 @@ public function calculateValue(array $yaml, array $data, string $index, int $cou
         if (array_key_exists($this->key, $yaml)) {
             $key = $this->key;
         } else {
-            $key = $this->default;
+            $key = is_int($this->default) ? $this->default : (string) $this->default;
             $yaml = [$key => $this->default];
         }
 

LibreNMS/Enum/AlertRuleOperationPhase.php

@@ -0,0 +1,19 @@
+<?php
+
+/**
+ * Operation lists: Operations (problem), Recovery operations, Update operations.
+ */
+
+namespace LibreNMS\Enum;
+
+abstract class AlertRuleOperationPhase
+{
+    /** Problem escalations” */
+    public const PROBLEM = 'problem';
+
+    /** “Recovery operations” */
+    public const RECOVERY = 'recovery';
+
+    /** “Update operations”  (acknowledgements, etc.) */
+    public const UPDATE = 'update';
+}