[][src]Module frame_support::debug

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.

use frame_support::debug;

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.

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.

use frame_support::debug::native;

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);


pub use crate::runtime_print as print;



Native-only logging.



Logs a message at the debug level.


Logs a message at the error level.


Logs a message at the info level.


Logs a message at the trace level.


Logs a message at the warn level.



Runtime logger implementation - log crate backend.


A target for core::write! macro - constructs a string in memory.



Print out the debuggable type.