Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

3.9 KB
Raw Blame
//! SQS-backed webhook event queue.

#[cfg(test)]
#[path = "sqs_queue_test.rs"]
mod sqs_queue_test;

use std::{sync::Arc, time::Duration};

use anyhow::{Context, ensure};
use sqs_client::{ReceivedMessage, SQS};

use crate::domain::{
    models::{RawWebhookEventQueueMessage, WebhookEventQueueMessage},
    ports::{WebhookEventEnqueuer, WebhookEventQueue},
};

const MAX_VISIBILITY_TIMEOUT_SECONDS: u64 = 12 * 60 * 60;

/// SQS-backed implementation of webhook enqueueing and worker queue operations.
#[derive(Clone)]
pub struct SqsWebhookQueue {
    sqs: Arc<SQS>,
    queue_url: String,
    max_messages: i32,
    wait_time_seconds: i32,
}

impl SqsWebhookQueue {
    /// Create a webhook queue adapter pointing at `queue_url`.
    pub fn new(
        sqs: Arc<SQS>,
        queue_url: String,
        max_messages: i32,
        wait_time_seconds: i32,
    ) -> Self {
        Self {
            sqs,
            queue_url,
            max_messages,
            wait_time_seconds,
        }
    }
}

impl WebhookEventEnqueuer for SqsWebhookQueue {
    type Err = anyhow::Error;

    #[tracing::instrument(
        err,
        skip(self, message),
        fields(
            webhook_id = %message.webhook_id,
            event_id = %message.event.event_id,
        )
    )]
    async fn enqueue(&self, message: WebhookEventQueueMessage) -> Result<(), Self::Err> {
        let prepared = prepare_webhook_message(&message)?;

        self.sqs
            .send_fifo_message(
                &self.queue_url,
                prepared.body,
                prepared.group_id,
                prepared.deduplication_id,
            )
            .await?;

        Ok(())
    }
}

impl WebhookEventQueue for SqsWebhookQueue {
    type Err = anyhow::Error;

    #[tracing::instrument(err, skip(self))]
    async fn receive_messages(&self) -> Result<Vec<RawWebhookEventQueueMessage>, Self::Err> {
        let messages = self
            .sqs
            .receive_messages(&self.queue_url, self.max_messages, self.wait_time_seconds)
            .await?;

        Ok(messages.into_iter().map(raw_webhook_message).collect())
    }

    #[tracing::instrument(err, skip(self, receipt_handle))]
    async fn delete_message(&self, receipt_handle: &str) -> Result<(), Self::Err> {
        self.sqs
            .delete_message(&self.queue_url, receipt_handle)
            .await?;

        Ok(())
    }

    #[tracing::instrument(
        err,
        skip(self, receipt_handle),
        fields(delay_seconds = delay.as_secs())
    )]
    async fn delay_message(&self, receipt_handle: &str, delay: Duration) -> Result<(), Self::Err> {
        let visibility_timeout = visibility_timeout_seconds(delay)?;

        self.sqs
            .change_message_visibility(&self.queue_url, receipt_handle, visibility_timeout)
            .await?;

        Ok(())
    }
}

#[derive(Debug, PartialEq, Eq)]
struct PreparedWebhookMessage {
    body: String,
    group_id: String,
    deduplication_id: String,
}

fn prepare_webhook_message(
    message: &WebhookEventQueueMessage,
) -> anyhow::Result<PreparedWebhookMessage> {
    let group_id = message.webhook_id.clone();
    let deduplication_id = format!("{}:{}", message.webhook_id, message.event.event_id);
    let body =
        serde_json::to_string(message).context("unable to serialize webhook queue message")?;

    Ok(PreparedWebhookMessage {
        body,
        group_id,
        deduplication_id,
    })
}

fn raw_webhook_message(message: ReceivedMessage) -> RawWebhookEventQueueMessage {
    RawWebhookEventQueueMessage {
        message_id: message.message_id,
        body: message.body,
        receipt_handle: message.receipt_handle,
    }
}

fn visibility_timeout_seconds(delay: Duration) -> anyhow::Result<i32> {
    let seconds = delay.as_secs();
    ensure!(
        seconds <= MAX_VISIBILITY_TIMEOUT_SECONDS,
        "webhook message visibility delay cannot exceed {MAX_VISIBILITY_TIMEOUT_SECONDS} seconds"
    );

    Ok(seconds as i32)
}