Add ignored parameters with #[trace_ignore]

[kleimkuhler]

As mentioned in #5:

...
Since some parameters may not be valid span fields, we might consider adding an additional attribute (#[trace_ignore]?) to annotate those fields that should be skipped.

I think this could be easier to add now that parameters are passed into span!. @hawkw was what you had in mind for this something like this?

#[trace]
#[trace_ignore(bar, baz)]
fn example(foo: t1, bar: t2, bar: t3) -> t4 {
    ...
}

[hawkw]

@kleimkuhler that seems reasonable. Alternatively, we could place the attribute on the argument to ignore, as in:

#[trace]
fn example(foo: t1, #[trace_ignore] bar: t2, #[trace_ignore] baz: t3) -> t4 {
    ...
}

though I'm not sure if there's existing precedent for attributes on args?

[hawkw]

Yet another option would be passing the ignored fields as an argument to the #[trace] attribute, like

#[trace(ignore = bar, baz)]

though that seems potentially confusing.

We could also just make the #[trace] attribute opt-in, so you could say

#[trace(foo)]
fn example(foo: t1, bar: t2, baz: t3) -> t4 {
    ...
}

to ignore bar and baz. Using #[trace] without any arguments would be equivalent to passing all the function's parameters.

I'm not sure which is the most ergonomic syntax --- @davidbarsky, any opinions?

[kleimkuhler]

Of those options I think #[trace(...)] is most reasonable. I don't really like the way tagging individual parameters looks.

Opt-in vs opt-out is something I'd be interested to hear @davidbarsky thoughts on! I'm not really sure if one makes sense over the other.

[hawkw]

Yeah, I'm inclined to agree that putting the attribute on individual parameters is probably not the most intuitive, since AFAIK there's not really much precedent for attributes on function args. Beyond that I'm fine with whatever, as long as `#[trace]` on its own defaults to recording all the parameters (which IMO is going to be the most common case).

[anp]

(assuming trace -> instrument, please correct me if I'm wrong)

Using the macro a little bit I've found that I want nearly all of the arguments in functions where it's used. Based on this, I'd have a preference for an opt-out argument to the macro. I'd also have a preference for the shortest argument name possible, something like skip or not.

[carllerche]

Makes sense to me!

[hdevalence]

I'd be happy to work on a PR for this, using skip as suggested above. I'm not sure what the best way to specify multiple arguments-to-skip is.

Would multiple skip parameters work, as in

#[instrument(skip = b, skip = c)]
fn instrumented_fn(a: A, b: B, c: C) { /* ... */ }

[hawkw]

I'd be happy to work on a PR for this, using skip as suggested above. I'm not sure what the best way to specify multiple arguments-to-skip is.

Would multiple skip parameters work, as in

#[instrument(skip = b, skip = c)]
fn instrumented_fn(a: A, b: B, c: C) { /* ... */ }

@hdevalence I'm fine with that proposal. As an alternative, we could also do something like:

#[instrument(skip(a, b))]
fn instrumented_fn(a: A, b: B, c: C) { /* ... */ }

possibly using something like syn's MetaList. I'm open to either syntax — what do you think feels more natural?

[hdevalence]

@hawkw the second syntax seems better as a user, thanks for the pointer to MetaList.