Integrate tracing (#6339)

Tracing Integration
- [reference](5bbf1859e9/projects/project-ideas.md (L297))


  - [x] replace slog & log with tracing throughout the codebase
- [x] implement custom crit log
- [x] make relevant changes in the formatter
- [x] replace sloggers
- [x] re-write SSE logging components

cc: @macladson @eserilev

beacon_node/beacon_chain/src/test_utils.rs

@@ -35,6 +35,7 @@ pub use genesis::{InteropGenesisBuilder, DEFAULT_ETH1_BLOCK_HASH};
 use int_to_bytes::int_to_bytes32;
 use kzg::trusted_setup::get_trusted_setup;
 use kzg::{Kzg, TrustedSetup};
+use logging::create_test_tracing_subscriber;
 use merkle_proof::MerkleTree;
 use operation_pool::ReceivedPreCapella;
 use parking_lot::Mutex;
@@ -44,17 +45,12 @@ use rand::Rng;
 use rand::SeedableRng;
 use rayon::prelude::*;
 use sensitive_url::SensitiveUrl;
-use slog::{o, Drain, Logger};
-use slog_async::Async;
-use slog_term::{FullFormat, PlainSyncDecorator, TermDecorator};
 use slot_clock::{SlotClock, TestingSlotClock};
 use state_processing::per_block_processing::compute_timestamp_at_slot;
 use state_processing::state_advance::complete_state_advance;
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 use std::fmt;
-use std::fs::{File, OpenOptions};
-use std::io::BufWriter;
 use std::str::FromStr;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, LazyLock};
@@ -235,7 +231,6 @@ pub struct Builder<T: BeaconChainTypes> {
     genesis_state_builder: Option<InteropGenesisBuilder<T::EthSpec>>,
     import_all_data_columns: bool,
     runtime: TestRuntime,
-    log: Logger,
 }
 
 impl<E: EthSpec> Builder<EphemeralHarnessType<E>> {
@@ -247,12 +242,8 @@ impl<E: EthSpec> Builder<EphemeralHarnessType<E>> {
             .expect("cannot build without validator keypairs");
 
         let store = Arc::new(
-            HotColdDB::open_ephemeral(
-                self.store_config.clone().unwrap_or_default(),
-                spec.clone(),
-                self.log.clone(),
-            )
-            .unwrap(),
+            HotColdDB::open_ephemeral(self.store_config.clone().unwrap_or_default(), spec.clone())
+                .unwrap(),
         );
         let genesis_state_builder = self.genesis_state_builder.take().unwrap_or_else(|| {
             // Set alternating withdrawal credentials if no builder is specified.
@@ -283,12 +274,8 @@ impl<E: EthSpec> Builder<EphemeralHarnessType<E>> {
         let spec = self.spec.as_ref().expect("cannot build without spec");
 
         let store = Arc::new(
-            HotColdDB::open_ephemeral(
-                self.store_config.clone().unwrap_or_default(),
-                spec.clone(),
-                self.log.clone(),
-            )
-            .unwrap(),
+            HotColdDB::open_ephemeral(self.store_config.clone().unwrap_or_default(), spec.clone())
+                .unwrap(),
         );
         let mutator = move |builder: BeaconChainBuilder<_>| {
             builder
@@ -372,7 +359,6 @@ where
 {
     pub fn new(eth_spec_instance: E) -> Self {
         let runtime = TestRuntime::default();
-        let log = runtime.log.clone();
 
         Self {
             eth_spec_instance,
@@ -391,7 +377,6 @@ where
             genesis_state_builder: None,
             import_all_data_columns: false,
             runtime,
-            log,
         }
     }
 
@@ -439,12 +424,6 @@ where
         self
     }
 
-    pub fn logger(mut self, log: Logger) -> Self {
-        self.log = log.clone();
-        self.runtime.set_logger(log);
-        self
-    }
-
     /// This mutator will be run before the `store_mutator`.
     pub fn initial_mutator(mut self, mutator: BoxedMutator<E, Hot, Cold>) -> Self {
         assert!(
@@ -501,12 +480,8 @@ where
             suggested_fee_recipient: Some(Address::repeat_byte(42)),
             ..Default::default()
         };
-        let execution_layer = ExecutionLayer::from_config(
-            config,
-            self.runtime.task_executor.clone(),
-            self.log.clone(),
-        )
-        .unwrap();
+        let execution_layer =
+            ExecutionLayer::from_config(config, self.runtime.task_executor.clone()).unwrap();
 
         self.execution_layer = Some(execution_layer);
         self
@@ -586,7 +561,6 @@ where
     pub fn build(self) -> BeaconChainHarness<BaseHarnessType<E, Hot, Cold>> {
         let (shutdown_tx, shutdown_receiver) = futures::channel::mpsc::channel(1);
 
-        let log = self.log;
         let spec = self.spec.expect("cannot build without spec");
         let seconds_per_slot = spec.seconds_per_slot;
         let validator_keypairs = self
@@ -599,7 +573,6 @@ where
 
         let chain_config = self.chain_config.unwrap_or_default();
         let mut builder = BeaconChainBuilder::new(self.eth_spec_instance, kzg.clone())
-            .logger(log.clone())
             .custom_spec(spec.clone())
             .store(self.store.expect("cannot build without store"))
             .store_migrator_config(
@@ -614,10 +587,7 @@ where
             .shutdown_sender(shutdown_tx)
             .chain_config(chain_config)
             .import_all_data_columns(self.import_all_data_columns)
-            .event_handler(Some(ServerSentEventHandler::new_with_capacity(
-                log.clone(),
-                5,
-            )))
+            .event_handler(Some(ServerSentEventHandler::new_with_capacity(5)))
             .validator_monitor_config(validator_monitor_config);
 
         builder = if let Some(mutator) = self.initial_mutator {
@@ -737,13 +707,10 @@ where
     Cold: ItemStore<E>,
 {
     pub fn builder(eth_spec_instance: E) -> Builder<BaseHarnessType<E, Hot, Cold>> {
+        create_test_tracing_subscriber();
         Builder::new(eth_spec_instance)
     }
 
-    pub fn logger(&self) -> &slog::Logger {
-        &self.chain.log
-    }
-
     pub fn execution_block_generator(&self) -> RwLockWriteGuard<'_, ExecutionBlockGenerator<E>> {
         self.mock_execution_layer
             .as_ref()
@@ -2618,7 +2585,6 @@ where
             return;
         }
 
-        let log = self.logger();
         let contributions =
             self.make_sync_contributions(state, block_root, slot, RelativeSyncCommittee::Current);
 
@@ -2649,7 +2615,6 @@ where
                 slot,
                 &block_root,
                 &sync_aggregate,
-                log,
                 &self.spec,
             );
     }
@@ -3159,58 +3124,6 @@ pub struct MakeAttestationOptions {
     pub fork: Fork,
 }
 
-pub enum LoggerType {
-    Test,
-    // The logs are output to files for each test.
-    CI,
-    // No logs will be printed.
-    Null,
-}
-
-fn ci_decorator() -> PlainSyncDecorator<BufWriter<File>> {
-    let log_dir = std::env::var(CI_LOGGER_DIR_ENV_VAR).unwrap_or_else(|e| {
-        panic!("{CI_LOGGER_DIR_ENV_VAR} env var must be defined when using ci_logger: {e:?}");
-    });
-    let fork_name = std::env::var(FORK_NAME_ENV_VAR)
-        .map(|s| format!("{s}_"))
-        .unwrap_or_default();
-    // The current test name can be got via the thread name.
-    let test_name = std::thread::current()
-        .name()
-        .unwrap()
-        .to_string()
-        // Colons are not allowed in files that are uploaded to GitHub Artifacts.
-        .replace("::", "_");
-    let log_path = format!("/{log_dir}/{fork_name}{test_name}.log");
-    let file = OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(log_path)
-        .unwrap();
-    let file = BufWriter::new(file);
-    PlainSyncDecorator::new(file)
-}
-
-pub fn build_log(level: slog::Level, logger_type: LoggerType) -> Logger {
-    match logger_type {
-        LoggerType::Test => {
-            let drain = FullFormat::new(TermDecorator::new().build()).build().fuse();
-            let drain = Async::new(drain).chan_size(10_000).build().fuse();
-            Logger::root(drain.filter_level(level).fuse(), o!())
-        }
-        LoggerType::CI => {
-            let drain = FullFormat::new(ci_decorator()).build().fuse();
-            let drain = Async::new(drain).chan_size(10_000).build().fuse();
-            Logger::root(drain.filter_level(level).fuse(), o!())
-        }
-        LoggerType::Null => {
-            let drain = FullFormat::new(TermDecorator::new().build()).build().fuse();
-            let drain = Async::new(drain).build().fuse();
-            Logger::root(drain.filter(|_| false).fuse(), o!())
-        }
-    }
-}
-
 pub enum NumBlobs {
     Random,
     Number(usize),