[sozo] add trace logs

bin/sozo/Cargo.toml

@@ -48,6 +48,7 @@ thiserror.workspace = true
 tokio.workspace = true
 tracing-log = "0.1.3"
 tracing.workspace = true
+tracing-subscriber.workspace = true
 url.workspace = true
 katana-rpc-api.workspace = true
 

bin/sozo/src/args.rs

@@ -6,7 +6,8 @@ use scarb_ui::Verbosity;
 use smol_str::SmolStr;
 use tracing::level_filters::LevelFilter;
 use tracing_log::AsTrace;
-
+use tracing::Subscriber;
+use tracing_subscriber::{fmt, EnvFilter};
 use crate::commands::Commands;
 use crate::utils::generate_version;
 
@@ -50,6 +51,18 @@ impl SozoArgs {
             Verbosity::Quiet
         }
     }
+
+    pub fn init_logging(&self) -> Result<(), Box<dyn std::error::Error>> {
+        const DEFAULT_LOG_FILTER: &str = "info,hyper=off,scarb=off";
+
+        let builder = fmt::Subscriber::builder().with_env_filter(
+            EnvFilter::try_from_default_env().or(EnvFilter::try_new(DEFAULT_LOG_FILTER))?,
+        );
+
+        let subscriber: Box<dyn Subscriber + Send + Sync> = Box::new(builder.finish());
+
+        Ok(tracing::subscriber::set_global_default(subscriber)?)
+    }
 }
 
 /// Profile specifier.

bin/sozo/src/commands/account.rs

@@ -11,6 +11,7 @@
 use super::options::signer::SignerOptions;
 use super::options::starknet::StarknetOptions;
 use crate::utils;
+use tracing::trace;
 
 #[derive(Debug, Args)]
 pub struct AccountArgs {
@@ -83,12 +84,20 @@
 
 impl AccountArgs {
     pub fn run(self, config: &Config) -> Result<()> {
+        trace!(command=?self.command, "Executing command.");
         let env_metadata = utils::load_metadata_from_config(config)?;
 
         config.tokio_handle().block_on(async {
             match self.command {
                 AccountCommand::New { signer, force, file } => {
+
                     let signer: LocalWallet = signer.signer(env_metadata.as_ref(), false)?;
+                    trace!(  
+                        ?signer,
+                        force,
+                        ?file,
+                        "Executing New command."
+                    );
                     account::new(signer, force, file).await
                 }
                 AccountCommand::Deploy {
@@ -101,9 +110,21 @@
                     file,
                     no_confirmation,
                 } => {
+
                     let provider = starknet.provider(env_metadata.as_ref())?;
-                    let signer = signer.signer(env_metadata.as_ref(), false)?;
+                    let signer: LocalWallet = signer.signer(env_metadata.as_ref(), false)?;
                     let fee_setting = fee.into_setting()?;
+                    trace!(
+                        ?starknet,
+                        ?signer,
+                        ?fee_setting,
+                        simulate,
+                        ?nonce,
+                        poll_interval,
+                        ?file,
+                        no_confirmation,
+                        "Executing Deploy command."
+                    );
                     account::deploy(
                         provider,
                         signer,
@@ -117,6 +138,13 @@
                     .await
                 }
                 AccountCommand::Fetch { starknet, force, output, address } => {
+                    trace!(
+                        ?starknet,
+                        force,
+                        ?output,
+                        ?address,
+                        "Executing Fetch command."
+                    );
                     let provider = starknet.provider(env_metadata.as_ref())?;
                     account::fetch(provider, force, output, address).await
                 }

bin/sozo/src/commands/auth.rs

@@ -3,6 +3,7 @@
 use dojo_world::metadata::Environment;
 use scarb::core::Config;
 use sozo_ops::auth;
+use tracing::trace;
 
 use super::options::account::AccountOptions;
 use super::options::starknet::StarknetOptions;
@@ -56,7 +57,10 @@
 
 impl AuthArgs {
     pub fn run(self, config: &Config) -> Result<()> {
+        trace!(command=?self.command, "Executing Auth command.", );
+
         let env_metadata = utils::load_metadata_from_config(config)?;
+        trace!(metadata=?env_metadata, "Loaded environment.");
 
         match self.command {
             AuthCommand::Grant { kind, world, starknet, account, transaction } => config
@@ -102,14 +106,23 @@
     kind: AuthKind,
     transaction: TransactionOptions,
 ) -> Result<()> {
+    trace!(?kind, ?world, ?starknet, ?account, ?transaction, "Executing Grant command.");
     let world =
         utils::world_from_env_metadata(world, account, starknet, &env_metadata).await.unwrap();
 
     match kind {
         AuthKind::Writer { models_contracts } => {
+            trace!(
+                contracts=?models_contracts,
+                "Granting Writer permissions."
+            );
             auth::grant_writer(&world, models_contracts, transaction.into()).await
         }
         AuthKind::Owner { owners_resources } => {
+            trace!(
+                resources=?owners_resources,
+                "Granting Owner permissions."
+            );
             auth::grant_owner(&world, owners_resources, transaction.into()).await
         }
     }
@@ -123,13 +136,22 @@
     kind: AuthKind,
     transaction: TransactionOptions,
 ) -> Result<()> {
+    trace!(?kind, ?world, ?starknet, ?account, ?transaction, "Executing Revoke command.");
     let world =
         utils::world_from_env_metadata(world, account, starknet, &env_metadata).await.unwrap();
     match kind {
         AuthKind::Writer { models_contracts } => {
+            trace!(
+                contracts=?models_contracts,
+                "Revoking Writer permissions."
+            );
             auth::revoke_writer(&world, models_contracts, transaction.into()).await
         }
         AuthKind::Owner { owners_resources } => {
+            trace!(
+                resources=?owners_resources,
+                "Revoking Owner permissions."
+            );
             auth::revoke_owner(&world, owners_resources, transaction.into()).await
         }
     }

bin/sozo/src/commands/build.rs

@@ -7,6 +7,7 @@ use prettytable::{format, Cell, Row, Table};
 use scarb::core::{Config, TargetKind};
 use scarb::ops::CompileOpts;
 use sozo_ops::statistics::{get_contract_statistics_for_dir, ContractStatistics};
+use tracing::trace;
 
 #[derive(Debug, Args)]
 pub struct BuildArgs {
@@ -36,6 +37,7 @@ impl BuildArgs {
             config,
             CompileOpts { include_targets: vec![], exclude_targets: vec![TargetKind::TEST] },
         )?;
+        trace!(?compile_info, "Compiled workspace.");
 
         let mut builtin_plugins = vec![];
         if self.typescript {
@@ -54,6 +56,8 @@ impl BuildArgs {
             let target_dir = &compile_info.target_dir;
             let contracts_statistics = get_contract_statistics_for_dir(target_dir)
                 .context("Error getting contracts stats")?;
+            trace!(?contracts_statistics, ?target_dir, "Fetched contract statistics for target directory.");
+
             let table = create_stats_table(contracts_statistics);
             table.printstd()
         }
@@ -69,6 +73,7 @@ impl BuildArgs {
             plugins: vec![],
             builtin_plugins,
         };
+        trace!(pluginManager=?bindgen, "Generating bindings.");
 
         tokio::runtime::Runtime::new()
             .unwrap()
@@ -95,7 +100,6 @@ fn create_stats_table(contracts_statistics: Vec<ContractStatistics>) -> Table {
         let contract_name = contract_stats.contract_name;
         let number_felts = contract_stats.number_felts;
         let file_size = contract_stats.file_size;
-
         table.add_row(Row::new(vec![
             Cell::new_align(&contract_name, format::Alignment::LEFT),
             Cell::new_align(format!("{}", number_felts).as_str(), format::Alignment::RIGHT),

bin/sozo/src/commands/call.rs

@@ -6,6 +6,7 @@
 use super::options::starknet::StarknetOptions;
 use super::options::world::WorldOptions;
 use crate::utils;
+use tracing::trace;
 
 #[derive(Debug, Args)]
 #[command(about = "Call a system with the given calldata.")]
@@ -35,9 +36,12 @@
 
 impl CallArgs {
     pub fn run(self, config: &Config) -> Result<()> {
-        let env_metadata = utils::load_metadata_from_config(config)?;
+        trace!(contract=?self.contract, entrypoint=self.entrypoint, calldata=?self.calldata, block_id=self.block_id, "Executing Call command.");
 
+        let env_metadata = utils::load_metadata_from_config(config)?;
+        trace!(?env_metadata, "Fetched environment metadata.");
         config.tokio_handle().block_on(async {
+
             let world_reader =
                 utils::world_reader_from_env_metadata(self.world, self.starknet, &env_metadata)
                     .await

bin/sozo/src/commands/clean.rs

@@ -5,6 +5,7 @@ use camino::Utf8PathBuf;
 use clap::Args;
 use dojo_lang::compiler::{ABIS_DIR, BASE_DIR, MANIFESTS_DIR};
 use scarb::core::Config;
+use tracing::trace;
 
 #[derive(Debug, Args)]
 pub struct CleanArgs {
@@ -21,10 +22,12 @@ impl CleanArgs {
     ///
     /// * `profile_dir` - The directory where the profile files are located.
     pub fn clean_manifests(&self, profile_dir: &Utf8PathBuf) -> Result<()> {
+        trace!(?profile_dir, "Cleaning manifests.");
         let dirs = vec![profile_dir.join(BASE_DIR), profile_dir.join(ABIS_DIR).join(BASE_DIR)];
 
         for d in dirs {
             if d.exists() {
+                trace!(directory=?d, "Removing directory.");
                 fs::remove_dir_all(d)?;
             }
         }
@@ -34,6 +37,7 @@ impl CleanArgs {
 
     pub fn run(self, config: &Config) -> Result<()> {
         let ws = scarb::ops::read_workspace(config.manifest_path(), config)?;
+        trace!(ws=?ws, "Workspace read successfully.");
 
         let profile_name =
             ws.current_profile().expect("Scarb profile is expected at this point.").to_string();
@@ -45,10 +49,12 @@ impl CleanArgs {
         let profile_dir = manifest_dir.join(MANIFESTS_DIR).join(profile_name);
 
         // By default, this command cleans the build manifests and scarb artifacts.
+        trace!("Cleaning Scarb artifacts and build manifests.");
         scarb::ops::clean(config)?;
         self.clean_manifests(&profile_dir)?;
 
         if self.all && profile_dir.exists() {
+            trace!(?profile_dir, "Removing entire profile directory.");
             fs::remove_dir_all(profile_dir)?;
         }