add notificaiton alert solved procedure

Author: GabrielSalla

configs.yaml

@@ -32,6 +32,8 @@ controller_procedures:
     schedule: "*/5 * * * *"
     params:
       time_tolerance: 10
+  notifications_alert_solved:
+    schedule: "*/5 * * * *"
 
 executor_concurrency: 5
 executor_sleep: 5

src/components/controller/procedures/__init__.py

@@ -1,9 +1,10 @@
 from typing import Callable, Coroutine
 
-from . import monitors_stuck
+from . import monitors_stuck, notifications_alert_solved
 
 procedures: dict[str, Callable[..., Coroutine[None, None, None]]] = {
     "monitors_stuck": monitors_stuck.monitors_stuck,
+    "notifications_alert_solved": notifications_alert_solved.notifications_alert_solved,
 }
 
 __all__ = ["procedures"]

src/components/controller/procedures/notifications_alert_solved.py

@@ -0,0 +1,33 @@
+"""
+Search for active notifications linked to alerts that have already been solved and closes the
+identified notifications.
+"""
+
+import logging
+
+import databases
+from models import Notification
+
+from .constants import SQL_FILES_PATH
+
+_logger = logging.getLogger("procedures.notifications_alert_solved")
+
+
+async def notifications_alert_solved() -> None:
+    with open(SQL_FILES_PATH / "notification_alert_solved.sql") as file:
+        query = file.read()
+
+    result = await databases.query_application(query)
+
+    if result is None:
+        _logger.error("Error with query result")
+        return
+
+    for notification_info in result:
+        notification = await Notification.get_by_id(notification_info["id"])
+        if notification is None:
+            _logger.error(f"Notification with id '{notification_info['id']}' not found")
+            continue
+
+        await notification.close()
+        _logger.warning(f"{notification} closed")

src/components/controller/procedures/sql_files/notification_alert_solved.sql

@@ -0,0 +1,16 @@
+with active_notifications as (
+  select
+    id,
+    alert_id as notification_alert_id,
+    status as notification_status
+  from "Notifications"
+  where
+    status = 'active'
+)
+select active_notifications.id as id
+from active_notifications
+  inner join "Alerts" as alerts
+    on active_notifications.notification_alert_id = alerts.id
+where
+  alerts.status = 'solved' and
+  alerts.solved_at < current_timestamp - interval '5 minutes';

tests/components/controller/procedures/test_notification_alert_solved.py

@@ -0,0 +1,105 @@
+from datetime import datetime, timedelta
+from unittest.mock import AsyncMock
+
+import pytest
+
+import components.controller.procedures.notifications_alert_solved as notifications_alert_solved
+from models import Alert, AlertStatus, Monitor, Notification, NotificationStatus
+from tests.test_utils import assert_message_in_log, assert_message_not_in_log
+from utils.time import now
+
+pytestmark = pytest.mark.asyncio(loop_scope="session")
+
+
+def get_time(reference: str) -> datetime | None:
+    values = {
+        "now": now(),
+        "ten_seconds_ago": now() - timedelta(seconds=11),
+        "five_minutes_ago": now() - timedelta(seconds=301),
+    }
+    return values.get(reference)
+
+
+@pytest.mark.parametrize("alert_status", [AlertStatus.active, AlertStatus.solved])
+@pytest.mark.parametrize(
+    "notification_status", [NotificationStatus.active, NotificationStatus.closed]
+)
+@pytest.mark.parametrize("alert_solved_at", [None, "now", "five_minutes_ago"])
+async def test_notification_alert_solved(
+    caplog, sample_monitor: Monitor, monkeypatch, alert_status, notification_status, alert_solved_at
+):
+    """'_notification_alert_solved' should close notifications that are active but the alert is
+    already solved"""
+    alert = await Alert.create(
+        monitor_id=sample_monitor.id,
+        status=alert_status,
+        solved_at=get_time(alert_solved_at),  # type:ignore[assignment]
+    )
+    notification = await Notification.create(
+        monitor_id=sample_monitor.id, alert_id=alert.id, target="", status=notification_status
+    )
+
+    if alert_status == AlertStatus.active:
+        triggered = False
+    elif notification_status == NotificationStatus.closed:
+        triggered = False
+    else:
+        triggered = alert_solved_at == "five_minutes_ago"
+
+    await notifications_alert_solved.notifications_alert_solved()
+
+    await notification.refresh()
+    if triggered:
+        assert notification.status == NotificationStatus.closed
+        assert notification.closed_at > now() - timedelta(seconds=1)
+        assert_message_in_log(caplog, f"{notification} closed")
+    else:
+        assert notification.status == notification_status
+        assert notification.closed_at is None
+        assert_message_not_in_log(caplog, f"{notification} closed")
+
+
+async def test_notifications_alert_solved_query_result_none(caplog, monkeypatch):
+    """'notifications_alert_solved' should log an error if the query result is None"""
+    monkeypatch.setattr(
+        notifications_alert_solved.databases, "query_application", AsyncMock(return_value=None)
+    )
+
+    await notifications_alert_solved.notifications_alert_solved()
+
+    assert_message_in_log(caplog, "Error with query result")
+
+
+async def test_notifications_alert_solved_monitor_not_found(caplog, monkeypatch):
+    """'notifications_alert_solved' should log an error if the notification is not found"""
+    monkeypatch.setattr(
+        notifications_alert_solved.databases,
+        "query_application",
+        AsyncMock(return_value=[{"id": 99999999}]),
+    )
+
+    await notifications_alert_solved.notifications_alert_solved()
+
+    assert_message_in_log(caplog, "Notification with id '99999999' not found")
+
+
+async def test_notifications_alert_solved_monitor_not_found_2_results(
+    caplog, monkeypatch, sample_monitor: Monitor
+):
+    """'notifications_alert_solved' should log an error if one notification is not found but should
+    continue with the other notifications"""
+    alert = await Alert.create(monitor_id=sample_monitor.id, status=AlertStatus.active)
+    notification = await Notification.create(
+        monitor_id=sample_monitor.id, alert_id=alert.id, target="", status=NotificationStatus.active
+    )
+
+    monkeypatch.setattr(
+        notifications_alert_solved.databases,
+        "query_application",
+        AsyncMock(return_value=[{"id": 99999999}, {"id": notification.id}]),
+    )
+
+    await notifications_alert_solved.notifications_alert_solved()
+
+    assert_message_in_log(caplog, "Notification with id '99999999' not found")
+    assert_message_in_log(caplog, f"{notification} closed")