Merge branch 'main' into codeboten/otelconf-unmarshal

Author: codeboten

CHANGELOG.md

@@ -17,6 +17,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Add unmarshaling and validation for `BatchLogRecordProcessor`, `BatchSpanProcessor`, and `PeriodicMetricReader` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8049)
 - Add unmarshaling and validation for `TextMapPropagator` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8052)
 - Add unmarshaling and validation for `OTLPHttpExporter`, `OTLPGrpcExporter`, `OTLPGrpcMetricExporter` and `OTLPHttpMetricExporter` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8112)
+- Add a `WithSpanNameFormatter` option to `go.opentelemetry.io/contrib/instrumentation/go.mongodb.org/mongo-driver/v2/mongo/otelmongo`. (#7986)
 - Add unmarshaling and validation for `AttributeType`, `AttributeNameValue`, `SimpleSpanProcessor`, `SimpleLogRecordProcessor`, `ZipkinSpanExporter`, `NameStringValuePair`, `InstrumentType` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8127)
 
 ### Changed

instrumentation/go.mongodb.org/mongo-driver/v2/mongo/otelmongo/config.go

@@ -4,6 +4,7 @@
 package otelmongo // import "go.opentelemetry.io/contrib/instrumentation/go.mongodb.org/mongo-driver/v2/mongo/otelmongo"
 
 import (
+	"go.mongodb.org/mongo-driver/v2/event"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/trace"
 )
@@ -18,6 +19,8 @@ type config struct {
 	Tracer trace.Tracer
 
 	CommandAttributeDisabled bool
+
+	SpanNameFormatter SpanNameFormatterFunc
 }
 
 // newConfig returns a config with all Options set.
@@ -26,6 +29,16 @@ func newConfig(opts ...Option) config {
 		TracerProvider:           otel.GetTracerProvider(),
 		CommandAttributeDisabled: true,
 	}
+
+	cfg.SpanNameFormatter = func(event *event.CommandStartedEvent) string {
+		collection, _ := extractCollection(event)
+		if collection != "" {
+			return collection + "." + event.CommandName
+		}
+
+		return event.CommandName
+	}
+
 	for _, opt := range opts {
 		opt.apply(&cfg)
 	}
@@ -48,6 +61,22 @@ func (o optionFunc) apply(c *config) {
 	o(c)
 }
 
+// SpanNameFormatterFunc is a function that resolves the span name given an
+// *event.CommandStartedEvent.
+type SpanNameFormatterFunc func(e *event.CommandStartedEvent) string
+
+// WithSpanNameFormatter specifies a function that resolves the span name given an
+// *event.CommandStartedEvent. If none is specified, the default resolver is used,
+// which returns "<collection>.<command>" if the collection is non-empty,
+// and just "<command>" otherwise.
+func WithSpanNameFormatter(resolver SpanNameFormatterFunc) Option {
+	return optionFunc(func(cfg *config) {
+		if resolver != nil {
+			cfg.SpanNameFormatter = resolver
+		}
+	})
+}
+
 // WithTracerProvider specifies a tracer provider to use for creating a tracer.
 // If none is specified, the global provider is used.
 func WithTracerProvider(provider trace.TracerProvider) Option {

instrumentation/go.mongodb.org/mongo-driver/v2/mongo/otelmongo/example_test.go

@@ -5,8 +5,10 @@ package otelmongo_test
 
 import (
 	"context"
+	"fmt"
 
 	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/event"
 	"go.mongodb.org/mongo-driver/v2/mongo"
 	"go.mongodb.org/mongo-driver/v2/mongo/options"
 
@@ -45,3 +47,37 @@ func Example() {
 		panic(err)
 	}
 }
+
+func ExampleWithSpanNameFormatter() {
+	// connect to MongoDB
+	opts := options.Client()
+	opts.Monitor = otelmongo.NewMonitor(
+		otelmongo.WithSpanNameFormatter(func(event *event.CommandStartedEvent) string {
+			// optionally, the collection name can be extracted for more
+			// descriptive span names; see the extractCollection helper function
+			// in the otelmongo package for an example of how to do this.
+			return fmt.Sprintf("my-prefix-%s", event.CommandName)
+		}),
+	)
+	opts.ApplyURI("mongodb://localhost:27017")
+	client, err := mongo.Connect(opts)
+	if err != nil {
+		panic(err)
+	}
+
+	defer func() {
+		if err := client.Disconnect(context.TODO()); err != nil {
+			panic(err)
+		}
+	}()
+	db := client.Database("mystore")
+	inventory := db.Collection("inventory")
+
+	_, err = inventory.InsertOne(context.TODO(), bson.D{
+		{Key: "item", Value: "canvas"},
+		// [..]
+	})
+	if err != nil {
+		panic(err)
+	}
+}

instrumentation/go.mongodb.org/mongo-driver/v2/mongo/otelmongo/mongo.go

@@ -30,8 +30,6 @@ type monitor struct {
 }
 
 func (m *monitor) Started(ctx context.Context, evt *event.CommandStartedEvent) {
-	var spanName string
-
 	hostname, port := peerInfo(evt)
 
 	attrs := []attribute.KeyValue{
@@ -45,11 +43,14 @@ func (m *monitor) Started(ctx context.Context, evt *event.CommandStartedEvent) {
 	if !m.cfg.CommandAttributeDisabled {
 		attrs = append(attrs, semconv.DBQueryText(sanitizeCommand(evt.Command)))
 	}
-	if collection, err := extractCollection(evt); err == nil && collection != "" {
-		spanName = collection + "."
+
+	collection, err := extractCollection(evt)
+	if err == nil && collection != "" {
 		attrs = append(attrs, semconv.DBCollectionName(collection))
 	}
-	spanName += evt.CommandName
+
+	spanName := m.cfg.SpanNameFormatter(evt)
+
 	opts := []trace.SpanStartOption{
 		trace.WithSpanKind(trace.SpanKindClient),
 		trace.WithAttributes(attrs...),
@@ -105,6 +106,7 @@ func sanitizeCommand(command bson.Raw) string {
 // For CRUD operations, this is the first key/value string pair in the bson
 // document where key == "<operation>" (e.g. key == "insert").
 // For database meta-level operations, such a key may not exist.
+// This function returns the collection name or an error if no collection can be determined.
 func extractCollection(evt *event.CommandStartedEvent) (string, error) {
 	elt, err := evt.Command.IndexErr(0)
 	if err != nil {

instrumentation/go.mongodb.org/mongo-driver/v2/mongo/otelmongo/mongo_test.go

@@ -24,6 +24,75 @@ import (
 
 type validator func(sdktrace.ReadOnlySpan) bool
 
+func TestWithSpanNameFormatter(t *testing.T) {
+	tt := []struct {
+		title             string
+		operation         func(context.Context, *mongo.Database) (any, error)
+		expectedSpanName  string
+		mockResponses     []bson.D
+		SpanNameFormatter SpanNameFormatterFunc
+	}{
+		{
+			title: "insert using default SpanNameFormatter",
+			operation: func(ctx context.Context, db *mongo.Database) (any, error) {
+				return db.Collection("test-collection").InsertOne(ctx, bson.D{{Key: "test-item", Value: "test-value"}})
+			},
+			expectedSpanName:  "test-collection.insert",
+			SpanNameFormatter: nil,
+			mockResponses:     []bson.D{{{Key: "ok", Value: 1}}},
+		},
+		{
+			title: "delete with custom SpanNameFormatter",
+			operation: func(ctx context.Context, db *mongo.Database) (any, error) {
+				return db.Collection("test-collection").DeleteOne(ctx, bson.D{{Key: "test-item", Value: "test-value"}})
+			},
+			SpanNameFormatter: func(event *event.CommandStartedEvent) string {
+				return "my-" + event.CommandName + "-span"
+			},
+			expectedSpanName: "my-delete-span",
+			mockResponses:    []bson.D{{{Key: "ok", Value: 1}}},
+		},
+	}
+	for _, tc := range tt {
+		t.Run(tc.title, func(t *testing.T) {
+			md := drivertest.NewMockDeployment()
+
+			sr := tracetest.NewSpanRecorder()
+			provider := sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
+
+			ctx, cancel := context.WithTimeout(t.Context(), time.Second*3)
+			defer cancel()
+
+			ctx, span := provider.Tracer("test").Start(ctx, "mongodb-test")
+			addr := "mongodb://localhost:27017/?connect=direct"
+			opts := options.Client()
+			opts.Deployment = md //nolint:staticcheck // This method is the current documented way to set the mongodb mock. See https://github.com/mongodb/mongo-go-driver/blob/v2.0.0/x/mongo/driver/drivertest/opmsg_deployment_test.go#L24
+			opts.Monitor = NewMonitor(
+				WithTracerProvider(provider),
+				WithSpanNameFormatter(tc.SpanNameFormatter),
+			)
+			opts.ApplyURI(addr)
+
+			md.AddResponses(tc.mockResponses...)
+			client, err := mongo.Connect(opts)
+			defer func() {
+				e := client.Disconnect(t.Context())
+				require.NoError(t, e)
+			}()
+			require.NoError(t, err)
+
+			_, err = tc.operation(ctx, client.Database("test-database"))
+			require.NoError(t, err)
+
+			span.End()
+			spans := sr.Ended()
+
+			s := spans[0]
+			assert.Equal(t, tc.expectedSpanName, s.Name())
+		})
+	}
+}
+
 func TestDBCrudOperation(t *testing.T) {
 	commonValidators := []validator{
 		func(s sdktrace.ReadOnlySpan) bool {