feat: send slack message to test everything is working as expected

Author: McPatate

charts/issue-bot/templates/deployment.yaml

@@ -58,6 +58,10 @@ spec:
           value: "{{ .Values.issueBot.modelApi.authToken }}"
         - name: ISSUE_BOT__MODEL_API__URL
           value: "{{ .Values.issueBot.modelApi.url }}"
+        - name: ISSUE_BOT__SLACK__AUTH_TOKEN
+          value: "{{ .Values.issueBot.slack.authToken }}"
+        - name: ISSUE_BOT__SLACK__CHANNEL
+          value: "{{ .Values.issueBot.slack.channel }}"
         - name: ISSUE_BOT__DATABASE__CONNECTION_STRING
           value: "{{ .Values.issueBot.databaseConnectionString }}"
         ports:

charts/issue-bot/values.yaml

@@ -15,6 +15,9 @@ issueBot:
   modelApi:
     url: ""
     authToken: ""
+  slack:
+    authToken: ""
+    channel: ""
   pathPrefix: /
   ingress:
     annotations: {}

issue-bot/configuration/base.yaml

@@ -30,3 +30,8 @@ server:
   ip: 0.0.0.0
   metrics_port: 4243
   port: 4242
+
+slack:
+  auth_token: ""
+  channel: ""
+  chat_write_url: https://slack.com/api/chat.postMessage

issue-bot/src/config.rs

@@ -73,6 +73,13 @@ pub struct MessageConfig {
     pub post: String,
 }
 
+#[derive(Clone, Debug, Deserialize)]
+pub struct SlackConfig {
+    pub auth_token: String,
+    pub channel: String,
+    pub chat_write_url: String,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct IssueBotConfig {
     pub auth_token: String,
@@ -82,6 +89,7 @@ pub struct IssueBotConfig {
     pub message_config: MessageConfig,
     pub model_api: ModelApiConfig,
     pub server: ServerConfig,
+    pub slack: SlackConfig,
 }
 
 pub fn load_config<'de, T: Deserialize<'de>>(prefix: &str) -> Result<T, ConfigError> {

issue-bot/src/main.rs

@@ -26,6 +26,7 @@ use middlewares::RequestSpan;
 use pgvector::Vector;
 use routes::{health, index_repository};
 use serde::{Deserialize, Deserializer};
+use slack::Slack;
 use sqlx::{
     postgres::{PgConnectOptions, PgPoolOptions},
     prelude::FromRow,
@@ -50,6 +51,7 @@ mod huggingface;
 mod metrics;
 mod middlewares;
 mod routes;
+mod slack;
 
 #[derive(Clone)]
 pub struct AppState {
@@ -251,10 +253,11 @@ async fn handle_webhooks_wrapper(
     embedding_api: EmbeddingApi,
     github_api: GithubApi,
     huggingface_api: HuggingfaceApi,
+    slack: Slack,
     pool: Pool<Postgres>,
 ) -> anyhow::Result<()> {
     select! {
-        res = handle_webhooks(rx, embedding_api, github_api, huggingface_api, pool) => { res },
+        res = handle_webhooks(rx, embedding_api, github_api, huggingface_api, slack, pool) => { res },
         _ = shutdown_signal() => { Ok(()) },
     }
 }
@@ -264,6 +267,7 @@ async fn handle_webhooks(
     embedding_api: EmbeddingApi,
     github_api: GithubApi,
     huggingface_api: HuggingfaceApi,
+    slack: Slack,
     pool: Pool<Postgres>,
 ) -> anyhow::Result<()> {
     while let Some(webhook_data) = rx.recv().await {
@@ -283,6 +287,15 @@ async fn handle_webhooks(
                             .fetch_all(&pool)
                             .await?;
 
+                        slack
+                            .closest_issues(
+                                &issue.title,
+                                issue.number,
+                                &issue.html_url,
+                                &closest_issues,
+                            )
+                            .await?;
+
                         match (issue.is_pull_request, &issue.source) {
                             (false, Source::Github) => {
                                 github_api
@@ -296,7 +309,6 @@ async fn handle_webhooks(
                             }
                             _ => (),
                         }
-                        // TODO: send slack message
 
                         sqlx::query(
                         r#"insert into issues (source_id, source, title, body, is_pull_request, number, html_url, url, embedding)
@@ -569,6 +581,7 @@ async fn main() -> anyhow::Result<()> {
     let embedding_api = EmbeddingApi::new(config.model_api).await?;
     let github_api = GithubApi::new(config.github_api, config.message_config.clone())?;
     let huggingface_api = HuggingfaceApi::new(config.huggingface_api, config.message_config)?;
+    let slack = Slack::new(&config.slack)?;
 
     let (tx, rx) = mpsc::channel(4_096);
 
@@ -588,7 +601,7 @@ async fn main() -> anyhow::Result<()> {
             false,
             setup_metrics_recorder()
         ))),
-        handle_webhooks_wrapper(rx, embedding_api, github_api, huggingface_api, pool)
+        handle_webhooks_wrapper(rx, embedding_api, github_api, huggingface_api, slack, pool)
     )?;
 
     Ok(())

issue-bot/src/slack.rs

@@ -0,0 +1,78 @@
+use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION};
+use serde::Serialize;
+use thiserror::Error;
+
+use crate::{config::SlackConfig, ClosestIssue};
+
+#[derive(Debug, Error)]
+pub enum SlackError {
+    #[error("http client error: {0}")]
+    HttpClient(#[from] reqwest::Error),
+    #[error("invalid auth token value: {0}")]
+    InvalidHeader(#[from] reqwest::header::InvalidHeaderValue),
+}
+
+#[derive(Serialize)]
+struct SlackBody {
+    channel: String,
+    text: String,
+}
+
+impl SlackBody {
+    pub fn new(channel: &str, text: String) -> Self {
+        Self {
+            channel: channel.to_owned(),
+            text,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct Slack {
+    channel: String,
+    chat_write_url: String,
+    client: reqwest::Client,
+}
+
+impl Slack {
+    pub fn new(config: &SlackConfig) -> Result<Self, SlackError> {
+        let mut headers = HeaderMap::new();
+
+        let mut auth_value = HeaderValue::from_str(&format!("Bearer {}", config.auth_token))?;
+        auth_value.set_sensitive(true);
+        headers.insert(AUTHORIZATION, auth_value);
+
+        let client = reqwest::Client::builder()
+            .default_headers(headers)
+            .build()?;
+
+        Ok(Self {
+            channel: config.channel.to_owned(),
+            chat_write_url: config.chat_write_url.to_owned(),
+            client,
+        })
+    }
+
+    pub async fn closest_issues(
+        &self,
+        issue_title: &str,
+        issue_number: i32,
+        issue_html_url: &str,
+        closest_issues: &[ClosestIssue],
+    ) -> Result<(), SlackError> {
+        let mut msg = vec![format!(
+            "Closest issues for {} <{}|#{}>",
+            issue_title, issue_number, issue_html_url
+        )];
+        for ci in closest_issues {
+            msg.push(format!("- {} (<{}|#{}>)", ci.title, ci.html_url, ci.number));
+        }
+        let body = SlackBody::new(&self.channel, msg.join("\n"));
+        self.client
+            .post(self.chat_write_url.to_owned())
+            .json(&body)
+            .send()
+            .await?;
+        Ok(())
+    }
+}