tracing

rust/Cargo.lock

@@ -2388,6 +2388,8 @@ dependencies = [
 [[package]]
 name = "tracing-attributes"
 version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab"
 dependencies = [
  "proc-macro2",
  "quote",

rust/Cargo.toml

@@ -62,9 +62,6 @@ version = "0.1"
 [dependencies.tracing-attributes]
 version = "0.1"
 
-[patch.crates-io]
-tracing-attributes = { path = "./tracing/tracing-attributes" }
-
 [dependencies.tracing-subscriber]
 version = "0.3"
 features = ["json", "env-filter"]

rust/src/routing/mod.rs

@@ -43,13 +43,14 @@ async fn simple_handler(State(state): State<AppState>) -> &'static str {
         SqlitePoolOptions::new()
             .max_connections(5)
             .connect_with(
-                SqliteConnectOptions::from_str("/tmp/tmp.SmE1WKBVMf")
+                SqliteConnectOptions::from_str("/tmp/tmp.JKl26kmKW5")
                     .unwrap()
                     .log_statements(log::LevelFilter::Warn)
                     .log_slow_statements(
                         log::LevelFilter::Warn,
                         std::time::Duration::from_millis(100),
                     )
+                    .tracing_span(tracing::warn_span!("packager::sqlx"))
                     .pragma("foreign_keys", "1"),
             )
             .await
@@ -66,7 +67,7 @@ async fn simple_handler(State(state): State<AppState>) -> &'static str {
             .await
             .unwrap()
     }
-    // .instrument(tracing::warn_span!("test_span"))
+    .instrument(tracing::warn_span!("packager::sqlx"))
     .await;
     "ok"
 }

rust/src/sqlite.rs

@@ -18,6 +18,7 @@ pub async fn init_database_pool(url: &str) -> Result<Pool<Sqlite>, StartError> {
             SqliteConnectOptions::from_str(url)?
                 .log_statements(log::LevelFilter::Debug)
                 .log_slow_statements(log::LevelFilter::Warn, time::Duration::from_millis(100))
+                .tracing_span(tracing::info_span!("sqlx_pool"))
                 .pragma("foreign_keys", "1"),
         )
         .await?)
@@ -30,7 +31,8 @@ pub async fn migrate(url: &str) -> Result<(), StartError> {
         .connect_with(
             SqliteConnectOptions::from_str(url)?
                 .pragma("foreign_keys", "0")
-                .log_statements(log::LevelFilter::Warn),
+                .log_statements(log::LevelFilter::Warn)
+                .tracing_span(tracing::info_span!("sqlx_migration")),
         )
         .await?;
 

rust/src/telemetry.rs

@@ -9,7 +9,7 @@ use http::Request;
 use tower_http::{classify::ServerErrorsFailureClass, trace::TraceLayer};
 use tracing::{Span, Subscriber};
 
-use tracing_log::LogTracer;
+use tracing::Instrument;
 use tracing_subscriber::{
     filter::{LevelFilter, Targets},
     fmt::{
@@ -52,14 +52,14 @@ where
 
         write!(
             &mut writer,
-            "{}\t{}:\t",
+            "\n{}\t{}:\t",
             metadata.level(),
             metadata.target()
         )?;
 
         if let Some(scope) = ctx.event_scope() {
             for span in scope.from_root() {
-                write!(writer, "span: {}\t", span.metadata().name())?;
+                write!(writer, "span: {:?} {:?}\t", span.metadata(), span.id())?;
             }
         } else {
             write!(writer, "NO SPAN\t")?;
@@ -103,11 +103,16 @@ where
         .with_default(LevelFilter::WARN)
         .with_targets(vec![
             (env!("CARGO_PKG_NAME"), LevelFilter::DEBUG),
-            ("request", LevelFilter::DEBUG),
             ("runtime", LevelFilter::OFF),
             ("sqlx", LevelFilter::TRACE),
         ]);
 
+    let stdout_filter = Targets::new()
+        .with_default(LevelFilter::TRACE)
+        .with_targets(vec![("runtime", LevelFilter::OFF)])
+        .with_targets(vec![("tokio", LevelFilter::OFF)])
+        .with_targets(vec![("hyper", LevelFilter::OFF)]);
+
     let stdout_layer = stdout_layer.with_filter(stdout_filter);
 
     let console_layer = match tokio_console_config {
@@ -125,8 +130,7 @@ where
                 .with_service_name(env!("CARGO_PKG_NAME"))
                 .with_max_packet_size(20_000)
                 .with_auto_split_batch(true)
-                // .install_batch(Tokio)
+                .install_batch(Tokio)
-                .install_simple()
                 .unwrap();
 
             let opentelemetry_filter = {
@@ -134,9 +138,9 @@ where
                     .with_default(LevelFilter::DEBUG)
                     .with_targets(vec![
                         (env!("CARGO_PKG_NAME"), LevelFilter::DEBUG),
-                        ("request", LevelFilter::DEBUG),
                         ("runtime", LevelFilter::OFF),
-                        ("sqlx", LevelFilter::DEBUG),
+                        ("tokio", LevelFilter::OFF),
+                        ("sqlx", LevelFilter::TRACE),
                     ])
             };
 
@@ -171,7 +175,9 @@ where
 
     tracing_log::log_tracer::Builder::new().init().unwrap();
 
-    let result = f(args).await;
+    let result = f(args)
+        .instrument(tracing::debug_span!(target: env!("CARGO_PKG_NAME"), env!("CARGO_PKG_NAME")))
+        .await;
 
     for shutdown_func in shutdown_functions {
         shutdown_func().unwrap();
@@ -188,13 +194,12 @@ impl fmt::Display for Latency {
 }
 
 pub fn init_request_tracing(router: Router) -> Router {
-    return router;
     router.layer(
         TraceLayer::new_for_http()
             .make_span_with(|_request: &Request<_>| {
                 let request_id = Uuid::new_v4();
                 tracing::debug_span!(
-                    target: "request",
+                    target: "packager::request",
                     "request",
                     %request_id,
                 )
@@ -203,7 +208,7 @@ pub fn init_request_tracing(router: Router) -> Router {
                 let request_headers = request.headers();
                 let http_version = request.version();
                 tracing::debug!(
-                    target: "request",
+                    target: "packager::request",
                     method = request.method().as_str(),
                     path = request.uri().path(),
                     ?http_version,
@@ -216,7 +221,7 @@ pub fn init_request_tracing(router: Router) -> Router {
                     let response_headers = response.headers();
                     let latency = Latency(latency);
                     tracing::debug!(
-                        target: "request",
+                        target: "packager::request",
                         %latency,
                         status = response.status().as_str(),
                         ?response_headers,
@@ -230,7 +235,7 @@ pub fn init_request_tracing(router: Router) -> Router {
                     match error {
                         ServerErrorsFailureClass::StatusCode(code) => {
                             tracing::error!(
-                                target: "request",
+                                target: "packager::request",
                                 %latency,
                                 "request failed with error response {}",
                                 code,
@@ -238,7 +243,7 @@ pub fn init_request_tracing(router: Router) -> Router {
                         }
                         ServerErrorsFailureClass::Error(message) => {
                             tracing::error!(
-                                target: "request",
+                                target: "packager::request",
                                 %latency,
                                 "request failed: {}",
                                 message,