Struct lambda_runtime::Diagnostic

pub struct Diagnostic<'a> {
    pub error_type: Cow<'a, str>,
    pub error_message: Cow<'a, str>,
}

Diagnostic information about an error.

Diagnostic is automatically derived for types that implement Display; e.g., Error.

error_type is derived from the type name of the original error with std::any::type_name as a fallback, which may not be reliable for conditional error handling. You can define your own error container that implements Into<Diagnostic> if you need to handle errors based on error types.

Example:

use lambda_runtime::{Diagnostic, Error, LambdaEvent};
use std::borrow::Cow;

#[derive(Debug)]
struct ErrorResponse(Error);

impl<'a> Into<Diagnostic<'a>> for ErrorResponse {
    fn into(self) -> Diagnostic<'a> {
        Diagnostic {
            error_type: Cow::Borrowed("MyError"),
            error_message: Cow::Owned(self.0.to_string()),
        }
    }
}

async fn function_handler(_event: LambdaEvent<()>) -> Result<(), ErrorResponse> {
   // ... do something
   Ok(())
}

Fields

error_type: Cow<'a, str>

Error type.

error_type is derived from the type name of the original error with std::any::type_name as a fallback. Please implement your own Into<Diagnostic> if you need more reliable error types.

error_message: Cow<'a, str>

Error message.

error_message is the output from the Display implementation of the original error as a fallback.

Trait Implementations

impl<'a> Clone for Diagnostic<'a>

fn clone(&self) -> Diagnostic<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Diagnostic<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for Diagnostic<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, T> From<T> for Diagnostic<'a>

where T: Display,

fn from(value: T) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for Diagnostic<'a>

fn eq(&self, other: &Diagnostic<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for Diagnostic<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for Diagnostic<'a>

impl<'a> StructuralPartialEq for Diagnostic<'a>