fix(logging): Change near_vm log level to debug (near#9431)

https://near.zulipchat.com/#narrow/stream/297873-pagoda.2Fnode/topic/release.201.2E36/near/384954807
nikurt · Aug 24, 2023 · 9a26688 · 9a26688
1 parent 6de62c8
commit 9a26688
Show file tree

Hide file tree

Showing 11 changed files with 42 additions and 40 deletions.
diff --git a/runtime/near-vm/compiler-singlepass/src/codegen_x64.rs b/runtime/near-vm/compiler-singlepass/src/codegen_x64.rs
@@ -1695,7 +1695,7 @@ impl<'a> FuncGen<'a> {
         });
     }
 
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub(crate) fn new(
         assembler: &'a mut Assembler,
         module: &'a ModuleInfo,
@@ -1802,7 +1802,7 @@ impl<'a> FuncGen<'a> {
         None
     }
 
-    #[tracing::instrument(target = "near_vm", skip(self))]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip(self))]
     pub(crate) fn feed_operator(&mut self, op: Operator) -> Result<(), CodegenError> {
         assert!(self.fp_stack.len() <= self.value_stack.len());
 
@@ -7663,7 +7663,7 @@ impl<'a> FuncGen<'a> {
         Ok(())
     }
 
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub(crate) fn finalize(mut self, data: &FunctionBodyData) -> CompiledFunction {
         debug_assert!(
             self.gas_iter.next().is_none(),
@@ -7776,7 +7776,7 @@ fn sort_call_movs(movs: &mut [(Location, GPR)]) {
 }
 
 // Standard entry trampoline.
-#[tracing::instrument(target = "near_vm")]
+#[tracing::instrument(target = "near_vm", level = "trace")]
 pub(crate) fn gen_std_trampoline(
     sig: &FunctionType,
     calling_convention: CallingConvention,
@@ -7869,7 +7869,7 @@ pub(crate) fn gen_std_trampoline(
 }
 
 /// Generates dynamic import function call trampoline for a function type.
-#[tracing::instrument(target = "near_vm", skip(vmoffsets))]
+#[tracing::instrument(target = "near_vm", level = "trace", skip(vmoffsets))]
 pub(crate) fn gen_std_dynamic_import_trampoline(
     vmoffsets: &VMOffsets,
     sig: &FunctionType,
@@ -7987,7 +7987,7 @@ pub(crate) fn gen_std_dynamic_import_trampoline(
 }
 
 // Singlepass calls import functions through a trampoline.
-#[tracing::instrument(target = "near_vm", skip(vmoffsets))]
+#[tracing::instrument(target = "near_vm", level = "trace", skip(vmoffsets))]
 pub(crate) fn gen_import_call_trampoline(
     vmoffsets: &VMOffsets,
     index: FunctionIndex,

diff --git a/runtime/near-vm/compiler-singlepass/src/compiler.rs b/runtime/near-vm/compiler-singlepass/src/compiler.rs
@@ -41,7 +41,7 @@ impl SinglepassCompiler {
 impl Compiler for SinglepassCompiler {
     /// Compile the module using Singlepass, producing a compilation result with
     /// associated relocations.
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "info", skip_all)]
     fn compile_module(
         &self,
         target: &Target,
@@ -87,7 +87,7 @@ impl Compiler for SinglepassCompiler {
         };
         let import_idxs = 0..module.import_counts.functions as usize;
         let import_trampolines: PrimaryMap<SectionIndex, _> =
-            tracing::info_span!(target: "near_vm", "import_trampolines", n_imports = import_idxs.len()).in_scope(
+            tracing::debug_span!(target: "near_vm", "import_trampolines", n_imports = import_idxs.len()).in_scope(
                 || {
                     import_idxs
                         .into_par_iter()
@@ -111,7 +111,7 @@ impl Compiler for SinglepassCompiler {
             .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
             .into_par_iter()
             .map_init(make_assembler, |assembler, (i, input)| {
-                tracing::info_span!(target: "near_vm", "function", i = i.index()).in_scope(|| {
+                tracing::debug_span!(target: "near_vm", "function", i = i.index()).in_scope(|| {
                     let reader =
                         near_vm_compiler::FunctionReader::new(input.module_offset, input.data);
                     let stack_init_gas_cost = tunables
@@ -155,7 +155,7 @@ impl Compiler for SinglepassCompiler {
                         reader.get_operators_reader()?.into_iter_with_offsets();
                     while generator.has_control_frames() {
                         let (op, pos) =
-                            tracing::info_span!(target: "near_vm", "parsing-next-operator")
+                            tracing::debug_span!(target: "near_vm", "parsing-next-operator")
                                 .in_scope(|| operator_reader.next().unwrap())?;
                         generator.set_srcloc(pos as u32);
                         generator.feed_operator(op).map_err(to_compile_error)?;
@@ -169,7 +169,7 @@ impl Compiler for SinglepassCompiler {
             .collect::<PrimaryMap<LocalFunctionIndex, CompiledFunction>>();
 
         let function_call_trampolines =
-            tracing::info_span!(target: "near_vm", "function_call_trampolines").in_scope(|| {
+            tracing::debug_span!(target: "near_vm", "function_call_trampolines").in_scope(|| {
                 module
                     .signatures
                     .values()
@@ -184,23 +184,25 @@ impl Compiler for SinglepassCompiler {
             });
 
         let dynamic_function_trampolines =
-            tracing::info_span!(target: "near_vm", "dynamic_function_trampolines").in_scope(|| {
-                module
-                    .imported_function_types()
-                    .collect::<Vec<_>>()
-                    .into_par_iter()
-                    .map_init(make_assembler, |assembler, func_type| {
-                        gen_std_dynamic_import_trampoline(
-                            &vmoffsets,
-                            &func_type,
-                            calling_convention,
-                            assembler,
-                        )
-                    })
-                    .collect::<Vec<_>>()
-                    .into_iter()
-                    .collect::<PrimaryMap<FunctionIndex, FunctionBody>>()
-            });
+            tracing::debug_span!(target: "near_vm", "dynamic_function_trampolines").in_scope(
+                || {
+                    module
+                        .imported_function_types()
+                        .collect::<Vec<_>>()
+                        .into_par_iter()
+                        .map_init(make_assembler, |assembler, func_type| {
+                            gen_std_dynamic_import_trampoline(
+                                &vmoffsets,
+                                &func_type,
+                                calling_convention,
+                                assembler,
+                            )
+                        })
+                        .collect::<Vec<_>>()
+                        .into_iter()
+                        .collect::<PrimaryMap<FunctionIndex, FunctionBody>>()
+                },
+            );
 
         Ok(Compilation {
             functions,

diff --git a/runtime/near-vm/compiler/src/translator/environ.rs b/runtime/near-vm/compiler/src/translator/environ.rs
@@ -59,7 +59,7 @@ impl<'data> ModuleEnvironment<'data> {
 
     /// Translate a wasm module using this environment. This consumes the
     /// `ModuleEnvironment` and produces a `ModuleInfoTranslation`.
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub fn translate(mut self, data: &'data [u8]) -> WasmResult<ModuleEnvironment<'data>> {
         assert!(self.module_translation_state.is_none());
         let module_translation_state = translate_module(data, &mut self)?;

diff --git a/runtime/near-vm/compiler/src/translator/module.rs b/runtime/near-vm/compiler/src/translator/module.rs
@@ -15,7 +15,7 @@ use wasmparser::{NameSectionReader, Parser, Payload};
 
 /// Translate a sequence of bytes forming a valid Wasm binary into a
 /// parsed ModuleInfo `ModuleTranslationState`.
-#[tracing::instrument(target = "near_vm", skip_all)]
+#[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
 pub fn translate_module<'data>(
     data: &'data [u8],
     environ: &mut ModuleEnvironment<'data>,

diff --git a/runtime/near-vm/compiler/src/translator/state.rs b/runtime/near-vm/compiler/src/translator/state.rs
@@ -35,7 +35,7 @@ impl ModuleTranslationState {
     }
 
     /// Build map of imported functions names for intrinsification.
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub fn build_import_map(&mut self, module: &ModuleInfo) {
         for key in module.imports.keys() {
             let value = &module.imports[key];

diff --git a/runtime/near-vm/engine/src/universal/engine.rs b/runtime/near-vm/engine/src/universal/engine.rs
@@ -91,7 +91,7 @@ impl UniversalEngine {
     }
 
     /// Compile a WebAssembly binary
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub fn compile_universal(
         &self,
         binary: &[u8],
@@ -181,7 +181,7 @@ impl UniversalEngine {
     }
 
     /// Load a [`UniversalExecutable`](crate::UniversalExecutable) with this engine.
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub fn load_universal_executable(
         &self,
         executable: &UniversalExecutable,
@@ -470,7 +470,7 @@ impl UniversalEngine {
     }
 
     /// Validates a WebAssembly module
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub fn validate(&self, binary: &[u8]) -> Result<(), CompileError> {
         self.inner().validate(binary)
     }

diff --git a/runtime/near-vm/engine/src/universal/link.rs b/runtime/near-vm/engine/src/universal/link.rs
@@ -165,7 +165,7 @@ fn apply_relocation(
 
 /// Links a module, patching the allocated functions with the
 /// required relocations and jump tables.
-#[tracing::instrument(target = "near_vm", skip_all)]
+#[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
 pub fn link_module(
     allocated_functions: &PrimaryMap<LocalFunctionIndex, VMLocalFunction>,
     jt_offsets: impl Fn(LocalFunctionIndex, JumpTable) -> near_vm_compiler::CodeOffset,

diff --git a/runtime/near-vm/test-api/src/sys/instance.rs b/runtime/near-vm/test-api/src/sys/instance.rs
@@ -102,7 +102,7 @@ impl Instance {
     /// Those are, as defined by the spec:
     ///  * Link errors that happen when plugging the imports into the instance
     ///  * Runtime errors that happen when running the module `start` function.
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub fn new_with_config(
         module: &Module,
         config: InstanceConfig,

diff --git a/runtime/near-vm/test-api/src/sys/module.rs b/runtime/near-vm/test-api/src/sys/module.rs
@@ -96,7 +96,7 @@ impl Module {
     /// # }
     /// ```
     #[allow(unreachable_code)]
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub fn new(store: &Store, bytes: impl AsRef<[u8]>) -> Result<Self, CompileError> {
         #[cfg(feature = "wat")]
         let bytes = wat::parse_bytes(bytes.as_ref()).map_err(|e| {
@@ -111,7 +111,7 @@ impl Module {
     /// Opposed to [`Module::new`], this function is not compatible with
     /// the WebAssembly text format (if the "wat" feature is enabled for
     /// this crate).
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub(crate) fn from_binary(store: &Store, binary: &[u8]) -> Result<Self, CompileError> {
         let engine = store.engine();
         engine.validate(binary)?;

diff --git a/runtime/near-vm/vm/src/instance/mod.rs b/runtime/near-vm/vm/src/instance/mod.rs
@@ -1146,7 +1146,7 @@ impl InstanceHandle {
 ///   visible to code in `near_vm_vm`, so it's the caller's responsibility to ensure these
 ///   functions are called with the correct type.
 /// - `instance_ptr` must point to a valid `near_vm_test_api::Instance`.
-#[tracing::instrument(target = "near_vm", skip_all)]
+#[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
 pub unsafe fn initialize_host_envs<Err: Sized>(
     handle: &std::sync::Mutex<InstanceHandle>,
     instance_ptr: *const ffi::c_void,

diff --git a/runtime/near-vm/vm/src/vmoffsets.rs b/runtime/near-vm/vm/src/vmoffsets.rs
@@ -116,7 +116,7 @@ impl VMOffsets {
     }
 
     /// Add imports and locals from the provided ModuleInfo.
-    #[tracing::instrument(target = "near_vm", skip_all)]
+    #[tracing::instrument(target = "near_vm", level = "trace", skip_all)]
     pub fn with_module_info(mut self, module: &ModuleInfo) -> Self {
         self.num_imported_functions = module.import_counts.functions;
         self.num_imported_tables = module.import_counts.tables;