Merge pull request #122 from GabrielSalla/create-server-routes

Create server routes

Author: GabrielSalla

src/components/http_server/alert_routes.py

@@ -3,12 +3,64 @@
 from aiohttp.web_response import Response
 
 import commands as commands
-from models import Alert
+from models import Alert, Issue, IssueStatus
+from utils.time import localize
 
 alert_routes = web.RouteTableDef()
 base_route = "/alert"
 
 
+@alert_routes.get(base_route + "/{alert_id}")
+@alert_routes.get(base_route + "/{alert_id}/")
+async def get_alert(request: Request) -> Response:
+    """Route to get the information for an alert"""
+    alert_id = int(request.match_info["alert_id"])
+
+    alert = await Alert.get_by_id(alert_id)
+    if not alert:
+        error_response = {"status": "error", "message": f"alert '{alert_id}' not found"}
+        return web.json_response(error_response, status=404)
+
+    response = {
+        "id": alert.id,
+        "status": alert.status.value,
+        "acknowledged": alert.acknowledged,
+        "locked": alert.locked,
+        "priority": alert.priority,
+        "acknowledge_priority": alert.acknowledge_priority,
+        "can_acknowledge": alert.can_acknowledge,
+        "can_lock": alert.can_lock,
+        "can_solve": alert.can_solve,
+        "created_at": localize(alert.created_at).strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    return web.json_response(response)
+
+
+@alert_routes.get(base_route + "/{alert_id}/issues")
+@alert_routes.get(base_route + "/{alert_id}/issues/")
+async def list_alert_active_issues(request: Request) -> Response:
+    """List active issues for an alert"""
+    alert_id = int(request.match_info["alert_id"])
+
+    issues = await Issue.get_all(
+        Issue.alert_id == alert_id,
+        Issue.status == IssueStatus.active,
+        order_by=[Issue.id],
+    )
+
+    response = [
+        {
+            "id": issue.id,
+            "status": issue.status.value,
+            "model_id": issue.model_id,
+            "data": issue.data,
+            "created_at": localize(issue.created_at).strftime("%Y-%m-%d %H:%M:%S"),
+        }
+        for issue in issues
+    ]
+    return web.json_response(response)
+
+
 @alert_routes.post(base_route + "/{alert_id}/acknowledge")
 @alert_routes.post(base_route + "/{alert_id}/acknowledge/")
 async def alert_acknowledge(request: Request) -> Response:

src/components/http_server/monitor_routes.py

@@ -1,5 +1,6 @@
 import logging
 import traceback
+from collections import Counter
 from typing import Any
 
 import pydantic
@@ -10,7 +11,8 @@
 import commands
 from components.http_server.format_monitor_name import format_monitor_name
 from components.monitors_loader import MonitorValidationError
-from models import CodeModule, Monitor
+from models import Alert, AlertStatus, CodeModule, Monitor
+from utils.time import localize
 
 _logger = logging.getLogger("monitor_routes")
 
@@ -22,21 +24,65 @@
 @monitor_routes.get(base_route + "/list")
 @monitor_routes.get(base_route + "/list/")
 async def list_monitors(request: Request) -> Response:
-    monitors = await Monitor.get_raw(columns=[Monitor.id, Monitor.name, Monitor.enabled])
+    """Route to list all monitors"""
+    monitors = await Monitor.get_all()
+    enabled_monitors = (monitor for monitor in monitors if monitor.enabled)
+
+    active_alerts = await Alert.get_raw(
+        columns=[Alert.monitor_id],
+        column_filters=[
+            Alert.status == AlertStatus.active,
+            Alert.monitor_id.in_(monitor.id for monitor in enabled_monitors),
+        ],
+    )
+    alerts_counter = Counter(alert.monitor_id for alert in active_alerts)
+
     response = [
         {
-            "id": monitor[0],
-            "name": monitor[1],
-            "enabled": monitor[2],
+            "id": monitor.id,
+            "name": monitor.name,
+            "enabled": monitor.enabled,
+            "active_alerts": alerts_counter.get(monitor.id, 0),
         }
         for monitor in monitors
     ]
     return web.json_response(response)
 
 
+@monitor_routes.get(base_route + "/{monitor_id}/alerts")
+@monitor_routes.get(base_route + "/{monitor_id}/alerts/")
+async def list_monitor_active_alerts(request: Request) -> Response:
+    """Route to list active alerts for a monitor"""
+    monitor_id = int(request.match_info["monitor_id"])
+
+    alerts = await Alert.get_all(
+        Alert.monitor_id == monitor_id,
+        Alert.status == AlertStatus.active,
+        order_by=[Alert.id],
+    )
+
+    response = [
+        {
+            "id": alert.id,
+            "status": alert.status.value,
+            "acknowledged": alert.acknowledged,
+            "locked": alert.locked,
+            "priority": alert.priority,
+            "acknowledge_priority": alert.acknowledge_priority,
+            "can_acknowledge": alert.can_acknowledge,
+            "can_lock": alert.can_lock,
+            "can_solve": alert.can_solve,
+            "created_at": localize(alert.created_at).strftime("%Y-%m-%d %H:%M:%S"),
+        }
+        for alert in alerts
+    ]
+    return web.json_response(response)
+
+
 @monitor_routes.get(base_route + "/{monitor_name}")
 @monitor_routes.get(base_route + "/{monitor_name}/")
 async def get_monitor(request: Request) -> Response:
+    """Route to get a monitor by name"""
     monitor_name = request.match_info["monitor_name"]
 
     monitor = await Monitor.get(Monitor.name == monitor_name)

src/models/alert.py

@@ -74,6 +74,11 @@ def can_lock(self) -> bool:
         """Check if the alert can be locked"""
         return not self.locked
 
+    @property
+    def can_solve(self) -> bool:
+        """Check if the alert can be solved"""
+        return not self.issue_options.solvable
+
     @staticmethod
     def calculate_priority(
         rule: AgeRule | CountRule | ValueRule, issues: list[Issue] | Sequence[Issue]

src/plugins/slack/notifications/slack_notification.py

@@ -236,7 +236,7 @@ async def _build_notification_buttons(
                 text="Lock", action_id=f"sentinela_lock_{alert.id}", value=f"lock {alert.id}"
             )
         )
-    if not monitor.code.issue_options.solvable:
+    if alert.can_solve:
         buttons.append(
             slack.MessageButton(
                 text="Solve", action_id=f"sentinela_solve_{alert.id}", value=f"solve {alert.id}"

src/utils/time.py

@@ -12,6 +12,11 @@ def now() -> datetime.datetime:
     return datetime.datetime.now(tz=timezone(configs.time_zone))
 
 
+def localize(dt: datetime.datetime) -> datetime.datetime:
+    """Localize a datetime object to the configured timezone"""
+    return dt.astimezone(timezone(configs.time_zone))
+
+
 def format_datetime_iso(timestamp: datetime.datetime | None) -> str | None:
     return timestamp.isoformat(timespec="milliseconds") if timestamp is not None else None
 

tests/components/http_server/test_alert_routes.py

@@ -6,8 +6,9 @@
 
 import components.controller.controller as controller
 import components.http_server as http_server
-from models import Alert, Monitor
+from models import Alert, Issue, Monitor
 from tests.message_queue.utils import get_queue_items
+from utils.time import localize
 
 pytestmark = pytest.mark.asyncio(loop_scope="session")
 
@@ -23,6 +24,78 @@ async def setup_http_server():
     await http_server.wait_stop()
 
 
+async def test_get_alert(sample_monitor: Monitor):
+    alerts = await Alert.create_batch(
+        [
+            Alert(
+                monitor_id=sample_monitor.id,
+                priority=1,
+            ),
+            Alert(
+                monitor_id=sample_monitor.id,
+                priority=2,
+            ),
+        ]
+    )
+
+    for alert in alerts:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(BASE_URL + f"/{alert.id}") as response:
+                assert await response.json() == {
+                    "id": alert.id,
+                    "status": alert.status.value,
+                    "acknowledged": alert.acknowledged,
+                    "locked": alert.locked,
+                    "priority": alert.priority,
+                    "acknowledge_priority": alert.acknowledge_priority,
+                    "can_acknowledge": alert.can_acknowledge,
+                    "can_lock": alert.can_lock,
+                    "can_solve": alert.can_solve,
+                    "created_at": localize(alert.created_at).strftime("%Y-%m-%d %H:%M:%S"),
+                }
+
+
+async def test_get_alert_not_found(sample_monitor: Monitor):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(BASE_URL + "/0") as response:
+            assert response.status == 404
+            assert await response.json() == {"status": "error", "message": "alert '0' not found"}
+
+
+@pytest.mark.parametrize("issues_count", range(4))
+async def test_list_alert_active_issues(sample_monitor: Monitor, issues_count):
+    alert = await Alert.create(monitor_id=sample_monitor.id)
+
+    issues = await Issue.create_batch(
+        [
+            Issue(
+                monitor_id=sample_monitor.id,
+                alert_id=alert.id,
+            )
+            for _ in range(issues_count)
+        ]
+    )
+
+    async with aiohttp.ClientSession() as session:
+        async with session.get(BASE_URL + f"/{alert.id}/issues") as response:
+            assert await response.json() == [
+                {
+                    "id": issue.id,
+                    "status": issue.status.value,
+                    "model_id": issue.model_id,
+                    "data": issue.data,
+                    "created_at": localize(issue.created_at).strftime("%Y-%m-%d %H:%M:%S"),
+                }
+                for issue in issues
+            ]
+
+
+async def test_list_alert_active_issues_alert_not_found():
+    async with aiohttp.ClientSession() as session:
+        async with session.get(BASE_URL + "/0/issues") as response:
+            assert await response.json() == []
+
+
 async def test_alert_acknowledge(clear_queue, sample_monitor: Monitor):
     """The 'alert acknowledge' route should queue an request to acknowledge the provided alert"""
     alert = await Alert.create(monitor_id=sample_monitor.id)

tests/components/http_server/test_monitor_routes.py

@@ -9,7 +9,7 @@
 import components.http_server as http_server
 import components.monitors_loader as monitors_loader
 import databases as databases
-from models import CodeModule, Monitor
+from models import Alert, AlertStatus, CodeModule, Monitor
 
 pytestmark = pytest.mark.asyncio(loop_scope="session")
 
@@ -37,10 +37,103 @@ async def test_list_monitors(clear_database, sample_monitor: Monitor):
             "id": sample_monitor.id,
             "name": sample_monitor.name,
             "enabled": sample_monitor.enabled,
+            "active_alerts": 0,
         },
     ]
 
 
+@pytest.mark.parametrize("active_alerts", range(1, 5))
+async def test_list_monitors_with_alerts(clear_database, sample_monitor: Monitor, active_alerts):
+    """The 'monitor list' route should return a list of all monitors and the count of active alerts
+    for them"""
+    await Alert.create_batch(
+        Alert(
+            monitor_id=sample_monitor.id,
+            priority=i,
+            acknowledge_priority=5 - i,
+        )
+        for i in range(active_alerts)
+    )
+    await Alert.create(
+        monitor_id=sample_monitor.id,
+        status=AlertStatus.solved,
+        priority=1,
+        acknowledge_priority=1,
+    )
+
+    url = BASE_URL + "/list"
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            response_data = await response.json()
+
+    assert response_data == [
+        {
+            "id": sample_monitor.id,
+            "name": sample_monitor.name,
+            "enabled": sample_monitor.enabled,
+            "active_alerts": active_alerts,
+        },
+    ]
+
+
+async def test_list_monitors_not_enabled(clear_database, sample_monitor: Monitor):
+    """The 'monitor list' route should return a list of all monitors and the count of active alerts
+    for them"""
+    await Alert.create(
+        monitor_id=sample_monitor.id,
+        priority=1,
+        acknowledge_priority=1,
+    )
+    sample_monitor.enabled = False
+    await sample_monitor.save()
+
+    url = BASE_URL + "/list"
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            response_data = await response.json()
+
+    assert response_data == [
+        {
+            "id": sample_monitor.id,
+            "name": sample_monitor.name,
+            "enabled": sample_monitor.enabled,
+            "active_alerts": 0,
+        },
+    ]
+
+
+@pytest.mark.parametrize("alerts_number", [1, 2])
+async def test_list_monitor_active_alerts(clear_database, alerts_number, sample_monitor: Monitor):
+    """The 'monitor active alerts' route should return a list of all active alerts for a monitor"""
+    alerts = await Alert.create_batch(
+        Alert(
+            monitor_id=sample_monitor.id,
+            priority=i,
+            acknowledge_priority=5 - 1,
+        )
+        for i in range(alerts_number)
+    )
+
+    url = BASE_URL + f"/{sample_monitor.id}/alerts"
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            response_data = await response.json()
+
+    assert isinstance(response_data, list)
+    assert len(response_data) == alerts_number
+    for alert, response_alert in zip(alerts, response_data):
+        assert alert.id == response_alert["id"]
+        assert alert.status == response_alert["status"]
+        assert alert.acknowledged == response_alert["acknowledged"]
+        assert alert.locked == response_alert["locked"]
+        assert alert.priority == response_alert["priority"]
+        assert alert.acknowledge_priority == response_alert["acknowledge_priority"]
+        assert alert.can_acknowledge == response_alert["can_acknowledge"]
+        assert alert.can_lock == response_alert["can_lock"]
+        assert alert.can_solve == response_alert["can_solve"]
+        assert alert.created_at.strftime("%Y-%m-%d %H:%M:%S") == response_alert["created_at"]
+
+
 async def test_get_monitor(clear_database, sample_monitor: Monitor):
     """The 'monitor get' route should return the monitor attributes and code information"""
     code_module = await CodeModule.get(CodeModule.monitor_id == sample_monitor.id)