feat(rust): document tracing and log integration for logs (#14045)

Co-authored-by: Alex Krawiec <alex.krawiec@sentry.io>

Author: 2 people

docs/platforms/rust/common/logs/index.mdx

@@ -24,11 +24,14 @@ sentry = { version = "{{@inject packages.version('sentry.rust') }}", features =
 To enable logging, you need to initialize the SDK with the `enable_logs` option set to `true`.
 
 ```rust
-let _guard = sentry::init(("___PUBLIC_DSN___", sentry::ClientOptions {
-    release: sentry::release_name!(),
-    enable_logs: true,
-    ..Default::default()
-}));
+let _guard = sentry::init((
+    "___PUBLIC_DSN___",
+    sentry::ClientOptions {
+        release: sentry::release_name!(),
+        enable_logs: true,
+        ..Default::default()
+    }
+));
 ```
 
 ## Usage
@@ -69,11 +72,123 @@ As of today, array and object types will be converted to strings using their JSO
 
 ## Integrations
 
-We're actively working on adding integration support for Logs.
-Currently, we're looking at adding support for the `tracing` and `log` crates.
-You can follow progress on the following GitHub issues or open a [new one](https://github.com/getsentry/sentry-rust/issues/new/choose) for any additional integration you would like to see.
-- [`tracing`](https://github.com/getsentry/sentry-rust/issues/799)
-- [`log`](https://github.com/getsentry/sentry-rust/issues/818)
+### `tracing` Integration
+
+To use the `tracing` integration with logs, add the necessary dependencies to your `Cargo.toml`.
+
+```toml {filename:Cargo.toml}
+[dependencies]
+sentry = { version = "{{@inject packages.version('sentry.rust') }}", features = ["tracing", "logs"] }
+tracing = "0.1.41"
+tracing-subscriber = "0.3.19"
+```
+
+Initialize the SDK with `enable_logs` set to `true`, and configure the `tracing` subscriber to map `tracing` events to logs based on metadata such as severity.
+Then, use standard `tracing` macros to capture logs.
+
+```rust {filename:main.rs}
+use sentry::integrations::tracing::EventFilter;
+use tracing::{error, info, warn};
+use tracing_subscriber::prelude::*;
+
+fn main() {
+    let _guard = sentry::init((
+        "___PUBLIC_DSN___",
+        sentry::ClientOptions {
+            release: sentry::release_name!(),
+            enable_logs: true,
+            ..Default::default()
+        },
+    ));
+
+    let sentry_layer =
+        sentry::integrations::tracing::layer().event_filter(|md| match *md.level() {
+            // Capture error events as Sentry events
+            // These are grouped into issues, representing high-severity errors to act upon
+            tracing::Level::ERROR => EventFilter::Event,
+            // Ignore trace level events, as they're too verbose
+            tracing::Level::TRACE => EventFilter::Ignore,
+            // Capture everything else as a traditional structured log
+            _ => EventFilter::Log,
+        });
+
+    tracing_subscriber::registry()
+        .with(tracing_subscriber::fmt::layer())
+        .with(sentry_layer)
+        .init();
+
+    info!("Hello, world!");
+
+    warn!(
+        database.host = "prod-db-01",
+        database.port = 5432,
+        retry_attempt = 2,
+        "Database connection slow"
+    );
+
+    error!(error_code = 500, "Critical system failure");
+}
+```
+
+The fields of `tracing` events are automatically captured as attributes in Sentry logs.
+
+To map a `tracing` event to multiple `EventFilter`s, for example to capture both an event and a log for error level `tracing` events, use an additional Sentry layer with the desired event filter.
+
+### `log` Integration
+
+To use the `log` integration with logs, add the necessary dependencies to your `Cargo.toml`.
+
+```toml {filename:Cargo.toml}
+[dependencies]
+sentry = { version = "{{@inject packages.version('sentry.rust') }}", features = ["log", "logs"] }
+log = "0.4"
+# optional: use any log implementation you prefer
+env_logger = "0.11"
+```
+
+Initialize the SDK with `enable_logs` set to `true`, and configure the `log` integration to map `log` records to logs based on metadata such as severity.
+Then, use standard `log` macros to capture logs.
+
+```rust {filename:main.rs}
+use sentry_log::LogFilter;
+use log::{info, warn, error};
+
+fn main() {
+    let _guard = sentry::init((
+        "___PUBLIC_DSN___",
+        sentry::ClientOptions {
+            release: sentry::release_name!(),
+            enable_logs: true,
+            ..Default::default()
+        },
+    ));
+
+    let logger = sentry::integrations::log::SentryLogger::with_dest(
+        env_logger::Builder::from_default_env().build(),
+    )
+    .filter(|md| match md.level() {
+        // Capture error records as Sentry events
+        // These are grouped into issues, representing high-severity errors to act upon
+        log::Level::Error => LogFilter::Event,
+        // Ignore trace level records, as they're too verbose
+        log::Level::Trace => LogFilter::Ignore,
+        // Capture everything else as a log
+        _ => LogFilter::Log,
+    });
+
+    log::set_boxed_logger(Box::new(logger)).unwrap();
+    log::set_max_level(log::LevelFilter::Trace);
+
+    info!("Hello, world!");
+    warn!("Database connection slow");
+    error!("Critical system failure");
+}
+```
+
+### Additional Integrations
+
+We're always looking to expand integration support for Logs.
+If you'd like to see support for additional logging libraries, please open a [new issue](https://github.com/getsentry/sentry-rust/issues/new/choose) with your request.
 
 ## Options