[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;
 
@@ -35,6 +36,10 @@ pub struct SozoArgs {
     #[arg(help = "Run without accessing the network.")]
     pub offline: bool,
 
+    #[arg(long)]
+    #[arg(help = "Output logs in JSON format.")]
+    pub json_log: bool,
+
     #[command(subcommand)]
     pub command: Commands,
 }
@@ -50,6 +55,24 @@ impl SozoArgs {
             Verbosity::Quiet
         }
     }
+
+    pub fn init_logging(&self) -> Result<(), Box<dyn std::error::Error>> {
+        const DEFAULT_LOG_FILTER: &str = "info,server=debug,\
+                                          blockifier=off,jsonrpsee_server=off,\
+                                          hyper=off,messaging=debug,node=error";
+
+        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> = if self.json_log {
+            Box::new(builder.json().finish())
+        } else {
+            Box::new(builder.finish())
+        };
+
+        Ok(tracing::subscriber::set_global_default(subscriber)?)
+    }
 }
 
 /// Profile specifier.
@@ -78,4 +101,4 @@ impl ProfileSpec {
             _ => Profile::default(),
         })
     }
-}
+}

bin/sozo/src/commands/account.rs

@@ -11,6 +11,9 @@ use super::options::fee::FeeOptions;
 use super::options::signer::SignerOptions;
 use super::options::starknet::StarknetOptions;
 use crate::utils;
+use tracing::trace;
+
+pub(crate) const LOG_TARGET: &str = "sozo::cli::commands::account";
 
 #[derive(Debug, Args)]
 pub struct AccountArgs {
@@ -83,11 +86,19 @@ pub enum AccountCommand {
 
 impl AccountArgs {
     pub fn run(self, config: &Config) -> Result<()> {
+        trace!(target: LOG_TARGET, 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 } => {
+                    trace!(
+                        target: LOG_TARGET,
+                        ?signer,
+                        force,
+                        ?file,
+                        "Executing New command"
+                    );
                     let signer: LocalWallet = signer.signer(env_metadata.as_ref(), false)?;
                     account::new(signer, force, file).await
                 }
@@ -101,8 +112,20 @@ impl AccountArgs {
                     file,
                     no_confirmation,
                 } => {
+                    trace!(
+                        target: LOG_TARGET,
+                        ?starknet,
+                        ?signer,
+                        ?fee,
+                        simulate,
+                        ?nonce,
+                        poll_interval,
+                        ?file,
+                        no_confirmation,
+                        "Executing Deploy command."
+                    );
                     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()?;
                     account::deploy(
                         provider,
@@ -117,10 +140,18 @@ impl AccountArgs {
                     .await
                 }
                 AccountCommand::Fetch { starknet, force, output, address } => {
+                    trace!(
+                        target: LOG_TARGET,
+                        ?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,13 +3,16 @@ use clap::{Args, Subcommand};
 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;
 use super::options::transaction::TransactionOptions;
 use super::options::world::WorldOptions;
 use crate::utils;
 
+pub(crate) const LOG_TARGET: &str = "sozo::cli::commands::auth";
+
 #[derive(Debug, Args)]
 pub struct AuthArgs {
     #[command(subcommand)]
@@ -56,7 +59,10 @@ pub enum AuthCommand {
 
 impl AuthArgs {
     pub fn run(self, config: &Config) -> Result<()> {
+        trace!(target: LOG_TARGET, command=?self.command, "Executing Auth command.", );
+
         let env_metadata = utils::load_metadata_from_config(config)?;
+        trace!(target: LOG_TARGET, metadata=?env_metadata, "Loaded environment.");
 
         match self.command {
             AuthCommand::Grant { kind, world, starknet, account, transaction } => config
@@ -102,14 +108,25 @@ pub async fn grant(
     kind: AuthKind,
     transaction: TransactionOptions,
 ) -> Result<()> {
+    trace!(target: LOG_TARGET, ?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!(
+                target: LOG_TARGET,
+                contracts=?models_contracts,
+                "Granting 'Writer' permissions."
+            );
             auth::grant_writer(&world, models_contracts, transaction.into()).await
         }
         AuthKind::Owner { owners_resources } => {
+            trace!(
+                target: LOG_TARGET,
+                resources=?owners_resources,
+                "Granting 'Owner' permissions."
+            );
             auth::grant_owner(&world, owners_resources, transaction.into()).await
         }
     }
@@ -123,13 +140,24 @@ pub async fn revoke(
     kind: AuthKind,
     transaction: TransactionOptions,
 ) -> Result<()> {
+    trace!(target: LOG_TARGET, ?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!(
+                target: LOG_TARGET,
+                contracts=?models_contracts,
+                "Revoking 'Writer' permissions."
+            );
             auth::revoke_writer(&world, models_contracts, transaction.into()).await
         }
         AuthKind::Owner { owners_resources } => {
+            trace!(
+                target: LOG_TARGET,
+                resources=?owners_resources,
+                "Revoking 'Owner' permissions."
+            );
             auth::revoke_owner(&world, owners_resources, transaction.into()).await
         }
     }
@@ -185,4 +213,4 @@ mod tests {
         let result = auth::ModelContract::from_str(input);
         assert!(result.is_err());
     }
-}
+}

bin/sozo/src/commands/build.rs

@@ -7,6 +7,9 @@ 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;
+
+pub(crate) const LOG_TARGET: &str = "sozo::cli::commands::build";
 
 #[derive(Debug, Args)]
 pub struct BuildArgs {
@@ -36,6 +39,7 @@ impl BuildArgs {
             config,
             CompileOpts { include_targets: vec![], exclude_targets: vec![TargetKind::TEST] },
         )?;
+        trace!(target: LOG_TARGET, ?compile_info, "Compiled workspace.");
 
         let mut builtin_plugins = vec![];
         if self.typescript {
@@ -54,6 +58,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!(target: LOG_TARGET, ?contracts_statistics, ?target_dir, "Fetched contract statistics for target directory.");
+
             let table = create_stats_table(contracts_statistics);
             table.printstd()
         }
@@ -69,11 +75,13 @@ impl BuildArgs {
             plugins: vec![],
             builtin_plugins,
         };
+        trace!(target: LOG_TARGET, pluginManager=?bindgen, "Generating bindings.");
 
         tokio::runtime::Runtime::new()
             .unwrap()
             .block_on(bindgen.generate())
             .expect("Error generating bindings");
+        trace!(target: LOG_TARGET, "Completed generating bindings.");
 
         Ok(())
     }
@@ -89,20 +97,28 @@ fn create_stats_table(contracts_statistics: Vec<ContractStatistics>) -> Table {
         Cell::new_align("Bytecode size (felts)", format::Alignment::CENTER),
         Cell::new_align("Class size (bytes)", format::Alignment::CENTER),
     ]));
+    trace!(target: LOG_TARGET, "Creating table for contract statistics.");
 
     for contract_stats in contracts_statistics {
         // Add table rows
         let contract_name = contract_stats.contract_name;
         let number_felts = contract_stats.number_felts;
         let file_size = contract_stats.file_size;
-
+        trace!(
+            target: LOG_TARGET,
+            contract_name,
+            number_felts,
+            file_size,
+            "Adding row to table."
+        );
         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),
             Cell::new_align(format!("{}", file_size).as_str(), format::Alignment::RIGHT),
         ]));
     }
 
+    trace!(target: LOG_TARGET, "Completed creating stats table.");
     table
 }
 
@@ -180,4 +196,4 @@ mod tests {
         // Assert
         assert_eq!(table, expected_table, "Tables mismatch")
     }
-}
+}

bin/sozo/src/commands/call.rs

@@ -6,6 +6,9 @@ use starknet::core::types::FieldElement;
 use super::options::starknet::StarknetOptions;
 use super::options::world::WorldOptions;
 use crate::utils;
+use tracing::trace;
+
+pub(crate) const LOG_TARGET: &str = "sozo::cli::commands::call";
 
 #[derive(Debug, Args)]
 #[command(about = "Call a system with the given calldata.")]
@@ -35,9 +38,12 @@ pub struct CallArgs {
 
 impl CallArgs {
     pub fn run(self, config: &Config) -> Result<()> {
-        let env_metadata = utils::load_metadata_from_config(config)?;
+        trace!(target: LOG_TARGET, contract=?self.contract, entrypoint=self.entrypoint, calldata=?self.calldata, block_id=self.block_id);
 
+        let env_metadata = utils::load_metadata_from_config(config)?;
+        trace!(target: LOG_TARGET, ?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
@@ -53,4 +59,4 @@ impl CallArgs {
             .await
         })
     }
-}
+}

bin/sozo/src/commands/clean.rs

@@ -5,6 +5,9 @@ use camino::Utf8PathBuf;
 use clap::Args;
 use dojo_lang::compiler::{ABIS_DIR, BASE_DIR, MANIFESTS_DIR};
 use scarb::core::Config;
+use tracing::trace;
+
+pub(crate) const LOG_TARGET: &str = "sozo::cli::commands::clean";
 
 #[derive(Debug, Args)]
 pub struct CleanArgs {
@@ -21,11 +24,15 @@ impl CleanArgs {
     ///
     /// * `profile_dir` - The directory where the profile files are located.
     pub fn clean_manifests(&self, profile_dir: &Utf8PathBuf) -> Result<()> {
+        trace!(target: LOG_TARGET, ?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!(target: LOG_TARGET, directory=?d, "Removing directory.");
                 fs::remove_dir_all(d)?;
+            } else {
+                trace!(target: LOG_TARGET, directory=?d, "Directory does not exist.");
             }
         }
 
@@ -34,6 +41,7 @@ impl CleanArgs {
 
     pub fn run(self, config: &Config) -> Result<()> {
         let ws = scarb::ops::read_workspace(config.manifest_path(), config)?;
+        trace!(target: LOG_TARGET, ws=?ws, "Workspace read successfully.");
 
         let profile_name =
             ws.current_profile().expect("Scarb profile is expected at this point.").to_string();
@@ -45,11 +53,15 @@ 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!(target: LOG_TARGET, "Cleaning Scarb artifacts and build manifests.");
         scarb::ops::clean(config)?;
         self.clean_manifests(&profile_dir)?;
 
         if self.all && profile_dir.exists() {
+            trace!(target: LOG_TARGET, ?profile_dir, "Removing entire profile directory.");
             fs::remove_dir_all(profile_dir)?;
+        } else {
+            trace!(target: LOG_TARGET, ?profile_dir, "Profile directory does not exist.");
         }
 
         Ok(())
@@ -131,4 +143,4 @@ mod tests {
         assert!(!manifest_toml.exists(), "Expected 'manifest.toml' to not exist");
         assert!(!manifest_json.exists(), "Expected 'manifest.json' to not exist");
     }
-}
+}