How to report errors on the current spans with '?' operator

[wcarmon]

Maybe there is already a clean solution for this.

If so, please link so I can read about it.

Issue

• Given some code like this:

fn foo() -> Result<Bar, anyhow::Error> {
    do_something_failable_1()
        .map_err(|e| {
          error!("{e:?}"); // report error to current span
          e
    })?;

    do_something_failable_2()
        .map_err(|e| {
            error!("{e:?}"); // report error to current span
            e
        })?;

    foo_bar()
}

Is there a simpler way to report errors on the current span? It's starting to look like go code 😆

Motivation

• Conciseness
• Correct view in Jaeger (or other Trace visualization tool)

[wcarmon]

best I could do so far...

/// Usage:
/// something_failable().map_err(trace_err)?;
pub fn trace_err<E>(e: E) -> anyhow::Error
where
    E: Into<anyhow::Error>,
{
    let out = e.into();
    error!("{:?}", &out);
    out
}

[davidbarsky]

Naively, if you're writing to jaeger, you're probably using tracing-opentelemetry, which should handle this for you? If that's not sufficient, I'd suggest creating your own error type that builds atop of tracing-error, and when you're returning your own equivalent of anyhow::Error, the From implementation from different supported error types would perform error reporting.

I think that'll handle both conciseness and reporting to Jaeger?

[hawkw]

The #[instrument] attribute macro has the ability to automatically record an event when the annotated function returns an error, like this:

#[tracing::instrument(err)]
fn do_something() -> anyhow::Result<()> {
   // ...
}

If you're using #[instrument] to generate spans, you can use this attribute to automatically emit events for errors returned by instrumented functions.

However, this will only work if you want to have a span generated for that function as well. If you're recording spans using the span! macros, or if the functions which you want to record error events from do not have their own spans but are instead inside the span of a calling function, you may not want to use #[instrument(err)].

It occurs to me, though, that we could probably add a new attribute in the tracing-attributes crate for automatically recording error events whenever a function returns an error, similar to how #[instrument(err)] works, but without generating a new span as well. This attribute could be placed on functions which are called inside another span, but still want to emit error events. Similarly, we could have an attribute for emitting events for non-error return values, like #[instrument(ret)].

[wcarmon]

Confirmed/tested for #[tracing::instrument(err)] with anyhow::Result<...>.

Thanks for excellent software and quick, helpful responses @hawkw and @davidbarsky

[hawkw]

Great, glad we could help! :D

[hawkw]

I opened issue #2464 to track adding a new attribute for just emitting return-value and error events without also creating a span.