Struct Diagnostic 

pub struct Diagnostic {
    pub error_type: String,
    pub error_message: String,
}

Diagnostic information about an error.

Diagnostic is automatically derived for some common types, like boxed types that implement Error. If you use an error type which comes from a external crate like anyhow, you need convert it to common types like Box<dyn std::error::Error>. See the examples for more details.

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.

To get more descriptive error_type fields, you can implement From for your error type. That gives you full control on what the error_type is.

Example:

use lambda_runtime::{Diagnostic, Error, LambdaEvent};

#[derive(Debug)]
struct ErrorResponse(&'static str);

impl From<ErrorResponse> for Diagnostic {
    fn from(error: ErrorResponse) -> Diagnostic {
        Diagnostic {
            error_type: "MyError".into(),
            error_message: error.0.to_string(),
        }
    }
}

async fn function_handler(_event: LambdaEvent<()>) -> Result<(), ErrorResponse> {
   Err(ErrorResponse("this is an error response"))
}

Fields

error_type: String

error_type is the type of exception or error returned by the function. Use this field to categorize the different kinds of errors that your function might experience.

In standard implementations, error_type is derived from the type name of the original error with std::any::type_name, however this is not descriptive enough for an error type. Implement your own Into<Diagnostic> to return a more descriptive error type.

error_message: String

error_message is a string expression of the error. In standard implementations, it’s the output from the Display implementation of the original error.

Trait Implementations

impl Clone for Diagnostic

fn clone(&self) -> Diagnostic

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Diagnostic

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

Formats the value using the given formatter.

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<Diagnostic, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&'static str> for Diagnostic

fn from(value: &'static str) -> Diagnostic

Converts to this type from the input type.

impl From<Box<dyn Error>> for Diagnostic

fn from(value: Box<dyn Error>) -> Diagnostic

Converts to this type from the input type.

impl From<Box<dyn Error + Sync + Send>> for Diagnostic

fn from(value: Box<dyn Error + Sync + Send>) -> Diagnostic

Converts to this type from the input type.

impl From<DeserializeError> for Diagnostic

fn from(value: DeserializeError) -> Diagnostic

Converts to this type from the input type.

impl From<Error> for Diagnostic

fn from(value: Error) -> Diagnostic

Converts to this type from the input type.

impl From<Infallible> for Diagnostic

fn from(value: Infallible) -> Diagnostic

Converts to this type from the input type.

impl From<String> for Diagnostic

fn from(value: String) -> Diagnostic

Converts to this type from the input type.

impl PartialEq for Diagnostic

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Diagnostic

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Diagnostic

impl StructuralPartialEq for Diagnostic