Integrate tracing

Cargo.toml

@@ -78,7 +78,6 @@ members = [
     "testing/execution_engine_integration",
     "testing/node_test_rig",
     "testing/simulator",
-    "testing/test-test_logger",
     "testing/state_transition_vectors",
     "testing/web3signer_tests",
 
@@ -157,10 +156,6 @@ serde_json = "1"
 serde_repr = "0.1"
 serde_yaml = "0.9"
 sha2 = "0.9"
-slog = { version = "2", features = ["max_level_debug", "release_max_level_debug", "nested-values"] }
-slog-async = "2"
-slog-term = "2"
-sloggers = { version = "2", features = ["json"] }
 smallvec = { version = "1.11.2", features = ["arbitrary"] }
 snap = "1"
 ssz_types = "0.8"

beacon_node/Cargo.toml

@@ -26,7 +26,7 @@ types = { workspace = true }
 store = { workspace = true }
 client = { path = "client" }
 clap = { workspace = true }
-slog = { workspace = true }
+tracing = { workspace = true }
 dirs = { workspace = true }
 directory = { workspace = true }
 environment = { workspace = true }

beacon_node/beacon_chain/Cargo.toml

@@ -58,10 +58,6 @@ sensitive_url = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 slasher = { workspace = true }
-slog = { workspace = true }
-slog-async = { workspace = true }
-slog-term = { workspace = true }
-sloggers = { workspace = true }
 slot_clock = { workspace = true }
 smallvec = { workspace = true }
 ssz_types = { workspace = true }
@@ -76,6 +72,7 @@ tokio-stream = { workspace = true }
 tree_hash = { workspace = true }
 tree_hash_derive = { workspace = true }
 types = { workspace = true }
+tracing = { workspace = true }
 
 [[test]]
 name = "beacon_chain_tests"

beacon_node/beacon_chain/src/attestation_rewards.rs

@@ -4,7 +4,6 @@ use eth2::lighthouse::StandardAttestationRewards;
 use eth2::types::ValidatorId;
 use safe_arith::SafeArith;
 use serde_utils::quoted_u64::Quoted;
-use slog::debug;
 use state_processing::common::base::{self, SqrtTotalActiveBalance};
 use state_processing::per_epoch_processing::altair::{
     process_inactivity_updates_slow, process_justification_and_finalization,
@@ -29,6 +28,7 @@ use store::consts::altair::{
     PARTICIPATION_FLAG_WEIGHTS, TIMELY_HEAD_FLAG_INDEX, TIMELY_SOURCE_FLAG_INDEX,
     TIMELY_TARGET_FLAG_INDEX,
 };
+use tracing::debug;
 use types::consts::altair::WEIGHT_DENOMINATOR;
 use types::{BeaconState, Epoch, EthSpec, RelativeEpoch};
 
@@ -38,7 +38,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         epoch: Epoch,
         validators: Vec<ValidatorId>,
     ) -> Result<StandardAttestationRewards, BeaconChainError> {
-        debug!(self.log, "computing attestation rewards"; "epoch" => epoch, "validator_count" => validators.len());
+        debug!(
+            %epoch,
+            validator_count = validators.len(),
+            "computing attestation rewards"
+        );
 
         // Get state
         let state_slot = (epoch + 1).end_slot(T::EthSpec::slots_per_epoch());
@@ -215,10 +219,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             // Return 0s for unknown/inactive validator indices.
             let Ok(validator) = state.get_validator(validator_index) else {
                 debug!(
-                    self.log,
-                    "No rewards for inactive/unknown validator";
-                    "index" => validator_index,
-                    "epoch" => previous_epoch
+                    index = validator_index,
+                    epoch = %previous_epoch,
+                    "No rewards for inactive/unknown validator"
                 );
                 total_rewards.push(TotalAttestationRewards {
                     validator_index: validator_index as u64,

beacon_node/beacon_chain/src/attestation_simulator.rs

@@ -1,9 +1,9 @@
 use crate::{BeaconChain, BeaconChainTypes};
-use slog::{debug, error};
 use slot_clock::SlotClock;
 use std::sync::Arc;
 use task_executor::TaskExecutor;
 use tokio::time::sleep;
+use tracing::{debug, error};
 use types::{EthSpec, Slot};
 
 /// Don't run the attestation simulator if the head slot is this many epochs
@@ -36,10 +36,7 @@ async fn attestation_simulator_service<T: BeaconChainTypes>(
             Some(duration) => {
                 sleep(duration + additional_delay).await;
 
-                debug!(
-                    chain.log,
-                    "Simulating unagg. attestation production";
-                );
+                debug!("Simulating unagg. attestation production");
 
                 // Run the task in the executor
                 let inner_chain = chain.clone();
@@ -53,7 +50,7 @@ async fn attestation_simulator_service<T: BeaconChainTypes>(
                 );
             }
             None => {
-                error!(chain.log, "Failed to read slot clock");
+                error!("Failed to read slot clock");
                 // If we can't read the slot clock, just wait another slot.
                 sleep(slot_duration).await;
             }
@@ -85,10 +82,9 @@ pub fn produce_unaggregated_attestation<T: BeaconChainTypes>(
             let data = unaggregated_attestation.data();
 
             debug!(
-                chain.log,
-                "Produce unagg. attestation";
-                "attestation_source" => data.source.root.to_string(),
-                "attestation_target" => data.target.root.to_string(),
+                attestation_source = data.source.root.to_string(),
+                attestation_target = data.target.root.to_string(),
+                "Produce unagg. attestation"
             );
 
             chain
@@ -98,9 +94,8 @@ pub fn produce_unaggregated_attestation<T: BeaconChainTypes>(
         }
         Err(e) => {
             debug!(
-                chain.log,
-                "Failed to simulate attestation";
-                "error" => ?e
+                error = ?e,
+                "Failed to simulate attestation"
             );
         }
     }

beacon_node/beacon_chain/src/attestation_verification.rs

@@ -43,7 +43,6 @@ use crate::{
 use bls::verify_signature_sets;
 use itertools::Itertools;
 use proto_array::Block as ProtoBlock;
-use slog::debug;
 use slot_clock::SlotClock;
 use state_processing::{
     common::{
@@ -58,6 +57,7 @@ use state_processing::{
 };
 use std::borrow::Cow;
 use strum::AsRefStr;
+use tracing::debug;
 use tree_hash::TreeHash;
 use types::{
     Attestation, AttestationRef, BeaconCommittee, BeaconStateError::NoCommitteeFound, ChainSpec,
@@ -409,10 +409,9 @@ fn process_slash_info<T: BeaconChainTypes>(
                     Ok((indexed, _)) => (indexed, true, err),
                     Err(e) => {
                         debug!(
-                            chain.log,
-                            "Unable to obtain indexed form of attestation for slasher";
-                            "attestation_root" => format!("{:?}", attestation.tree_hash_root()),
-                            "error" => format!("{:?}", e)
+                            attestation_root = ?attestation.tree_hash_root(),
+                            error =  ?e,
+                            "Unable to obtain indexed form of attestation for slasher"
                         );
                         return err;
                     }
@@ -426,9 +425,8 @@ fn process_slash_info<T: BeaconChainTypes>(
         if check_signature {
             if let Err(e) = verify_attestation_signature(chain, &indexed_attestation) {
                 debug!(
-                    chain.log,
-                    "Signature verification for slasher failed";
-                    "error" => format!("{:?}", e),
+                    error = ?e,
+                    "Signature verification for slasher failed"
                 );
                 return err;
             }

beacon_node/beacon_chain/src/beacon_block_reward.rs

@@ -2,7 +2,6 @@ use crate::{BeaconChain, BeaconChainError, BeaconChainTypes, StateSkipConfig};
 use attesting_indices_base::get_attesting_indices;
 use eth2::lighthouse::StandardBlockReward;
 use safe_arith::SafeArith;
-use slog::error;
 use state_processing::common::attesting_indices_base;
 use state_processing::{
     common::{
@@ -19,6 +18,7 @@ use store::{
     consts::altair::{PARTICIPATION_FLAG_WEIGHTS, PROPOSER_WEIGHT, WEIGHT_DENOMINATOR},
     RelativeEpoch,
 };
+use tracing::error;
 use types::{AbstractExecPayload, BeaconBlockRef, BeaconState, BeaconStateError, EthSpec};
 
 type BeaconBlockSubRewardValue = u64;
@@ -56,9 +56,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .compute_beacon_block_proposer_slashing_reward(block, state)
             .map_err(|e| {
                 error!(
-                self.log,
-                "Error calculating proposer slashing reward";
-                "error" => ?e
+                error = ?e,
+                "Error calculating proposer slashing reward"
                 );
                 BeaconChainError::BlockRewardError
             })?;
@@ -67,9 +66,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .compute_beacon_block_attester_slashing_reward(block, state)
             .map_err(|e| {
                 error!(
-                self.log,
-                "Error calculating attester slashing reward";
-                "error" => ?e
+                    error = ?e,
+                "Error calculating attester slashing reward"
                 );
                 BeaconChainError::BlockRewardError
             })?;
@@ -78,19 +76,17 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             self.compute_beacon_block_attestation_reward_base(block, state)
                 .map_err(|e| {
                     error!(
-                        self.log,
-                        "Error calculating base block attestation reward";
-                        "error" => ?e
+                        error = ?e,
+                        "Error calculating base block attestation reward"
                     );
                     BeaconChainError::BlockRewardAttestationError
                 })?
         } else {
             self.compute_beacon_block_attestation_reward_altair_deneb(block, state)
                 .map_err(|e| {
                     error!(
-                        self.log,
-                        "Error calculating altair block attestation reward";
-                        "error" => ?e
+                        error = ?e,
+                        "Error calculating altair block attestation reward"
                     );
                     BeaconChainError::BlockRewardAttestationError
                 })?