pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-17 17:11:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Init RuntimeLogger automatically for each runtime api call (#8128)

Browse Source 
* Init `RuntimeLogger` automatically for each runtime api call

This pr change the runtime api in such a way to always and automatically
enable the `RuntimeLogger`. This enables the user to use `log` or
`tracing` from inside the runtime to create log messages. As logging
introduces some extra code and especially increases the size of the wasm
blob. It is advised to disable all logging completely with
`sp-api/disable-logging` when doing the wasm builds for the on-chain
wasm runtime.

Besides these changes, the pr also brings most of the logging found in
frame to the same format "runtime::*".

* Update frame/im-online/src/lib.rs

Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>

* Update test-utils/runtime/Cargo.toml

* Fix test

* Don't use tracing in the runtime, as we don't support it :D

* Fixes

Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>
This commit is contained in:
Bastian Köcher
2021-03-01 15:29:17 +01:00
committed by GitHub
parent f2d9bb9ea6
commit 68390d4085
65 changed files with 571 additions and 422 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/support/src/debug.rs
-247
View File
@@ -1,247 +0,0 @@
// This file is part of Substrate.
// Copyright (C) 2019-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! Runtime debugging and logging utilities.
//!
//! This module contains macros and functions that will allow
//! you to print logs out of the runtime code.
//!
//! First and foremost be aware that adding regular logging code to
//! your runtime will have a negative effect on the performance
//! and size of the blob. Luckily there are some ways to mitigate
//! this that are described below.
//!
//! First component to utilize debug-printing and logging is actually
//! located in `primitives` crate: `sp_core::RuntimeDebug`.
//! This custom-derive generates `core::fmt::Debug` implementation,
//! just like regular `derive(Debug)`, however it does not generate
//! any code when the code is compiled to WASM. This means that
//! you can safely sprinkle `RuntimeDebug` in your runtime codebase,
//! without affecting the size. This also allows you to print/log
//! both when the code is running natively or in WASM, but note
//! that WASM debug formatting of structs will be empty.
//!
//! ```rust,no_run
//! use frame_support::debug;
//!
//! #[derive(sp_core::RuntimeDebug)]
//! struct MyStruct {
//! a: u64,
//! }
//!
//! // First initialize the logger.
//! //
//! // This is only required when you want the logs to be printed
//! // also during non-native run.
//! // Note that enabling the logger has performance impact on
//! // WASM runtime execution and should be used sparingly.
//! debug::RuntimeLogger::init();
//!
//! let x = MyStruct { a: 5 };
//! // will log an info line `"My struct: MyStruct{a:5}"` when running
//! // natively, but will only print `"My struct: "` when running WASM.
//! debug::info!("My struct: {:?}", x);
//!
//! // same output here, although this will print to stdout
//! // (and without log format)
//! debug::print!("My struct: {:?}", x);
//! ```
//!
//! If you want to avoid extra overhead in WASM, but still be able
//! to print / log when the code is executed natively you can use
//! macros coming from `native` sub-module. This module enables
//! logs conditionally and strips out logs in WASM.
//!
//! ```rust,no_run
//! use frame_support::debug::native;
//!
//! #[derive(sp_core::RuntimeDebug)]
//! struct MyStruct {
//! a: u64,
//! }
//!
//! // We don't initialize the logger, since
//! // we are not printing anything out in WASM.
//! // debug::RuntimeLogger::init();
//!
//! let x = MyStruct { a: 5 };
//!
//! // Displays an info log when running natively, nothing when WASM.
//! native::info!("My struct: {:?}", x);
//!
//! // same output to stdout, no overhead on WASM.
//! native::print!("My struct: {:?}", x);
//! ```
use sp_std::fmt::{self, Debug};
pub use log::{info, debug, error, trace, warn};
pub use crate::runtime_print as print;
pub use sp_std::Writer;
/// Native-only logging.
///
/// Using any functions from this module will have any effect
/// only if the runtime is running natively (i.e. not via WASM)
#[cfg(feature = "std")]
pub mod native {
pub use super::{info, debug, error, trace, warn, print};
}
/// Native-only logging.
///
/// Using any functions from this module will have any effect
/// only if the runtime is running natively (i.e. not via WASM)
#[cfg(not(feature = "std"))]
pub mod native {
#[macro_export]
macro_rules! noop {
($($arg:tt)+) => {}
}
pub use noop as info;
pub use noop as debug;
pub use noop as error;
pub use noop as trace;
pub use noop as warn;
pub use noop as print;
}
/// Print out a formatted message.
///
/// # Example
///
/// ```
/// frame_support::runtime_print!("my value is {}", 3);
/// ```
#[macro_export]
macro_rules! runtime_print {
($($arg:tt)+) => {
{
use core::fmt::Write;
let mut w = $crate::sp_std::Writer::default();
let _ = core::write!(&mut w, $($arg)+);
$crate::sp_io::misc::print_utf8(&w.inner())
}
}
}
/// Print out the debuggable type.
pub fn debug(data: &impl Debug) {
runtime_print!("{:?}", data);
}
/// Runtime logger implementation - `log` crate backend.
///
/// The logger should be initialized if you want to display
/// logs inside the runtime that is not necessarily running natively.
///
/// When runtime is executed natively any log statements are displayed
/// even if this logger is NOT initialized.
///
/// Note that even though the logs are not displayed in WASM, they
/// may still affect the size and performance of the generated runtime.
/// To lower the footprint make sure to only use macros from `native`
/// sub-module.
pub struct RuntimeLogger;
impl RuntimeLogger {
/// Initialize the logger.
///
/// This is a no-op when running natively (`std`).
#[cfg(feature = "std")]
pub fn init() {}
/// Initialize the logger.
///
/// This is a no-op when running natively (`std`).
#[cfg(not(feature = "std"))]
pub fn init() {
static LOGGER: RuntimeLogger = RuntimeLogger;
let _ = log::set_logger(&LOGGER);
// Set max level to `TRACE` to ensure we propagate
// all log entries to the native side that will do the
// final filtering on what should be printed.
//
// If we don't set any level, logging is disabled
// completly.
log::set_max_level(log::LevelFilter::Trace);
}
}
impl log::Log for RuntimeLogger {
fn enabled(&self, _metadata: &log::Metadata) -> bool {
// to avoid calling to host twice, we pass everything
// and let the host decide what to print.
// If someone is initializing the logger they should
// know what they are doing.
true
}
fn log(&self, record: &log::Record) {
use fmt::Write;
let mut w = sp_std::Writer::default();
let _ = core::write!(&mut w, "{}", record.args());
sp_io::logging::log(
record.level().into(),
record.target(),
w.inner(),
);
}
fn flush(&self) {}
}
#[cfg(test)]
mod tests {
use substrate_test_runtime_client::{
ExecutionStrategy, TestClientBuilderExt, DefaultTestClientBuilderExt,
TestClientBuilder, runtime::TestAPI,
};
use sp_api::ProvideRuntimeApi;
use sp_runtime::generic::BlockId;
#[test]
fn ensure_runtime_logger_works() {
let executable = std::env::current_exe().unwrap();
let output = std::process::Command::new(executable)
.env("RUN_TEST", "1")
.env("RUST_LOG", "trace")
.args(&["--nocapture", "ensure_runtime_logger_works_implementation"])
.output()
.unwrap();
let output = dbg!(String::from_utf8(output.stderr).unwrap());
assert!(output.contains("Hey I'm runtime"));
}
/// This is no actual test. It will be called by `ensure_runtime_logger_works`
/// to check that the runtime can print from the wasm side using the
/// `RuntimeLogger`.
#[test]
fn ensure_runtime_logger_works_implementation() {
if std::env::var("RUN_TEST").is_ok() {
sp_tracing::try_init_simple();
let client = TestClientBuilder::new().set_execution_strategy(ExecutionStrategy::AlwaysWasm).build();
let runtime_api = client.runtime_api();
let block_id = BlockId::Number(0);
runtime_api.do_trace_log(&block_id).expect("Logging should not fail");
}
}
}
substrate/frame/support/src/dispatch.rs
+2 -2
View File
@@ -1345,7 +1345,7 @@ macro_rules! decl_module {
$system::Config
>::PalletInfo as $crate::traits::PalletInfo>::name::<Self>().expect("pallet will have name in the runtime; qed");
$crate::debug::info!(
$crate::log::info!(
target: $crate::LOG_TARGET,
"⚠️ running migration for {} and setting new storage version to {:?}",
pallet_name,
@@ -1389,7 +1389,7 @@ macro_rules! decl_module {
$system::Config
>::PalletInfo as $crate::traits::PalletInfo>::name::<Self>().expect("pallet will have name in the runtime; qed");
$crate::debug::info!(
$crate::log::info!(
target: $crate::LOG_TARGET,
"✅ no migration for '{}' and setting new storage version to {:?}",
pallet_name,
substrate/frame/support/src/hash.rs
+2 -2
View File
@@ -102,7 +102,7 @@ impl StorageHasher for Twox64Concat {
impl ReversibleStorageHasher for Twox64Concat {
fn reverse(x: &[u8]) -> &[u8] {
if x.len() < 8 {
crate::debug::error!("Invalid reverse: hash length too short");
log::error!("Invalid reverse: hash length too short");
return &[]
}
&x[8..]
@@ -125,7 +125,7 @@ impl StorageHasher for Blake2_128Concat {
impl ReversibleStorageHasher for Blake2_128Concat {
fn reverse(x: &[u8]) -> &[u8] {
if x.len() < 16 {
crate::debug::error!("Invalid reverse: hash length too short");
log::error!("Invalid reverse: hash length too short");
return &[]
}
&x[16..]
substrate/frame/support/src/lib.rs
+27 -3
View File
@@ -44,9 +44,9 @@ pub use sp_state_machine::BasicExternalities;
pub use sp_io::{storage::root as storage_root, self};
#[doc(hidden)]
pub use sp_runtime::RuntimeDebug;
#[doc(hidden)]
pub use log;
#[macro_use]
pub mod debug;
#[macro_use]
mod origin;
#[macro_use]
@@ -340,6 +340,30 @@ macro_rules! ord_parameter_types {
}
}
/// Print out a formatted message.
///
/// # Example
///
/// ```
/// frame_support::runtime_print!("my value is {}", 3);
/// ```
#[macro_export]
macro_rules! runtime_print {
($($arg:tt)+) => {
{
use core::fmt::Write;
let mut w = $crate::sp_std::Writer::default();
let _ = core::write!(&mut w, $($arg)+);
$crate::sp_io::misc::print_utf8(&w.inner())
}
}
}
/// Print out the debuggable type.
pub fn debug(data: &impl sp_std::fmt::Debug) {
runtime_print!("{:?}", data);
}
#[doc(inline)]
pub use frame_support_procedural::{
decl_storage, construct_runtime, transactional, RuntimeDebugNoBound
@@ -1051,7 +1075,7 @@ pub mod pallet_prelude {
pub use frame_support::traits::GenesisBuild;
pub use frame_support::{
EqNoBound, PartialEqNoBound, RuntimeDebugNoBound, DebugNoBound, CloneNoBound, Twox256,
Twox128, Blake2_256, Blake2_128, Identity, Twox64Concat, Blake2_128Concat, debug, ensure,
Twox128, Blake2_256, Blake2_128, Identity, Twox64Concat, Blake2_128Concat, ensure,
RuntimeDebug, storage,
traits::{Get, Hooks, IsType, GetPalletVersion, EnsureOrigin},
dispatch::{DispatchResultWithPostInfo, Parameter, DispatchError},
substrate/frame/support/src/storage/child.rs
+5 -1
View File
@@ -40,7 +40,11 @@ pub fn get<T: Decode + Sized>(
).and_then(|v| {
Decode::decode(&mut &v[..]).map(Some).unwrap_or_else(|_| {
// TODO #3700: error should be handleable.
runtime_print!("ERROR: Corrupted state in child trie at {:?}/{:?}", storage_key, key);
crate::runtime_print!(
"ERROR: Corrupted state in child trie at {:?}/{:?}",
storage_key,
key,
);
None
})
})
substrate/frame/support/src/storage/generator/double_map.rs
+3 -3
View File
@@ -393,7 +393,7 @@ impl<
let value = match unhashed::get::<O>(&previous_key) {
Some(value) => value,
None => {
crate::debug::error!("Invalid translate: fail to decode old value");
log::error!("Invalid translate: fail to decode old value");
continue
},
};
@@ -401,7 +401,7 @@ impl<
let key1 = match K1::decode(&mut key_material) {
Ok(key1) => key1,
Err(_) => {
crate::debug::error!("Invalid translate: fail to decode key1");
log::error!("Invalid translate: fail to decode key1");
continue
},
};
@@ -410,7 +410,7 @@ impl<
let key2 = match K2::decode(&mut key2_material) {
Ok(key2) => key2,
Err(_) => {
crate::debug::error!("Invalid translate: fail to decode key2");
log::error!("Invalid translate: fail to decode key2");
continue
},
};
substrate/frame/support/src/storage/generator/map.rs
+2 -2
View File
@@ -172,7 +172,7 @@ impl<
let value = match unhashed::get::<O>(&previous_key) {
Some(value) => value,
None => {
crate::debug::error!("Invalid translate: fail to decode old value");
log::error!("Invalid translate: fail to decode old value");
continue
},
};
@@ -181,7 +181,7 @@ impl<
let key = match K::decode(&mut key_material) {
Ok(key) => key,
Err(_) => {
crate::debug::error!("Invalid translate: fail to decode key");
log::error!("Invalid translate: fail to decode key");
continue
},
};
substrate/frame/support/src/storage/mod.rs
+8 -7
View File
@@ -62,7 +62,7 @@ mod debug_helper {
let mut val = v.borrow_mut();
*val += 1;
if *val > 10 {
crate::debug::warn!(
log::warn!(
"Detected with_transaction with nest level {}. Nested usage of with_transaction is not recommended.",
*val
);
@@ -532,9 +532,9 @@ impl<T> Iterator for PrefixIterator<T> {
let raw_value = match unhashed::get_raw(&self.previous_key) {
Some(raw_value) => raw_value,
None => {
crate::debug::error!(
log::error!(
"next_key returned a key with no value at {:?}",
self.previous_key
self.previous_key,
);
continue
}
@@ -546,9 +546,10 @@ impl<T> Iterator for PrefixIterator<T> {
let item = match (self.closure)(raw_key_without_prefix, &raw_value[..]) {
Ok(item) => item,
Err(e) => {
crate::debug::error!(
log::error!(
"(key, value) failed to decode at {:?}: {:?}",
self.previous_key, e
self.previous_key,
e,
);
continue
}
@@ -628,9 +629,9 @@ pub trait StoragePrefixedMap<Value: FullCodec> {
None => unhashed::kill(&previous_key),
},
None => {
crate::debug::error!(
log::error!(
"old key failed to decode at {:?}",
previous_key
previous_key,
);
continue
},
substrate/frame/support/src/storage/unhashed.rs
+1 -1
View File
@@ -25,7 +25,7 @@ pub fn get<T: Decode + Sized>(key: &[u8]) -> Option<T> {
sp_io::storage::get(key).and_then(|val| {
Decode::decode(&mut &val[..]).map(Some).unwrap_or_else(|_| {
// TODO #3700: error should be handleable.
runtime_print!("ERROR: Corrupted state at {:?}", key);
crate::runtime_print!("ERROR: Corrupted state at {:?}", key);
None
})
})