`dyn Display` primitive value

[hawkw]

In some cases, it may be desirable for types implementing Valuable to record themselves as a pre-formatted human-readable text representation. Currently, this is only possible with the Value::String variant, which takes a &'a str.

For types that want to record themselves using a Display (or Debug) implementation, though, Value::String isn't really sufficient. Because it takes a borrowed string slice, those types would have to allocate ahead of time and store their own formatted representation, so that the borrowed string slice can be handed out in their Valuable impls. This is not ideal.

Therefore, we should probably add &dyn fmt::Display as a primitive Value variant.

[fluffysquirrels]

I would also like this or a similar solution.

The workaround I use is to return a single-value tuple that is a String. This works well enough, but does add a layer of noise in the output I would prefer to avoid.

Here's an example:

struct MyStruct;

impl Valuable for MyStruct {
    fn as_value(&self) -> Value<'_> {
        // We don't store a String of the value, so can't return an &str
        // and use `Value<'a>::String(&'a str)`, encode as a tuple instead.
        Value::Tuplable(self)
    }

    fn visit(&self, visit: &mut dyn valuable::Visit) {
        let s: String = foo();
        let val = Value::String(s.as_str());
        visit.visit_unnamed_fields(&[val]);
    }
}

impl Tuplable for MyStruct {
    fn definition(&self) -> TupleDef {
        TupleDef::new_static(1)
    }
}

[adityashah1212]

I actually had a separate proposal. The Valuable trait should provide a format method that can be used by the tracing::subscriber to optionally format the contents to the users choosing. The advantage of doing this would be, when storing data textually, it can be stored as human readable formatted strings, but when processing/filtering it, it can be treated as integer values.