use crate::{
error::{BoxError, Error, chain},
error_policy::FailureKind,
};
use serde::Serialize;
use std::{fmt::Display, str::FromStr};
#[derive(Clone, Debug, Serialize)]
#[non_exhaustive]
pub struct DeadLetter<I, R> {
pub subscription: String,
pub failure: FailureKind,
pub error: String,
pub attempts: usize,
pub input: Option<I>,
pub raw: R,
}
impl<I, R> DeadLetter<I, R> {
pub(crate) fn new(
subscription: String,
failure: FailureKind,
error: &BoxError,
attempts: usize,
input: Option<I>,
raw: R,
) -> Self {
Self {
subscription,
failure,
error: chain(error.as_ref()),
attempts,
input,
raw,
}
}
pub fn try_map_raw<T, E>(
self,
map: impl FnOnce(R) -> Result<T, E>,
) -> Result<DeadLetter<I, T>, E> {
Ok(DeadLetter {
subscription: self.subscription,
failure: self.failure,
error: self.error,
attempts: self.attempts,
input: self.input,
raw: map(self.raw)?,
})
}
}
pub const DEAD_LETTER_HEADER_PREFIX: &str = "beavers-dlq-";
const SUBSCRIPTION: &str = "beavers-dlq-subscription";
const FAILURE: &str = "beavers-dlq-failure";
const ERROR: &str = "beavers-dlq-error";
const ATTEMPTS: &str = "beavers-dlq-attempts";
const COUNT: &str = "beavers-dlq-count";
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct DeadLetterDetails {
pub subscription: String,
pub failure: FailureKind,
pub error: String,
pub attempts: usize,
pub count: u32,
}
#[cfg_attr(
not(any(
feature = "kafka",
feature = "pulsar",
feature = "pubsub",
feature = "rabbitmq",
feature = "servicebus",
feature = "sqs"
)),
allow(dead_code)
)]
impl DeadLetterDetails {
pub(crate) fn of<I, R>(dead_letter: &DeadLetter<I, R>, previous: Option<&Self>) -> Self {
Self {
subscription: dead_letter.subscription.clone(),
failure: dead_letter.failure,
error: dead_letter.error.clone(),
attempts: dead_letter.attempts,
count: previous.map_or(1, |previous| previous.count.saturating_add(1)),
}
}
pub(crate) fn fields(&self) -> [(&'static str, String); 5] {
[
(SUBSCRIPTION, self.subscription.clone()),
(FAILURE, self.failure.as_str().to_owned()),
(ERROR, self.error.clone()),
(ATTEMPTS, self.attempts.to_string()),
(COUNT, self.count.to_string()),
]
}
pub(crate) fn parse<'a>(
field: impl Fn(&str) -> Result<Option<&'a str>, Error>,
) -> Result<Option<Self>, Error> {
let Some(failure) = field(FAILURE)? else {
return Ok(None);
};
let required = |name: &str| {
field(name)?.ok_or_else(|| {
Error::invalid_record(format!("dead-letter header {name} is missing"))
})
};
Ok(Some(Self {
subscription: required(SUBSCRIPTION)?.to_owned(),
failure: failure.parse()?,
error: required(ERROR)?.to_owned(),
attempts: parse_number(ATTEMPTS, required(ATTEMPTS)?)?,
count: parse_number(COUNT, required(COUNT)?)?,
}))
}
}
#[cfg_attr(
not(any(
feature = "kafka",
feature = "pulsar",
feature = "pubsub",
feature = "rabbitmq",
feature = "servicebus",
feature = "sqs"
)),
allow(dead_code)
)]
pub(crate) fn parse_number<T>(name: &str, value: &str) -> Result<T, Error>
where
T: FromStr,
T::Err: Display,
{
value.parse().map_err(|error| {
Error::invalid_record(format!(
"dead-letter header {name} is not a number: {value:?}: {error}"
))
})
}