oluso 0.2.0

AI-powered error monitoring for Rust applications: automatic panic reporting, breadcrumb tracking, and intelligent error grouping.
Documentation
use std::fmt;
use std::time::Duration;

use crate::types::ErrorReport;

#[derive(Debug)]
pub enum TransportError {
    Request(reqwest::Error),
    Serialize(serde_json::Error),
    PayloadTooLarge(usize),
    Status(u16),
}

impl fmt::Display for TransportError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TransportError::Request(err) => write!(f, "failed to send error report: {err}"),
            TransportError::Serialize(err) => write!(f, "failed to serialize error report: {err}"),
            TransportError::PayloadTooLarge(size) => write!(
                f,
                "error report payload is {size} bytes; maximum is {MAX_PAYLOAD_BYTES}"
            ),
            TransportError::Status(status) => {
                write!(f, "error reporting failed with status {status}")
            }
        }
    }
}

impl std::error::Error for TransportError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            TransportError::Request(err) => Some(err),
            TransportError::Serialize(err) => Some(err),
            TransportError::PayloadTooLarge(_) | TransportError::Status(_) => None,
        }
    }
}

pub(crate) async fn send_error_report(
    http: &reqwest::Client,
    endpoint: &str,
    api_key: &str,
    timeout: Duration,
    report: &ErrorReport,
) -> Result<(), TransportError> {
    const CONTENT_TYPE: &str = "application/json";
    let body = serde_json::to_vec(report).map_err(TransportError::Serialize)?;
    if body.len() > MAX_PAYLOAD_BYTES {
        return Err(TransportError::PayloadTooLarge(body.len()));
    }
    let response = http
        .post(endpoint)
        .header("x-oluso-signature", api_key)
        .timeout(timeout)
        .header("content-type", CONTENT_TYPE)
        .body(body)
        .send()
        .await
        .map_err(TransportError::Request)?;

    if !response.status().is_success() {
        return Err(TransportError::Status(response.status().as_u16()));
    }

    Ok(())
}

pub(crate) const MAX_PAYLOAD_BYTES: usize = 512 * 1024;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn payload_limit_is_bounded_to_contract() {
        assert_eq!(MAX_PAYLOAD_BYTES, 524_288);
        assert!(matches!(
            TransportError::PayloadTooLarge(MAX_PAYLOAD_BYTES + 1),
            TransportError::PayloadTooLarge(_)
        ));
    }
}