Add tracing commong to cja and re-export it for other apps to use

Cargo.toml

@@ -5,8 +5,8 @@ members = [
   "db",
   "posts",
   "server",
-  "tracing-common",
   "video-toolkit",
+  "tracing-common",
 ]
 resolver = "2"
 

byte/src/main.rs

@@ -21,7 +21,7 @@ pub(crate) struct Config {
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    setup_tracing()?;
+    setup_tracing("byte")?;
 
     let (say_sender, say_reciever) = tokio::sync::mpsc::channel::<String>(32);
 

cja/Cargo.toml

@@ -28,5 +28,7 @@ axum = "0.7.4"
 tower-service = "0.3.2"
 tower = "0.4.13"
 
+tracing-common = { path = "../tracing-common" }
+
 [lints]
 workspace = true

cja/src/lib.rs

@@ -7,3 +7,4 @@ pub mod jobs;
 pub mod server;
 
 pub mod app_state;
+pub mod setup;

cja/src/setup.rs

@@ -0,0 +1 @@
+pub use tracing_common::*;

server/src/http_server/mod.rs

@@ -7,18 +7,15 @@ use axum::{
 };
 use chrono::{DateTime, NaiveTime, Utc};
 use include_dir::{include_dir, Dir};
-use miette::{Context, IntoDiagnostic, Result};
+use miette::{IntoDiagnostic, Result};
 use posts::{
     blog::{BlogPost, ToCanonicalPath},
     date::PostedOn,
     til::TilPost,
     title::Title,
     Post,
 };
-use std::{net::SocketAddr, sync::Arc};
-use tokio::net::TcpListener;
-use tower_cookies::CookieManagerLayer;
-use tower_http::trace::TraceLayer;
+use std::sync::Arc;
 
 use crate::{AppConfig, AppState};
 use errors::MietteError;

server/src/main.rs

@@ -1,20 +1,16 @@
 #![allow(dead_code)]
 
-use std::{collections::HashMap, sync::Arc, time::Duration};
+use std::sync::Arc;
 
+use cja::setup::{setup_sentry, setup_tracing};
 use clap::Parser;
 use commands::Command;
 
-use miette::{Context, IntoDiagnostic};
-use opentelemetry_otlp::WithExportConfig;
+use miette::IntoDiagnostic;
 
-use sentry::ClientInitGuard;
 use serde::{Deserialize, Serialize};
 
 use tracing::instrument;
-use tracing_opentelemetry::OpenTelemetryLayer;
-use tracing_subscriber::{prelude::*, util::SubscriberInitExt, EnvFilter, Registry};
-use tracing_tree::HierarchicalLayer;
 
 pub use miette::Result;
 
@@ -35,93 +31,6 @@ pub(crate) use state::{AppConfig, AppState};
 
 pub(crate) mod google;
 
-fn setup_sentry() -> Option<ClientInitGuard> {
-    let git_commit: Option<std::borrow::Cow<_>> =
-        option_env!("VERGEN_GIT_SHA").map(std::convert::Into::into);
-    let release_name =
-        git_commit.unwrap_or_else(|| sentry::release_name!().unwrap_or_else(|| "dev".into()));
-
-    if let Ok(sentry_dsn) = std::env::var("SENTRY_DSN") {
-        println!("Sentry enabled");
-
-        Some(sentry::init((
-            sentry_dsn,
-            sentry::ClientOptions {
-                traces_sample_rate: 0.5,
-                release: Some(release_name),
-                ..Default::default()
-            },
-        )))
-    } else {
-        println!("Sentry not configured in this environment");
-
-        None
-    }
-}
-
-fn setup_tracing() -> Result<()> {
-    let rust_log =
-        std::env::var("RUST_LOG").unwrap_or_else(|_| "info,server=trace,tower_http=debug".into());
-
-    let env_filter = EnvFilter::builder()
-        .parse(&rust_log)
-        .into_diagnostic()
-        .wrap_err_with(|| miette::miette!("Couldn't create env filter from {}", rust_log))?;
-
-    let opentelemetry_layer = if let Ok(honeycomb_key) = std::env::var("HONEYCOMB_API_KEY") {
-        let mut map = HashMap::<String, String>::new();
-        map.insert("x-honeycomb-team".to_string(), honeycomb_key);
-        map.insert("x-honeycomb-dataset".to_string(), "coreyja.com".to_string());
-
-        let tracer = opentelemetry_otlp::new_pipeline()
-            .tracing()
-            .with_exporter(
-                opentelemetry_otlp::new_exporter()
-                    .http()
-                    .with_endpoint("https://api.honeycomb.io/v1/traces")
-                    .with_timeout(Duration::from_secs(3))
-                    .with_headers(map),
-            )
-            .install_batch(opentelemetry::runtime::Tokio)
-            .into_diagnostic()?;
-
-        let opentelemetry_layer = OpenTelemetryLayer::new(tracer);
-        println!("Honeycomb layer configured");
-
-        Some(opentelemetry_layer)
-    } else {
-        println!("Skipping Honeycomb layer");
-
-        None
-    };
-
-    let hierarchical = {
-        let hierarchical = HierarchicalLayer::default()
-            .with_writer(std::io::stdout)
-            .with_indent_lines(true)
-            .with_indent_amount(2)
-            .with_thread_names(true)
-            .with_thread_ids(true)
-            .with_verbose_exit(true)
-            .with_verbose_entry(true)
-            .with_targets(true);
-
-        println!("Let's also log to stdout.");
-
-        hierarchical
-    };
-
-    Registry::default()
-        .with(hierarchical)
-        .with(opentelemetry_layer)
-        .with(env_filter)
-        .with(sentry_tracing::layer())
-        .try_init()
-        .into_diagnostic()?;
-
-    Ok(())
-}
-
 #[derive(Parser)]
 #[command(author, version, about)]
 struct CliArgs {
@@ -141,7 +50,7 @@ fn main() -> Result<()> {
 }
 
 async fn _main() -> Result<()> {
-    setup_tracing()?;
+    setup_tracing("server")?;
 
     let cli = CliArgs::parse();
     let command = cli.command.unwrap_or_default();

tracing-common/Cargo.toml

@@ -6,6 +6,15 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+sentry = { version = "0.31.5", default-features = false, features = [
+  "rustls",
+  "backtrace",
+  "contexts",
+  "panic",
+  "tower",
+  "reqwest",
+] }
+sentry-tracing = "0.31.8"
 tracing = { workspace = true }
 tracing-opentelemetry = { workspace = true }
 tracing-subscriber = { workspace = true }

tracing-common/src/lib.rs

@@ -1,14 +1,41 @@
 use std::{collections::HashMap, time::Duration};
 
-use miette::{Context, IntoDiagnostic, Result};
+use miette::{Context as _, IntoDiagnostic as _};
 use opentelemetry_otlp::WithExportConfig;
+use sentry::ClientInitGuard;
 use tracing_opentelemetry::OpenTelemetryLayer;
-use tracing_subscriber::{prelude::*, EnvFilter, Registry};
+use tracing_subscriber::{
+    layer::SubscriberExt as _, util::SubscriberInitExt as _, EnvFilter, Registry,
+};
 use tracing_tree::HierarchicalLayer;
 
-pub fn setup_tracing() -> Result<()> {
-    let rust_log =
-        std::env::var("RUST_LOG").unwrap_or_else(|_| "warn,server=trace,tower_http=debug".into());
+pub fn setup_sentry() -> Option<ClientInitGuard> {
+    let git_commit: Option<std::borrow::Cow<_>> =
+        option_env!("VERGEN_GIT_SHA").map(std::convert::Into::into);
+    let release_name =
+        git_commit.unwrap_or_else(|| sentry::release_name!().unwrap_or_else(|| "dev".into()));
+
+    if let Ok(sentry_dsn) = std::env::var("SENTRY_DSN") {
+        println!("Sentry enabled");
+
+        Some(sentry::init((
+            sentry_dsn,
+            sentry::ClientOptions {
+                traces_sample_rate: 0.5,
+                release: Some(release_name),
+                ..Default::default()
+            },
+        )))
+    } else {
+        println!("Sentry not configured in this environment");
+
+        None
+    }
+}
+
+pub fn setup_tracing(crate_name: &str) -> miette::Result<()> {
+    let rust_log = std::env::var("RUST_LOG")
+        .unwrap_or_else(|_| format!("info,{crate_name}=trace,tower_http=debug"));
 
     let env_filter = EnvFilter::builder()
         .parse(&rust_log)
@@ -42,8 +69,8 @@ pub fn setup_tracing() -> Result<()> {
         None
     };
 
-    let heirarchical = {
-        let heirarchical = HierarchicalLayer::default()
+    let hierarchical = {
+        let hierarchical = HierarchicalLayer::default()
             .with_writer(std::io::stdout)
             .with_indent_lines(true)
             .with_indent_amount(2)
@@ -55,13 +82,14 @@ pub fn setup_tracing() -> Result<()> {
 
         println!("Let's also log to stdout.");
 
-        heirarchical
+        hierarchical
     };
 
     Registry::default()
-        .with(heirarchical)
+        .with(hierarchical)
         .with(opentelemetry_layer)
         .with(env_filter)
+        .with(sentry_tracing::layer())
         .try_init()
         .into_diagnostic()?;
 

video-toolkit/src/main.rs

@@ -36,7 +36,7 @@ enum Command {
 async fn main() -> Result<()> {
     std::env::set_var("RUST_LOG", "info");
 
-    setup_tracing()?;
+    setup_tracing("video-toolkit")?;
     let cli = CliArgs::parse();
 
     match cli.command {