actix/actix-website
1
0
Fork 0
mirror of https://github.com/actix/actix-website synced 2025-01-23 00:25:55 +01:00
Code Issues Releases Wiki Activity

Change sentry example to use new sentry-actix

Browse Source
This commit is contained in:
Armin Ronacher 2018-06-19 19:50:00 +02:00
parent 7a5b633dd1
commit 0f15bd9dc3
1 changed files with 33 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
content/docs/sentry.md
View File

@ -8,68 +8,23 @@ weight: 1020
[Sentry](https://sentry.io/) is a crash reporting system that supports the [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 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 # Middleware
This middleware captures any error in the server error range (500 - 599) This middleware captures any error in the server error range (500 - 599)
and sends the attached error to sentry with its stacktrace. 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 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. to be informed about hard panics.
```rust ```rust
extern crate sentry; extern crate sentry;
extern crate sentry_actix;
use sentry_actix::SentryMiddleware;
use std::env; use std::env;
@ -79,7 +34,33 @@ fn main() {
sentry::integrations::panic::register_panic_handler(); sentry::integrations::panic::register_panic_handler();
let mut app = App::with_state(state) 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);
});
```