oluso 0.2.0

AI-powered error monitoring for Rust applications: automatic panic reporting, breadcrumb tracking, and intelligent error grouping.
Documentation
use std::collections::VecDeque;
use std::future::Future;

use tokio::sync::Mutex;

use crate::types::ErrorReport;

struct QueuedReport {
    report: ErrorReport,
    retries: u8,
}

/// In-memory-only retry queue for reports that failed to send. There's
/// nothing durable to persist to here the way @oluso/browser persists to
/// `localStorage` -- a queued report only gets a second chance if a *later*
/// error triggers `process()` again in the same process. On a
/// process that crashes or restarts before that happens, the report is
/// simply lost, same as if retrying weren't attempted at all.
pub(crate) struct OfflineQueue {
    inner: Mutex<VecDeque<QueuedReport>>,
    max_size: usize,
}

impl OfflineQueue {
    pub fn new(max_size: usize) -> Self {
        Self {
            inner: Mutex::new(VecDeque::new()),
            max_size,
        }
    }

    pub async fn enqueue(&self, report: ErrorReport) {
        let mut queue = self.inner.lock().await;
        queue.push_back(QueuedReport { report, retries: 0 });
        while queue.len() > self.max_size {
            queue.pop_front();
        }
    }

    pub async fn is_empty(&self) -> bool {
        self.inner.lock().await.is_empty()
    }

    /// Drains the queue, sending each report in order via `send`, stopping
    /// at the first failure (requeuing it, up to 3 attempts, then dropping
    /// it) rather than hammering an endpoint that's still down. If another
    /// `process` call is already draining the queue, this returns
    /// immediately instead of waiting its turn -- the in-flight call will
    /// pick up whatever's left.
    ///
    /// `send` takes the report by value (cloned out of the queue) rather
    /// than by reference: `Fn(&ErrorReport) -> Fut` would need `Fut`'s type
    /// to vary per call with the reference's lifetime, which a single named
    /// `Fut` type parameter can't express without boxing. This only runs on
    /// the (already rare) retry path, so the clone is not worth avoiding.
    pub async fn process<F, Fut, E>(&self, send: F)
    where
        F: Fn(ErrorReport) -> Fut,
        Fut: Future<Output = Result<(), E>>,
    {
        let Ok(mut queue) = self.inner.try_lock() else {
            return;
        };

        while let Some(front) = queue.front() {
            let report = front.report.clone();
            match send(report).await {
                Ok(()) => {
                    queue.pop_front();
                }
                Err(_) => {
                    if let Some(front) = queue.front_mut() {
                        front.retries += 1;
                        if front.retries >= 3 {
                            queue.pop_front();
                        }
                    }
                    break;
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::{ErrorContext, Severity};
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::sync::Arc;

    fn dummy_report(message: &str) -> ErrorReport {
        ErrorReport {
            schema_version: 2,
            title: message.to_string(),
            message: message.to_string(),
            stack_trace: None,
            environment: "test".to_string(),
            severity: Severity::Medium,
            tags: vec![],
            fingerprint: "abc".to_string(),
            context: ErrorContext::default(),
            timestamp: 0,
            exception: crate::types::ExceptionDetails {
                r#type: "Error".into(),
                message: message.into(),
                stack_trace: None,
                attributes: std::collections::HashMap::new(),
                causes: Vec::new(),
            },
            sdk: crate::types::SdkInfo {
                name: "oluso-rust".into(),
                version: "test".into(),
                language: "rust".into(),
            },
        }
    }

    #[tokio::test]
    async fn drains_the_queue_on_successful_sends() {
        let queue = OfflineQueue::new(10);
        queue.enqueue(dummy_report("a")).await;
        queue.enqueue(dummy_report("b")).await;

        queue.process(|_report| async { Ok::<_, ()>(()) }).await;
        assert!(queue.is_empty().await);
    }

    #[tokio::test]
    async fn stops_at_the_first_failure_and_leaves_the_rest_queued() {
        let queue = OfflineQueue::new(10);
        queue.enqueue(dummy_report("a")).await;
        queue.enqueue(dummy_report("b")).await;

        let attempts = Arc::new(AtomicUsize::new(0));
        let attempts_clone = attempts.clone();
        queue
            .process(move |_report| {
                attempts_clone.fetch_add(1, Ordering::SeqCst);
                async { Err::<(), _>(()) }
            })
            .await;

        assert_eq!(attempts.load(Ordering::SeqCst), 1);
        assert!(!queue.is_empty().await);
    }

    #[tokio::test]
    async fn drops_a_report_after_three_failed_retries() {
        let queue = OfflineQueue::new(10);
        queue.enqueue(dummy_report("a")).await;

        for _ in 0..3 {
            queue.process(|_report| async { Err::<(), _>(()) }).await;
        }

        assert!(queue.is_empty().await);
    }

    #[tokio::test]
    async fn respects_max_size_by_dropping_the_oldest() {
        let queue = OfflineQueue::new(2);
        queue.enqueue(dummy_report("a")).await;
        queue.enqueue(dummy_report("b")).await;
        queue.enqueue(dummy_report("c")).await;

        let seen = Arc::new(Mutex::new(Vec::new()));
        let seen_clone = seen.clone();
        queue
            .process(move |report| {
                let seen = seen_clone.clone();
                let message = report.message.clone();
                async move {
                    seen.lock().await.push(message);
                    Ok::<_, ()>(())
                }
            })
            .await;

        assert_eq!(*seen.lock().await, vec!["b", "c"]);
    }
}