chore: add some more instrumentation (#11157)

Author: DaniPopes

crates/common/src/compile.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     TestFunctionExt,
-    preprocessor::TestOptimizerPreprocessor,
+    preprocessor::DynamicTestLinkingPreprocessor,
     reports::{ReportKind, report_kind},
     shell,
     term::SpinnerReporter,
@@ -146,13 +146,15 @@ impl ProjectCompiler {
         self.dynamic_test_linking = preprocess;
         self
     }
+
     /// Compiles the project.
+    #[instrument(target = "forge::compile", skip_all)]
     pub fn compile<C: Compiler<CompilerContract = Contract>>(
         mut self,
         project: &Project<C>,
     ) -> Result<ProjectCompileOutput<C>>
     where
-        TestOptimizerPreprocessor: Preprocessor<C>,
+        DynamicTestLinkingPreprocessor: Preprocessor<C>,
     {
         self.project_root = project.root().to_path_buf();
 
@@ -180,7 +182,7 @@ impl ProjectCompiler {
             let mut compiler =
                 foundry_compilers::project::ProjectCompiler::with_sources(project, sources)?;
             if preprocess {
-                compiler = compiler.with_preprocessor(TestOptimizerPreprocessor);
+                compiler = compiler.with_preprocessor(DynamicTestLinkingPreprocessor);
             }
             compiler.compile().map_err(Into::into)
         })
@@ -196,7 +198,6 @@ impl ProjectCompiler {
     /// let prj = config.project().unwrap();
     /// ProjectCompiler::new().compile_with(|| Ok(prj.compile()?)).unwrap();
     /// ```
-    #[instrument(target = "forge::compile", skip_all)]
     fn compile_with<C: Compiler<CompilerContract = Contract>, F>(
         self,
         f: F,
@@ -519,7 +520,7 @@ pub fn compile_target<C: Compiler<CompilerContract = Contract>>(
     quiet: bool,
 ) -> Result<ProjectCompileOutput<C>>
 where
-    TestOptimizerPreprocessor: Preprocessor<C>,
+    DynamicTestLinkingPreprocessor: Preprocessor<C>,
 {
     ProjectCompiler::new().quiet(quiet).files([target_path.into()]).compile(project)
 }

crates/common/src/preprocessor/mod.rs

@@ -25,10 +25,17 @@ fn span_to_range(source_map: &SourceMap, span: Span) -> Range<usize> {
     source_map.span_to_source(span).unwrap().1
 }
 
+/// Preprocessor that replaces static bytecode linking in tests and scripts (`new Contract`) with
+/// dynamic linkage through (`Vm.create*`).
+///
+/// This allows for more efficient caching when iterating on tests.
+///
+/// See <https://github.com/foundry-rs/foundry/pull/10010>.
 #[derive(Debug)]
-pub struct TestOptimizerPreprocessor;
+pub struct DynamicTestLinkingPreprocessor;
 
-impl Preprocessor<SolcCompiler> for TestOptimizerPreprocessor {
+impl Preprocessor<SolcCompiler> for DynamicTestLinkingPreprocessor {
+    #[instrument(name = "DynamicTestLinkingPreprocessor::preprocess", skip_all)]
     fn preprocess(
         &self,
         _solc: &SolcCompiler,
@@ -97,7 +104,7 @@ impl Preprocessor<SolcCompiler> for TestOptimizerPreprocessor {
     }
 }
 
-impl Preprocessor<MultiCompiler> for TestOptimizerPreprocessor {
+impl Preprocessor<MultiCompiler> for DynamicTestLinkingPreprocessor {
     fn preprocess(
         &self,
         compiler: &MultiCompiler,

crates/evm/evm/src/executors/fuzz/mod.rs

@@ -177,7 +177,7 @@ impl FuzzedExecutor {
             reason: None,
             counterexample: None,
             logs: fuzz_result.logs,
-            labeled_addresses: call.labels,
+            labels: call.labels,
             traces: last_run_traces,
             breakpoints: last_run_breakpoints,
             gas_report_traces: traces.into_iter().map(|a| a.arena).collect(),

crates/evm/fuzz/src/lib.rs

@@ -206,7 +206,7 @@ pub struct FuzzTestResult {
     pub logs: Vec<Log>,
 
     /// Labeled addresses
-    pub labeled_addresses: AddressHashMap<String>,
+    pub labels: AddressHashMap<String>,
 
     /// Exemplary traces for a fuzz run of the test function
     ///

crates/evm/traces/src/decoder/mod.rs

@@ -167,6 +167,7 @@ impl CallTraceDecoder {
         INIT.get_or_init(Self::init)
     }
 
+    #[instrument(name = "CallTraceDecoder::init", level = "debug")]
     fn init() -> Self {
         Self {
             contracts: Default::default(),

crates/evm/traces/src/identifier/signatures.rs

@@ -83,7 +83,7 @@ impl Serialize for SignaturesCache {
 
 impl SignaturesCache {
     /// Loads the cache from a file.
-    #[instrument(target = "evm::traces")]
+    #[instrument(target = "evm::traces", name = "SignaturesCache::load")]
     pub fn load(path: &Path) -> Self {
         trace!(target: "evm::traces", ?path, "reading signature cache");
         fs::read_json_file(path)
@@ -94,7 +94,7 @@ impl SignaturesCache {
     }
 
     /// Saves the cache to a file.
-    #[instrument(target = "evm::traces", skip(self))]
+    #[instrument(target = "evm::traces", name = "SignaturesCache::save", skip(self))]
     pub fn save(&self, path: &Path) {
         if let Some(parent) = path.parent()
             && let Err(err) = std::fs::create_dir_all(parent)

crates/forge/src/cmd/coverage.rs

@@ -185,7 +185,7 @@ impl CoverageArgs {
     }
 
     /// Builds the coverage report.
-    #[instrument(name = "prepare", skip_all)]
+    #[instrument(name = "Coverage::prepare", skip_all)]
     fn prepare(
         &self,
         project_paths: &ProjectPathsConfig,
@@ -258,6 +258,7 @@ impl CoverageArgs {
     }
 
     /// Runs tests, collects coverage data and generates the final report.
+    #[instrument(name = "Coverage::collect", skip_all)]
     async fn collect(
         mut self,
         root: &Path,
@@ -329,10 +330,17 @@ impl CoverageArgs {
         }
 
         // Output final reports.
+        self.report(&report)?;
+
+        Ok(())
+    }
+
+    #[instrument(name = "Coverage::report", skip_all)]
+    fn report(&mut self, report: &CoverageReport) -> Result<()> {
         for reporter in &mut self.reporters {
-            reporter.report(&report)?;
+            let _guard = debug_span!("reporter.report", kind=%reporter.name()).entered();
+            reporter.report(report)?;
         }
-
         Ok(())
     }
 

crates/forge/src/cmd/test/mod.rs

@@ -208,6 +208,7 @@ impl TestArgs {
     /// Returns sources which include any tests to be executed.
     /// If no filters are provided, sources are filtered by existence of test/invariant methods in
     /// them, If filters are provided, sources are additionally filtered by them.
+    #[instrument(target = "forge::test", skip_all)]
     pub fn get_sources_to_compile(
         &self,
         config: &Config,
@@ -612,9 +613,7 @@ impl TestArgs {
 
                 // Clear the addresses and labels from previous runs.
                 decoder.clear_addresses();
-                decoder
-                    .labels
-                    .extend(result.labeled_addresses.iter().map(|(k, v)| (*k, v.clone())));
+                decoder.labels.extend(result.labels.iter().map(|(k, v)| (*k, v.clone())));
 
                 // Identify addresses and decode traces.
                 let mut decoded_traces = Vec::with_capacity(result.traces.len());

crates/forge/src/coverage.rs

@@ -15,6 +15,9 @@ pub use foundry_evm::coverage::*;
 
 /// A coverage reporter.
 pub trait CoverageReporter {
+    /// Returns a debug string for the reporter.
+    fn name(&self) -> &'static str;
+
     /// Returns `true` if the reporter needs source maps for the final report.
     fn needs_source_maps(&self) -> bool {
         false
@@ -62,6 +65,10 @@ impl CoverageSummaryReporter {
 }
 
 impl CoverageReporter for CoverageSummaryReporter {
+    fn name(&self) -> &'static str {
+        "summary"
+    }
+
     fn report(&mut self, report: &CoverageReport) -> eyre::Result<()> {
         for (path, summary) in report.summary_by_file() {
             self.total.merge(&summary);
@@ -108,6 +115,10 @@ impl LcovReporter {
 }
 
 impl CoverageReporter for LcovReporter {
+    fn name(&self) -> &'static str {
+        "lcov"
+    }
+
     fn report(&mut self, report: &CoverageReport) -> eyre::Result<()> {
         let mut out = std::io::BufWriter::new(fs::create_file(&self.path)?);
 
@@ -184,6 +195,10 @@ impl CoverageReporter for LcovReporter {
 pub struct DebugReporter;
 
 impl CoverageReporter for DebugReporter {
+    fn name(&self) -> &'static str {
+        "debug"
+    }
+
     fn report(&mut self, report: &CoverageReport) -> eyre::Result<()> {
         for (path, items) in report.items_by_file() {
             sh_println!("Uncovered for {}:", path.display())?;
@@ -237,6 +252,10 @@ impl BytecodeReporter {
 }
 
 impl CoverageReporter for BytecodeReporter {
+    fn name(&self) -> &'static str {
+        "bytecode"
+    }
+
     fn needs_source_maps(&self) -> bool {
         true
     }

crates/forge/src/result.rs

@@ -407,7 +407,8 @@ pub struct TestResult {
     pub line_coverage: Option<HitMaps>,
 
     /// Labeled addresses
-    pub labeled_addresses: AddressHashMap<String>,
+    #[serde(rename = "labeled_addresses")] // Backwards compatibility.
+    pub labels: AddressHashMap<String>,
 
     #[serde(with = "foundry_common::serde_helpers::duration")]
     pub duration: Duration,
@@ -472,11 +473,20 @@ impl fmt::Display for TestResult {
     }
 }
 
+macro_rules! extend {
+    ($a:expr, $b:expr, $trace_kind:expr) => {
+        $a.logs.extend($b.logs);
+        $a.labels.extend($b.labels);
+        $a.traces.extend($b.traces.map(|traces| ($trace_kind, traces)));
+        $a.merge_coverages($b.line_coverage);
+    };
+}
+
 impl TestResult {
     /// Creates a new test result starting from test setup results.
     pub fn new(setup: &TestSetup) -> Self {
         Self {
-            labeled_addresses: setup.labels.clone(),
+            labels: setup.labels.clone(),
             logs: setup.logs.clone(),
             traces: setup.traces.clone(),
             line_coverage: setup.coverage.clone(),
@@ -491,13 +501,25 @@ impl TestResult {
 
     /// Creates a test setup result.
     pub fn setup_result(setup: TestSetup) -> Self {
+        let TestSetup {
+            address: _,
+            fuzz_fixtures: _,
+            logs,
+            labels,
+            traces,
+            coverage,
+            deployed_libs: _,
+            reason,
+            skipped,
+            deployment_failure: _,
+        } = setup;
         Self {
-            status: if setup.skipped { TestStatus::Skipped } else { TestStatus::Failure },
-            reason: setup.reason,
-            logs: setup.logs,
-            traces: setup.traces,
-            line_coverage: setup.coverage,
-            labeled_addresses: setup.labels,
+            status: if skipped { TestStatus::Skipped } else { TestStatus::Failure },
+            reason,
+            logs,
+            traces,
+            line_coverage: coverage,
+            labels,
             ..Default::default()
         }
     }
@@ -525,11 +547,7 @@ impl TestResult {
         self.kind =
             TestKind::Unit { gas: raw_call_result.gas_used.wrapping_sub(raw_call_result.stipend) };
 
-        // Record logs, labels, traces and merge coverages.
-        self.logs.extend(raw_call_result.logs);
-        self.labeled_addresses.extend(raw_call_result.labels);
-        self.traces.extend(raw_call_result.traces.map(|traces| (TraceKind::Execution, traces)));
-        self.merge_coverages(raw_call_result.line_coverage);
+        extend!(self, raw_call_result, TraceKind::Execution);
 
         self.status = match success {
             true => TestStatus::Success,
@@ -557,10 +575,7 @@ impl TestResult {
         };
 
         // Record logs, labels, traces and merge coverages.
-        self.logs.extend(result.logs);
-        self.labeled_addresses.extend(result.labeled_addresses);
-        self.traces.extend(result.traces.map(|traces| (TraceKind::Execution, traces)));
-        self.merge_coverages(result.line_coverage);
+        extend!(self, result, TraceKind::Execution);
 
         self.status = if result.skipped {
             TestStatus::Skipped
@@ -667,10 +682,7 @@ impl TestResult {
 
     /// Merges the given raw call result into `self`.
     pub fn extend(&mut self, call_result: RawCallResult) {
-        self.logs.extend(call_result.logs);
-        self.labeled_addresses.extend(call_result.labels);
-        self.traces.extend(call_result.traces.map(|traces| (TraceKind::Execution, traces)));
-        self.merge_coverages(call_result.line_coverage);
+        extend!(self, call_result, TraceKind::Execution);
     }
 
     /// Merges the given coverage result into `self`.
@@ -825,9 +837,10 @@ impl TestSetup {
     }
 
     pub fn extend(&mut self, raw: RawCallResult, trace_kind: TraceKind) {
-        self.logs.extend(raw.logs);
-        self.labels.extend(raw.labels);
-        self.traces.extend(raw.traces.map(|traces| (trace_kind, traces)));
-        HitMaps::merge_opt(&mut self.coverage, raw.line_coverage);
+        extend!(self, raw, trace_kind);
+    }
+
+    pub fn merge_coverages(&mut self, other_coverage: Option<HitMaps>) {
+        HitMaps::merge_opt(&mut self.coverage, other_coverage);
     }
 }