Add support for JSON log format (cowprotocol#3336)

# Description
Structured logs offer several advantages for our services:
- Improved troubleshooting and root cause analysis, as the flow of a
request can be more easily traced.
- Simpler log correlation.
- Easier integration and automation.

This PR introduces a new parameter, `use_json_format`, for log output
(currently set to `false` by default). When enabled, the `tracing` crate
will emit logs in JSON format instead of the standard plain text.

Below is an example of a log entry from the `autopilot` service using
the new structured format:
```json
{"timestamp":"2025-03-25T12:12:42.492Z","level":"DEBUG","fields":{"message":"stored order events","label":"Executing","count":1,"elapsed":"7.604417ms"},"target":"autopilot::database::order_events","span":{"auction_id":1057,"name":"auction"},"spans":[{"auction_id":1057,"name":"auction"}]}
```

Related to cowprotocol#3282

# Changes
- Added the `json` feature to the `tracing-subscriber` crate, and
updated the version to the latest.
- Introduced a new `log_use_json_format` parameter to specify whether to
use structured logging. It is disabled by default.
- Used across all crates that perform logging: `orderbook`, `autopilot`,
`driver`, `solver`, `alerter`, and `refunder`.
- Since logging is encapsulated within the `observer` crate, the
creation of the new JSON logging layer only needed to be implemented
there.
- The new parameter is currently set to `false` in all unit and E2E
tests.

## How to test
Testing was done by running e2e tests in both scenarios (new parameter
enabled and disabled) and inspecting the resulting logs for the
services.

Author: mrnaveira

Cargo.lock

@@ -48,8 +48,8 @@ thiserror = "1.0.61"
 toml = "0.8.14"
 tokio = { version = "1.38.0", features = ["tracing"] }
 tokio-stream = { version = "0.1.15", features = ["sync"] }
-tracing = "0.1.40"
-tracing-subscriber = "0.3.18"
+tracing = "0.1.41"
+tracing-subscriber = { version = "0.3.19", features = ["json"] }
 url = "2.5.0"
 warp = { git = 'https://github.com/cowprotocol/warp.git', rev = "586244e", default-features = false }
 web3 = { version = "0.19.0", default-features = false }

Cargo.toml

@@ -378,11 +378,19 @@ struct Arguments {
 
     #[clap(long, env)]
     zero_ex_api_key: String,
+
+    /// Whether to use JSON format for the logs.
+    #[clap(long, env, default_value = "false")]
+    pub use_json_logs: bool,
 }
 
 pub async fn start(args: impl Iterator<Item = String>) {
     let args = Arguments::parse_from(args);
-    observe::tracing::initialize("alerter=debug", tracing::Level::ERROR.into());
+    observe::tracing::initialize(
+        "alerter=debug",
+        tracing::Level::ERROR.into(),
+        args.use_json_logs,
+    );
     observe::panic_hook::install();
     observe::metrics::setup_registry(Some("gp_v2_alerter".to_string()), None);
     tracing::info!("running alerter with {:#?}", args);

crates/alerter/src/lib.rs

@@ -122,6 +122,7 @@ pub async fn start(args: impl Iterator<Item = String>) {
     observe::tracing::initialize(
         args.shared.logging.log_filter.as_str(),
         args.shared.logging.log_stderr_threshold,
+        args.shared.logging.use_json_logs,
     );
     observe::panic_hook::install();
     tracing::info!("running autopilot with validated arguments:\n{}", args);

crates/autopilot/src/run.rs

@@ -17,6 +17,10 @@ pub struct Args {
     )]
     pub log: String,
 
+    /// Whether to use JSON format for the logs.
+    #[clap(long, env, default_value = "false")]
+    pub use_json_logs: bool,
+
     /// The node RPC API endpoint.
     #[clap(long, env)]
     pub ethrpc: Url,

crates/driver/src/infra/cli.rs

@@ -32,8 +32,8 @@ pub mod metrics;
 
 /// Setup the observability. The log argument configures the tokio tracing
 /// framework.
-pub fn init(log: &str) {
-    observe::tracing::initialize_reentrant(log);
+pub fn init(log: &str, use_json_format: bool) {
+    observe::tracing::initialize_reentrant(log, use_json_format);
     metrics::init();
 }
 

crates/driver/src/infra/observe/mod.rs

@@ -45,7 +45,7 @@ pub async fn run(
 /// Run the driver. This function exists to avoid multiple monomorphizations of
 /// the `run` code, which bloats the binaries and increases compile times.
 async fn run_with(args: cli::Args, addr_sender: Option<oneshot::Sender<SocketAddr>>) {
-    crate::infra::observe::init(&args.log);
+    crate::infra::observe::init(&args.log, args.use_json_logs);
 
     let ethrpc = ethrpc(&args).await;
     let web3 = ethrpc.web3().clone();

crates/driver/src/run.rs

@@ -888,6 +888,7 @@ impl Setup {
     pub async fn done(self) -> Test {
         observe::tracing::initialize_reentrant(
             "driver=trace,driver::tests::setup::blockchain=debug,warn",
+            false,
         );
 
         if let Some(name) = self.name.as_ref() {

crates/driver/src/tests/setup/mod.rs

@@ -183,7 +183,7 @@ async fn run<F, Fut, T>(
     Fut: Future<Output = ()>,
     T: AsRef<str>,
 {
-    observe::tracing::initialize_reentrant(&with_default_filters(filters).join(","));
+    observe::tracing::initialize_reentrant(&with_default_filters(filters).join(","), false);
     observe::panic_hook::install();
 
     // The mutex guarantees that no more than a test at a time is running on

crates/e2e/src/setup/mod.rs

@@ -387,7 +387,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn mainnet() {
-        observe::tracing::initialize_reentrant("shared=debug");
+        observe::tracing::initialize_reentrant("shared=debug", false);
         let node = std::env::var("NODE_URL").unwrap().parse().unwrap();
         let receiver = current_block_stream(node, Duration::from_secs(1))
             .await