From 0f15bd9dc3181ee5c92aaa73b0e67475c2801323 Mon Sep 17 00:00:00 2001
From: Armin Ronacher <armin.ronacher@active-4.com>
Date: Tue, 19 Jun 2018 19:50:00 +0200
Subject: [PATCH] Change sentry example to use new sentry-actix

---
 content/docs/sentry.md | 85 ++++++++++++++++--------------------------
 1 file changed, 33 insertions(+), 52 deletions(-)

diff --git a/content/docs/sentry.md b/content/docs/sentry.md
index fe899b3..a93c2d4 100644
--- a/content/docs/sentry.md
+++ b/content/docs/sentry.md
@@ -8,68 +8,23 @@ weight: 1020
 
 [Sentry](https://sentry.io/) is a crash reporting system that supports the
 failure crate which is the base of the actix error reporting.  With a
-middleware it's possible to automatically report server errors to sentry.
+middleware it's possible to automatically report server errors to Sentry.
 
 # Middleware
 
 This middleware captures any error in the server error range (500 - 599)
 and sends the attached error to sentry with its stacktrace.
 
-```rust
-use actix_web::{HttpRequest, HttpResponse, Error};
-use actix_web::middleware::{Middleware, Response};
-use failure::Fail;
-use sentry::with_client_and_scope;
-use sentry::protocol::{Event, Level};
-use sentry::integrations::failure::exception_from_single_fail;
-
-/// Reports certain failures to sentry.
-pub struct CaptureSentryError;
-
-impl<S> Middleware<S> for CaptureSentryError {
-    fn response(&self, _: &mut HttpRequest<S>, mut resp: HttpResponse)
-        -> Result<Response, Error>
-    {
-        if resp.status().is_server_error() {
-            if let Some(error) = resp.error() {
-                report_actix_error_to_sentry(error);
-            }
-        }
-        Ok(Response::Done(resp))
-    }
-}
-
-pub fn report_actix_error_to_sentry(err: &Error) {
-    with_client_and_scope(|client, scope| {
-        let mut exceptions = vec![
-            exception_from_single_fail(err.cause(), Some(err.backtrace())),
-        ];
-        let mut ptr: Option<&Fail> = err.cause().cause();
-        while let Some(cause) = ptr {
-            exceptions.push(exception_from_single_fail(cause, cause.backtrace()));
-            ptr = Some(cause);
-        }
-        exceptions.reverse();
-        client.capture_event(
-            Event {
-                exceptions: exceptions,
-                level: Level::Error,
-                ..Default::default()
-            },
-            Some(scope),
-        )
-    });
-}
-```
-
-# Middleware Usage
-
 To use the middleware the [sentry crate](https://crates.io/crates/sentry) needs to be
-initialized and configured.  Additionally it makes sense to also register the panic handler
+initialized and configured and the [sentry-actix middleware](https://crates.io/crates/sentry-actix)
+needs to be added.  Additionally it makes sense to also register the panic handler
 to be informed about hard panics.
 
 ```rust
 extern crate sentry;
+extern crate sentry_actix;
+
+use sentry_actix::SentryMiddleware;
 
 use std::env;
 
@@ -79,7 +34,33 @@ fn main() {
     sentry::integrations::panic::register_panic_handler();
 
     let mut app = App::with_state(state)
-        .middleware(CaptureSentryError)
+        .middleware(SentryMiddleware::new())
         // ...
 }
 ```
+
+# Reusing the Hub
+
+If you use this integration the default sentry hub (`Hub::current()`) is typically the wrong one.
+To get the request specific one you need to use the `ActixWebHubExt` trait:
+
+```rust
+use sentry::{Hub, Level};
+use sentry_actix::ActixWebHubExt;
+
+let hub = Hub::from_request(req);
+hub.capture_message("Something is not well", Level::Warning);
+```
+
+The hub can also be made current for the duration of a call.  Then `Hub::current()` works correctly
+until the end of the `run` block.
+
+```rust
+use sentry::{Hub, Level};
+use sentry_actix::ActixWebHubExt;
+
+let hub = Hub::from_request(req);
+Hub::run(hub, || {
+    sentry::capture_message("Something is not well", Level::Warning);
+});
+```