Merge pull request #96 from GabrielSalla/internal-monitor-notification-config

GabrielSalla · web-flow · commit 4b84b2aa6993 · 2025-06-19T17:07:06.000-03:00
Internal monitor notifications set through config
diff --git a/configs/configs-scalable.yaml b/configs/configs-scalable.yaml
@@ -7,6 +7,12 @@ plugins:
 load_sample_monitors: true
 sample_monitors_path: sample_monitors
 internal_monitors_path: internal_monitors
+internal_monitors_notification:
+  enabled: true
+  notification_class: plugin.slack.notifications.SlackNotification
+  params:
+    min_priority_to_send: low
+    min_priority_to_mention: moderate
 monitors_load_schedule: "*/5 * * * *"
 
 logging:
diff --git a/configs/configs.yaml b/configs/configs.yaml
@@ -7,6 +7,12 @@ plugins:
 load_sample_monitors: true
 sample_monitors_path: sample_monitors
 internal_monitors_path: internal_monitors
+internal_monitors_notification:
+  enabled: true
+  notification_class: plugin.slack.notifications.SlackNotification
+  params:
+    min_priority_to_send: low
+    min_priority_to_mention: moderate
 monitors_load_schedule: "*/5 * * * *"
 
 logging:
diff --git a/docs/configuration_file.md b/docs/configuration_file.md
@@ -8,12 +8,16 @@ This document provides an overview of the configuration parameters available in
 - `load_sample_monitors`: Boolean. Flag to enable the sample monitors.
 - `sample_monitors_path`: String. Path relative to the project root, where the sample monitors are stored.
 - `internal_monitors_path`: String. Path relative to the project root, where the internal monitors are stored.
+- `internal_monitors_notification`: Map. Settings for the notification to be sent by the internal monitors.
+  - `enabled`: Boolean. Flag to enable the internal monitors notification.
+  - `notification_class`: String. Class to be used for the notification. Example: `plugin.my_plugin.notifications.SomeNotificationClass`.
+  - `params`: Map. The desired parameters for the notification. Each notification class will have its own set of parameters. Check the documentation for each notification class to learn more about the available parameters.
 - `monitors_load_schedule`: String using Cron format. Schedule to reload monitors from the database.
 
 ## Logging
 - `logging.mode`: String. Logging mode. Can be "friendly" or "json".
 - `logging.format`: String. Settings for formatting the "friendly" logs.
-- `logging.fields`: Object. Fields to include in the "json" logs and their name from the `logging` module.
+- `logging.fields`: Map. Fields to include in the "json" logs and their name from the `logging` module.
 
 Suggested configuration for `friendly` logs:
 ```yaml
@@ -59,8 +63,8 @@ application_queue:
 ## Controller Settings
 - `controller_process_schedule`: String using Cron format. Schedule to check if monitors need to be processed.
 - `controller_concurrency`: Integer. Number of monitors that can be processed at the same time by the Controller.
-- `controller_procedures`: Object. Procedures to be executed by the Controller and their settings.
-- `controller_procedures.monitors_stuck`: Object. Settings for the procedure to fix monitors stuck in "queued" or "running" status.
+- `controller_procedures`: Map. Procedures to be executed by the Controller and their settings.
+- `controller_procedures.monitors_stuck`: Map. Settings for the procedure to fix monitors stuck in "queued" or "running" status.
 - `controller_procedures.monitors_stuck.schedule`: String using Cron format. Schedule to execute the `monitors_stuck` procedure.
 - `controller_procedures.monitors_stuck.params.time_tolerance`: Integer. Time tolerance in seconds for a monitor to be considered as stuck. This parameter is directly impacted by the `executor_monitor_heartbeat_time` setting and the recommended value is 2 times the heartbeat time.
 
diff --git a/docs/plugins/plugins.md b/docs/plugins/plugins.md
@@ -54,10 +54,11 @@ Notifications must have the structure defined by the `src.notifications.base_not
 Notification base structure must be as follows:
 ```python
 from data_models.monitor_options import reaction_function_type
+from monitor_utils import AlertPriority
 
 
 class Notification:
-    min_priority_to_send: int = 5
+    min_priority_to_send: AlertPriority = AlertPriority.low
 
     def reactions_list(self) -> list[tuple[str, list[reaction_function_type]]]:
         ...
@@ -66,10 +67,11 @@ class Notification:
 An example of a notification implementation is shown bellow, where there are 3 different events with reactions set for them.
 ```python
 from data_models.monitor_options import reaction_function_type
+from monitor_utils import AlertPriority
 
 
 class MyNotification:
-    min_priority_to_send: int = 5
+    min_priority_to_send: AlertPriority = AlertPriority.low
 
     def reactions_list(self) -> list[tuple[str, list[reaction_function_type]]]:
         """Get a list of events that the notification will react to"""
diff --git a/docs/plugins/slack.md b/docs/plugins/slack.md
@@ -12,10 +12,8 @@ The following environment variables are used by the Slack plugin:
 - `SLACK_TOKEN`: The token used to send messages to Slack. This token is generated when you create your Slack app and install it in your workspace. Example: `xoxb-1234567890-1234567890123-12345678901234567890abcdef`.
 - `SLACK_WEBSOCKET_ENABLED`: A flag to enable or disable the websocket connection for receiving events from Slack. Set this to `true` to enable the websocket or `false` to disable it. Defaults to `false`.
 - `SLACK_APP_TOKEN`: The token used to start the websocket connection for receiving events from interactions with the Sentinela Slack app. This token is generated when you create your Slack app and enable the Socket Mode. Example: `xapp-1234567890-1234567890123-12345678901234567890abcdef`.
-- `SAMPLE_SLACK_CHANNEL`: The Slack channel where notifications for **sample monitors** will be sent. Example: `C0011223344`.
-- `SAMPLE_SLACK_MENTION`: The Slack user or group to mention in notifications for **sample monitors**. Example: `U0011223344`.
-- `SLACK_MAIN_CHANNEL`: The Slack channel where notifications for **internal monitors** will be sent. Example: `C0011223344`.
-- `SLACK_MAIN_MENTION`: The Slack user or group to mention in notifications for **internal monitors**. Example: `U0011223344`.
+- `SLACK_MAIN_CHANNEL`: The Slack channel where notifications for **internal monitors** and **sample monitors** will be sent. Example: `C0011223344`.
+- `SLACK_MAIN_MENTION`: The Slack user or group to mention in notifications for **internal monitors** and **sample monitors**. Example: `U0011223344`.
 
 ## Slack commands
 Sentinela provides two main ways to interact through Slack:
@@ -91,5 +89,15 @@ notification_options = [
 ]
 ```
 
+### Using Slack notification for internal monitors
+To use the Slack notification for internal monitors, the settings for the `internal_monitors_notification` key in the `configs.yaml` file must be configured as follows:
+- `notification_class`: Should be set to `plugin.slack.notifications.SlackNotification`
+- `params`: Should include the desired parameters for the notification.
+    - `channel` and `mention` will be obtained from the environment variables `SLACK_MAIN_CHANNEL` and `SLACK_MAIN_MENTION`, respectively, as specified in [Environment variables](#environment-variables).
+  - `title` and `issues_fields` are specific to each monitor and are already defined in the internal monitors. If configured in the `params` field, they will be ignored.
+  - `min_priority_to_send`, `min_priority_to_mention`, `mention_on_update`, and `issue_show_limit` can be set in the `params` field to customize the notification behavior. If not set, the default values will be used.
+
+The provided settings will be applied to every internal and sample monitors.
+
 ## Services
 The Slack plugin includes a service that connects to the Slack websocket API to receive mentions and button press events. Any event received will queue an action to be processed by Sentinela.
diff --git a/internal_monitors/monitor_high_active_issues_count/monitor_high_active_issues_count.py b/internal_monitors/monitor_high_active_issues_count/monitor_high_active_issues_count.py
@@ -3,20 +3,18 @@
 affected from a high resource usage.
 """
 
-import os
 from typing import TypedDict, cast
 
 from databases import query_application
 from monitor_utils import (
     AlertOptions,
-    AlertPriority,
     IssueOptions,
     MonitorOptions,
     PriorityLevels,
     ValueRule,
     read_file,
 )
-from plugins.slack import SlackNotification
+from notifications.internal_monitor_notification import internal_monitor_notification
 
 TRIGGER_THRESHOLD = 500
 
@@ -66,13 +64,7 @@ def is_solved(issue_data: IssueDataType) -> bool:
     return active_issues_count < TRIGGER_THRESHOLD / 2
 
 
-notification_options = [
-    SlackNotification(
-        channel=os.environ["SLACK_MAIN_CHANNEL"],
-        title="Monitor with high active issues count",
-        issues_fields=["monitor_id", "monitor_name", "active_issues_count"],
-        mention=os.environ["SLACK_MAIN_MENTION"],
-        min_priority_to_send=AlertPriority.low,
-        min_priority_to_mention=AlertPriority.moderate,
-    )
-]
+notification_options = internal_monitor_notification(
+    name="Monitor with high active issues count",
+    issues_fields=["monitor_id", "monitor_name", "active_issues_count"],
+)
diff --git a/resources/kubernetes_template/config_map.yaml b/resources/kubernetes_template/config_map.yaml
@@ -13,6 +13,12 @@ data:
     load_sample_monitors: true
     sample_monitors_path: sample_monitors
     internal_monitors_path: internal_monitors
+    internal_monitors_notification:
+      enabled: true
+      notification_class: plugin.slack.notifications.SlackNotification
+      params:
+        min_priority_to_send: low
+        min_priority_to_mention: moderate
     monitors_load_schedule: "*/5 * * * *"
 
     logging:
diff --git a/sample_monitors/test_monitor/test_monitor.py b/sample_monitors/test_monitor/test_monitor.py
@@ -1,9 +1,8 @@
-import os
 import random
 from typing import TypedDict
 
 from monitor_utils import AlertOptions, CountRule, IssueOptions, MonitorOptions, PriorityLevels
-from plugins.slack import SlackNotification
+from notifications.internal_monitor_notification import internal_monitor_notification
 
 monitor_options = MonitorOptions(
     search_cron="* * * * *",
@@ -64,11 +63,6 @@ def is_solved(issue_data: IssueDataType) -> bool:
     return issue_data["value"] == 1
 
 
-notification_options = [
-    SlackNotification(
-        channel=os.environ["SAMPLE_SLACK_CHANNEL"],
-        title="Test monitor",
-        issues_fields=["id", "value"],
-        mention=os.environ["SAMPLE_SLACK_MENTION"],
-    )
-]
+notification_options = internal_monitor_notification(
+    name="Test monitor", issues_fields=["id", "value"]
+)
diff --git a/src/configs/configs_loader.py b/src/configs/configs_loader.py
@@ -2,7 +2,15 @@
 from typing import Any, Literal
 
 import yaml
-from pydantic.dataclasses import Field, dataclass
+from pydantic.dataclasses import dataclass
+from pydantic.fields import Field
+
+
+@dataclass
+class InternalMonitorsNotificationConfig:
+    enabled: bool
+    notification_class: str
+    params: dict[str, Any] = Field(default_factory=dict)
 
 
 @dataclass
@@ -40,6 +48,8 @@ class Configs:
     load_sample_monitors: bool
     sample_monitors_path: str
     internal_monitors_path: str
+    internal_monitors_notification: InternalMonitorsNotificationConfig
+
     monitors_load_schedule: str
 
     application_database_settings: ApplicationDatabaseConfig
diff --git a/src/main.py b/src/main.py
@@ -28,13 +28,16 @@ async def init(controller_enabled: bool, executor_enabled: bool) -> None:
     log.setup()
     app.setup()
     registry.init()
-    # Depends on internal database migrated
-    await monitors_loader.init(controller_enabled)
-    await http_server.init(controller_enabled)
 
+    # Plugins must be initialized before the monitors loader as the register process will require
+    # the plugins to be loaded
     plugins.load_plugins()
     await plugins.services.init_plugin_services(controller_enabled, executor_enabled)
 
+    # Depends on internal database migrated
+    await monitors_loader.init(controller_enabled)
+    await http_server.init(controller_enabled)
+
     # The following modules depend on the plugins being loaded
     await databases.init()
     await message_queue.init()
diff --git a/src/notifications/base_notification.py b/src/notifications/base_notification.py
@@ -1,10 +1,19 @@
-from typing import Protocol, runtime_checkable
+from typing import Any, Protocol, runtime_checkable
 
 from data_models.monitor_options import reaction_function_type
+from models.utils.priority import AlertPriority
 
 
 @runtime_checkable
 class BaseNotification(Protocol):  # pragma: no cover
-    min_priority_to_send: int = 5
+    min_priority_to_send: AlertPriority = AlertPriority.informational
+
+    @classmethod
+    def create(
+        cls: type["BaseNotification"],
+        name: str,
+        issues_fields: list[str],
+        params: dict[str, Any],
+    ) -> "BaseNotification": ...
 
     def reactions_list(self) -> list[tuple[str, list[reaction_function_type]]]: ...
diff --git a/src/notifications/internal_monitor_notification.py b/src/notifications/internal_monitor_notification.py
@@ -0,0 +1,29 @@
+import logging
+
+from configs import configs
+from notifications.base_notification import BaseNotification
+from plugins.attribute_select import get_plugin_attribute
+
+_logger = logging.getLogger("internal_monitor_notification")
+
+
+def internal_monitor_notification(name: str, issues_fields: list[str]) -> list[BaseNotification]:
+    """Create a notification instance for internal monitors, using the settings in the configs
+    file."""
+    internal_monitors_notification = configs.internal_monitors_notification
+
+    if not internal_monitors_notification.enabled:
+        return []
+
+    notification_class_path = internal_monitors_notification.notification_class
+    notification_class = get_plugin_attribute(notification_class_path)
+    params = internal_monitors_notification.params
+
+    if not isinstance(notification_class, BaseNotification):
+        raise TypeError(f"Attribute '{notification_class_path}' is not a valid notification")
+
+    try:
+        return [notification_class.create(name=name, issues_fields=issues_fields, params=params)]
+    except Exception as e:
+        _logger.error(e.args[0])
+        return []
diff --git a/src/plugins/slack/__init__.py b/src/plugins/slack/__init__.py
@@ -1,8 +1,7 @@
-from . import actions, services
-from .notifications.slack_notification import SlackNotification
+from . import actions, notifications, services
 
 __all__ = [
     "actions",
+    "notifications",
     "services",
-    "SlackNotification",
 ]
diff --git a/src/plugins/slack/notifications/__init__.py b/src/plugins/slack/notifications/__init__.py
@@ -0,0 +1,3 @@
+from .slack_notification import SlackNotification
+
+__all__ = ["SlackNotification"]
diff --git a/src/plugins/slack/notifications/slack_notification.py b/src/plugins/slack/notifications/slack_notification.py
@@ -63,12 +63,51 @@ class SlackNotification:
     channel: str
     title: str
     issues_fields: list[str]
-    min_priority_to_send: int = AlertPriority.low
+    min_priority_to_send: AlertPriority = AlertPriority.low
     mention: str | None = None
     mention_on_update: bool = False
-    min_priority_to_mention: int = AlertPriority.moderate
+    min_priority_to_mention: AlertPriority = AlertPriority.moderate
     issue_show_limit: int = 10
 
+    @classmethod
+    def create(
+        cls: type["SlackNotification"],
+        name: str,
+        issues_fields: list[str],
+        params: dict[str, Any] = {},
+    ) -> "SlackNotification":
+        """Create a new instance of the 'SlackNotification' class from the notification protocol."""
+        try:
+            channel = os.environ["SLACK_MAIN_CHANNEL"]
+        except KeyError:
+            raise KeyError(
+                "Environment variable 'SLACK_MAIN_CHANNEL' is not set. "
+                "Unable to create 'SlackNotification' instance"
+            )
+
+        init_params: dict[str, Any] = {
+            "channel": channel,
+            "title": name,
+            "issues_fields": issues_fields,
+            "mention": os.environ.get("SLACK_MAIN_MENTION"),
+        }
+
+        if "min_priority_to_send" in params:
+            init_params["min_priority_to_send"] = AlertPriority[params["min_priority_to_send"]]
+
+        if "mention_on_update" in params:
+            init_params["mention_on_update"] = params["mention_on_update"]
+
+        if "min_priority_to_mention" in params:
+            init_params["min_priority_to_mention"] = AlertPriority[
+                params["min_priority_to_mention"]
+            ]
+
+        if "issue_show_limit" in params:
+            init_params["issue_show_limit"] = params["issue_show_limit"]
+
+        return cls(**init_params)
+
     def reactions_list(self) -> list[tuple[str, list[reaction_function_type]]]:
         """Get a list of events that the notification will react to"""
         handle_notification_function = partial(handle_event, notification_options=self)
diff --git a/tests/module_loader/test_checker.py b/tests/module_loader/test_checker.py
@@ -16,6 +16,7 @@
     PriorityLevels,
     ReactionOptions,
 )
+from models.utils.priority import AlertPriority
 
 
 @pytest.fixture(scope="function")
@@ -265,7 +266,15 @@ def test_check_reaction_options_wrong_type(monitor_mock):
 class BaseNotification:
     """Notification class to be used in the tests"""
 
-    min_priority_to_send: int = 5
+    min_priority_to_send: AlertPriority = AlertPriority.informational
+
+    @classmethod
+    def create(
+        cls: type["BaseNotification"],
+        name: str,
+        issues_fields: list[str],
+        params: dict[str, Any],
+    ) -> "BaseNotification": ...
 
     def reactions_list(self) -> list[tuple[str, list[Coroutine[Any, Any, Any]]]]:
         return []
diff --git a/tests/notifications/test_internal_monitor_notification.py b/tests/notifications/test_internal_monitor_notification.py
diff --git a/tests/plugins/slack/notifications/test_slack_notification.py b/tests/plugins/slack/notifications/test_slack_notification.py
