use std::collections::VecDeque;
use std::future::Future;
use tokio::sync::Mutex;
use crate::types::ErrorReport;
struct QueuedReport {
report: ErrorReport,
retries: u8,
}
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()
}
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"]);
}
}