feat: Added separate actix integration

Author: mitsuhiko

integrations/sentry-actix/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "sentry-actix"
+version = "0.1.0"
+authors = ["Armin Ronacher <armin.ronacher@active-4.com>"]
+
+[dependencies]
+actix-web = "0.6.13"
+sentry = { version = "0.6.0", path = "../../" }
+failure = "0.1.1"
+uuid = "0.6.5"

integrations/sentry-actix/examples/basic.rs

@@ -0,0 +1,27 @@
+extern crate actix_web;
+extern crate sentry;
+extern crate sentry_actix;
+
+use std::io;
+use std::env;
+
+use sentry_actix::CaptureSentryError;
+use actix_web::{server, App, Error, HttpRequest};
+
+fn failing(_req: HttpRequest) -> Result<String, Error> {
+    Err(io::Error::new(io::ErrorKind::Other, "Something went really wrong here").into())
+}
+
+fn main() {
+    let _guard = sentry::init("https://a94ae32be2584e0bbd7a4cbb95971fee@sentry.io/1041156");
+    env::set_var("RUST_BACKTRACE", "1");
+    sentry::integrations::panic::register_panic_handler();
+
+    server::new(|| {
+        App::new()
+            .middleware(CaptureSentryError)
+            .resource("/", |r| r.f(failing))
+    }).bind("127.0.0.1:3001")
+        .unwrap()
+        .run();
+}

examples/actix-demo.rs renamed to integrations/sentry-actix/src/lib.rs

@@ -1,12 +1,12 @@
 extern crate actix_web;
 extern crate failure;
 extern crate sentry;
+extern crate uuid;
 
-use std::env;
-use std::io;
-
+use std::sync::Arc;
+use uuid::Uuid;
 use actix_web::middleware::{Middleware, Response, Started};
-use actix_web::{server, App, Error, HttpMessage, HttpRequest, HttpResponse};
+use actix_web::{Error, HttpMessage, HttpRequest, HttpResponse};
 use failure::Fail;
 use sentry::integrations::failure::exception_from_single_fail;
 use sentry::protocol::{Event, Level};
@@ -17,7 +17,7 @@ pub struct CaptureSentryError;
 
 impl<S: 'static> Middleware<S> for CaptureSentryError {
     fn start(&self, req: &mut HttpRequest<S>) -> Result<Started, Error> {
-        let hub = Hub::new_from_top(Hub::current());
+        let hub = Arc::new(Hub::new_from_top(Hub::current()));
         let outer_req = req;
         let req = outer_req.clone();
         hub.add_event_processor(Box::new(move || {
@@ -51,52 +51,56 @@ impl<S: 'static> Middleware<S> for CaptureSentryError {
     fn response(&self, req: &mut HttpRequest<S>, resp: HttpResponse) -> Result<Response, Error> {
         if resp.status().is_server_error() {
             if let Some(error) = resp.error() {
-                let hub = req.extensions().get().unwrap();
-                report_actix_error_to_sentry(error, hub);
+                let hub = Hub::from_request(req);
+                println!("capturing error");
+                hub.capture_actix_error(error);
             }
         }
         Ok(Response::Done(resp))
     }
 }
 
-pub fn report_actix_error_to_sentry(err: &Error, hub: &Hub) {
-    let mut exceptions = vec![];
-    let mut ptr: Option<&Fail> = Some(err.as_fail());
-    let mut idx = 0;
-    while let Some(fail) = ptr {
-        exceptions.push(exception_from_single_fail(
-            fail,
-            if idx == 0 {
-                Some(err.backtrace())
-            } else {
-                fail.backtrace()
-            },
-        ));
-        ptr = fail.cause();
-        idx += 1;
-    }
-    exceptions.reverse();
-    hub.capture_event(Event {
-        exceptions: exceptions,
-        level: Level::Error,
-        ..Default::default()
-    });
+/// Utility function that takes an actix error and reports it to the default hub.
+pub fn capture_actix_error(err: &Error) -> Uuid {
+    Hub::with_active(|hub| {
+        hub.capture_actix_error(err)
+    })
 }
 
-fn failing(_req: HttpRequest) -> Result<String, Error> {
-    Err(io::Error::new(io::ErrorKind::Other, "Something went really wrong here").into())
+/// Hub extensions for actix.
+pub trait HubExt {
+    /// Returns the hub from a given http request.
+    fn from_request<S>(req: &HttpRequest<S>) -> &Arc<Hub>;
+    /// Captures an actix error on the given hub.
+    fn capture_actix_error(&self, err: &Error) -> Uuid;
 }
 
-fn main() {
-    let _guard = sentry::init("https://a94ae32be2584e0bbd7a4cbb95971fee@sentry.io/1041156");
-    env::set_var("RUST_BACKTRACE", "1");
-    sentry::integrations::panic::register_panic_handler();
+impl HubExt for Hub {
+    fn from_request<S>(req: &HttpRequest<S>) -> &Arc<Hub> {
+        req.extensions().get().expect("CaptureSentryError middleware was not registered")
+    }
 
-    server::new(|| {
-        App::new()
-            .middleware(CaptureSentryError)
-            .resource("/", |r| r.f(failing))
-    }).bind("127.0.0.1:3001")
-        .unwrap()
-        .run();
+    fn capture_actix_error(&self, err: &Error) -> Uuid {
+        let mut exceptions = vec![];
+        let mut ptr: Option<&Fail> = Some(err.as_fail());
+        let mut idx = 0;
+        while let Some(fail) = ptr {
+            exceptions.push(exception_from_single_fail(
+                fail,
+                if idx == 0 {
+                    Some(err.backtrace())
+                } else {
+                    fail.backtrace()
+                },
+            ));
+            ptr = fail.cause();
+            idx += 1;
+        }
+        exceptions.reverse();
+        self.capture_event(Event {
+            exceptions: exceptions,
+            level: Level::Error,
+            ..Default::default()
+        })
+    }
 }