docs: Update Rust docs and snippets for upcoming release

__tests__/__snapshots__/documentation.js.snap

@@ -374,12 +374,7 @@ Array [
   "platforms/react-native/ram-bundles/index.html",
   "platforms/react-native/sourcemaps/index.html",
   "platforms/rust/actix/index.html",
-  "platforms/rust/env_logger/index.html",
-  "platforms/rust/error_chain/index.html",
-  "platforms/rust/failure/index.html",
   "platforms/rust/index.html",
-  "platforms/rust/log/index.html",
-  "platforms/rust/panic/index.html",
   "project-resources/index.html",
   "sdks/javascript/index.html",
   "sitemap.xml",

src/_data/platforms.yml

@@ -584,7 +584,7 @@
       name: Rust
       wizard_parent: rust
       wizard: true
-      version: 0.6.0
+      version: 0.19.0
       version_key: SENTRY_VERSION
       case_style: snake_case
 -

src/collections/_documentation/enriching-error-data/with-scope/rust.md

@@ -1,18 +1,13 @@
 ```rust
-use sentry::{Level, with_scope};
-use sentry::integrations::failure::capture_error;
-use failure::err_msg;
-
-with_scope(|scope| {
+sentry::with_scope(|scope| {
     scope.set_tag("my-tag", "my value");
-    scope.set_level(Some(Level::Warning));
 }, || {
     // will be tagged with my-tag="my value"
-    capture_error(err_msg("my error"))
+    sentry::capture_message("my error", sentry::Level::Error)
 });
 
 // will not be tagged with my-tag
-capture_error(err_msg("my other error"))
+sentry::capture_message("my other error", sentry::Level::Error)
 ```
 
 *Note that in Rust two callbacks are invoked.  One for configuring the scope, and a second

src/collections/_documentation/error-reporting/capture-error/rust.md

@@ -1,13 +1,24 @@
-In Rust you can capture errors that implement the `Fail` trait or that are `failure::Error`
-objects:
+In Rust, you can capture any `std::error::Error` type. 
 
 ```rust
-use sentry::integrations::failure::capture_error;
+let result = match function_returns_error() {
+    Ok(result) => result,
+    Err(err) => {
+        sentry::capture_error(&err);
+        return Err(err);
+    }
+};
+```
+
+Integrations may provide more specialized capturing methods.
+
+```rust
+use sentry::integrations::anyhow::capture_anyhow;
 
-let result = match function_that_might_fail() {
+let result = match function_returns_anyhow() {
     Ok(result) => result,
     Err(err) => {
-        capture_error(&err);
+        capture_anyhow(&err);
         return Err(err);
     }
 };

src/collections/_documentation/error-reporting/capture-message/rust.md

@@ -1,5 +1,3 @@
 ```rust
-use sentry::{capture_message, Level};
-
-capture_message("Something went wrong", Level::Info);
+sentry::capture_message("Something went wrong", sentry::Level::Info);
 ```

src/collections/_documentation/error-reporting/configuration/before-send/rust.md

@@ -1,10 +1,10 @@
 ```rust
 sentry::init(sentry::ClientOptions {
-    before_send: Some(Arc::new(Box::new(|mut event| {
+    before_send: Some(Arc::new(|mut event| {
         // Modify event here
         event.server_name = None;  // Don't send server name
         Some(event)
-    }))),
+    })),
     ..Default::default()
 });
 ```

src/collections/_documentation/error-reporting/configuration/config-intro/rust.md

@@ -1,8 +1,6 @@
 Options are passed to the `init()` as tuple where the first argument is the DSN and the second the options:
 
 ```rust
-use sentry;
-
 sentry::init(("___PUBLIC_DSN___", sentry::ClientOptions {
     max_breadcrumbs: 50,
     debug: true,

src/collections/_documentation/error-reporting/configuration/drain-example/rust.md

@@ -4,9 +4,8 @@ the guard and make sure it disposes on shutdown.  Alternatively the client can b
 
 ```rust
 use std::time::Duration;
-use sentry::Hub;
 
-if let Some(client) = Hub.current().client() {
+if let Some(client) = sentry::Hub::current().client() {
     client.close(Some(Duration::from_secs(2)));
 }
 ```

src/collections/_documentation/error-reporting/configuration/index.md

@@ -176,15 +176,15 @@ happen as part of the `init()` call, in some others, different patterns apply.
 {:.config-key}
 ### `integrations`
 
-{% unsupported csharp aspnetcore rust %}
+{% unsupported csharp aspnetcore %}
 In some SDKs, the integrations are configured through this parameter on library initialization.
 For more information, have a look at the specific integration documentation.
 {% endunsupported %}
 
 {:.config-key}
 ### `default-integrations`
 
-{% unsupported csharp aspnetcore rust %}
+{% unsupported csharp aspnetcore %}
 This can be used to disable integrations that are added by default.  When set to `false` no
 default integrations are added.
 {% endunsupported %}

src/collections/_documentation/error-reporting/getting-started-verify/rust.md

@@ -4,9 +4,7 @@ The quickest way to verify Sentry in your Rust application is to cause a panic:
 
 ```rust
 fn main() {
-    // Initialize sentry here
-
-    sentry::integrations::panic::register_panic_handler();
+    let _guard = sentry::init("___PUBLIC_DSN___");
 
     // Sentry will capture this
     panic!("Everything is on fire!");

src/collections/_documentation/platforms/rust/actix.md

@@ -22,7 +22,7 @@ In your `Cargo.toml`:
 ```toml
 [dependencies]
 sentry = "{% sdk_version sentry.rust %}"
-sentry-actix = "{% package_version cargo:sentry-actix %}"
+sentry-actix = "{% sdk_version sentry.rust %}"
 ```
 
 And your Rust code:
@@ -45,7 +45,6 @@ fn failing(_req: &HttpRequest) -> Result<String, Error> {
 fn main() {
     let _guard = sentry::init("___PUBLIC_DSN___");
     env::set_var("RUST_BACKTRACE", "1");
-    sentry::integrations::panic::register_panic_handler();
 
     server::new(|| {
         App::new()

src/collections/_documentation/platforms/rust/index.md

@@ -9,36 +9,26 @@ protocol for Rust and provides convenient helpers for sending common types of
 events to Sentry.
 
 The Rust SDK follows the new unified SDK architecture.  To get started have a
-look at the [quickstart](/error-reporting/quickstart/?platform=rust) docs.
+look at the [quickstart](/error-reporting/quickstart/?platform=rust) docs and the crates [API Docs](https://docs.rs/sentry).
+
+## Quick Start
+
+```rust
+let _guard = sentry::init("___PUBLIC_DSN___");
+sentry::capture_message("Hello World!", sentry::Level::Info);
+```
 
 ## Integrations
 
 *Integrations* extend the functionality of the SDK for some common frameworks
 and libraries.
 
-### Framework integrations
-
-Sentry-Rust supports the following application frameworks:
-
-* [actix-web](/platforms/rust/actix/)
-
-### Error handling integrations
-
-Sentry-Rust supports the most commonly used libraries for advanced error management:
-
-* [failure](/platforms/rust/failure/)
-* [error-chain](/platforms/rust/error_chain/)
-
-Additionally you can catch panics using the panic integration:
-
-* [panic](/platforms/rust/panic/)
-
-### Logging integrations
+A list of integrations and their feature flags can be found
+[in the integration API docs](https://docs.rs/sentry/0/sentry/integrations/index.html).
 
-Logs can be automatically converted into breadcrumbs.
+Apart from those, the Rust SDK also supports the following application frameworks:
 
-* [env_logger](/platforms/rust/env_logger/)
-* [log](/platforms/rust/log/)
+* [actix-web 0.7](/platforms/rust/actix/)
 
 ## More Information