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(_)
));
}
}