Drop null_logger (#6013)

* Drop null_logger

Cargo.lock

@@ -780,7 +780,6 @@ dependencies = [
  "bitvec 1.0.1",
  "bls",
  "derivative",
- "environment",
  "eth1",
  "eth2",
  "eth2_network_config",
@@ -2473,6 +2472,7 @@ dependencies = [
  "execution_layer",
  "futures",
  "lighthouse_metrics",
+ "logging",
  "merkle_proof",
  "parking_lot 0.12.3",
  "sensitive_url",
@@ -2957,7 +2957,6 @@ dependencies = [
  "arc-swap",
  "builder_client",
  "bytes",
- "environment",
  "eth2",
  "eth2_network_config",
  "ethereum_serde_utils",
@@ -2972,6 +2971,7 @@ dependencies = [
  "kzg",
  "lighthouse_metrics",
  "lighthouse_version",
+ "logging",
  "lru",
  "parking_lot 0.12.3",
  "pretty_reqwest_error",
@@ -3834,7 +3834,6 @@ dependencies = [
  "bs58 0.4.0",
  "bytes",
  "directory",
- "environment",
  "eth1",
  "eth2",
  "ethereum_serde_utils",
@@ -3876,10 +3875,10 @@ name = "http_metrics"
 version = "0.1.0"
 dependencies = [
  "beacon_chain",
- "environment",
  "lighthouse_metrics",
  "lighthouse_network",
  "lighthouse_version",
+ "logging",
  "malloc_utils",
  "reqwest",
  "serde",
@@ -4464,6 +4463,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_yaml",
+ "sloggers",
  "snap",
  "state_processing",
  "store",
@@ -9495,6 +9495,7 @@ dependencies = [
  "eth2_keystore",
  "eth2_network_config",
  "futures",
+ "logging",
  "parking_lot 0.12.3",
  "reqwest",
  "serde",

beacon_node/beacon_chain/Cargo.toml

@@ -15,7 +15,6 @@ test_backfill = []
 
 [dev-dependencies]
 maplit = { workspace = true }
-environment = { workspace = true }
 serde_json = { workspace = true }
 
 [dependencies]

beacon_node/beacon_chain/src/eth1_chain.rs

@@ -685,7 +685,6 @@ fn is_candidate_block(block: &Eth1Block, period_start: u64, spec: &ChainSpec) ->
 #[cfg(test)]
 mod test {
     use super::*;
-    use environment::null_logger;
     use types::{DepositData, MinimalEthSpec, Signature};
 
     type E = MinimalEthSpec;
@@ -743,6 +742,7 @@ mod test {
     mod eth1_chain_json_backend {
         use super::*;
         use eth1::DepositLog;
+        use logging::test_logger;
         use types::{test_utils::generate_deterministic_keypair, MainnetEthSpec};
 
         fn get_eth1_chain() -> Eth1Chain<CachingEth1Backend<E>, E> {
@@ -750,7 +750,7 @@ mod test {
                 ..Eth1Config::default()
             };
 
-            let log = null_logger().unwrap();
+            let log = test_logger();
             Eth1Chain::new(
                 CachingEth1Backend::new(eth1_config, log, MainnetEthSpec::default_spec()).unwrap(),
             )

beacon_node/beacon_chain/src/shuffling_cache.rs

@@ -294,7 +294,7 @@ impl BlockShufflingIds {
 #[cfg(not(debug_assertions))]
 #[cfg(test)]
 mod test {
-    use task_executor::test_utils::null_logger;
+    use task_executor::test_utils::test_logger;
     use types::*;
 
     use crate::test_utils::EphemeralHarnessType;
@@ -315,7 +315,7 @@ mod test {
             previous: Some(shuffling_id(current_epoch - 1)),
             block_root: Hash256::from_low_u64_le(0),
         };
-        let logger = null_logger().unwrap();
+        let logger = test_logger();
         ShufflingCache::new(TEST_CACHE_SIZE, head_shuffling_ids, logger)
     }
 

beacon_node/eth1/Cargo.toml

@@ -21,6 +21,7 @@ ethereum_ssz_derive = { workspace = true }
 tree_hash = { workspace = true }
 parking_lot = { workspace = true }
 slog = { workspace = true }
+logging = { workspace = true }
 superstruct = { workspace = true }
 tokio = { workspace = true }
 state_processing = { workspace = true }

beacon_node/eth1/tests/test.rs

@@ -4,10 +4,9 @@ use eth1::{Config, Eth1Endpoint, Service};
 use eth1::{DepositCache, DEFAULT_CHAIN_ID};
 use eth1_test_rig::{AnvilEth1Instance, Http, Middleware, Provider};
 use execution_layer::http::{deposit_methods::*, HttpJsonRpc, Log};
+use logging::test_logger;
 use merkle_proof::verify_merkle_proof;
 use sensitive_url::SensitiveUrl;
-use slog::Logger;
-use sloggers::{null::NullLoggerBuilder, Build};
 use std::ops::Range;
 use std::time::Duration;
 use tree_hash::TreeHash;
@@ -15,16 +14,11 @@ use types::{DepositData, EthSpec, Hash256, Keypair, MainnetEthSpec, MinimalEthSp
 
 const DEPOSIT_CONTRACT_TREE_DEPTH: usize = 32;
 
-pub fn null_logger() -> Logger {
-    let log_builder = NullLoggerBuilder;
-    log_builder.build().expect("should build logger")
-}
-
 pub fn new_env() -> Environment<MinimalEthSpec> {
     EnvironmentBuilder::minimal()
         .multi_threaded_tokio_runtime()
         .expect("should start tokio runtime")
-        .null_logger()
+        .test_logger()
         .expect("should start null logger")
         .build()
         .expect("should build env")
@@ -103,7 +97,7 @@ mod eth1_cache {
     #[tokio::test]
     async fn simple_scenario() {
         async {
-            let log = null_logger();
+            let log = test_logger();
 
             for follow_distance in 0..3 {
                 let eth1 = new_anvil_instance()
@@ -185,7 +179,7 @@ mod eth1_cache {
     #[tokio::test]
     async fn big_skip() {
         async {
-            let log = null_logger();
+            let log = test_logger();
 
             let eth1 = new_anvil_instance()
                 .await
@@ -240,7 +234,7 @@ mod eth1_cache {
     #[tokio::test]
     async fn pruning() {
         async {
-            let log = null_logger();
+            let log = test_logger();
 
             let eth1 = new_anvil_instance()
                 .await
@@ -292,7 +286,7 @@ mod eth1_cache {
     #[tokio::test]
     async fn double_update() {
         async {
-            let log = null_logger();
+            let log = test_logger();
 
             let n = 16;
 
@@ -345,7 +339,7 @@ mod deposit_tree {
     #[tokio::test]
     async fn updating() {
         async {
-            let log = null_logger();
+            let log = test_logger();
 
             let n = 4;
 
@@ -426,7 +420,7 @@ mod deposit_tree {
     #[tokio::test]
     async fn double_update() {
         async {
-            let log = null_logger();
+            let log = test_logger();
 
             let n = 8;
 
@@ -688,7 +682,7 @@ mod fast {
     #[tokio::test]
     async fn deposit_cache_query() {
         async {
-            let log = null_logger();
+            let log = test_logger();
 
             let eth1 = new_anvil_instance()
                 .await
@@ -771,7 +765,7 @@ mod persist {
     #[tokio::test]
     async fn test_persist_caches() {
         async {
-            let log = null_logger();
+            let log = test_logger();
 
             let eth1 = new_anvil_instance()
                 .await

beacon_node/execution_layer/Cargo.toml

@@ -10,6 +10,7 @@ alloy-primitives = { workspace = true }
 types = { workspace = true }
 tokio = { workspace = true }
 slog = { workspace = true }
+logging = { workspace = true }
 sensitive_url = { workspace = true }
 reqwest = { workspace = true }
 ethereum_serde_utils = { workspace = true }
@@ -17,7 +18,6 @@ serde_json = { workspace = true }
 serde = { workspace = true }
 warp = { workspace = true }
 jsonwebtoken = "8"
-environment = { workspace = true }
 bytes = { workspace = true }
 task_executor = { workspace = true }
 hex = { workspace = true }

beacon_node/execution_layer/src/test_utils/mod.rs

@@ -6,10 +6,10 @@ use crate::engine_api::{
 };
 use crate::json_structures::JsonClientVersionV1;
 use bytes::Bytes;
-use environment::null_logger;
 use execution_block_generator::PoWBlock;
 use handle_rpc::handle_rpc;
 use kzg::Kzg;
+use logging::test_logger;
 use parking_lot::{Mutex, RwLock, RwLockWriteGuard};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -149,7 +149,7 @@ impl<E: EthSpec> MockServer<E> {
         let ctx: Arc<Context<E>> = Arc::new(Context {
             config: server_config,
             jwt_key,
-            log: null_logger().unwrap(),
+            log: test_logger(),
             last_echo_request: last_echo_request.clone(),
             execution_block_generator: RwLock::new(execution_block_generator),
             previous_request: <_>::default(),

beacon_node/genesis/tests/tests.rs

@@ -12,7 +12,7 @@ pub fn new_env() -> Environment<MinimalEthSpec> {
     EnvironmentBuilder::minimal()
         .multi_threaded_tokio_runtime()
         .expect("should start tokio runtime")
-        .null_logger()
+        .test_logger()
         .expect("should start null logger")
         .build()
         .expect("should build env")

beacon_node/http_api/Cargo.toml

@@ -44,10 +44,10 @@ bytes = { workspace = true }
 beacon_processor = { workspace = true }
 
 [dev-dependencies]
-environment = { workspace = true }
 serde_json = { workspace = true }
 proto_array = { workspace = true }
 genesis = { workspace = true }
+logging = { workspace = true }
 
 [[test]]
 name = "bn_http_api_tests"

beacon_node/http_api/tests/tests.rs

@@ -3,7 +3,6 @@ use beacon_chain::{
     test_utils::{AttestationStrategy, BeaconChainHarness, BlockStrategy, EphemeralHarnessType},
     BeaconChain, ChainConfig, StateSkipConfig, WhenSlotSkipped,
 };
-use environment::null_logger;
 use eth2::{
     mixin::{RequestAccept, ResponseForkName, ResponseOptional},
     reqwest::RequestBuilder,
@@ -24,6 +23,7 @@ use http_api::{
     BlockId, StateId,
 };
 use lighthouse_network::{types::SyncState, Enr, EnrExt, PeerId};
+use logging::test_logger;
 use network::NetworkReceivers;
 use proto_array::ExecutionStatus;
 use sensitive_url::SensitiveUrl;
@@ -251,7 +251,7 @@ impl ApiTester {
             "precondition: justification"
         );
 
-        let log = null_logger().unwrap();
+        let log = test_logger();
 
         let ApiServer {
             ctx,
@@ -349,7 +349,7 @@ impl ApiTester {
 
         let chain = harness.chain.clone();
 
-        let log = null_logger().unwrap();
+        let log = test_logger();
 
         let ApiServer {
             ctx,

beacon_node/http_metrics/Cargo.toml

@@ -22,5 +22,5 @@ malloc_utils = { workspace = true }
 [dev-dependencies]
 tokio = { workspace = true }
 reqwest = { workspace = true }
-environment = { workspace = true }
 types = { workspace = true }
+logging = { workspace = true }

beacon_node/http_metrics/tests/tests.rs

@@ -1,6 +1,6 @@
 use beacon_chain::test_utils::EphemeralHarnessType;
-use environment::null_logger;
 use http_metrics::Config;
+use logging::test_logger;
 use reqwest::header::HeaderValue;
 use reqwest::StatusCode;
 use std::net::{IpAddr, Ipv4Addr};
@@ -13,7 +13,7 @@ type Context = http_metrics::Context<EphemeralHarnessType<MainnetEthSpec>>;
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn returns_200_ok() {
     async {
-        let log = null_logger().unwrap();
+        let log = test_logger();
 
         let context = Arc::new(Context {
             config: Config {

beacon_node/tests/test.rs

@@ -25,7 +25,7 @@ fn build_node<E: EthSpec>(env: &mut Environment<E>) -> LocalBeaconNode<E> {
 #[test]
 fn http_server_genesis_state() {
     let mut env = env_builder()
-        .null_logger()
+        .test_logger()
         //.async_logger("debug", None)
         .expect("should build env logger")
         .multi_threaded_tokio_runtime()

common/logging/src/lib.rs

@@ -289,10 +289,10 @@ pub fn test_logger() -> Logger {
         sloggers::terminal::TerminalLoggerBuilder::new()
             .level(sloggers::types::Severity::Debug)
             .build()
-            .expect("Should build test_logger")
+            .expect("Should build TerminalLoggerBuilder")
     } else {
         sloggers::null::NullLoggerBuilder
             .build()
-            .expect("Should build null_logger")
+            .expect("Should build NullLoggerBuilder")
     }
 }

common/task_executor/src/test_utils.rs

@@ -1,7 +1,6 @@
 use crate::TaskExecutor;
-use logging::test_logger;
+pub use logging::test_logger;
 use slog::Logger;
-use sloggers::{null::NullLoggerBuilder, Build};
 use std::sync::Arc;
 use tokio::runtime;
 
@@ -67,10 +66,3 @@ impl TestRuntime {
         self.task_executor.log = log;
     }
 }
-
-pub fn null_logger() -> Result<Logger, String> {
-    let log_builder = NullLoggerBuilder;
-    log_builder
-        .build()
-        .map_err(|e| format!("Failed to start null logger: {:?}", e))
-}

lcli/Cargo.toml

@@ -14,6 +14,7 @@ jemalloc = ["malloc_utils/jemalloc"]
 bls = { workspace = true }
 clap = { workspace = true }
 log = { workspace = true }
+sloggers = { workspace = true }
 serde = { workspace = true }
 serde_yaml = { workspace = true }
 serde_json = { workspace = true }

lcli/src/transition_blocks.rs

@@ -66,13 +66,14 @@ use beacon_chain::{
 };
 use clap::ArgMatches;
 use clap_utils::{parse_optional, parse_required};
-use environment::{null_logger, Environment};
+use environment::Environment;
 use eth2::{
     types::{BlockId, StateId},
     BeaconNodeHttpClient, SensitiveUrl, Timeouts,
 };
 use eth2_network_config::Eth2NetworkConfig;
 use log::{debug, info};
+use sloggers::{null::NullLoggerBuilder, Build};
 use ssz::Encode;
 use state_processing::state_advance::complete_state_advance;
 use state_processing::{
@@ -196,7 +197,9 @@ pub fn run<E: EthSpec>(
     let store = HotColdDB::open_ephemeral(
         <_>::default(),
         spec.clone(),
-        null_logger().map_err(|e| format!("Failed to create null_logger: {:?}", e))?,
+        NullLoggerBuilder
+            .build()
+            .map_err(|e| format!("Error on NullLoggerBuilder: {:?}", e))?,
     )
     .map_err(|e| format!("Failed to create ephemeral store: {:?}", e))?;
     let store = Arc::new(store);

lighthouse/environment/src/lib.rs

@@ -12,7 +12,7 @@ use eth2_network_config::Eth2NetworkConfig;
 use futures::channel::mpsc::{channel, Receiver, Sender};
 use futures::{future, StreamExt};
 
-use logging::SSELoggingComponents;
+use logging::{test_logger, SSELoggingComponents};
 use serde::{Deserialize, Serialize};
 use slog::{error, info, o, warn, Drain, Duplicate, Level, Logger};
 use sloggers::{file::FileLoggerBuilder, types::Format, types::Severity, Build};
@@ -34,8 +34,6 @@ use {
 #[cfg(not(target_family = "unix"))]
 use {futures::channel::oneshot, std::cell::RefCell};
 
-pub use task_executor::test_utils::null_logger;
-
 const LOG_CHANNEL_SIZE: usize = 16384;
 const SSE_LOG_CHANNEL_SIZE: usize = 2048;
 /// The maximum time in seconds the client will wait for all internal tasks to shutdown.
@@ -184,9 +182,9 @@ impl<E: EthSpec> EnvironmentBuilder<E> {
         Ok(self)
     }
 
-    /// Specifies that all logs should be sent to `null` (i.e., ignored).
-    pub fn null_logger(mut self) -> Result<Self, String> {
-        self.log = Some(null_logger()?);
+    /// Sets a logger suitable for test usage.
+    pub fn test_logger(mut self) -> Result<Self, String> {
+        self.log = Some(test_logger());
         Ok(self)
     }
 

lighthouse/environment/tests/environment_builder.rs

@@ -9,7 +9,7 @@ fn builder() -> EnvironmentBuilder<MainnetEthSpec> {
     EnvironmentBuilder::mainnet()
         .multi_threaded_tokio_runtime()
         .expect("should set runtime")
-        .null_logger()
+        .test_logger()
         .expect("should set logger")
 }
 

testing/web3signer_tests/Cargo.toml

@@ -27,3 +27,4 @@ eth2_network_config = { workspace = true }
 serde_json = { workspace = true }
 zip = { workspace = true }
 parking_lot = { workspace = true }
+logging = { workspace = true }

testing/web3signer_tests/src/lib.rs

@@ -22,6 +22,7 @@ mod tests {
     };
     use eth2_keystore::KeystoreBuilder;
     use eth2_network_config::Eth2NetworkConfig;
+    use logging::test_logger;
     use parking_lot::Mutex;
     use reqwest::Client;
     use serde::Serialize;
@@ -318,7 +319,7 @@ mod tests {
             using_web3signer: bool,
             spec: ChainSpec,
         ) -> Self {
-            let log = environment::null_logger().unwrap();
+            let log = test_logger();
             let validator_dir = TempDir::new().unwrap();
 
             let config = validator_client::Config::default();

validator_client/src/doppelganger_service.rs

@@ -687,8 +687,8 @@ impl DoppelgangerService {
 #[cfg(test)]
 mod test {
     use super::*;
-    use environment::null_logger;
     use futures::executor::block_on;
+    use logging::test_logger;
     use slot_clock::TestingSlotClock;
     use std::future;
     use std::time::Duration;
@@ -732,7 +732,7 @@ mod test {
         fn build(self) -> TestScenario {
             let mut rng = XorShiftRng::from_seed([42; 16]);
             let slot_clock = TestingSlotClock::new(Slot::new(0), GENESIS_TIME, SLOT_DURATION);
-            let log = null_logger().unwrap();
+            let log = test_logger();
 
             TestScenario {
                 validators: (0..self.validator_count)