Print run

A procedural macro to trace function and module execution in Rust – with style.

print-run is a procedural macro for Rust that automatically prints messages when a function starts and finishes. It supports colorized output, timestamps, duration display, indentation for nested calls, and more.

It’s designed to be a lightweight and stylish debugging or tracing tool — ideal for building skeletons, quick experiments, or educational projects.

✨ Features

• Works with functions, implementations, and inline modules
• Automatically logs entry and exit of functions
• Draws nested visual markers
• Supports async programming
• Shows execution duration
• Includes timestamps
• Colorized output

📦 Installation

Install using Cargo:

cargo add print-run

Or add this crate to your dependencies in Cargo.toml:

[dependencies]
print-run = "0.1"

🚀 Getting Started

Basic usage

use print_run::print_run;

#[print_run]
fn my_function() {
    let x = 5;
    msg!("Some value: {}", x);
}

my_function();

Output:

my_function starting
 Some value: 5
my_function ended

Using arguments

#[print_run(colored, duration, indent, supress_labels, timestamps)]
fn my_function() { ... }

Output (color not shown in markdown):

15:21:29.964 ┌ my_function
15:21:29.964 ┆  Some value: 5
15:21:29.964 └ my_function [9.50µs]

For implementations

struct MyStruct;

#[print_run(indent)]
impl MyStruct {
    fn static_fn() { ... }
    fn instance_fn(&self) { ... }
}

Output:

┌ MyStruct::static_fn starting
└ MyStruct::static_fn ended
┌ MyStruct.instance_fn starting
└ MyStruct.instance_fn ended

For entire modules

[!WARNING] Only inline modules are supported due to Rust’s procedural macro limitations.

Every function inside the module will inherit the #[print_run(...)] attributes, including implementations. You can override them locally or exclude specific functions using #[print_run(skip)].

The msg! macro is available in all instrumented functions.

#[print_run(colored, indent)]
mod my_module {
    fn something() {}
    fn another() {}

    #[print_run(duration)]
    fn overridden() {}

    #[print_run(skip)]
    fn not_printed() {}

    struct MyStruct;
    impl MyStruct {
        fn static_fn() {}
        fn method_1(&self) {}
        fn method_2(&self) {}
    }
}

Global defaults

You can define defaults (once per crate) by placing print_run_defaults anywhere in the crate:

#[print_run_defaults(indent)]

ℹ️ Note: Rust currently does not support custom crate-wide attributes like #![print_run_defaults()].

⚙️ Configuration

The following arguments are supported by #[print_run(...)] and #[print_run_defaults(...)]:

All arguments can be combined but skip will override the rest.

📝 About msg!

The msg! macro works like println!, but:

• Adds indentation (if indent is enabled)
• Adds timestamps (if timestamps is enabled)
• Uses bold text (for better clarity)
• Automatically included in any function with #[print_run]
• Falls back to println! when used in skipped functions

📄 License

Licensed under MIT.

🙌 Contributions

Contributions, suggestions, and issues are welcome! Feel free to fork the repo or open a PR.