feat(go/adbc/driver): initial tracing instrumentation for Snowflake driver

go/adbc/driver/internal/driverbase/connection.go

@@ -27,10 +27,13 @@ import (
 	"strings"
 
 	"github.com/apache/arrow-adbc/go/adbc"
+	"github.com/apache/arrow-adbc/go/adbc/driver/internal"
 	"github.com/apache/arrow-go/v18/arrow"
 	"github.com/apache/arrow-go/v18/arrow/array"
 	"github.com/apache/arrow-go/v18/arrow/memory"
+	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/propagation"
+	semconv "go.opentelemetry.io/otel/semconv/v1.30.0"
 	"go.opentelemetry.io/otel/trace"
 	"golang.org/x/sync/errgroup"
 )
@@ -148,7 +151,9 @@ func (base *ConnectionImplBase) Rollback(context.Context) error {
 	return base.ErrorHelper.Errorf(adbc.StatusNotImplemented, "Rollback")
 }
 
-func (base *ConnectionImplBase) GetInfo(ctx context.Context, infoCodes []adbc.InfoCode) (array.RecordReader, error) {
+func (base *ConnectionImplBase) GetInfo(ctx context.Context, infoCodes []adbc.InfoCode) (reader array.RecordReader, err error) {
+	_, span := internal.StartSpan(ctx, "ConnectionImplBase.GetInfo", base)
+	defer internal.EndSpan(span, err)
 
 	if len(infoCodes) == 0 {
 		infoCodes = base.DriverInfo.InfoSupportedCodes()
@@ -198,13 +203,16 @@ func (base *ConnectionImplBase) GetInfo(ctx context.Context, infoCodes []adbc.In
 				boolInfoBldr.AppendNull()
 			}
 		default:
-			return nil, fmt.Errorf("no defined type code for info_value of type %T", v)
+			err = fmt.Errorf("no defined type code for info_value of type %T", v)
+			return nil, err
 		}
 	}
 
 	final := bldr.NewRecord()
 	defer final.Release()
-	return array.NewRecordReader(adbc.GetInfoSchema, []arrow.Record{final})
+
+	reader, err = array.NewRecordReader(adbc.GetInfoSchema, []arrow.Record{final})
+	return reader, err
 }
 
 func (base *ConnectionImplBase) Close() error {
@@ -365,6 +373,23 @@ func (cnxn *ConnectionImplBase) StartSpan(
 	return cnxn.Tracer.Start(ctx, spanName, opts...)
 }
 
+func (cnxn *ConnectionImplBase) GetInitialSpanAttributes() []attribute.KeyValue {
+	return getInitialSpanAttributes(cnxn.DriverInfo)
+}
+
+func getInitialSpanAttributes(driverInfo *DriverInfo) []attribute.KeyValue {
+	var attrs []attribute.KeyValue
+	var systemName = driverInfo.GetName()
+	if value, ok := driverInfo.GetInfoForInfoCode(adbc.InfoVendorName); ok {
+		if s, ok := value.(string); ok {
+			systemName = s
+		}
+	}
+	attrs = append(attrs, semconv.DBSystemNameKey.String(systemName))
+
+	return attrs
+}
+
 // GetObjects implements Connection.
 func (cnxn *connection) GetObjects(ctx context.Context, depth adbc.ObjectDepth, catalog *string, dbSchema *string, tableName *string, columnName *string, tableType []string) (array.RecordReader, error) {
 	helper := cnxn.dbObjectsEnumerator

go/adbc/driver/internal/driverbase/database.go

@@ -19,6 +19,7 @@ package driverbase
 
 import (
 	"context"
+	"errors"
 	"log/slog"
 	"os"
 	"strings"
@@ -28,12 +29,13 @@ import (
 	"github.com/apache/arrow-adbc/go/adbc"
 	"github.com/apache/arrow-go/v18/arrow/memory"
 	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
 	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
 	"go.opentelemetry.io/otel/sdk/resource"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
-	semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.30.0"
 	"go.opentelemetry.io/otel/trace"
 )
 
@@ -105,6 +107,7 @@ type DatabaseImplBase struct {
 	Tracer      trace.Tracer
 
 	tracerShutdownFunc func(context.Context) error
+	traceParent        string
 }
 
 // NewDatabaseImplBase instantiates DatabaseImplBase.
@@ -184,6 +187,27 @@ func (base *DatabaseImplBase) SetOptions(options map[string]string) error {
 	return nil
 }
 
+func (d *DatabaseImplBase) GetInitialSpanAttributes() []attribute.KeyValue {
+	return getInitialSpanAttributes(d.DriverInfo)
+}
+
+func (d *DatabaseImplBase) GetTraceParent() (traceParent string) {
+	return d.traceParent
+}
+
+func (d *DatabaseImplBase) SetTraceParent(traceParent string) {
+	d.traceParent = traceParent
+}
+
+func (d *DatabaseImplBase) StartSpan(
+	ctx context.Context,
+	spanName string,
+	opts ...trace.SpanStartOption,
+) (context.Context, trace.Span) {
+	ctx, _ = maybeAddTraceParent(ctx, d, nil)
+	return d.Tracer.Start(ctx, spanName, opts...)
+}
+
 // database is the implementation of adbc.Database.
 type database struct {
 	DatabaseImpl
@@ -384,19 +408,28 @@ func newAdbcFileExporter(driverName string) (*stdouttrace.Exporter, error) {
 
 func newTracerProvider(exporters ...sdktrace.SpanExporter) (*sdktrace.TracerProvider, error) {
 	// Ensure default SDK resource and the required service name are set.
-	mergedResource, err := resource.Merge(
+	tracerResource, err := resource.Merge(
 		resource.Default(),
 		resource.NewWithAttributes(
 			semconv.SchemaURL,
 			semconv.ServiceName(driverNamespace),
 		),
 	)
 	if err != nil {
-		return nil, err
+		if errors.Is(err, resource.ErrSchemaURLConflict) {
+			// If unable to merge with the default resource (conflicting ShhemaURL),
+			// use just our resource
+			tracerResource = resource.NewWithAttributes(
+				semconv.SchemaURL,
+				semconv.ServiceName(driverNamespace),
+			)
+		} else {
+			return nil, err
+		}
 	}
 
 	opts := []sdktrace.TracerProviderOption{
-		sdktrace.WithResource(mergedResource),
+		sdktrace.WithResource(tracerResource),
 	}
 	for _, exporter := range exporters {
 		opts = append(opts, sdktrace.WithBatcher(exporter))

go/adbc/driver/internal/driverbase/driver_info.go

@@ -22,6 +22,8 @@ import (
 	"sort"
 
 	"github.com/apache/arrow-adbc/go/adbc"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
 )
 
 const (
@@ -43,6 +45,39 @@ var infoValueTypeCodeForInfoCode = map[adbc.InfoCode]adbc.InfoValueTypeCode{
 	adbc.InfoVendorSubstraitMaxVersion: adbc.InfoValueStringType,
 }
 
+const (
+	// namespace prefix
+	otelInfoSemConv attribute.Key = "apache.arrow.adbc.info."
+
+	// The database vendor/product name (e.g. the server name) (type: utf8)
+	otelSemConvInfoVendorName attribute.Key = otelInfoSemConv + "vendor.name"
+	// The database vendor/product version (type: utf8)
+	otelSemConvInfoVendorVersion attribute.Key = otelInfoSemConv + "vendor.version"
+	// The database vendor/product Arrow library version (type: utf8)
+	otelSemConvInfoVendorArrowVersion attribute.Key = otelInfoSemConv + "vendor.arrow.version"
+	// Indicates whether SQL queries are supported (type: bool).
+	otelSemConvInfoVendorSql attribute.Key = otelInfoSemConv + "vendor.sql"
+	// The driver name (type: utf8)
+	otelSemConvInfoDriverName attribute.Key = otelInfoSemConv + "driver.name"
+	// The driver version (type: utf8)
+	otelSemConvInfoDriverVersion attribute.Key = otelInfoSemConv + "driver.version"
+	// The driver Arrow library version (type: utf8)
+	otelSemConvInfoDriverArrowVersion attribute.Key = otelInfoSemConv + "driver.arrow.version"
+	// The driver ADBC API version (type: int64)
+	otelSemConvInfoDriverAdbcVersion attribute.Key = otelInfoSemConv + "driver.adbc.version"
+)
+
+var otelAttrForInfoCode = map[adbc.InfoCode]attribute.Key{
+	adbc.InfoVendorName:         otelSemConvInfoVendorName,
+	adbc.InfoVendorVersion:      otelSemConvInfoVendorVersion,
+	adbc.InfoVendorArrowVersion: otelSemConvInfoVendorArrowVersion,
+	adbc.InfoDriverName:         otelSemConvInfoDriverName,
+	adbc.InfoDriverVersion:      otelSemConvInfoDriverVersion,
+	adbc.InfoDriverArrowVersion: otelSemConvInfoDriverArrowVersion,
+	adbc.InfoDriverADBCVersion:  otelSemConvInfoDriverAdbcVersion,
+	adbc.InfoVendorSql:          otelSemConvInfoVendorSql,
+}
+
 func DefaultDriverInfo(name string) *DriverInfo {
 	defaultInfoVendorName := name
 	defaultInfoDriverName := fmt.Sprintf("ADBC %s Driver - Go", name)
@@ -121,3 +156,26 @@ func (di *DriverInfo) GetInfoForInfoCode(code adbc.InfoCode) (any, bool) {
 	val, ok := di.info[code]
 	return val, ok
 }
+
+func SetOTelDriverInfoAttributes(driverInfo *DriverInfo, span trace.Span) {
+	attrs := []attribute.KeyValue{}
+	codes := driverInfo.InfoSupportedCodes()
+	for _, code := range codes {
+		if attr, ok := otelAttrForInfoCode[code]; ok {
+			if attrVal, ok := driverInfo.GetInfoForInfoCode(code); ok {
+				if attrVal == nil {
+					continue
+				}
+				switch v := attrVal.(type) {
+				case string:
+					attrs = append(attrs, attr.String(v))
+				case bool:
+					attrs = append(attrs, attr.Bool(v))
+				case int64:
+					attrs = append(attrs, attr.Int64(v))
+				}
+			}
+		}
+	}
+	span.SetAttributes(attrs...)
+}

go/adbc/driver/internal/driverbase/statement.go

@@ -22,6 +22,7 @@ import (
 	"strings"
 
 	"github.com/apache/arrow-adbc/go/adbc"
+	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/trace"
 )
 
@@ -123,8 +124,10 @@ func (st *StatementImplBase) StartSpan(
 	spanName string,
 	opts ...trace.SpanStartOption,
 ) (context.Context, trace.Span) {
-	var span trace.Span
 	ctx, _ = maybeAddTraceParent(ctx, st.cnxn, st)
-	ctx, span = st.Tracer.Start(ctx, spanName, opts...)
-	return ctx, span
+	return st.Tracer.Start(ctx, spanName, opts...)
+}
+
+func (st *StatementImplBase) GetInitialSpanAttributes() []attribute.KeyValue {
+	return st.cnxn.GetInitialSpanAttributes()
 }

go/adbc/driver/internal/shared_utils.go

@@ -27,8 +27,8 @@ import (
 	"github.com/apache/arrow-go/v18/arrow"
 	"github.com/apache/arrow-go/v18/arrow/array"
 	"github.com/apache/arrow-go/v18/arrow/memory"
-	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
+	semconv "go.opentelemetry.io/otel/semconv/v1.30.0"
 	"go.opentelemetry.io/otel/trace"
 )
 
@@ -745,14 +745,32 @@ func ToXdbcDataType(dt arrow.DataType) (xdbcType XdbcDataType) {
 	}
 }
 
-func SetErrorOnSpan(span trace.Span, err error) bool {
+// Starts a trace.Span with the given spanName for the tracing object with
+// the given ctx context.
+func StartSpan(ctx context.Context, spanName string, tracing adbc.OTelTracing, opts ...trace.SpanStartOption) (context.Context, trace.Span) {
+	if tracing == nil {
+		return ctx, trace.SpanFromContext(ctx)
+	}
+
+	attrs := tracing.GetInitialSpanAttributes()
+	attrs = append(attrs, semconv.DBOperationName(spanName))
+	opts = append(opts, trace.WithAttributes(attrs...))
+
+	return tracing.StartSpan(ctx, spanName, opts...)
+}
+
+// Ends the given span. If err is not nil, then the
+// error is recorded and the status is set appropriately.
+// Otherwise, the status is set to Ok.
+func EndSpan(span trace.Span, err error, options ...trace.SpanEndOption) {
 	if err != nil {
 		span.RecordError(err)
 		if adbcError, ok := err.(adbc.Error); ok {
-			span.SetAttributes(attribute.String("error.type", adbcError.Code.String()))
+			span.SetAttributes(semconv.ErrorTypeKey.String(adbcError.Code.String()))
 		}
 		span.SetStatus(codes.Error, err.Error())
-		return true
+	} else {
+		span.SetStatus(codes.Ok, "")
 	}
-	return false
+	span.End(options...)
 }