feat(handlers): return Result and remove runtime panic paths (#605)

nolik · claude · web-flow · commit 172ef66ca6a6 · 2026-07-18T15:48:49.000+02:00
Handlers now return `Result&lt;(), AppError&gt;`; the dispatcher endpoint
collects the outcome and logs any error once at the boundary, swallowing
it so a single bad update can't tear down the dispatcher (§1).

Panic sites removed:
- chat_gpt_handler: `msg.text().expect(...)` (x2) -&gt; `let Some(..) else`.
- url_summary_handler: `get_content_call(..).unwrap()` and
  `html2text::from_read(..).unwrap()` -&gt; `?` (HTTP via AppError::Http,
  HTML parse via AppError::BadInput). `get_content_call` now returns
  `Result&lt;_, AppError&gt;` instead of `Box&lt;dyn Error&gt;`.
- rust_mention_handler: `DateTime::from_timestamp(..).unwrap()` -&gt;
  `let Some(..) else { warn!; return Ok(()) }`.
- gpt_service: `gpt_call` returns `Result&lt;_, AppError&gt;` instead of
  `Box&lt;dyn Error&gt;`; `choices[0]` index replaced with `.into_iter().next()`
  + fallback so an empty choices array can't panic.
- chat_repository: `FromRedisValue` for ChatMessage/BotProfile now maps a
  serde failure to a `RedisError` instead of `.expect()`, so a corrupted
  Redis payload returns an error rather than crashing.

The `.map_err(error!).ok()` best-effort swallows and the RUST_CHAT
constant are addressed in the next iteration. No happy-path behavior
change. Local gate green (fmt, clippy -D warnings, unit tests, all
integration tests compile).

Co-authored-by: Claude Opus 4.8 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/boot.rs b/src/boot.rs
@@ -1,6 +1,7 @@
 use std::sync::{Arc, LazyLock};
 
 use chrono::Duration;
+use log::error;
 use redis::aio::ConnectionManager;
 use regex::Regex;
 use sqlx::{PgPool, Pool, Postgres};
@@ -15,7 +16,7 @@ use teloxide::RequestError;
 
 use crate::{
     bf_mention_handler, chat_gpt_handler, gayness_handler, rust_mention_handler,
-    url_summary_handler,
+    url_summary_handler, AppError,
 };
 
 const RUST_REGEX: &str = r"(?i)(rust|раст)(.\W|.$|\W|$)";
@@ -87,7 +88,10 @@ pub fn build_handler() -> UpdateHandler<RequestError> {
              db_pool: Pool<Postgres>,
              gpt_parameters: GptParameters,
              bot: Bot| async move {
-                if let Common(MessageCommon {
+                // Every handler returns `Result<(), AppError>`; errors are
+                // logged once here at the dispatcher boundary and swallowed so
+                // a single bad update never tears down the dispatcher.
+                let outcome: Result<(), AppError> = if let Common(MessageCommon {
                     media_kind: Text(media_text),
                     ..
                 }) = &msg.kind
@@ -121,10 +125,12 @@ pub fn build_handler() -> UpdateHandler<RequestError> {
                             .await
                         }
                         text if mention_parameters.blazing_fast_regex.is_match(text) => {
-                            bf_mention_handler::handle_bf_matched_mention(bot, msg).await
+                            bf_mention_handler::handle_bf_matched_mention(bot, msg).await;
+                            Ok(())
                         }
                         text if mention_parameters.gayness_regex.is_match(text) => {
-                            gayness_handler::handle_gayness_mention(bot, msg).await
+                            gayness_handler::handle_gayness_mention(bot, msg).await;
+                            Ok(())
                         }
                         _ => {
                             if let Some(reply_msg) = &msg.reply_to_message() {
@@ -134,10 +140,18 @@ pub fn build_handler() -> UpdateHandler<RequestError> {
                                     reply_msg,
                                     &gpt_parameters,
                                 )
-                                .await;
+                                .await
+                            } else {
+                                Ok(())
                             }
                         }
                     }
+                } else {
+                    Ok(())
+                };
+
+                if let Err(err) = outcome {
+                    error!("message handler failed: {err}");
                 }
 
                 respond(())
diff --git a/src/chat_gpt_handler.rs b/src/chat_gpt_handler.rs
@@ -4,7 +4,7 @@ use std::sync::LazyLock;
 use crate::chat_gpt_handler::BotProfile::{Fedor, Felix, Ferris};
 use crate::chat_gpt_handler::ChatMessageRole::{System, User};
 use crate::gpt_service::{ChatMessage, ChatMessageRole};
-use crate::{chat_repository, gpt_service, GptParameters};
+use crate::{chat_repository, gpt_service, AppError, GptParameters};
 use log::{error, info};
 use redis::aio::ConnectionManager;
 use regex::Regex;
@@ -66,9 +66,15 @@ static CHAT_SUMMARY_REQUEST_REGEX: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(SUMMARY_REQUEST_REGEX).expect("SUMMARY_REQUEST_REGEX must compile")
 });
 
-pub async fn handle_chat_gpt_question(bot: Bot, msg: Message, gpt_parameters: &GptParameters) {
+pub async fn handle_chat_gpt_question(
+    bot: Bot,
+    msg: Message,
+    gpt_parameters: &GptParameters,
+) -> Result<(), AppError> {
     let chat_id = msg.chat.id;
-    let message = msg.text().expect("can't parse incoming message");
+    let Some(message) = msg.text() else {
+        return Ok(());
+    };
     info!("gpt invocation: chat_id: {chat_id}, message: {message}");
     let bot_profiles = &*BOT_PROFILES;
     let bot_configuration = bot_profiles
@@ -124,6 +130,7 @@ pub async fn handle_chat_gpt_question(bot: Bot, msg: Message, gpt_parameters: &G
         bot_reply_msg_response,
     )
     .await;
+    Ok(())
 }
 
 async fn update_bot_context_and_identifiers(
@@ -165,9 +172,11 @@ pub async fn handle_reply(
     msg: &Message,
     reply_msg: &Message,
     gpt_parameters: &GptParameters,
-) {
+) -> Result<(), AppError> {
     info!("handle reply gpt question");
-    let message = msg.text().expect("can't parse incoming message");
+    let Some(message) = msg.text() else {
+        return Ok(());
+    };
     let chat_id = msg.chat.id;
     let chat_key = &format!("chat:{:#?}", chat_id.0);
     info!("chat_key: {chat_key:?}");
@@ -218,6 +227,7 @@ pub async fn handle_reply(
         )
         .await;
     }
+    Ok(())
 }
 
 async fn fetch_chat_summary_context(
diff --git a/src/chat_repository.rs b/src/chat_repository.rs
@@ -29,7 +29,7 @@ impl ToRedisArgs for ChatMessage {
 impl FromRedisValue for ChatMessage {
     fn from_redis_value(v: &Value) -> RedisResult<Self> {
         let str_value: String = FromRedisValue::from_redis_value(v)?;
-        Ok(serde_json::from_str(&str_value).expect("Can't deserialize Context as string"))
+        serde_json::from_str(&str_value).map_err(deserialize_error::<Self>)
     }
 }
 
@@ -45,10 +45,20 @@ impl ToRedisArgs for BotProfile {
 impl FromRedisValue for BotProfile {
     fn from_redis_value(v: &Value) -> RedisResult<Self> {
         let str_value: String = FromRedisValue::from_redis_value(v)?;
-        Ok(serde_json::from_str(&str_value).expect("Can't deserialize Context as string"))
+        serde_json::from_str(&str_value).map_err(deserialize_error::<Self>)
     }
 }
 
+/// Translate a serde_json failure while reading a value back from Redis into a
+/// `RedisError` instead of panicking on malformed/corrupted payloads.
+fn deserialize_error<T>(err: serde_json::Error) -> redis::RedisError {
+    redis::RedisError::from((
+        redis::ErrorKind::TypeError,
+        "Can't deserialize value from Redis",
+        format!("{}: {err}", std::any::type_name::<T>()),
+    ))
+}
+
 pub async fn get_chat_history(
     connection_manager: &mut ConnectionManager,
     key: i64,
diff --git a/src/gpt_service.rs b/src/gpt_service.rs
@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use teloxide::types::ChatId;
 
-use crate::GptParameters;
+use crate::{AppError, GptParameters};
 
 const GPT_REQUEST_TIMEOUT: Duration = Duration::from_secs(90);
 
@@ -43,14 +43,18 @@ pub async fn chat_gpt_call(
     chat_id: ChatId,
     messages: Vec<ChatMessage>,
 ) -> ChatMessage {
+    let fallback = || ChatMessage {
+        role: ChatMessageRole::Assistant,
+        content: "Братан, давай папазжей, занят сейчас.".to_owned(),
+    };
     match gpt_call(params, chat_id, messages).await {
-        Ok(choices) => choices[0].message.to_owned(),
+        Ok(choices) => choices
+            .into_iter()
+            .next()
+            .map_or_else(fallback, |choice| choice.message),
         Err(err) => {
             error!("Can't execute chat_gpt_call: {}", err);
-            ChatMessage {
-                role: ChatMessageRole::Assistant,
-                content: "Братан, давай папазжей, занят сейчас.".to_owned(),
-            }
+            fallback()
         }
     }
 }
@@ -59,7 +63,7 @@ async fn gpt_call(
     params: &GptParameters,
     chat_id: ChatId,
     messages: Vec<ChatMessage>,
-) -> Result<Vec<Choice>, Box<dyn std::error::Error>> {
+) -> Result<Vec<Choice>, AppError> {
     info!(
         "gpt call invocation from chat_id: {} with context: {:#?}",
         chat_id, messages
diff --git a/src/rust_mention_handler.rs b/src/rust_mention_handler.rs
@@ -1,10 +1,10 @@
 use chrono::{DateTime, Duration, TimeZone, Utc};
-use log::{error, info};
+use log::{error, info, warn};
 use sqlx::PgPool;
 use teloxide::prelude::*;
 use teloxide::types::{InputFile, MessageId, ReplyParameters, ThreadId, User};
 
-use crate::mention_repository;
+use crate::{mention_repository, AppError};
 
 const RUST_CHAT: i64 = -1001228598755;
 const STICKERS: &[&str; 5] = &[
@@ -22,9 +22,12 @@ pub async fn handle_rust_matched_mention(
     message: Message,
     db_pool: PgPool,
     req_time_diff: Duration,
-) {
+) -> Result<(), AppError> {
     let message_date = message.date.timestamp();
-    let curr_date = DateTime::from_timestamp(message_date, 0).unwrap();
+    let Some(curr_date) = DateTime::from_timestamp(message_date, 0) else {
+        warn!("skipping rust mention: nonsensical message timestamp {message_date}");
+        return Ok(());
+    };
     info!(
         "rust mention invocation: chat_id: {}, time: {}",
         message.chat.id, curr_date
@@ -69,6 +72,7 @@ pub async fn handle_rust_matched_mention(
             .ok();
         }
     }
+    Ok(())
 }
 
 async fn send_rust_mention_response(
diff --git a/src/url_summary_handler.rs b/src/url_summary_handler.rs
@@ -1,6 +1,6 @@
 use crate::gpt_service::ChatMessage;
 use crate::gpt_service::ChatMessageRole::{System, User};
-use crate::{gpt_service, GptParameters};
+use crate::{gpt_service, AppError, GptParameters};
 use log::{error, info};
 use regex::Regex;
 use reqwest::Client;
@@ -19,53 +19,55 @@ pub async fn handle_url_summary(
     msg: Message,
     url_regex: Regex,
     gpt_parameters: &GptParameters,
-) {
-    if let Common(MessageCommon {
+) -> Result<(), AppError> {
+    let Common(MessageCommon {
         media_kind: Text(media_text),
         ..
     }) = msg.kind
-    {
-        let msg_text = &media_text.text;
-        let chat_id = msg.chat.id;
-        info!(
-            "url summary invocation: chat_id: {}, msg {}",
-            chat_id, msg_text
-        );
-        let url = url_regex
-            .find(msg_text)
-            .map(|m| m.as_str().to_string())
-            .or(find_link(&media_text));
-        let Some(url) = url else {
-            info!("No URL found in message: {}", msg_text);
-            return;
-        };
+    else {
+        return Ok(());
+    };
 
-        let content = get_content_call(&gpt_parameters.http_client, &url)
-            .await
-            .unwrap();
-        let clean_content = html2text::from_read(content.as_bytes(), 120).unwrap();
-        // Check if the content is long enough to summarize
-        if clean_content.len() < 1000 {
-            return;
-        }
-        let summary = get_gpt_summary(gpt_parameters, chat_id, clean_content).await;
+    let msg_text = &media_text.text;
+    let chat_id = msg.chat.id;
+    info!(
+        "url summary invocation: chat_id: {}, msg {}",
+        chat_id, msg_text
+    );
+    let url = url_regex
+        .find(msg_text)
+        .map(|m| m.as_str().to_string())
+        .or(find_link(&media_text));
+    let Some(url) = url else {
+        info!("No URL found in message: {}", msg_text);
+        return Ok(());
+    };
 
-        let reply_msg = bot
-            .send_message(chat_id, format!("TLDR:\n{}", summary))
-            .reply_parameters(ReplyParameters::new(msg.id));
-        if let Some(thread_id) = msg.thread_id {
-            reply_msg
-                .message_thread_id(thread_id)
-                .await
-                .map_err(|err| error!("Can't send reply: {:?}", err))
-                .ok();
-        } else {
-            reply_msg
-                .await
-                .map_err(|err| error!("Can't send reply: {:?}", err))
-                .ok();
-        }
+    let content = get_content_call(&gpt_parameters.http_client, &url).await?;
+    let clean_content = html2text::from_read(content.as_bytes(), 120)
+        .map_err(|err| AppError::BadInput(format!("failed to parse article HTML: {err}")))?;
+    // Check if the content is long enough to summarize
+    if clean_content.len() < 1000 {
+        return Ok(());
+    }
+    let summary = get_gpt_summary(gpt_parameters, chat_id, clean_content).await;
+
+    let reply_msg = bot
+        .send_message(chat_id, format!("TLDR:\n{}", summary))
+        .reply_parameters(ReplyParameters::new(msg.id));
+    if let Some(thread_id) = msg.thread_id {
+        reply_msg
+            .message_thread_id(thread_id)
+            .await
+            .map_err(|err| error!("Can't send reply: {:?}", err))
+            .ok();
+    } else {
+        reply_msg
+            .await
+            .map_err(|err| error!("Can't send reply: {:?}", err))
+            .ok();
     }
+    Ok(())
 }
 
 fn find_link(media_text: &MediaText) -> Option<String> {
@@ -82,10 +84,7 @@ fn find_link(media_text: &MediaText) -> Option<String> {
         .find_map(|el| el)
 }
 
-async fn get_content_call(
-    client: &Client,
-    url: &str,
-) -> Result<String, Box<dyn std::error::Error>> {
+async fn get_content_call(client: &Client, url: &str) -> Result<String, AppError> {
     let response = client
         .get(url)
         .timeout(ARTICLE_EXTRACTION_TIMEOUT)
