Add tracing and restructure the Cargo.tomls

src/app.rs

@@ -1,12 +1,32 @@
 use actix_web::body::MessageBody;
 use actix_web::dev::{ServiceFactory, ServiceRequest, ServiceResponse};
-use actix_web::middleware::{Logger, NormalizePath};
+use actix_web::middleware::NormalizePath;
 use actix_web::{web, App};
 use rustical_frontend::configure_frontend;
 use rustical_store::auth::AuthenticationProvider;
 use rustical_store::CalendarStore;
 use std::sync::Arc;
 use tokio::sync::RwLock;
+use tracing_actix_web::{DefaultRootSpanBuilder, RootSpanBuilder, TracingLogger};
+
+struct DomainRootSpanBuilder;
+
+impl RootSpanBuilder for DomainRootSpanBuilder {
+    fn on_request_start(request: &ServiceRequest) -> tracing::Span {
+        tracing_actix_web::root_span!(
+            request,
+            request_body = tracing::field::Empty,
+            user = tracing::field::Empty,
+            reponse_body = tracing::field::Empty
+        )
+    }
+    fn on_request_end<B: MessageBody>(
+        span: tracing::Span,
+        outcome: &Result<ServiceResponse<B>, actix_web::Error>,
+    ) {
+        DefaultRootSpanBuilder::on_request_end(span, outcome);
+    }
+}
 
 pub fn make_app<CS: CalendarStore + ?Sized>(
     cal_store: Arc<RwLock<CS>>,
@@ -21,7 +41,8 @@ pub fn make_app<CS: CalendarStore + ?Sized>(
     >,
 > {
     App::new()
-        .wrap(Logger::new("[%s] %r"))
+        .wrap(TracingLogger::<DomainRootSpanBuilder>::new())
+        // .wrap(Logger::new("[%s] %r"))
         .wrap(NormalizePath::trim())
         .service(web::scope("/caldav").configure(|cfg| {
             rustical_caldav::configure_dav(

src/config.rs

@@ -25,10 +25,16 @@ pub enum AuthConfig {
     Static(StaticUserStoreConfig),
 }
 
+#[derive(Debug, Deserialize, Serialize)]
+pub struct TracingConfig {
+    pub opentelemetry: bool,
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Config {
     pub calendar_store: CalendarStoreConfig,
     pub auth: AuthConfig,
     pub http: HttpConfig,
     pub frontend: FrontendConfig,
+    pub tracing: TracingConfig,
 }

src/main.rs

@@ -3,13 +3,28 @@ use actix_web::HttpServer;
 use anyhow::Result;
 use app::make_app;
 use clap::Parser;
-use config::{CalendarStoreConfig, SqliteCalendarStoreConfig};
+use config::{CalendarStoreConfig, SqliteCalendarStoreConfig, TracingConfig};
+use opentelemetry::global;
+use opentelemetry::trace::TracerProvider;
+use opentelemetry::KeyValue;
+use opentelemetry_otlp::WithExportConfig;
+use opentelemetry_sdk::propagation::TraceContextPropagator;
+use opentelemetry_sdk::trace::{self, BatchConfig, Tracer};
+use opentelemetry_sdk::{runtime, Resource};
+use opentelemetry_semantic_conventions::resource::{SERVICE_NAME, SERVICE_VERSION};
+use opentelemetry_semantic_conventions::SCHEMA_URL;
 use rustical_store::auth::StaticUserStore;
 use rustical_store::sqlite_store::{create_db_pool, SqliteCalendarStore};
 use rustical_store::CalendarStore;
 use std::fs;
 use std::sync::Arc;
+use std::time::Duration;
 use tokio::sync::RwLock;
+use tracing::level_filters::LevelFilter;
+use tracing_opentelemetry::OpenTelemetryLayer;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
+use tracing_subscriber::EnvFilter;
 
 mod app;
 mod config;
@@ -36,13 +51,59 @@ async fn get_cal_store(
     Ok(cal_store)
 }
 
+pub fn init_tracer() -> Tracer {
+    let otel_exporter = opentelemetry_otlp::new_exporter()
+        .tonic()
+        .with_timeout(Duration::from_secs(1));
+
+    let tracer_provider = opentelemetry_otlp::new_pipeline()
+        .tracing()
+        .with_exporter(otel_exporter)
+        .with_trace_config(
+            trace::Config::default().with_resource(Resource::from_schema_url(
+                [
+                    KeyValue::new(SERVICE_NAME, env!("CARGO_PKG_NAME")),
+                    KeyValue::new(SERVICE_VERSION, env!("CARGO_PKG_VERSION")),
+                ],
+                SCHEMA_URL,
+            )),
+        )
+        .with_batch_config(BatchConfig::default())
+        .install_batch(runtime::Tokio)
+        .expect("Failed to install tracer");
+
+    global::set_tracer_provider(tracer_provider.clone());
+    tracer_provider.tracer("rustical")
+}
+
+fn setup_tracing(config: &TracingConfig) {
+    let fmt_layer = tracing_subscriber::fmt::layer();
+    let filter_layer = EnvFilter::builder()
+        .with_default_directive(LevelFilter::WARN.into())
+        .from_env_lossy()
+        .add_directive("h2=warn".parse().unwrap())
+        .add_directive("hyper_util=warn".parse().unwrap())
+        .add_directive("tower=warn".parse().unwrap());
+
+    let registry = tracing_subscriber::registry()
+        .with(filter_layer)
+        .with(fmt_layer);
+
+    if config.opentelemetry {
+        global::set_text_map_propagator(TraceContextPropagator::new());
+        registry.with(OpenTelemetryLayer::new(init_tracer())).init();
+    } else {
+        registry.init();
+    }
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
-    env_logger::init_from_env(env_logger::Env::default().default_filter_or("info"));
-
     let args = Args::parse();
     let config: Config = toml::from_str(&fs::read_to_string(&args.config_file)?)?;
 
+    setup_tracing(&config.tracing);
+
     let cal_store = get_cal_store(args.migrate, &config.calendar_store).await?;
 
     let user_store = Arc::new(match config.auth {