When using info! from tracing , I want to print the function name.

[erikschul]

When using info! from tracing , I want to print the function name. Is that possible? Currently the "target" only prints the crate name?

[kaffarell]

tracing doesn't support this and I'm not sure if there is a clean way to do this in rust. Maybe you could cook something up with the backtrace crate, not sure though.

Edit: If you haven't seen already you can also print the file name and the line number.

[hds]

If you annotate the function with #[tracing::instrument] then any events created inside that function (e.g. info!(..)) will have that as a parent span, which has the function name as the span name.

[oxysoft]

Here is how we did it in our program

use std::fmt;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::SystemTime;
use tracing_subscriber::fmt::{format, time, format::FmtSpan};
use tracing_subscriber::util::SubscriberInitExt;
use imgui::Context;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::fmt::format::{FormatEvent, FormatFields, Writer};
use tracing_subscriber::registry::LookupSpan;
use tracing::Subscriber;
use tracing_subscriber::fmt::time::FormatTime;

static FRAME_COUNTER: AtomicU64 = AtomicU64::new(0);

pub fn set_frame(frame: u64) {
    FRAME_COUNTER.store(frame, Ordering::Relaxed);
}

struct FrameTime;

impl FormatTime for FrameTime {
    fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
        let frame = FRAME_COUNTER.load(Ordering::Relaxed);
        let now = SystemTime::now();
        let datetime: chrono::DateTime<chrono::Local> = now.into();
        write!(w, "{}", datetime.format("%H:%M:%S%.3f"))
    }
}

struct CustomFormatter;

impl<S, N> FormatEvent<S, N> for CustomFormatter
    where
        S: Subscriber + for<'a> LookupSpan<'a>,
        N: for<'a> FormatFields<'a> + 'static,
{
    fn format_event(
        &self,
        ctx: &tracing_subscriber::fmt::FmtContext<'_, S, N>,
        mut writer: Writer<'_>,
        event: &tracing::Event<'_>,
    ) -> fmt::Result {
        let span = ctx.lookup_current();
        let time = FrameTime;
        let level = event.metadata().level();
        let module_path = event.metadata().module_path();
        let module_name = module_path.and_then(|path| path.split("::").last()).unwrap_or_else(|| module_path.unwrap_or("unknown"));
        let function_name = span.map(|span| span.name());
        let frame = FRAME_COUNTER.load(Ordering::Relaxed);

        // Add color based on level
        let (level_color, level_indicator) = match *level {
            tracing::Level::ERROR => ("\x1b[31m", "✗"), // Red
            tracing::Level::WARN => ("\x1b[33m", "!"),  // Yellow
            tracing::Level::INFO => ("\x1b[32m", "•"),  // Green
            tracing::Level::DEBUG => ("\x1b[36m", "."), // Cyan
            tracing::Level::TRACE => ("\x1b[35m", "~"), // Magenta
        };

        // Start with grey timestamp
        write!(writer, "\x1b[90m")?;
        FormatTime::format_time(&time, &mut writer)?;
        write!(writer, " ")?;
        write!(writer, "{}", frame)?;
        write!(writer, "\x1b[0m ")?;

        // For errors, wrap the entire message in red
        if *level == tracing::Level::ERROR {
            write!(writer, "\x1b[31m")?;
        }

        write!(writer, "{}{}\x1b[0m ", level_color, level_indicator)?;

        if module_name != "unknown" {
            write!(writer, "\x1b[90m(")?; // Grey
            write!(writer, "{}", module_name)?;

            if let Some(func_name) = function_name {
                if func_name != "unknown" {
                    write!(writer, "::{}", func_name)?;
                }
            }

            write!(writer, ")\x1b[0m ")?;
        }

        ctx.format_fields(writer.by_ref(), event)?;
        
        // Reset color if this was an error message
        if *level == tracing::Level::ERROR {
            write!(writer, "\x1b[0m")?;
        }
        
        writeln!(writer)
    }
}


pub fn init() {
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::fmt::layer()
                .with_level(false)   // We handle level display ourselves
                .with_thread_ids(false)
                .with_thread_names(false)
                .with_file(false)
                .with_line_number(false)
                .with_span_events(FmtSpan::NONE)
                .with_target(false)  // We handle target display ourselves
                .event_format(CustomFormatter)
        )
        .with(tracing_subscriber::filter::LevelFilter::INFO)
        .init();
} 

Simply place #[tracing::instrument] on functions and the function name will be captured for all log macros inside.