Switched to HandlerError struct that can be created from any Display + Send + Sync + Debug. Updated samples to reflect this

Author: sapessi

lambda-runtime-client/src/error.rs

@@ -1,7 +1,14 @@
 //! This module defines the `RuntimeApiError` trait that developers should implement
 //! to send their custom errors to the AWS Lambda Runtime Client SDK. The module also
 //! defines the `ApiError` type returned by the `RuntimeClient` implementations.
-use std::{env, error::Error, fmt, io, num::ParseIntError, option::Option};
+use std::{
+    env,
+    error::Error,
+    fmt::{self, Display},
+    io,
+    num::ParseIntError,
+    option::Option,
+};
 
 use backtrace;
 use http::{header::ToStrError, uri::InvalidUri};
@@ -98,9 +105,9 @@ impl ErrorResponse {
     }
 }
 
-impl From<Box<dyn Error + Send + Sync>> for ErrorResponse {
-    fn from(e: Box<dyn Error + Send + Sync>) -> Self {
-        Self::handled(e.description().to_owned())
+impl<T: Display + Send + Sync> From<Box<T>> for ErrorResponse {
+    fn from(e: Box<T>) -> Self {
+        Self::handled(format!("{}", e))
     }
 }
 
@@ -146,6 +153,8 @@ impl Error for ApiError {
         None
     }
 }
+unsafe impl Send for ApiError {}
+unsafe impl Sync for ApiError {}
 
 impl From<serde_json::Error> for ApiError {
     fn from(e: serde_json::Error) -> Self {

lambda-runtime/examples/custom_error.rs

@@ -27,10 +27,6 @@ impl CustomError {
             msg: message.to_owned(),
         }
     }
-
-    fn boxed(self) -> Box<CustomError> {
-        Box::from(self)
-    }
 }
 
 #[derive(Deserialize)]
@@ -57,7 +53,7 @@ fn my_handler(e: CustomEvent, c: lambda::Context) -> Result<CustomOutput, Handle
         error!("Empty first name in request {}", c.aws_request_id);
         // in this case, we explicitly initialize and box our custom error type.
         // the HandlerError type is an alias to Box<dyn Error>/
-        return Err(CustomError::new("Empty first name").boxed());
+        return Err(CustomError::new("Empty first name").into());
     }
 
     // For errors simply want to return, because the HandlerError is an alias to any

lambda-runtime/examples/custom_error_failure.rs

@@ -5,7 +5,6 @@ extern crate simple_logger;
 #[macro_use]
 extern crate failure;
 
-use failure::Error;
 use lambda::{lambda, HandlerError};
 use log::error;
 use serde_derive::{Deserialize, Serialize};
@@ -37,7 +36,7 @@ fn main() -> Result<(), Box<dyn StdError>> {
 fn my_handler(e: CustomEvent, c: lambda::Context) -> Result<CustomOutput, HandlerError> {
     if e.first_name == "" {
         error!("Empty first name in request {}", c.aws_request_id);
-        return Err(Box::from(Error::from(CustomError {}).compat()));
+        return Err((CustomError {}).into());
     }
 
     let _age_num: u8 = e.age.parse()?;

lambda-runtime/src/error.rs

@@ -1,15 +1,34 @@
 //! The error module defines the error types that can be returned
 //! by custom handlers as well as the runtime itself.
-use std::{env, error::Error, fmt};
+use std::{
+    env,
+    error::Error,
+    fmt::{self, Debug, Display},
+};
 
 use lambda_runtime_client::error::ApiError;
 use serde_json;
 
-/// The `HandlerError` type can be use to abstract any error in the handler method.
-/// This allows handler functions to return any error using the `?` syntax. For example
-/// `let _age_num: u8 = e.age.parse()?;` will return the `<F as FromStr>::Err` from the
-/// handler function.
-pub type HandlerError = Box<dyn Error + Send + Sync>;
+/// The `HandlerError` struct can be use to abstract any `Err` of the handler method `Result`.
+/// The `HandlerError` object can be generated `From` any object that supports `Display`,
+/// `Send, `Sync`, and `Debug`. This allows handler functions to return any error using
+/// the `?` syntax. For example `let _age_num: u8 = e.age.parse()?;` will return the
+/// `<F as FromStr>::Err` from the handler function.
+pub struct HandlerError {
+    msg: String,
+}
+
+impl<E: Display + Send + Sync + Debug> From<E> for HandlerError {
+    fn from(e: E) -> HandlerError {
+        HandlerError { msg: format!("{}", e) }
+    }
+}
+
+impl Display for HandlerError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.msg)
+    }
+}
 
 /// The `RuntimeError` object is returned by the custom runtime as it polls
 /// for new events and tries to execute the handler function. The error

lambda-runtime/src/runtime.rs

@@ -215,7 +215,7 @@ where
                                             "Error for {} is not recoverable, sending fail_init signal and panicking.",
                                             request_id
                                         );
-                                        self.runtime_client.fail_init(ErrorResponse::from(Box::from(e)));
+                                        self.runtime_client.fail_init(ErrorResponse::from(Box::new(e)));
                                         panic!("Could not send response");
                                     }
                                 }
@@ -226,15 +226,18 @@ where
                                 "Could not marshal output object to Vec<u8> JSON represnetation for request {}: {}",
                                 request_id, e
                             );
-                            self.runtime_client.fail_init(ErrorResponse::from(Box::from(e)));
+                            self.runtime_client.fail_init(ErrorResponse::from(Box::new(e)));
                             panic!("Failed to marshal handler output, panic");
                         }
                     }
                 }
                 Err(e) => {
                     debug!("Handler returned an error for {}: {}", request_id, e);
                     debug!("Attempting to send error response to Runtime API for {}", request_id);
-                    match self.runtime_client.event_error(&request_id, ErrorResponse::from(e)) {
+                    match self
+                        .runtime_client
+                        .event_error(&request_id, ErrorResponse::from(Box::new(e)))
+                    {
                         Ok(_) => info!("Error response for {} accepted by Runtime API", request_id),
                         Err(e) => {
                             error!("Unable to send error response for {} to Runtime API: {}", request_id, e);
@@ -243,7 +246,7 @@ where
                                     "Error for {} is not recoverable, sending fail_init signal and panicking",
                                     request_id
                                 );
-                                self.runtime_client.fail_init(ErrorResponse::from(Box::from(e)));
+                                self.runtime_client.fail_init(ErrorResponse::from(Box::new(e)));
                                 panic!("Could not send error response");
                             }
                         }
@@ -271,11 +274,11 @@ where
                 match err.request_id.clone() {
                     Some(req_id) => {
                         self.runtime_client
-                            .event_error(&req_id, ErrorResponse::from(Box::from(err)))
+                            .event_error(&req_id, ErrorResponse::from(Box::new(err)))
                             .expect("Could not send event error response");
                     }
                     None => {
-                        self.runtime_client.fail_init(ErrorResponse::from(Box::from(err)));
+                        self.runtime_client.fail_init(ErrorResponse::from(Box::new(err)));
                     }
                 }
 
@@ -355,7 +358,7 @@ pub(crate) mod tests {
             "Handler threw an unexpected error: {}",
             output.err().unwrap()
         );
-        let output_string = output.unwrap();
+        let output_string = output.ok().unwrap();
         assert_eq!(output_string, "hello", "Unexpected output message: {}", output_string);
     }
 }