feat(statedb/export): add time metrics to export process

crates/rooch/src/commands/statedb/commands/export.rs

@@ -4,6 +4,7 @@
 use std::fmt::Display;
 use std::path::PathBuf;
 use std::str::FromStr;
+use std::time::Instant;
 
 use anyhow::Result;
 use clap::Parser;
@@ -305,6 +306,7 @@ impl ExportCommand {
 
         Self::internal_export_indexer(moveos_store, root_state_root, writer, object_ids)?;
         writer.flush()?;
+
         Ok(())
     }
 
@@ -346,6 +348,8 @@ impl ExportCommand {
         object_name: Option<String>, // human-readable object name for debug
         writer: &mut Writer<W>,
     ) -> Result<()> {
+        let start_time = Instant::now();
+
         let starting_key = None;
         let mut count: u64 = 0;
 
@@ -356,24 +360,27 @@ impl ExportCommand {
             .get_state_store()
             .iter(obj_state_root, starting_key)?;
 
+        let mut loop_time = Instant::now();
         for item in iter {
             let (k, v) = item?;
             writer.write_record([k.to_string().as_str(), v.to_string().as_str()])?;
             count += 1;
             if count % 1_000_000 == 0 {
                 println!(
-                    "exporting top_level_fields of object_id: {:?}({}), exported count: {}",
-                    object_id, object_name, count
-                )
+                    "exporting top_level_fields of object_id: {:?}({}), exported count: {}. cost: {:?}",
+                    object_id, object_name, count, loop_time.elapsed()
+                );
+                loop_time = Instant::now();
             }
         }
 
         println!(
-            "Done. export_top_level_fields of object_id: {:?}({}), state_root: {:?}, exported count: {}",
+            "Done. export_top_level_fields of object_id: {:?}({}), state_root: {:?}, exported count: {}. cost: {:?}",
             object_id,
             object_name,
             obj_state_root,
-            count
+            count,
+            start_time.elapsed()
         );
         Ok(())
     }

crates/rooch/src/commands/statedb/commands/genesis.rs

@@ -123,7 +123,6 @@ impl GenesisCommand {
         let apply_inscription_updates_thread = thread::spawn(move || {
             apply_inscription_updates(ord_rx, moveos_store_clone, startup_update_set_clone);
         });
-
         // import utxo
         let utxo_input_path = Arc::new(self.utxo_source.clone());
         let utxo_input_path_clone1 = Arc::clone(&utxo_input_path);

crates/rooch/src/commands/statedb/commands/mod.rs

@@ -8,8 +8,10 @@ use std::path::PathBuf;
 use std::str::FromStr;
 use std::time::Instant;
 
+use anyhow::Result;
 use bitcoin::hashes::Hash;
 use bitcoin::OutPoint;
+use csv::Writer;
 use xorf::{BinaryFuse8, Filter};
 use xxhash_rust::xxh3::xxh3_64;
 
@@ -20,6 +22,7 @@ use moveos_types::move_std::option::MoveOption;
 use moveos_types::move_std::string::MoveString;
 use moveos_types::moveos_std::object::{ObjectID, ObjectMeta};
 use moveos_types::moveos_std::simple_multimap::{Element, SimpleMultiMap};
+use moveos_types::state::{FieldKey, ObjectState};
 use rooch_common::fs::file_cache::FileCacheManager;
 use rooch_config::RoochOpt;
 use rooch_db::RoochDB;
@@ -387,6 +390,39 @@ where
     None
 }
 
+#[allow(dead_code)]
+struct ExportWriter {
+    writer: Option<Writer<File>>,
+}
+
+#[allow(dead_code)]
+impl ExportWriter {
+    fn new(output: Option<PathBuf>) -> Self {
+        let writer = match output {
+            Some(output) => {
+                let file_name = output.display().to_string();
+                let mut writer_builder = csv::WriterBuilder::new();
+                let writer_builder = writer_builder
+                    .delimiter(b',')
+                    .double_quote(false)
+                    .buffer_capacity(1 << 23);
+                let writer = writer_builder.from_path(file_name).unwrap();
+                Some(writer)
+            }
+            None => None,
+        };
+        ExportWriter { writer }
+    }
+    fn write(&mut self, k: &FieldKey, v: &ObjectState) -> anyhow::Result<()> {
+        if let Some(writer) = &mut self.writer {
+            writer.write_record([k.to_string().as_str(), v.to_string().as_str()])?;
+            Ok(())
+        } else {
+            Ok(())
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::HashSet;