ENGTAI-63552: adding filter eval for client spans

examples/postgres-query/go.mod

@@ -6,7 +6,9 @@ toolchain go1.24.2
 
 replace github.com/hypertrace/goagent => ../..
 
-replace github.com/hypertrace/goagent/instrumentation/hypertrace/github.com/jackc/hyperpgx => ../../instrumentation/opentelemetry/github.com/jackc/hyperpgx
+replace github.com/hypertrace/goagent/instrumentation/hypertrace/github.com/jackc/hyperpgx => ../../instrumentation/hypertrace/github.com/jackc/hyperpgx
+
+replace github.com/hypertrace/goagent/instrumentation/opentelemetry/github.com/jackc/hyperpgx => ../../instrumentation/opentelemetry/github.com/jackc/hyperpgx
 
 require github.com/hypertrace/goagent/instrumentation/hypertrace/github.com/jackc/hyperpgx v0.0.0-00010101000000-000000000000
 
@@ -21,6 +23,7 @@ require (
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 // indirect
 	github.com/hypertrace/agent-config/gen/go v0.0.0-20240523214336-1259231da906 // indirect
 	github.com/hypertrace/goagent v0.0.0-00010101000000-000000000000 // indirect
+	github.com/hypertrace/goagent/instrumentation/opentelemetry/github.com/jackc/hyperpgx v0.0.0-00010101000000-000000000000 // indirect
 	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
 	github.com/jackc/pgconn v1.8.1 // indirect
 	github.com/jackc/pgio v1.0.0 // indirect

instrumentation/hypertrace/database/hypersql/README.md

@@ -39,3 +39,42 @@ sql.Register("ht-mysql", driver)
 // Connect to a MySQL database using the hypersql driver wrapper
 db, err = sql.Open("ht-mysql", "user:password@/dbname")
 ```
+
+For adding a filter implementation to the instrumentation, there's an option to use hypersql.WithFilter to add filters to the instrumentation.
+```go
+
+import (
+    "github.com/go-sql-driver/mysql"
+    "github.com/hypertrace/goagent/instrumentation/hypertrace/database/hypersql"
+    "github.com/hypertrace/goagent/sdk/filter"
+)
+
+// Explicitly wrap the MySQL driver with hypersql
+driver := hypersql.Wrap(&mysql.MySQLDriver{}, hypersql.WithFilter(filter.NoopFilter{}))
+
+// Register our hypersql wrapper as a database driver
+sql.Register("ht-mysql", driver)
+
+// Connect to a MySQL database using the hypersql driver wrapper
+db, err = sql.Open("ht-mysql", "user:password@/dbname")
+```
+
+OR
+
+```go
+import (
+    "database/sql"
+    "github.com/hypertrace/goagent/instrumentation/hypertrace/database/hypersql"
+    "github.com/hypertrace/goagent/sdk/filter"
+)
+
+// Register our hypersql wrapper for the provided MySQL driver.
+driverName, err = hypersql.Register("mysql", hypersql.WithFilter(filter.NoopFilter{}))
+if err != nil {
+    log.Fatalf("unable to register goagent driver: %v\n", err)
+}
+
+// Connect to a MySQL database using the hypersql driver wrapper.
+db, err = sql.Open(driverName, "user:password@/dbname")
+
+```

instrumentation/hypertrace/database/hypersql/options.go

@@ -0,0 +1,24 @@
+package hypersql // import "github.com/hypertrace/goagent/instrumentation/hypertrace/database/hypersql"
+
+import (
+	"github.com/hypertrace/goagent/sdk/filter"
+	sdkSQL "github.com/hypertrace/goagent/sdk/instrumentation/database/sql"
+)
+
+type options struct {
+	Filter filter.Filter
+}
+
+func (o *options) toSDKOptions() *sdkSQL.Options {
+	opts := (sdkSQL.Options)(*o)
+	return &opts
+}
+
+type Option func(o *options)
+
+// WithFilter adds a filter to the GRPC option.
+func WithFilter(f filter.Filter) Option {
+	return func(o *options) {
+		o.Filter = f
+	}
+}

instrumentation/hypertrace/database/hypersql/options_test.go

@@ -0,0 +1,15 @@
+package hypersql // import "github.com/hypertrace/goagent/instrumentation/hypertrace/database/hypersql"
+
+import (
+	"testing"
+
+	"github.com/hypertrace/goagent/sdk/filter"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOptionsToSDK(t *testing.T) {
+	o := &options{
+		Filter: filter.NoopFilter{},
+	}
+	assert.Equal(t, filter.NoopFilter{}, o.toSDKOptions().Filter)
+}

instrumentation/hypertrace/database/hypersql/sql.go

@@ -1,13 +1,28 @@
 package hypersql // import "github.com/hypertrace/goagent/instrumentation/hypertrace/database/hypersql"
 
 import (
+	"database/sql/driver"
 	otelsql "github.com/hypertrace/goagent/instrumentation/opentelemetry/database/hypersql"
 )
 
 // Wrap takes a SQL driver and wraps it with Hypertrace instrumentation.
-var Wrap = otelsql.Wrap
+func Wrap(d driver.Driver, opts ...Option) driver.Driver {
+	o := &options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+
+	return otelsql.Wrap(d, o.toSDKOptions())
+}
 
 // Register initializes and registers the hypersql wrapped database driver
 // identified by its driverName. On success it
 // returns the generated driverName to use when calling sql.Open.
-var Register = otelsql.Register
+func Register(driverName string, opts ...Option) (string, error) {
+	o := &options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+	return otelsql.Register(driverName, o.toSDKOptions())
+
+}

instrumentation/hypertrace/github.com/jackc/hyperpgx/go.mod

@@ -8,10 +8,15 @@ replace github.com/hypertrace/goagent => ../../../../..
 
 replace github.com/hypertrace/goagent/instrumentation/opentelemetry/github.com/jackc/hyperpgx => ../../../../../instrumentation/opentelemetry/github.com/jackc/hyperpgx
 
-require github.com/hypertrace/goagent/instrumentation/opentelemetry/github.com/jackc/hyperpgx v0.0.0-00010101000000-000000000000
+require (
+	github.com/hypertrace/goagent v0.0.0-00010101000000-000000000000
+	github.com/hypertrace/goagent/instrumentation/opentelemetry/github.com/jackc/hyperpgx v0.0.0-00010101000000-000000000000
+	github.com/stretchr/testify v1.10.0
+)
 
 require (
 	github.com/cenkalti/backoff/v5 v5.0.2 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/ghodss/yaml v1.0.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -20,7 +25,6 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 // indirect
 	github.com/hypertrace/agent-config/gen/go v0.0.0-20240523214336-1259231da906 // indirect
-	github.com/hypertrace/goagent v0.0.0-00010101000000-000000000000 // indirect
 	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
 	github.com/jackc/pgconn v1.8.1 // indirect
 	github.com/jackc/pgio v1.0.0 // indirect
@@ -30,6 +34,7 @@ require (
 	github.com/jackc/pgtype v1.7.0 // indirect
 	github.com/jackc/pgx/v4 v4.11.0 // indirect
 	github.com/openzipkin/zipkin-go v0.4.3 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/tklauser/go-sysconf v0.3.14 // indirect
 	github.com/tklauser/numcpus v0.8.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
@@ -59,4 +64,5 @@ require (
 	google.golang.org/grpc v1.72.2 // indirect
 	google.golang.org/protobuf v1.36.6 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

instrumentation/hypertrace/github.com/jackc/hyperpgx/options.go

@@ -0,0 +1,24 @@
+package hyperpgx // import "github.com/hypertrace/goagent/instrumentation/hypertrace/github.com/jackc/hyperpgx"
+
+import (
+	otelpgx "github.com/hypertrace/goagent/instrumentation/opentelemetry/github.com/jackc/hyperpgx"
+	"github.com/hypertrace/goagent/sdk/filter"
+)
+
+type options struct {
+	Filter filter.Filter
+}
+
+func (o *options) toSDKOptions() *otelpgx.Options {
+	opts := (otelpgx.Options)(*o)
+	return &opts
+}
+
+type Option func(o *options)
+
+// WithFilter adds a filter to the GRPC option.
+func WithFilter(f filter.Filter) Option {
+	return func(o *options) {
+		o.Filter = f
+	}
+}

instrumentation/hypertrace/github.com/jackc/hyperpgx/options_test.go

@@ -0,0 +1,15 @@
+package hyperpgx // import "github.com/hypertrace/goagent/instrumentation/hypertrace/github.com/jackc/hyperpgx"
+
+import (
+	"testing"
+
+	"github.com/hypertrace/goagent/sdk/filter"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOptionsToSDK(t *testing.T) {
+	o := &options{
+		Filter: filter.NoopFilter{},
+	}
+	assert.Equal(t, filter.NoopFilter{}, o.toSDKOptions().Filter)
+}

instrumentation/hypertrace/github.com/jackc/hyperpgx/pgx.go

@@ -1,5 +1,16 @@
 package hyperpgx // import "github.com/hypertrace/goagent/instrumentation/hypertrace/github.com/jackc/hyperpgx"
 
-import otelpgx "github.com/hypertrace/goagent/instrumentation/opentelemetry/github.com/jackc/hyperpgx"
+import (
+	"context"
 
-var Connect = otelpgx.Connect
+	otelpgx "github.com/hypertrace/goagent/instrumentation/opentelemetry/github.com/jackc/hyperpgx"
+)
+
+func Connect(ctx context.Context, connString string, opts ...Option) (otelpgx.PGXConn, error) {
+	o := &options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+
+	return otelpgx.Connect(ctx, connString, o.toSDKOptions())
+}

instrumentation/hypertrace/google.golang.org/hypergrpc/client.go

@@ -11,10 +11,16 @@ import (
 // for use in a grpc.Dial call.
 // Interceptor format will be replaced with the stats.Handler since instrumentation has moved to the stats.Handler.
 // See: https://github.com/open-telemetry/opentelemetry-go-contrib/blob/v1.36.0/instrumentation/google.golang.org/grpc/otelgrpc/example_test.go
-func UnaryClientInterceptor() grpc.UnaryClientInterceptor {
+func UnaryClientInterceptor(opts ...Option) grpc.UnaryClientInterceptor {
+	o := &options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+
 	return sdkgrpc.WrapUnaryClientInterceptor(
 		grpcunaryinterceptors.UnaryClientInterceptor(),
 		opentelemetry.SpanFromContext,
+		o.toSDKOptions(),
 		map[string]string{},
 	)
 }

instrumentation/hypertrace/net/hyperhttp/transport.go

@@ -10,8 +10,13 @@ import (
 
 // NewTransport wraps the provided http.RoundTripper with one that
 // starts a span and injects the span context into the outbound request headers.
-func NewTransport(base http.RoundTripper) http.RoundTripper {
+func NewTransport(base http.RoundTripper, opts ...Option) http.RoundTripper {
+	o := &options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+
 	return otelhttp.NewTransport(
-		sdkhttp.WrapTransport(base, opentelemetry.SpanFromContext, map[string]string{}),
+		sdkhttp.WrapTransport(base, opentelemetry.SpanFromContext, o.toSDKOptions(), map[string]string{}),
 	)
 }

instrumentation/opentelemetry/database/hypersql/sql.go

@@ -2,19 +2,18 @@ package hypersql // import "github.com/hypertrace/goagent/instrumentation/opente
 
 import (
 	"database/sql/driver"
-
 	"github.com/hypertrace/goagent/instrumentation/opentelemetry"
 	sdkSQL "github.com/hypertrace/goagent/sdk/instrumentation/database/sql"
 )
 
 // Wrap takes a SQL driver and wraps it with Hypertrace instrumentation.
-func Wrap(d driver.Driver) driver.Driver {
-	return sdkSQL.Wrap(d, opentelemetry.StartSpan)
+func Wrap(d driver.Driver, options *sdkSQL.Options) driver.Driver {
+	return sdkSQL.Wrap(d, opentelemetry.StartSpan, options)
 }
 
 // Register initializes and registers the hypersql wrapped database driver
 // identified by its driverName. On success it
 // returns the generated driverName to use when calling hypersql.Open.
-func Register(driverName string) (string, error) {
-	return sdkSQL.Register(driverName, opentelemetry.StartSpan)
+func Register(driverName string, options *sdkSQL.Options) (string, error) {
+	return sdkSQL.Register(driverName, opentelemetry.StartSpan, options)
 }

instrumentation/opentelemetry/database/hypersql/sql_test.go

@@ -8,16 +8,27 @@ import (
 	"testing"
 
 	"github.com/hypertrace/goagent/instrumentation/opentelemetry/internal/tracetesting"
+	"github.com/hypertrace/goagent/sdk"
+	"github.com/hypertrace/goagent/sdk/filter/result"
+	sdkSQL "github.com/hypertrace/goagent/sdk/instrumentation/database/sql"
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stretchr/testify/assert"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 	apitrace "go.opentelemetry.io/otel/trace"
 )
 
+type mockFilter struct {
+	evaluator func(span sdk.Span) result.FilterResult
+}
+
+func (f *mockFilter) Evaluate(span sdk.Span) result.FilterResult {
+	return f.evaluator(span)
+}
+
 func createDB(t *testing.T) (*sql.DB, func() []sdktrace.ReadOnlySpan) {
 	_, flusher := tracetesting.InitTracer()
 
-	driverName, err := Register("sqlite3")
+	driverName, err := Register("sqlite3", nil)
 	if err != nil {
 		t.Fatalf("unable to register driver")
 	}
@@ -187,3 +198,57 @@ func TestTxWithRollbackSuccess(t *testing.T) {
 
 	db.Close()
 }
+
+func TestFilter(t *testing.T) {
+	_, flusher := tracetesting.InitTracer()
+
+	driverName, err := Register("sqlite3", &sdkSQL.Options{
+		Filter: &mockFilter{
+			evaluator: func(span sdk.Span) result.FilterResult {
+				assert.Equal(t, span.GetAttributes().GetValue("span.kind"), "client")
+
+				span.SetAttribute("span.type", "nospan")
+				return result.FilterResult{}
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("unable to register driver")
+	}
+
+	db, err := sql.Open(driverName, "file:test.db?cache=shared&mode=memory")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rows, err := db.Query("SELECT 1 WHERE 1 = ?", 1)
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err.Error())
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var n int
+		if err = rows.Scan(&n); err != nil {
+			t.Fatalf("unexpected error: %s", err.Error())
+		}
+	}
+	if err = rows.Err(); err != nil {
+		t.Fatalf("unexpected error: %s", err.Error())
+	}
+
+	spans := flusher()
+	assert.Equal(t, 1, len(spans))
+
+	span := spans[0]
+	assert.Equal(t, "db:query", span.Name())
+	assert.Equal(t, apitrace.SpanKindClient, span.SpanKind())
+
+	attrs := tracetesting.LookupAttributes(span.Attributes())
+	assert.Equal(t, "SELECT 1 WHERE 1 = ?", attrs.Get("db.statement").AsString())
+	assert.Equal(t, "sqlite", attrs.Get("db.system").AsString())
+	assert.False(t, attrs.Has("error"))
+	assert.Equal(t, "nospan", attrs.Get("span.type").AsString())
+
+	db.Close()
+}