editoast: replace log with tracing

With the objective to instrument `editoast` with OpenTelemetry,
`tracing` can bring some ease-of-use macros for instrumenting
functions.

This PR is a first step to move to `tracing` (only the log event generation).

editoast/Cargo.toml

@@ -46,7 +46,7 @@ actix-web = "4.4.1"
 actix-http = "3.5.1"
 actix-cors = "0.7.0"
 env_logger = "0.10.1"
-log = "0.4.20"
+tracing = { version = "0.1.40", features = [ "log" ] }
 redis = { version = "0.24.0", features = [
     "tokio-comp",
     "connection-manager",

editoast/src/converters/osm_to_railjson.rs

@@ -1,6 +1,6 @@
 use super::utils::*;
 use crate::{converters::generate_routes, schema::*};
-use log::{error, info};
+use tracing::{debug, error, info};
 
 use std::{collections::HashMap, error::Error, path::PathBuf};
 /// Run the osm-to-railjson subcommand
@@ -110,12 +110,12 @@ pub fn parse_osm(osm_pbf_in: PathBuf) -> Result<RailJson, Box<dyn Error + Send +
             (4, 4) => railjson
                 .switches
                 .push(double_slip_switch(node, &adj.branches)),
-            _ => log::debug!("node {id} with {edges_count} edges and {branches_count} branches"),
+            _ => debug!("node {id} with {edges_count} edges and {branches_count} branches"),
         }
     }
-    log::debug!("Start generating routes");
+    debug!("Start generating routes");
     railjson.routes = generate_routes::routes(&railjson);
-    log::debug!("Done, got {} routes", railjson.routes.len());
+    debug!("Done, got {} routes", railjson.routes.len());
     Ok(railjson)
 }
 

editoast/src/converters/utils.rs

@@ -2,10 +2,10 @@ use std::collections::HashMap;
 
 use crate::schema::utils::Identifier;
 use crate::schema::*;
-use log::{error, warn};
 use osm4routing::{Coord, Edge, NodeId};
 use osmpbfreader::Node;
 use std::str::FromStr;
+use tracing::{error, warn};
 
 // Given an edge and a coordinate, returns the coordinates used to compute the angle
 // It uses the nearest OpenStreetMap node, and the other as the the rails might do a loop

editoast/src/core/mod.rs

@@ -17,12 +17,12 @@ use async_trait::async_trait;
 use colored::{ColoredString, Colorize};
 use editoast_derive::EditoastError;
 pub use http_client::{HttpClient, HttpClientBuilder};
-use log::info;
 use reqwest::Url;
 use serde::{de::DeserializeOwned, Serialize};
 use serde_derive::Deserialize;
 use serde_json::Value;
 use thiserror::Error;
+use tracing::{debug, error, info};
 
 #[cfg(test)]
 use crate::core::mocking::MockingError;
@@ -93,8 +93,8 @@ impl CoreClient {
         body: Option<&B>,
     ) -> Result<R::Response> {
         let method_s = colored_method(&method);
-        log::info!(target: "editoast::coreclient", "{method_s} {path}");
-        log::debug!(target: "editoast::coreclient", "Request content: {body}", body = body.and_then(|b| serde_json::to_string_pretty(b).ok()).unwrap_or_default());
+        info!(target: "editoast::coreclient", "{method_s} {path}");
+        debug!(target: "editoast::coreclient", "Request content: {body}", body = body.and_then(|b| serde_json::to_string_pretty(b).ok()).unwrap_or_default());
         match self {
             CoreClient::Direct(client) => {
                 let mut i_try = 0;
@@ -129,11 +129,11 @@ impl CoreClient {
                             msg: err.to_string(),
                         })?;
                 if status.is_success() {
-                    log::info!(target: "editoast::coreclient", "{method_s} {path} {status}", status = status.to_string().bold().green());
+                    info!(target: "editoast::coreclient", "{method_s} {path} {status}", status = status.to_string().bold().green());
                     return R::from_bytes(bytes.as_ref());
                 }
 
-                log::error!(target: "editoast::coreclient", "{method_s} {path} {status}", status = status.to_string().bold().red());
+                error!(target: "editoast::coreclient", "{method_s} {path} {status}", status = status.to_string().bold().red());
                 Err(self.handle_error(bytes.as_ref(), status, url))
             }
             #[cfg(test)]

editoast/src/error.rs

@@ -11,6 +11,7 @@ use std::{
     error::Error,
     fmt::{Display, Formatter},
 };
+use tracing::error;
 use utoipa::ToSchema;
 use validator::{ValidationErrors, ValidationErrorsKind};
 
@@ -104,7 +105,7 @@ impl ResponseError for InternalError {
     }
 
     fn error_response(&self) -> HttpResponse {
-        log::error!(
+        error!(
             "[{}] {}: {}",
             self.error_type.bold(),
             self.message,

editoast/src/generated_data/error/mod.rs

@@ -18,10 +18,10 @@ use diesel::sql_types::{Array, BigInt, Json, Text};
 use diesel_async::{AsyncPgConnection as PgConnection, RunQueryDsl};
 use futures_util::Future;
 use itertools::Itertools;
-use log::warn;
 use serde_json::to_value;
 use sha1::{Digest, Sha1};
 use std::pin::Pin;
+use tracing::warn;
 
 use super::GeneratedData;
 use crate::error::Result;

editoast/src/generated_data/mod.rs

@@ -27,6 +27,7 @@ use psl_sign::PSLSignLayer;
 use signal::SignalLayer;
 use speed_section::SpeedSectionLayer;
 use switch::SwitchLayer;
+use tracing::debug;
 use track_section::TrackSectionLayer;
 
 use crate::error::Result;
@@ -86,13 +87,13 @@ pub async fn refresh_all(
     // The other layers depend on track section layer.
     // We must wait until its completion before running the other requests in parallel
     TrackSectionLayer::refresh_pool(db_pool.clone(), infra, infra_cache).await?;
-    log::debug!("⚙️ Infra {infra}: track section layer is generated");
+    debug!("⚙️ Infra {infra}: track section layer is generated");
     let mut conn = db_pool.get().await?;
     // The analyze step significantly improves the performance when importing and generating together
     // It doesn’t seem to make a different when the generation step is ran separately
     // It isn’t clear why without analyze the Postgres server seems to run at 100% without halting
     sql_query("analyze").execute(&mut conn).await?;
-    log::debug!("⚙️ Infra {infra}: database analyzed");
+    debug!("⚙️ Infra {infra}: database analyzed");
     futures::try_join!(
         SpeedSectionLayer::refresh_pool(db_pool.clone(), infra, infra_cache),
         SignalLayer::refresh_pool(db_pool.clone(), infra, infra_cache),
@@ -105,10 +106,10 @@ pub async fn refresh_all(
         NeutralSectionLayer::refresh_pool(db_pool.clone(), infra, infra_cache),
         NeutralSignLayer::refresh_pool(db_pool.clone(), infra, infra_cache),
     )?;
-    log::debug!("⚙️ Infra {infra}: object layers is generated");
+    debug!("⚙️ Infra {infra}: object layers is generated");
     // The error layer depends on the other layers and must be executed at the end.
     ErrorLayer::refresh_pool(db_pool.clone(), infra, infra_cache).await?;
-    log::debug!("⚙️ Infra {infra}: errors layer is generated");
+    debug!("⚙️ Infra {infra}: errors layer is generated");
     Ok(())
 }
 

editoast/src/main.rs

@@ -50,7 +50,6 @@ use diesel_json::Json as DieselJson;
 use futures_util::future::BoxFuture;
 use futures_util::FutureExt;
 use infra_cache::InfraCache;
-use log::{error, info, warn};
 use map::MapLayers;
 use models::electrical_profiles::ElectricalProfileSet;
 use models::infra::InfraError;
@@ -63,6 +62,7 @@ use std::io::{BufReader, IsTerminal};
 use std::process::exit;
 use std::{env, fs};
 use thiserror::Error;
+use tracing::{error, info, warn};
 use url::Url;
 use validator::{Validate, ValidationErrorsKind};
 use views::infra::InfraApiError;

editoast/src/models/infra.rs

@@ -27,10 +27,10 @@ use diesel_async::{AsyncPgConnection as PgConnection, RunQueryDsl};
 use editoast_derive::{EditoastError, Model};
 use futures::future::try_join_all;
 use futures::Future;
-use log::{debug, error};
 use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
 use thiserror::Error;
+use tracing::{debug, error};
 use uuid::Uuid;
 
 pub const INFRA_VERSION: &str = "0";

editoast/src/views/infra/auto_fixes/buffer_stop.rs

@@ -2,8 +2,8 @@ use super::{new_ref_fix_delete_pair, Fix};
 use crate::schema::{
     BufferStopCache, InfraError, InfraErrorType, OSRDObject as _, ObjectRef, ObjectType,
 };
-use log::debug;
 use std::collections::HashMap;
+use tracing::debug;
 
 pub fn fix_buffer_stop(
     buffer_stop: &BufferStopCache,

editoast/src/views/infra/auto_fixes/detector.rs

@@ -2,8 +2,8 @@ use super::{new_ref_fix_delete_pair, Fix};
 use crate::schema::{
     DetectorCache, InfraError, InfraErrorType, OSRDObject as _, ObjectRef, ObjectType,
 };
-use log::debug;
 use std::collections::HashMap;
+use tracing::debug;
 
 pub fn fix_detector(
     detector: &DetectorCache,

editoast/src/views/infra/auto_fixes/electrifications.rs

@@ -5,8 +5,8 @@ use crate::schema::{
 };
 use itertools::Itertools as _;
 use json_patch::{Patch, PatchOperation, RemoveOperation};
-use log::{debug, error};
 use std::collections::HashMap;
+use tracing::{debug, error};
 
 fn invalid_reference_to_ordered_operation(
     electrification: &Electrification,

editoast/src/views/infra/auto_fixes/mod.rs

@@ -13,9 +13,9 @@ use actix_web::web::{Data, Json as WebJson, Path};
 use chashmap::CHashMap;
 use editoast_derive::EditoastError;
 use itertools::Itertools as _;
-use log::{debug, error};
 use std::collections::hash_map::{Entry, HashMap};
 use thiserror::Error;
+use tracing::{debug, error};
 
 mod buffer_stop;
 mod detector;

editoast/src/views/infra/auto_fixes/operational_point.rs

@@ -2,8 +2,8 @@ use super::{new_ref_fix_delete_pair, Fix};
 use crate::schema::{
     InfraError, InfraErrorType, OSRDObject as _, ObjectRef, OperationalPointCache,
 };
-use log::debug;
 use std::collections::HashMap;
+use tracing::debug;
 
 pub fn fix_operational_point(
     operational_point: &OperationalPointCache,

editoast/src/views/infra/auto_fixes/route.rs

@@ -2,8 +2,8 @@ use super::{new_ref_fix_delete_pair, Fix};
 use crate::schema::{
     InfraError, InfraErrorType, OSRDIdentified as _, OSRDObject as _, ObjectRef, ObjectType, Route,
 };
-use log::debug;
 use std::collections::HashMap;
+use tracing::debug;
 
 pub fn fix_route(
     route: &Route,

editoast/src/views/infra/auto_fixes/signal.rs

@@ -2,8 +2,8 @@ use super::{new_ref_fix_delete_pair, Fix};
 use crate::schema::{
     InfraError, InfraErrorType, OSRDObject as _, ObjectRef, ObjectType, SignalCache,
 };
-use log::debug;
 use std::collections::HashMap;
+use tracing::debug;
 
 pub fn fix_signal(
     signal: &SignalCache,

editoast/src/views/infra/auto_fixes/speed_section.rs

@@ -5,8 +5,8 @@ use crate::schema::{
 };
 use itertools::Itertools as _;
 use json_patch::{Patch, PatchOperation, RemoveOperation};
-use log::{debug, error};
 use std::collections::HashMap;
+use tracing::{debug, error};
 
 fn invalid_reference_to_ordered_operation(
     speed_section: &SpeedSection,

editoast/src/views/infra/auto_fixes/switch.rs

@@ -2,8 +2,8 @@ use super::{new_ref_fix_delete_pair, Fix};
 use crate::schema::{
     InfraError, InfraErrorType, OSRDObject as _, ObjectRef, ObjectType, SwitchCache,
 };
-use log::debug;
 use std::collections::HashMap;
+use tracing::debug;
 
 pub fn fix_switch(
     switch: &SwitchCache,

editoast/src/views/infra/auto_fixes/track_section.rs

@@ -3,8 +3,8 @@ use crate::schema::{
     operation::RailjsonObject, utils::Identifier, BufferStop, Endpoint, InfraError, InfraErrorType,
     OSRDIdentified as _, OSRDObject as _, ObjectRef, TrackSectionCache,
 };
-use log::debug;
 use std::collections::HashMap;
+use tracing::debug;
 use uuid::Uuid;
 
 pub fn fix_track_section(

editoast/src/views/mod.rs

@@ -33,6 +33,7 @@ use actix_web::{get, services};
 use diesel::sql_query;
 use redis::cmd;
 use serde_derive::{Deserialize, Serialize};
+use tracing::debug;
 use utoipa::openapi::RefOr;
 use utoipa::{OpenApi, ToSchema};
 
@@ -144,7 +145,7 @@ impl OpenApiRoot {
 
         let routes = routes_v2();
         for (path, path_item) in routes.paths.into_flat_path_list() {
-            log::debug!("processing {path}");
+            debug!("processing {path}");
             if openapi.paths.paths.contains_key(&path) {
                 let existing_path_item = openapi.paths.paths.remove(&path).unwrap();
                 let merged = merge_path_items(existing_path_item, path_item);

editoast/src/views/openapi.rs

@@ -9,6 +9,7 @@ use std::{
 
 use actix_web::dev::HttpServiceFactory;
 use serde_json::Value as Json;
+use tracing::warn;
 use utoipa::{
     openapi::{
         path::PathItemBuilder, schema::AnyOf, AllOf, Array, Object, OneOf, PathItem, RefOr, Schema,
@@ -119,7 +120,7 @@ pub(super) fn merge_path_items(a: PathItem, b: PathItem) -> PathItem {
     let mut operations: BTreeMap<_, _> = a.operations;
     for (method, operation) in b.operations {
         if operations.contains_key(&method) {
-            log::warn!(
+            warn!(
                 "duplicate operation for method {}",
                 serde_json::to_string(&method).unwrap() // PathItemType does not implement Display or Debug :(
             );
@@ -487,7 +488,7 @@ impl OpenApiMerger {
             .unwrap();
         for (key, schema) in new_schemas.iter_mut() {
             if old_schemas.insert(key.clone(), schema.clone()).is_some() {
-                log::warn!("duplicated schema replaced: {}", key);
+                warn!("duplicated schema replaced: {}", key);
             }
         }
 
@@ -506,7 +507,7 @@ impl OpenApiMerger {
                     let old_path = old_path.as_object_mut().unwrap();
                     for (method, operation) in path.as_object_mut().unwrap().iter_mut() {
                         if old_path.insert(method.clone(), operation.clone()).is_some() {
-                            log::warn!("duplicated operation replaced: {} {}", method, key);
+                            warn!("duplicated operation replaced: {} {}", method, key);
                         }
                     }
                 }

editoast/src/views/pagination.rs

@@ -6,10 +6,10 @@ use diesel::sql_types::Untyped;
 use diesel::{QueryResult, QueryableByName};
 use diesel_async::methods::LoadQuery;
 use diesel_async::AsyncPgConnection as PgConnection;
-use log::warn;
 use serde::Deserialize;
 use serde::Serialize;
 use thiserror::Error;
+use tracing::warn;
 
 use editoast_derive::EditoastError;
 use utoipa::IntoParams;