middleware::LogRequests: Extract Sentry setup into dedicated middleware struct

src/middleware.rs

@@ -25,19 +25,19 @@ mod log_connection_pool_status;
 pub mod log_request;
 mod normalize_path;
 mod require_user_agent;
-mod response_timing;
+pub mod response_timing;
 mod static_or_continue;
 mod update_metrics;
 
 use conduit_conditional_get::ConditionalGet;
 use conduit_cookie::{Middleware as Cookie, SessionMiddleware};
 use conduit_middleware::MiddlewareBuilder;
 use conduit_router::RouteBuilder;
-use sentry_conduit::SentryMiddleware;
 
 use std::env;
 use std::sync::Arc;
 
+use crate::sentry::SentryMiddleware;
 use crate::{App, Env};
 
 pub fn build_middleware(app: Arc<App>, endpoints: RouteBuilder) -> MiddlewareBuilder {

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::response_timing::ResponseTime;
@@ -17,23 +16,9 @@ const SLOW_REQUEST_THRESHOLD_MS: u64 = 1000;
 pub(super) struct LogRequests();
 
 impl Middleware for LogRequests {
-    fn before(&self, req: &mut dyn RequestExt) -> BeforeResult {
-        if let Some(request_id) = req
-            .headers()
-            .get("x-request-id")
-            .and_then(|value| value.to_str().ok())
-        {
-            sentry::configure_scope(|scope| scope.set_tag("request.id", request_id));
-        }
-
-        Ok(())
-    }
-
     fn after(&self, req: &mut dyn RequestExt, res: AfterResult) -> AfterResult {
         println!("{}", RequestLine { req, res: &res });
 
-        report_to_sentry(req, &res);
-
         res
     }
 }
@@ -56,34 +41,6 @@ pub fn add_custom_metadata<V: Display>(req: &mut dyn RequestExt, key: &'static s
     sentry::configure_scope(|scope| scope.set_extra(key, value.to_string().into()));
 }
 
-fn report_to_sentry(req: &dyn RequestExt, res: &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));
-        }
-
-        {
-            let status = res
-                .as_ref()
-                .map(|resp| resp.status())
-                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
-
-            scope.set_tag("response.status", status.as_str());
-        }
-
-        if let Some(response_time) = req.extensions().get::<ResponseTime>() {
-            scope.set_extra("Response time [ms]", response_time.as_millis().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/sentry/middleware.rs

@@ -0,0 +1,58 @@
+use crate::middleware::response_timing::ResponseTime;
+use conduit::{RequestExt, StatusCode};
+use conduit_cookie::RequestSession;
+use conduit_middleware::{AfterResult, BeforeResult, Middleware};
+use sentry_conduit::SentryMiddleware;
+
+/// Custom wrapper around the `sentry_conduit` middleware, that adds additional
+/// metadata to the Sentry request scopes.
+#[derive(Default)]
+pub struct CustomSentryMiddleware {
+    inner: SentryMiddleware,
+}
+
+impl Middleware for CustomSentryMiddleware {
+    fn before(&self, req: &mut dyn RequestExt) -> BeforeResult {
+        self.inner.before(req)?;
+
+        if let Some(request_id) = req
+            .headers()
+            .get("x-request-id")
+            .and_then(|value| value.to_str().ok())
+        {
+            sentry::configure_scope(|scope| scope.set_tag("request.id", request_id));
+        }
+
+        Ok(())
+    }
+
+    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));
+            }
+
+            {
+                let status = res
+                    .as_ref()
+                    .map(|resp| resp.status())
+                    .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
+
+                scope.set_tag("response.status", status.as_str());
+            }
+
+            if let Some(response_time) = req.extensions().get::<ResponseTime>() {
+                scope.set_extra("Response time [ms]", response_time.as_millis().into());
+            }
+        });
+
+        self.inner.after(req, res)
+    }
+}

src/sentry.rs → src/sentry/mod.rs

@@ -1,3 +1,6 @@
+mod middleware;
+
+pub use middleware::CustomSentryMiddleware as SentryMiddleware;
 use sentry::{ClientInitGuard, ClientOptions, IntoDsn};
 
 /// Initializes the Sentry SDK from the environment variables.