otelslog: support conversion from `attribute.KeyValue` to `slog.Attr`

[sahidvelji]

Problem Statement

Logs are distinct from metrics and traces in that there is no user-facing OpenTelemetry logs API. Instead, there is tooling to bridge logs from existing popular log packages (such as slog, logrus, zap, logr) into the OpenTelemetry ecosystem.

https://opentelemetry.io/docs/languages/go/instrumentation/#logs

Given the above, there is some friction when working with otelslog (and other log bridges) and attribute.KeyValues.

There is often a need to log OpenTelemetry attributes using slog.Attr. When using otelslog, it is reasonable to assume that the user would also want to use the semconv package. But the identifiers in that package are all attribute.KeyValue or attribute.Key. It is also common for users to find themselves with a []attribute.KeyValue to use with metrics and traces. But such a slice cannot be easily used directly with slog without converting to []slog.Attr first. Having to deal with two sets of attributes (slog.Attr and attribute.KeyValue) is tedious.

Proposed Solution

Expose functionality in the otelslog package that allows for conversion from attribute.KeyValue to slog.Attr.

I'm looking for something like the following:

func AttrsFromKeyValues(kvs ...attribute.KeyValue) []slog.Attr

and possibly also a function that converts a single attribute:

func AttrFromKeyValue(kv attribute.KeyValue) slog.Attr

Alternatives

Have users implement this conversion themselves. Though I imagine that such conversion is a common use case, and should arguably be supported in otelslog.

Prior Art

N/A

Additional Context

While this is applicable to other log bridges, the focus of this proposal is on slog as it is part of the standard library.

[sahidvelji]

cc codeowners @MrAlias @pellared

[pellared]

I think that

opentelemetry-go-contrib/bridges/otelslog/convert.go

Line 20 in a4cbe9a

func convertValue(v any) log.Value {

should also convert https://pkg.go.dev/go.opentelemetry.io/otel/attribute#Value to log.Value by using https://pkg.go.dev/go.opentelemetry.io/otel/log#ValueFromAttribute.

Thanks to it we would cover the same scenario for all logging bridges that would pass attribute.Value.

As for func AttrFromKeyValue(kv attribute.KeyValue) slog.Attr, I think its implementation would be so straightforward that I am not sure at this point if it is worth adding.

EDIT: PoC is here:

• logutil: convert standard and log attributes #7660

[sahidvelji]

Suppose I have this example. My concern is that I need to write a for loop just to log my attribute.KeyValues. Hopefully this example is at least somewhat representative of actual usage. If not, please let me know where I can improve the example.

package main

import (
	"context"
	"log/slog"
	"os"

	"go.opentelemetry.io/contrib/bridges/otelslog"
	"go.opentelemetry.io/otel/attribute"
	semconv "go.opentelemetry.io/otel/semconv/v1.34.0"
)

func main() {
	logger := otelslog.NewLogger("<fully qualified package name>")

	// I think these should actually be resource attributes, but for the sake of this example
	// pretend that they are attributes that we want to log.
	// Suppose these attributes are returned by a function or are used
	// for spans or metrics, and I now want to log them.
	attributes := []attribute.KeyValue{
		semconv.ServiceNameKey.String("example-service"),
		semconv.ServiceVersionKey.String("1.0.0"),
		semconv.DeploymentEnvironmentNameKey.String("production"),
	}

	var err error

	// In order to log `attributes` with slog, we need to convert them to slog.Attr.
	slogAttrs := make([]slog.Attr, 0, len(attributes))
	for _, attr := range attributes {
		slogAttrs = append(slogAttrs, slog.Any(string(attr.Key), attr.Value.AsInterface()))
	}

	logger.LogAttrs(
		context.Background(),
		slog.LevelError,
		"msg",
		append(
			slogAttrs,
			slog.Any(string(semconv.ErrorMessageKey), err),
		)...,
	)
}

What if instead I could do the following?

package main

import (
	"context"
	"log/slog"
	"os"

	"go.opentelemetry.io/contrib/bridges/otelslog"
	"go.opentelemetry.io/otel/attribute"
	semconv "go.opentelemetry.io/otel/semconv/v1.34.0"
)

func main() {
	logger := otelslog.NewLogger("<fully qualified package name>")

	// I think these should actually be resource attributes, but for the sake of this example
	// pretend that they are attributes that we want to log.
	// Suppose these attributes are returned by a function or are used
	// for spans or metrics, and I now want to log them.
	attributes := []attribute.KeyValue{
		semconv.ServiceNameKey.String("example-service"),
		semconv.ServiceVersionKey.String("1.0.0"),
		semconv.DeploymentEnvironmentNameKey.String("production"),
	}

	var err error

-	// In order to log `attributes` with slog, we need to convert them to slog.Attr.
-	slogAttrs := make([]slog.Attr, 0, len(attributes))
-	for _, attr := range attributes {
-		slogAttrs = append(slogAttrs, slog.Any(string(attr.Key), attr.Value.AsInterface()))
-	}

	logger.LogAttrs(
		context.Background(),
		slog.LevelError,
		"msg",
		append(
-			slogAttrs,
-			slog.Any(string(semconv.ErrorMessageKey), err),
+			otelslog.AttrsFromKeyValues(attributes...),
+			otelslog.AttrFromKeyValue(semconv.ErrorMessage(err.Error()),
		)...,
	)
}

[pellared]

I am not sure if it is worth adding such simple function. There could be multiple variants of such function. E.g. some users may prefer https://pkg.go.dev/log/slog#Log over slog.LogAttr. Given this, currently, I prefer that the users create the helpers by themselves. I prefer if users reference otelslog only when creating the slog logger to decrease coupling. I prefer also minimalistic exported API.

[sahidvelji]

These are all fair points.

A question then: if I were to write such a function myself, would something like the following make sense?

func AttrsFromKeyValues(kvs ...attribute.KeyValue) []slog.Attr {
	attrs := make([]slog.Attr, 0, len(kvs))
	for _, kv := range kvs {
		var val slog.Value

		switch kv.Value.Type() {
		case attribute.BOOL:
			val = slog.BoolValue(kv.Value.AsBool())
		case attribute.INT64:
			val = slog.Int64Value(kv.Value.AsInt64())
		case attribute.FLOAT64:
			val = slog.Float64Value(kv.Value.AsFloat64())
		case attribute.STRING:
			val = slog.StringValue(kv.Value.AsString())
		default:
			val = slog.AnyValue(kv.Value.AsInterface())
		}

		attrs = append(attrs, slog.Attr{
			Key:   string(kv.Key),
			Value: val,
		})
	}
	return attrs
}

[pellared]

Given #7660 is shipped then I think even this would work:

func AttrsFromKeyValues(kvs ...attribute.KeyValue) []slog.Attr {
	attrs := make([]slog.Attr, len(kvs))
	for i, kv := range kvs {
		attrs[i] = slog.Any(kv.Key, kv.Value)
	}
	return attrs
}

[MrAlias]

What about providing something like this:

func Map[T any](attrs iter.Seq[attribute.KeyValue], conv func(attribute.KeyValue) T) iter.Seq[T] {
	return func(yield func(T) bool) {
		for a := range attrs {
			if !yield(conv(a)) {
				return
			}
		}
	}
}

That enables things like:

func main() {
	attr := []attribute.KeyValue{
		attribute.String("str", "value"),
		attribute.Int("int", 1),
	}

	conv := func(a attribute.KeyValue) slog.Attr {
		return slog.Any(string(a.Key), a.Value.AsInterface())
	}

	fmt.Println(slices.Collect(Map(slices.Values(attr), conv)))
	// Output: [{str value} {int 1}]
}

Or more generically:

func main() {
	attr := []attribute.KeyValue{
		attribute.String("str", "value"),
		attribute.Int("int", 1),
	}

	conv := func(a attribute.KeyValue) slog.Attr {
		return slog.Any(string(a.Key), a.Value.AsInterface())
	}

	for a := range Map(slices.Values(attr), conv) {
		// Do something with a.
		_ = a
	}
}

[sahidvelji]

Nice, I like that approach. It also applies broadly to all of the log bridges rather than just otelslog. But where would such a function live?