middleware::log_request: Split Sentry error reporting code into dedicated middleware

Author: Turbo87

src/middleware.rs

@@ -11,6 +11,7 @@ use self::head::Head;
 use self::known_error_to_json::KnownErrorToJson;
 use self::log_connection_pool_status::LogConnectionPoolStatus;
 use self::request_timing::RequestTiming;
+use self::sentry::SentryMiddleware as CustomSentryMiddleware;
 use self::static_or_continue::StaticOrContinue;
 use self::update_metrics::UpdateMetrics;
 
@@ -27,6 +28,7 @@ pub mod log_request;
 mod normalize_path;
 mod request_timing;
 mod require_user_agent;
+mod sentry;
 mod static_or_continue;
 mod update_metrics;
 
@@ -49,6 +51,7 @@ pub fn build_middleware(app: Arc<App>, endpoints: RouteBuilder) -> MiddlewareBui
     if env != Env::Test {
         m.add(ensure_well_formed_500::EnsureWellFormed500);
         m.add(log_request::LogRequests::default());
+        m.add(CustomSentryMiddleware::default());
         m.around(SentryMiddleware::default());
     }
 

src/middleware/log_request.rs

@@ -5,7 +5,6 @@ use super::prelude::*;
 use crate::util::request_header;
 
 use conduit::{header, RequestExt, StatusCode};
-use conduit_cookie::RequestSession;
 
 use crate::middleware::normalize_path::OriginalPath;
 use crate::middleware::request_timing::ResponseTime;
@@ -29,14 +28,12 @@ impl Middleware for LogRequests {
             }
         );
 
-        report_to_sentry(req, &res, response_time.as_millis());
-
         res
     }
 }
 
-struct CustomMetadata {
-    entries: Vec<(&'static str, String)>,
+pub struct CustomMetadata {
+    pub entries: Vec<(&'static str, String)>,
 }
 
 pub fn add_custom_metadata<V: Display>(req: &mut dyn RequestExt, key: &'static str, value: V) {
@@ -51,46 +48,6 @@ pub fn add_custom_metadata<V: Display>(req: &mut dyn RequestExt, key: &'static s
     }
 }
 
-fn report_to_sentry(req: &dyn RequestExt, res: &AfterResult, response_time: u64) {
-    sentry::configure_scope(|scope| {
-        {
-            let id = req.session().get("user_id").map(|str| str.to_string());
-
-            let user = sentry::User {
-                id,
-                ..Default::default()
-            };
-
-            scope.set_user(Some(user));
-        }
-
-        if let Some(request_id) = req
-            .headers()
-            .get("x-request-id")
-            .and_then(|value| value.to_str().ok())
-        {
-            scope.set_tag("request.id", request_id);
-        }
-
-        {
-            let status = res
-                .as_ref()
-                .map(|resp| resp.status())
-                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
-
-            scope.set_tag("response.status", status.as_str());
-        }
-
-        scope.set_extra("Response time [ms]", response_time.into());
-
-        if let Some(metadata) = req.extensions().find::<CustomMetadata>() {
-            for (key, value) in &metadata.entries {
-                scope.set_extra(key, value.to_string().into());
-            }
-        }
-    });
-}
-
 #[cfg(test)]
 pub(crate) fn get_log_message(req: &dyn RequestExt, key: &'static str) -> String {
     // Unwrap shouldn't panic as no other code has access to the private struct to remove it

src/middleware/sentry.rs

@@ -0,0 +1,55 @@
+use super::prelude::*;
+use crate::middleware::log_request::CustomMetadata;
+use crate::middleware::request_timing::ResponseTime;
+use conduit::{RequestExt, StatusCode};
+use conduit_cookie::RequestSession;
+
+#[derive(Default)]
+pub struct SentryMiddleware();
+
+impl Middleware for SentryMiddleware {
+    fn after(&self, req: &mut dyn RequestExt, res: AfterResult) -> AfterResult {
+        sentry::configure_scope(|scope| {
+            {
+                let id = req.session().get("user_id").map(|str| str.to_string());
+
+                let user = sentry::User {
+                    id,
+                    ..Default::default()
+                };
+
+                scope.set_user(Some(user));
+            }
+
+            if let Some(request_id) = req
+                .headers()
+                .get("x-request-id")
+                .and_then(|value| value.to_str().ok())
+            {
+                scope.set_tag("request.id", request_id);
+            }
+
+            {
+                let status = res
+                    .as_ref()
+                    .map(|resp| resp.status())
+                    .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
+
+                scope.set_tag("response.status", status.as_str());
+            }
+
+            let response_time = req.extensions().find::<ResponseTime>();
+            if let Some(response_time) = response_time {
+                scope.set_extra("Response time [ms]", response_time.as_millis().into());
+            }
+
+            if let Some(metadata) = req.extensions().find::<CustomMetadata>() {
+                for (key, value) in &metadata.entries {
+                    scope.set_extra(key, value.to_string().into());
+                }
+            }
+        });
+
+        res
+    }
+}