`Make` equivalent for product types

[alexcardell]

An Attributes.Make equivalent could be helpful for product types we want to extract multiple attributes out of easily

case class Record(i: Int, s: String, c: MyType)
val record: Record = ???

implicit val makeMyType: Attribute.Make[MyType] = ???

implicit val attributesRecord: Attributes.Make[Record] = 
    new Attributes.Make { record =>
         Attributes(List(... /* list of attributes for i, s, c fields */))
    }

Trace[F].span("new-span", record).surround { ... }

Looks quite convenient, could also be quite useful structured logging, I'd like to wire this up to a log4cats wrapper.

Is there a more convenient way of deriving this that could be provided? Or can the existing Attribute.Make be wrangled to not need this

[iRevive]

That's an interesting idea. Attributes.Make should work.
Currently, otel4s doesn't provide implicit conversions on the library level, so we will need the Attributes.from companion method:

Trace[F].span("new-span", Attributes.from(record)).surround { ... }

But users can always define an implicit conversion in their projects:

implicit def toAttributes[A: Attributes.Make](a: A): Attributes = Attributes.from(a)

[NthPortal]

Is there a more convenient way of deriving this that could be provided?

no there is not. from the otel docs:

The attribute value is either:

• A primitive type: string, boolean, double precision floating point (IEEE 754-1985) or signed 64 bit integer.
• An array of primitive type values. The array MUST be homogeneous, i.e., it MUST NOT contain values of different types.

even if it could be provided, it would only be for the very limited subset of product types where all the values are of the same type (or the result types of their Attribute.From instances are all the same). however, because Product is untyped, this would only be possible via macro at best. and trying to have it support Attribute.From would be extremely painful if possible at all. due to the difficulty and limited utility of such a derivation, I don't think it's worth exploring

[iRevive]

Yeah, I don't think we should extend Attribute.From in any way. However, we can still provide the Attributes.From.
We wouldn't violate any specification requirements either.

[NthPortal]

@iRevive I'm struggling to envision the API. what would that look like?

[iRevive]

@NthPortal it should be Attributes.Make, not From. I was thinking about the following structure:

// Attributes.scala
trait Make[A] {
  def make(a: A): Attributes
}
def from[A](value: A)(implicit make: Make[A]): Attributes =
  make.make(value)

// user code
case class UserContext(userId: String, userGroup: String)
implicit val userContextAttributes: Attributes.Make[UserContext] =
  new Attributes.Make[UserContext] {
    def make(a: UserContext): Attributes =
      Attributes(Attribute("user.id", a.userId), Attribute("user.group", a.userGroup))
  }
  
Attributes.from(UserContext("123", "system"))