feat: log(LogEntry) to handle different log types

fvm/src/call_manager/default.rs

@@ -517,6 +517,10 @@ where
     fn log(&mut self, msg: String) {
         self.trace(ExecutionEvent::Log(msg))
     }
+
+    fn trace_ipld(&mut self, op: crate::trace::IpldOperation, cid: Cid, size: usize) {
+        self.trace(ExecutionEvent::Ipld { op, cid, size })
+    }
 }
 
 impl<M> DefaultCallManager<M>

fvm/src/call_manager/mod.rs

@@ -24,7 +24,7 @@ mod default;
 pub use default::DefaultCallManager;
 use fvm_shared::event::StampedEvent;
 
-use crate::trace::ExecutionTrace;
+use crate::trace::{ExecutionTrace, IpldOperation};
 
 /// BlockID representing nil parameters or return data.
 pub const NO_DATA_BLOCK_ID: u32 = 0;
@@ -87,6 +87,7 @@ pub trait CallManager: 'static {
 
     /// Returns a reference to the machine.
     fn machine(&self) -> &Self::Machine;
+
     /// Returns a mutable reference to the machine.
     fn machine_mut(&mut self) -> &mut Self::Machine;
 
@@ -177,6 +178,8 @@ pub trait CallManager: 'static {
 
     /// log
     fn log(&mut self, msg: String);
+
+    fn trace_ipld(&mut self, op: IpldOperation, cid: Cid, size: usize);
 }
 
 /// The result of calling actor's entrypoint

fvm/src/kernel/default.rs

@@ -27,6 +27,7 @@ use crate::gas::GasTimer;
 use crate::init_actor::INIT_ACTOR_ID;
 use crate::machine::{MachineContext, NetworkConfig, BURNT_FUNDS_ACTOR_ID};
 use crate::state_tree::ActorState;
+use crate::trace::IpldOperation;
 use crate::{ipld, syscall_error};
 
 const BLAKE2B_256: u64 = 0xb220;
@@ -409,6 +410,9 @@ where
 
         t.stop();
 
+        self.call_manager
+            .trace_ipld(IpldOperation::Get, *cid, data.len());
+
         // This can fail because we can run out of gas.
         let children = ipld::scan_for_reachable_links(
             cid.codec(),
@@ -483,9 +487,13 @@ where
             // TODO: This is really "super fatal". It means we failed to store state, and should
             // probably abort the entire block.
             .or_fatal()?;
+        let size = block.data().len();
         self.blocks.mark_reachable(&k);
 
         t.stop_with(start);
+
+        self.call_manager.trace_ipld(IpldOperation::Put, k, size);
+
         Ok(k)
     }
 
@@ -880,6 +888,7 @@ where
 
     fn install_actor(&mut self, code_id: Cid) -> Result<()> {
         let start = GasTimer::start();
+
         let size = self
             .call_manager
             .engine()
@@ -892,6 +901,9 @@ where
             .charge_gas(self.call_manager.price_list().on_install_actor(size))?;
         t.stop_with(start);
 
+        self.call_manager
+            .trace_ipld(IpldOperation::Get, code_id, size);
+
         Ok(())
     }
 

fvm/src/trace/mod.rs

@@ -1,3 +1,4 @@
+use cid::Cid;
 // Copyright 2021-2023 Protocol Labs
 // SPDX-License-Identifier: Apache-2.0, MIT
 use fvm_ipld_encoding::ipld_block::IpldBlock;
@@ -13,6 +14,13 @@ use crate::kernel::SyscallError;
 /// Execution Trace, only for informational and debugging purposes.
 pub type ExecutionTrace = Vec<ExecutionEvent>;
 
+/// The type of operation being performed in an Ipld ExecutionEvent.
+#[derive(Clone, Debug, PartialEq)]
+pub enum IpldOperation {
+    Get, // open
+    Put, // link
+}
+
 /// An "event" that happened during execution.
 ///
 /// This is marked as `non_exhaustive` so we can introduce additional event types later.
@@ -39,4 +47,9 @@ pub enum ExecutionEvent {
         state: ActorState,
     },
     Log(String),
+    Ipld {
+        op: IpldOperation,
+        cid: Cid,
+        size: usize,
+    },
 }

fvm/tests/default_kernel/ops.rs

@@ -7,6 +7,7 @@ mod ipld {
     use cid::Cid;
     use fvm::kernel::{IpldBlockOps, SupportedHashes};
     use fvm::machine::Machine;
+    use fvm::trace::IpldOperation;
     use fvm_ipld_blockstore::Blockstore;
     use fvm_ipld_encoding::{DAG_CBOR, IPLD_RAW};
     use multihash_codetable::MultihashDigest;
@@ -200,6 +201,22 @@ mod ipld {
             )
         }
 
+        assert!(call_manager
+            .ipld_traces
+            .iter()
+            .any(|(op, c, _)| *op == IpldOperation::Put && *c == cid));
+
+        let (call_manager1, _) = kern1.into_inner();
+
+        assert!(call_manager1
+            .ipld_traces
+            .iter()
+            .any(|(op, c, _)| *op == IpldOperation::Put && *c == cid)); // cid1==cid
+        assert!(call_manager1
+            .ipld_traces
+            .iter()
+            .any(|(op, c, _)| *op == IpldOperation::Put && *c == other_cid));
+
         Ok(())
     }
 

fvm/tests/dummy.rs

@@ -13,6 +13,7 @@ use fvm::gas::{Gas, GasCharge, GasTimer, GasTracker};
 use fvm::machine::limiter::MemoryLimiter;
 use fvm::machine::{Machine, MachineContext, Manifest, NetworkConfig};
 use fvm::state_tree::StateTree;
+use fvm::trace::IpldOperation;
 use fvm::{kernel, Kernel};
 use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore};
 use fvm_ipld_encoding::{CborStore, DAG_CBOR};
@@ -191,6 +192,7 @@ pub struct DummyCallManager {
     pub origin: ActorID,
     pub nonce: u64,
     pub test_data: Rc<RefCell<TestData>>,
+    pub ipld_traces: Vec<(IpldOperation, Cid, usize)>,
     limits: DummyLimiter,
 }
 
@@ -216,6 +218,7 @@ impl DummyCallManager {
                 test_data: rc,
                 limits: DummyLimiter::default(),
                 gas_premium: TokenAmount::zero(),
+                ipld_traces: vec![],
             },
             cell_ref,
         )
@@ -235,6 +238,7 @@ impl DummyCallManager {
                 test_data: rc,
                 limits: DummyLimiter::default(),
                 gas_premium: TokenAmount::zero(),
+                ipld_traces: vec![],
             },
             cell_ref,
         )
@@ -267,6 +271,7 @@ impl CallManager for DummyCallManager {
             nonce,
             test_data: rc,
             limits,
+            ipld_traces: vec![],
         }
     }
 
@@ -404,4 +409,8 @@ impl CallManager for DummyCallManager {
     fn log(&mut self, _msg: String) {
         todo!()
     }
+
+    fn trace_ipld(&mut self, op: IpldOperation, cid: Cid, size: usize) {
+        self.ipld_traces.push((op, cid, size));
+    }
 }