added telegram alert (#62)

Fraccaman · web-flow · commit 11e48cc82ea5 · 2025-10-03T14:48:38.000+02:00
* added telegram alert

* added telegram alert

* added minimum severity for alert
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -29,6 +29,7 @@ async-trait = "0.1.88"
 chrono = "0.4.41"
 prost = "0.13"
 rlimit = "0.10.2"
+telegrama-rs = "0.1.0"
 
 [build-dependencies]
 vergen = { version = "8.0.0", features = ["build", "git", "gitcl"] }
diff --git a/config.toml.example b/config.toml.example
@@ -31,6 +31,7 @@ transfer_limit = 0
 slack_webhook = "example"
 channel = "example"
 mentions = ["@handle"]
+minimum_severity = "Low"
 
 [[ibc]]
 alias = "example"
diff --git a/src/alerts/log.rs b/src/alerts/log.rs
@@ -10,7 +10,7 @@ pub struct Log {
 
 #[async_trait]
 impl AlertTrait for Log {
-    async fn send_alerts(&self, alert: Alert) -> Result<String, String> {
+    async fn send_alerts(&self, alert: Alert) -> Result<Option<String>, String> {
         let title = alert.title.clone();
         let description = alert.description.clone();
         let metadata = alert.metadata.clone();
@@ -32,7 +32,7 @@ impl AlertTrait for Log {
             println!("{}: {}", text.0, text.1);
         }
 
-        Ok(alert.check_id)
+        Ok(Some(alert.check_id))
     }
 
     async fn send_resolve(&self, alert: Alert, date: &str) -> Result<(), String> {
diff --git a/src/alerts/mod.rs b/src/alerts/mod.rs
@@ -1,5 +1,6 @@
 pub mod log;
 pub mod slack;
+pub mod telegram;
 
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
@@ -19,24 +20,38 @@ pub struct AlertManager {
 impl AlertManager {
     pub fn new(app_config: &AppConfig) -> Self {
         let config = app_config.get_config();
+        let any_alert_config = config.slack.is_some() || config.telegram.is_some();
+
+        if !any_alert_config {
+            return Self {
+                communication: vec![Box::new(Log::new(config.block_explorer.clone()))],
+                on_fire: TtlCache::new(100),
+            };
+        };
+
+        let mut alerts: Vec<Box<dyn AlertTrait>> = vec![];
+
         if let Some(slack_config) = config.slack.clone() {
             let slack_alert = slack::SlackAlert::new(
                 config.block_explorer.clone(),
                 slack_config,
                 app_config.chain_id.clone(),
             );
-            Self {
-                communication: vec![
-                    Box::new(slack_alert),
-                    Box::new(Log::new(config.block_explorer.clone())),
-                ],
-                on_fire: TtlCache::new(100),
-            }
-        } else {
-            Self {
-                communication: vec![Box::new(Log::new(config.block_explorer.clone()))],
-                on_fire: TtlCache::new(100),
-            }
+            alerts.push(Box::new(slack_alert));
+        };
+
+        if let Some(telegram_config) = config.telegram.clone() {
+            let telegram_alert = telegram::TelegramAlert::new(
+                config.block_explorer.clone(),
+                telegram_config,
+                app_config.chain_id.clone(),
+            );
+            alerts.push(Box::new(telegram_alert));
+        };
+
+        Self {
+            communication: alerts,
+            on_fire: TtlCache::new(100),
         }
     }
 
@@ -101,7 +116,7 @@ impl AlertManager {
 
 #[async_trait]
 pub trait AlertTrait: Send + Sync {
-    async fn send_alerts(&self, alert: Alert) -> Result<String, String>;
+    async fn send_alerts(&self, alert: Alert) -> Result<Option<String>, String>;
     async fn send_resolve(&self, alert: Alert, date: &str) -> Result<(), String>;
     fn get_block_explorer(&self) -> BlockExplorer;
     fn get_id(&self) -> String;
diff --git a/src/alerts/slack.rs b/src/alerts/slack.rs
@@ -43,11 +43,16 @@ pub struct SlackAlert {
     pub channel: String,
     pub network_id: String,
     pub mentions: Vec<String>,
+    pub minimum_severity: Option<Severity>,
 }
 
 #[async_trait]
 impl AlertTrait for SlackAlert {
-    async fn send_alerts(&self, alert: Alert) -> Result<String, String> {
+    async fn send_alerts(&self, alert: Alert) -> Result<Option<String>, String> {
+        if alert.severity < self.minimum_severity.clone().unwrap_or(Severity::Low) {
+            return Ok(None);
+        }
+
         let block_explorer = self.block_explorer.clone();
 
         let title = alert.title.clone();
@@ -109,7 +114,7 @@ impl AlertTrait for SlackAlert {
             .await;
 
         match res {
-            Ok(response) if response.status().is_success() => return Ok(alert.check_id),
+            Ok(response) if response.status().is_success() => return Ok(Some(alert.check_id)),
             Ok(response) => {
                 return Err(format!(
                     "Failed to send slack alert, status: {:?}",
@@ -189,6 +194,7 @@ impl SlackAlert {
             channel: slack_config.channel,
             network_id,
             mentions: slack_config.mentions,
+            minimum_severity: slack_config.minimum_severity,
         }
     }
 }
diff --git a/src/alerts/telegram.rs b/src/alerts/telegram.rs
@@ -0,0 +1,155 @@
+use anyhow::Context;
+use async_trait::async_trait;
+use telegrama_rs::{ClientOptions, FormattingOptions, Response, Telegrama};
+
+use crate::{
+    alerts::AlertTrait,
+    shared::{
+        alert::{Alert, Severity},
+        block_explorer::BlockExplorer,
+        config::TelegramAlertConfig,
+    },
+};
+
+pub struct TelegramAlert {
+    pub block_explorer: BlockExplorer,
+    pub telegram_token: String,
+    pub telegram_chat_id: String,
+    pub network_id: String,
+    pub minimum_severity: Option<Severity>,
+}
+
+#[async_trait]
+impl AlertTrait for TelegramAlert {
+    async fn send_alerts(&self, alert: Alert) -> Result<Option<String>, String> {
+        if alert.severity < self.minimum_severity.clone().unwrap_or(Severity::Low) {
+            return Ok(None);
+        }
+
+        let block_explorer = self.block_explorer.clone();
+
+        let title = alert.title.clone();
+        let description = alert.description.clone();
+        let metadata = alert.metadata.clone();
+
+        let message = format!(
+            "*{title} - {network}*\n\
+            {description}.\n\
+            *Block*: {height}\n\
+            *Transaction*: {transaction}",
+            title = title,
+            description = description,
+            height = metadata
+                .clone()
+                .block_height
+                .map(|h| format!("<{}|{}>", block_explorer.get_block_url(h), h))
+                .unwrap_or_else(|| "N/A".to_string()),
+            transaction = metadata
+                .clone()
+                .tx_id
+                .map(|tx| format!("<{}|{}>", block_explorer.get_tx_url(&tx), tx))
+                .unwrap_or_else(|| "N/A".to_string()),
+            network = self.network_id,
+        );
+
+        let res = self.send_telegram_message(message).await;
+
+        match res {
+            Ok(response) if response.ok => return Ok(Some(alert.check_id)),
+            Ok(response) => {
+                return Err(format!(
+                    "Failed to send telegram alert, status: {}",
+                    response.description.unwrap_or_default()
+                ));
+            }
+            Err(err) => {
+                return Err(format!("Failed to send telegram alert: {}", err));
+            }
+        }
+    }
+
+    async fn send_resolve(&self, alert: Alert, date: &str) -> Result<(), String> {
+        let title = alert.title.clone();
+
+        let message = format!(
+            "*{title} - {network}*\n\
+            Issue from {data} was resolved.",
+            title = title,
+            data = date,
+            network = self.network_id,
+        );
+
+        let res = self.send_telegram_message(message).await;
+
+        match res {
+            Ok(response) if response.ok => return Ok(()),
+            Ok(response) => {
+                return Err(format!(
+                    "Failed to send slack alert, status: {}",
+                    response.description.unwrap_or_default()
+                ));
+            }
+            Err(err) => {
+                return Err(format!("Failed to send slack alert: {}", err));
+            }
+        }
+    }
+
+    fn get_block_explorer(&self) -> BlockExplorer {
+        self.block_explorer.clone()
+    }
+
+    fn get_id(&self) -> String {
+        "telegram".to_string()
+    }
+}
+
+impl TelegramAlert {
+    pub fn new(
+        block_explorer: BlockExplorer,
+        telegram_config: TelegramAlertConfig,
+        network_id: String,
+    ) -> Self {
+        Self {
+            block_explorer,
+            telegram_token: telegram_config.telegram_token,
+            telegram_chat_id: telegram_config.telegram_chat_id,
+            network_id,
+            minimum_severity: telegram_config.minimum_severity,
+        }
+    }
+
+    async fn send_telegram_message(&self, message: String) -> anyhow::Result<Response> {
+        Telegrama::configure(|config| {
+            config.set_bot_token(&self.telegram_token);
+            config.set_chat_id(&self.telegram_chat_id);
+
+            config.set_default_parse_mode("MarkdownV2"); // or "HTML"
+            config.set_disable_web_page_preview(true);
+
+            let formatting = FormattingOptions {
+                escape_markdown: true,
+                obfuscate_emails: true,
+                escape_html: false,
+                truncate: Some(4096),
+            };
+            config.set_formatting_options(formatting);
+
+            let client_options = ClientOptions {
+                timeout: 30,
+                retry_count: 3,
+                retry_delay: 1,
+            };
+            config.set_client_options(client_options);
+        });
+
+        Telegrama::send_message(
+            message,
+            &[
+                ("parse_mode", "MarkdownV2"),
+                ("disable_web_page_preview", "true"),
+            ],
+        )
+        .context("sending telegram message")
+    }
+}
diff --git a/src/shared/alert.rs b/src/shared/alert.rs
@@ -1,6 +1,8 @@
 use std::time::Duration;
 
-#[derive(Default, Debug, Clone)]
+use serde::Deserialize;
+
+#[derive(Default, Debug, Clone, Deserialize, PartialEq, Eq, PartialOrd)]
 pub enum Severity {
     #[default]
     Low,
diff --git a/src/shared/config.rs b/src/shared/config.rs
@@ -1,5 +1,7 @@
 use serde::Deserialize;
 
+use crate::shared::alert::Severity;
+
 use super::block_explorer::BlockExplorer;
 
 #[derive(Debug, Clone, Deserialize)]
@@ -11,6 +13,7 @@ pub struct Config {
     pub ibcs: Vec<Ibc>,
     pub tokens: Vec<TokenConfig>,
     pub slack: Option<SlackAlertConfig>,
+    pub telegram: Option<TelegramAlertConfig>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -58,6 +61,14 @@ pub struct SlackAlertConfig {
     pub slack_webhook: String,
     pub channel: String,
     pub mentions: Vec<String>,
+    pub minimum_severity: Option<Severity>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct TelegramAlertConfig {
+    pub telegram_token: String,
+    pub telegram_chat_id: String,
+    pub minimum_severity: Option<Severity>,
 }
 
 impl Config {

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ pub struct Log {`
`10`	`10`
`11`	`11`	`#[async_trait]`
`12`	`12`	`impl AlertTrait for Log {`
`13`		`- async fn send_alerts(&self, alert: Alert) -> Result<String, String> {`
	`13`	`+ async fn send_alerts(&self, alert: Alert) -> Result<Option<String>, String> {`
`14`	`14`	`let title = alert.title.clone();`
`15`	`15`	`let description = alert.description.clone();`
`16`	`16`	`let metadata = alert.metadata.clone();`
`@@ -32,7 +32,7 @@ impl AlertTrait for Log {`
`32`	`32`	`println!("{}: {}", text.0, text.1);`
`33`	`33`	`}`
`34`	`34`
`35`		`- Ok(alert.check_id)`
	`35`	`+ Ok(Some(alert.check_id))`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`async fn send_resolve(&self, alert: Alert, date: &str) -> Result<(), String> {`