feat: add notifications for slack, telegram and generic

Author: janezicmatej

.env.example

@@ -1,3 +1,7 @@
 IDENTITY_ADDRESS=address
 RPC_URL=url
-DISCORD_WEBHOOK=webhook
+NOTIFICATION_DISCORD_WEBHOOK=https://discord.com/api/webhooks/secret/secret
+NOTIFICATION_TELEGRAM_BOT_TOKEN=secret
+NOTIFICATION_TELEGRAM_CHAT_ID=secret
+NOTIFICATION_SLACK_WEBHOOK=https://hooks.slack.com/services/secret/secret/secret
+NOTIFICATION_GENERIC_WEBHOOK=http://host:port/path

README.md

@@ -6,10 +6,24 @@
 
 deploy:
 
+currently we support push notification over:
+- discord webhook
+- slack webhook
+- telegram bot sendMessage method
+- generic url post
+
+All of these can be configured via env variables. All of these have `NOTIFICATION` and 
+aren't a required value for the observer to start. All example values below
+
 ```bash
 docker run \
     -e RPC_URL="http://host/ext/bc/C/rpc" \
     -e IDENTITY_ADDRESS="0x0000000000000000000000000000000000000000" \
+    -e NOTIFICATION_DISCORD_WEBHOOK="https://discord.com/api/webhooks/secret/secret" \
+    -e NOTIFICATION_TELEGRAM_BOT_TOKEN="secret" \
+    -e NOTIFICATION_TELEGRAM_CHAT_ID="secret" \
+    -e NOTIFICATION_SLACK_WEBHOOK="https://hooks.slack.com/services/secret/secret/secret" \
+    -e NOTIFICATION_GENERIC_WEBHOOK="http://host:port/path" \
     ghcr.io/flare-foundation/fsp-observer:main
 ```
 
@@ -46,7 +60,7 @@ todos:
     - notification plugins
         - [x] stdout logging
         - [x] discord
-        - [ ] slack
-        - [ ] telegram
+        - [x] slack
+        - [x] telegram
         - [ ] pager duty
-        - [ ] generic post
+        - [x] generic post

configuration/config.py

@@ -4,7 +4,16 @@
 from py_flare_common.fsp.epoch.timing import coston, coston2, flare, songbird
 from web3 import Web3
 
-from .types import Configuration, Contracts, Epoch
+from .types import (
+    Configuration,
+    Contracts,
+    Epoch,
+    Notification,
+    NotificationDiscord,
+    NotificationGeneric,
+    NotificationSlack,
+    NotificationTelegram,
+)
 
 
 class ChainId:
@@ -57,6 +66,39 @@ def get_epoch(chain_id: int) -> Epoch:
     )
 
 
+def get_notification_config() -> Notification:
+    discord = None
+    discord_webhook = os.environ.get("NOTIFICATION_DISCORD_WEBHOOK")
+    if discord_webhook is not None:
+        discord = NotificationDiscord(discord_webhook)
+
+    slack = None
+    slack_webhook = os.environ.get("NOTIFICATION_SLACK_WEBHOOK")
+    if slack_webhook is not None:
+        slack = NotificationSlack(slack_webhook)
+
+    telegram = None
+    telegram_bot_token = os.environ.get("NOTIFICATION_TELEGRAM_BOT_TOKEN")
+    telegram_chat_id = os.environ.get("NOTIFICATION_TELEGRAM_CHAT_ID")
+    if telegram_bot_token is not None and telegram_chat_id is not None:
+        telegram = NotificationTelegram(
+            bot_token=telegram_bot_token,
+            chat_id=telegram_chat_id,
+        )
+
+    generic = None
+    generic_webhook = os.environ.get("NOTIFICATION_GENERIC_WEBHOOK")
+    if generic_webhook is not None:
+        generic = NotificationGeneric(generic_webhook)
+
+    return Notification(
+        discord=discord,
+        slack=slack,
+        telegram=telegram,
+        generic=generic,
+    )
+
+
 def get_config() -> Configuration:
     rpc_url = os.environ.get("RPC_URL")
 
@@ -81,7 +123,7 @@ def get_config() -> Configuration:
         chain_id=chain_id,
         contracts=Contracts.get_contracts(w),
         epoch=get_epoch(chain_id),
-        discord_webhook=os.environ.get("DISCORD_WEBHOOK"),
+        notification=get_notification_config(),
     )
 
     return config

configuration/types.py

@@ -179,11 +179,40 @@ class Epoch:
     reward_epoch_factory: RewardEpochFactory
 
 
+@frozen
+class NotificationDiscord:
+    webhook_url: str
+
+
+@frozen
+class NotificationSlack:
+    webhook_url: str
+
+
+@frozen
+class NotificationTelegram:
+    bot_token: str
+    chat_id: str
+
+
+@frozen
+class NotificationGeneric:
+    webhook_url: str
+
+
+@frozen
+class Notification:
+    discord: NotificationDiscord | None
+    slack: NotificationSlack | None
+    telegram: NotificationTelegram | None
+    generic: NotificationGeneric | None
+
+
 @frozen
 class Configuration:
     identity_address: ChecksumAddress
     chain_id: int
     contracts: Contracts
     rpc_url: str
     epoch: Epoch
-    discord_webhook: str | None
+    notification: Notification

observer/observer.py

@@ -25,7 +25,13 @@
 from web3.middleware import ExtraDataToPOAMiddleware
 
 from configuration.config import ChainId
-from configuration.types import Configuration
+from configuration.types import (
+    Configuration,
+    NotificationDiscord,
+    NotificationGeneric,
+    NotificationSlack,
+    NotificationTelegram,
+)
 from observer.reward_epoch_manager import (
     Entity,
     SigningPolicy,
@@ -62,17 +68,38 @@ def from_vrs(cls, s: SSignature) -> Self:
         )
 
 
-def notify_discord(config: Configuration, message: str) -> None:
-    if config.discord_webhook is None:
-        return
-
+def notify_discord(config: NotificationDiscord, message: str) -> None:
     requests.post(
-        config.discord_webhook,
+        config.webhook_url,
         headers={"Content-Type": "application/json"},
         json={"content": message},
     )
 
 
+def notify_slack(config: NotificationSlack, message: str) -> None:
+    requests.post(
+        config.webhook_url,
+        headers={"Content-Type": "application/json"},
+        json={"text": message},
+    )
+
+
+def notify_telegram(config: NotificationTelegram, message: str) -> None:
+    requests.post(
+        f"https://api.telegram.org/bot{config.bot_token}/sendMessage",
+        headers={"Content-Type": "application/json"},
+        json={"chat_id": config.chat_id, "text": message},
+    )
+
+
+def notify_generic(config: NotificationGeneric, issue: "Issue") -> None:
+    requests.post(
+        config.webhook_url,
+        headers={"Content-Type": "application/json"},
+        json={"level": issue.level.value, "message": issue.message},
+    )
+
+
 async def find_voter_registration_blocks(
     w: AsyncWeb3,
     current_block_id: int,
@@ -259,9 +286,22 @@ def add_message(self, m: str) -> Self:
         return self
 
 
-def log_issue(config, issue: Issue):
+def log_issue(config: Configuration, issue: Issue):
     LOGGER.log(issue.level.value, issue.message)
-    notify_discord(config, issue.level.name + " " + issue.message)
+
+    n = config.notification
+
+    if n.discord is not None:
+        notify_discord(n.discord, issue.level.name + " " + issue.message)
+
+    if n.slack is not None:
+        notify_slack(n.slack, issue.level.name + " " + issue.message)
+
+    if n.telegram is not None:
+        notify_telegram(n.telegram, issue.level.name + " " + issue.message)
+
+    if n.generic is not None:
+        notify_generic(n.generic, issue)
 
 
 def extract[T](
@@ -503,10 +543,10 @@ async def observer_loop(config: Configuration) -> None:
     #     Issue(
     #         IssueLevel.INFO,
     #         MessageBuilder()
-    #         .add_network(config.chain)
+    #         .add_network(config.chain_id)
     #         .add_protocol(100)
     #         .add_round(VotingEpoch(12, None))
-    #         .build_with_message("testing message"),
+    #         .build_with_message("testing message" + str(config.notification)),
     #     ),
     # )
     # return