chore: clean logs (#2561)

Author: tamirhemo

crates/core/executor/src/minimal/arch/x86_64/mod.rs

@@ -38,7 +38,7 @@ impl MinimalExecutor {
     }
 
     /// Transpile the program, saving the JIT function.
-    #[tracing::instrument(name = "MinimalExecutor::transpile", skip(program))]
+    #[tracing::instrument(name = "MinimalExecutor::transpile", level = "debug", skip(program))]
     fn transpile(program: &Program, is_debug: bool, max_trace_size: Option<u64>) -> JitFunction {
         let trace_buf_size = max_trace_size.unwrap_or(0);
 

crates/core/executor/src/splicing.rs

@@ -165,7 +165,6 @@ impl SplicingVM<'_> {
 
 impl<'a> SplicingVM<'a> {
     /// Create a new full-tracing VM from a minimal trace.
-    #[tracing::instrument(name = "SplicingVM::new", skip_all)]
     pub fn new<T: MinimalTrace>(
         trace: &'a T,
         program: Arc<Program>,

crates/hypercube/src/logup_gkr/prover.rs

@@ -133,7 +133,7 @@ impl<GC: IopCtx, SC: ShardContext<GC>> GkrProverImpl<GC, SC> {
 
         // Run the GKR circuit and get the output.
         let (output, circuit) = {
-            let _span = tracing::info_span!("generate GKR circuit").entered();
+            let _span = tracing::debug_span!("generate GKR circuit").entered();
             self.trace_generator.generate_gkr_circuit(
                 chips,
                 preprocessed_traces.clone(),
@@ -166,7 +166,7 @@ impl<GC: IopCtx, SC: ShardContext<GC>> GkrProverImpl<GC, SC> {
         let first_denominator_eval = denominator.eval_at_eq(&first_point_eq).to_host().unwrap()[0];
 
         let (eval_point, round_proofs) = {
-            let _span = tracing::info_span!("prove GKR circuit").entered();
+            let _span = tracing::debug_span!("prove GKR circuit").entered();
             self.prove_gkr_circuit(
                 first_numerator_eval,
                 first_denominator_eval,

crates/prover/src/worker/client/local.rs

@@ -99,7 +99,7 @@ impl Clone for LocalWorkerClient {
 
 impl WorkerClient for LocalWorkerClient {
     async fn submit_task(&self, kind: TaskType, task: RawTaskRequest) -> anyhow::Result<TaskId> {
-        tracing::info!("submitting task of kind {kind:?}");
+        tracing::debug!("submitting task of kind {kind:?}");
         let task_id = LocalWorkerClientInner::create_id();
         // Add the task to the proof index.
         self.inner

crates/prover/src/worker/controller/core.rs

@@ -161,7 +161,7 @@ where
         // Create a channel to send the splicing handles to be awaited and their task_ids being
         // sent after being submitted to the splicing pipeline.
         let (splicing_submit_tx, mut splicing_submit_rx) = mpsc::unbounded_channel();
-        let span = tracing::info_span!("minimal executor");
+        let span = tracing::debug_span!("minimal executor");
 
         // Making the minimal executor blocks the rest of execution anyway, so we initialize it before spawning the rest of the tokio tasks.
         let mut minimal_executor = if let Some(cache) = &self.minimal_executor_cache {
@@ -197,7 +197,7 @@ where
                 memory_tx
                     .send(unsafe_memory)
                     .map_err(|_| anyhow::anyhow!("failed to send unsafe memory"))?;
-                tracing::info!("Starting minimal executor");
+                tracing::debug!("Starting minimal executor");
                 let now = std::time::Instant::now();
                 let mut chunk_count = 0;
                 while let Some(chunk) = minimal_executor.execute_chunk() {
@@ -251,8 +251,8 @@ where
                     chunk_count += 1;
                 }
                 let elapsed = now.elapsed().as_secs_f64();
-                tracing::info!(
-                    "Minimal Executor finished. elapsed: {}s, mhz: {}",
+                tracing::debug!(
+                    "minimal Executor finished. elapsed: {}s, mhz: {}",
                     elapsed,
                     minimal_executor.global_clk() as f64 / (elapsed * 1e6)
                 );

crates/prover/src/worker/controller/splicing.rs

@@ -138,7 +138,7 @@ where
                     Ok(())
                 }
             }
-            .instrument(tracing::info_span!("get splices to serialize")),
+            .instrument(tracing::debug_span!("get splices to serialize")),
         );
 
         // This task waits for prove shard tasks to be sent.
@@ -162,7 +162,7 @@ where
                     Ok::<_, ExecutionError>(())
                 }
             }
-            .instrument(tracing::info_span!("spawn prove shard tasks")),
+            .instrument(tracing::debug_span!("spawn prove shard tasks")),
         );
 
         let common_prover_input = self
@@ -174,7 +174,7 @@ where
             })?;
 
         // Spawn the task that splices the trace.
-        let span = tracing::info_span!("splicing trace chunk");
+        let span = tracing::debug_span!("splicing trace chunk");
         join_set.spawn_blocking(
             move || {
             let _guard = span.enter();

crates/prover/src/worker/node/full/mod.rs

@@ -164,6 +164,7 @@ impl SP1LocalNode {
         Ok(output)
     }
 
+    #[instrument(name = "prove", skip_all, fields(mode = ?mode))]
     pub async fn prove_with_mode(
         &self,
         elf: &[u8],

crates/prover/src/worker/prover/core.rs

@@ -265,7 +265,7 @@ where
                             );
                             // Here, we reserve 1/8 of the shard size for common events. In other words,
                             // we assume that no event will take up more than 1/8 of the shard's events.
-                            let record = tracing::info_span!("allocating record").in_scope(|| {
+                            let record = tracing::debug_span!("allocating record").in_scope(|| {
                                 ExecutionRecord::new_preallocated(
                                     program.clone(),
                                     common_input.nonce,
@@ -458,7 +458,7 @@ where
         });
 
         // Generate dependencies on the main record.
-        let span = tracing::info_span!("generate dependencies");
+        let span = tracing::debug_span!("generate dependencies");
         let machine_clone = self.machine().clone();
         let record = tokio::task::spawn_blocking(move || {
             let _guard = span.enter();
@@ -470,7 +470,7 @@ where
         .map_err(|e| TaskError::Fatal(e.into()))?;
 
         // If this is not a Core proof request, spawn a task to get the recursion program.
-        let span = tracing::info_span!("get recursion program");
+        let span = tracing::debug_span!("get recursion program");
         let recursion_program_handle = if common_input.mode != ProofMode::Core {
             let handle = tokio::task::spawn_blocking({
                 let normalize_program_compiler = self.normalize_program_compiler.clone();
@@ -634,11 +634,11 @@ impl<A: ArtifactClient, C: SP1ProverComponents>
 
         let permits = self.permits.clone();
         let (_pk, vk) = self.core_prover.setup(program, permits).await;
-        tracing::info!("Setup completed for task {}", id);
+        tracing::debug!("setup completed for task {}", id);
 
         // Upload the vk
         self.artifact_client.upload(&output, vk).await.expect("failed to upload vk");
-        tracing::info!("Upload completed for artifact {}", output.to_id());
+        tracing::debug!("upload completed for artifact {}", output.to_id());
 
         // TODO: Add the busy time here.
         Ok((id, TaskMetadata::default()))

crates/prover/src/worker/prover/execute.rs

@@ -228,7 +228,7 @@ pub async fn execute_with_options(
                 .map_err(|e| anyhow::anyhow!("Gas engine submission failed: {}", e))?;
             handle_sender.send(handle)?;
         }
-        tracing::debug!("Minimal executor finished in {} cycles", minimal_executor.global_clk());
+        tracing::debug!("minimal executor finished in {} cycles", minimal_executor.global_clk());
 
         // Extract cycle tracker data before consuming the executor
         #[cfg(feature = "profiling")]

crates/sdk/src/blocking/cpu/mod.rs

@@ -80,6 +80,7 @@ impl CpuProver {
     /// Creates a new [`CpuProver`] with optional custom [`SP1CoreOpts`].
     #[must_use]
     pub fn new_with_opts(core_opts: Option<sp1_core_executor::SP1CoreOpts>) -> Self {
+        tracing::info!("initializing cpu prover");
         let worker_builder = cpu_worker_builder().with_core_opts(core_opts.unwrap_or_default());
         let prover = Arc::new(
             crate::blocking::block_on(