Merge pull request 'add err skip' (#81) from devstigneev/micro-wrapper-sql:issue_73 into master

Reviewed-on: #81

.gitignore

@@ -4,6 +4,7 @@
 *.dll
 *.so
 *.dylib
+bin
 
 # Test binary, built with `go test -c`
 *.test
@@ -13,3 +14,11 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+# Go workspace file
+go.work
+
+# General
+.DS_Store
+.idea
+.vscode

common.go

@@ -4,6 +4,7 @@ import (
 	"database/sql/driver"
 	"errors"
 	"fmt"
+	"runtime"
 )
 
 //go:generate sh -c "go run gen.go > wrap_gen.go"
@@ -31,7 +32,20 @@ func namedValueToLabels(named []driver.NamedValue) []interface{} {
 		} else {
 			name = fmt.Sprintf("$%d", param.Ordinal)
 		}
-		largs = append(largs, fmt.Sprintf("%s=%s", name, param.Value))
+		largs = append(largs, fmt.Sprintf("%s=%v", name, param.Value))
 	}
 	return largs
 }
+
+// getCallerName get the name of the function A where A() -> B() -> GetFunctionCallerName()
+func getCallerName() string {
+	pc, _, _, ok := runtime.Caller(3)
+	details := runtime.FuncForPC(pc)
+	var callerName string
+	if ok && details != nil {
+		callerName = details.Name()
+	} else {
+		callerName = labelUnknown
+	}
+	return callerName
+}

conn.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"time"
 
+	requestid "go.unistack.org/micro-wrapper-requestid/v4"
 	"go.unistack.org/micro/v4/tracer"
 )
 
@@ -15,9 +16,9 @@ var (
 	_ driver.ConnPrepareContext = (*wrapperConn)(nil)
 	_ driver.Pinger             = (*wrapperConn)(nil)
 	_ driver.Validator          = (*wrapperConn)(nil)
-	_ driver.Queryer            = (*wrapperConn)(nil)
+	_ driver.Queryer            = (*wrapperConn)(nil) // nolint:staticcheck
 	_ driver.QueryerContext     = (*wrapperConn)(nil)
-	_ driver.Execer             = (*wrapperConn)(nil)
+	_ driver.Execer             = (*wrapperConn)(nil) // nolint:staticcheck
 	_ driver.ExecerContext      = (*wrapperConn)(nil)
 	//	_ driver.Connector
 	//	_ driver.Driver
@@ -57,7 +58,7 @@ func (w *wrapperConn) Close() error {
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Close", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Close", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return err
@@ -82,7 +83,7 @@ func (w *wrapperConn) Begin() (driver.Tx, error) {
 		w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 		w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Begin", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Begin", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
 		return nil, err
 	}
@@ -90,7 +91,7 @@ func (w *wrapperConn) Begin() (driver.Tx, error) {
 	w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Begin", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Begin", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return &wrapperTx{tx: tx, opts: w.opts, ctx: ctx}, nil
@@ -98,13 +99,12 @@ func (w *wrapperConn) Begin() (driver.Tx, error) {
 
 // BeginTx implements driver.ConnBeginTx BeginTx
 func (w *wrapperConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
-	nctx, span := w.opts.Tracer.Start(ctx, "Transaction")
-	span.AddLabels("method", "BeginTx")
+	nctx, span := w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+	span.AddLabels("db.method", "BeginTx")
 	name := getQueryName(ctx)
-	if name != "" {
-		span.AddLabels("query", name)
-	} else {
-		name = labelUnknown
+	span.AddLabels("db.statement", name)
+	if id, ok := ctx.Value(requestid.XRequestIDKey).(string); ok {
+		span.AddLabels("x-request-id", id)
 	}
 	labels := []string{labelMethod, "BeginTx", labelQuery, name}
 
@@ -121,16 +121,15 @@ func (w *wrapperConn) BeginTx(ctx context.Context, opts driver.TxOptions) (drive
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
 		w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 		w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
-		span.AddLabels("error", true)
-		span.AddLabels("err", err.Error())
+		span.SetStatus(tracer.SpanStatusError, err.Error())
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "BeginTx", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "BeginTx", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
 		return nil, err
 	}
 	w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelSuccess)...).Inc()
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "BeginTx", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "BeginTx", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
 	return &wrapperTx{tx: tx, opts: w.opts, ctx: ctx, span: span}, nil
 }
@@ -144,7 +143,7 @@ func (w *wrapperConn) Prepare(query string) (driver.Stmt, error) {
 		ctx = context.Background()
 	}
 
-	labels := []string{labelMethod, "Prepare", labelQuery, labelUnknown}
+	labels := []string{labelMethod, "Prepare", labelQuery, getCallerName()}
 	ts := time.Now()
 	stmt, err := w.conn.Prepare(query)
 	td := time.Since(ts)
@@ -153,9 +152,8 @@ func (w *wrapperConn) Prepare(query string) (driver.Stmt, error) {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
 		w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 		w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
-
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Prepare", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Prepare", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
 		return nil, err
 	}
@@ -164,7 +162,7 @@ func (w *wrapperConn) Prepare(query string) (driver.Stmt, error) {
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Prepare", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Prepare", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return wrapStmt(stmt, query, w.opts), nil
@@ -174,19 +172,18 @@ func (w *wrapperConn) Prepare(query string) (driver.Stmt, error) {
 func (w *wrapperConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
 	var nctx context.Context
 	var span tracer.Span
-	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "PrepareContext")
-	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "PrepareContext")
-	}
-	span.AddLabels("method", "PrepareContext")
-	name := getQueryName(ctx)
-	if name != "" {
-		span.AddLabels("query", name)
-	} else {
-		name = labelUnknown
-	}
 
+	if w.ctx != nil {
+		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+	} else {
+		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+	}
+	span.AddLabels("db.method", "PrepareContext")
+	name := getQueryName(ctx)
+	span.AddLabels("db.statement", name)
+	if id, ok := ctx.Value(requestid.XRequestIDKey).(string); ok {
+		span.AddLabels("x-request-id", id)
+	}
 	labels := []string{labelMethod, "PrepareContext", labelQuery, name}
 	conn, ok := w.conn.(driver.ConnPrepareContext)
 	if !ok {
@@ -201,10 +198,9 @@ func (w *wrapperConn) PrepareContext(ctx context.Context, query string) (driver.
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
 		w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 		w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
-		span.AddLabels("error", true)
-		span.AddLabels("err", err.Error())
+		span.SetStatus(tracer.SpanStatusError, err.Error())
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "PrepareContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "PrepareContext", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
 		return nil, err
 	}
@@ -212,7 +208,7 @@ func (w *wrapperConn) PrepareContext(ctx context.Context, query string) (driver.
 	w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "PrepareContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "PrepareContext", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return wrapStmt(stmt, query, w.opts), nil
@@ -226,7 +222,7 @@ func (w *wrapperConn) Exec(query string, args []driver.Value) (driver.Result, er
 	} else {
 		ctx = context.Background()
 	}
-	labels := []string{labelMethod, "Exec", labelQuery, labelUnknown}
+	labels := []string{labelMethod, "Exec", labelQuery, getCallerName()}
 
 	// nolint:staticcheck
 	conn, ok := w.conn.(driver.Execer)
@@ -246,7 +242,7 @@ func (w *wrapperConn) Exec(query string, args []driver.Value) (driver.Result, er
 	w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Exec", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Exec", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
 	return res, err
 }
@@ -257,23 +253,21 @@ func (w *wrapperConn) ExecContext(ctx context.Context, query string, args []driv
 	var span tracer.Span
 
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "ExecContext")
+		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "ExecContext")
+		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	}
-	span.AddLabels("method", "ExecContext")
+	span.AddLabels("db.method", "ExecContext")
 	name := getQueryName(ctx)
-	if name != "" {
-		span.AddLabels("query", name)
-	} else {
-		name = labelUnknown
+	span.AddLabels("db.statement", name)
+	if id, ok := ctx.Value(requestid.XRequestIDKey).(string); ok {
+		span.AddLabels("x-request-id", id)
 	}
 	defer span.Finish()
 	if len(args) > 0 {
-		span.AddLabels("args", fmt.Sprintf("%v", namedValueToLabels(args)))
+		span.AddLabels("db.args", fmt.Sprintf("%v", namedValueToLabels(args)))
 	}
 	labels := []string{labelMethod, "ExecContext", labelQuery, name}
-	fmt.Printf("EXECCONTETX args %#+v\n", args)
 
 	conn, ok := w.conn.(driver.ExecerContext)
 	if !ok {
@@ -287,8 +281,7 @@ func (w *wrapperConn) ExecContext(ctx context.Context, query string, args []driv
 	te := td.Seconds()
 	if err != nil {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
-		span.AddLabels("error", true)
-		span.AddLabels("err", err.Error())
+		span.SetStatus(tracer.SpanStatusError, err.Error())
 	} else {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelSuccess)...).Inc()
 	}
@@ -296,7 +289,7 @@ func (w *wrapperConn) ExecContext(ctx context.Context, query string, args []driv
 	w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return res, err
@@ -318,9 +311,9 @@ func (w *wrapperConn) Ping(ctx context.Context) error {
 	var nctx context.Context
 	var span tracer.Span
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "Ping")
+		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "Ping")
+		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	}
 	defer span.Finish()
 	labels := []string{labelMethod, "Ping"}
@@ -330,10 +323,9 @@ func (w *wrapperConn) Ping(ctx context.Context) error {
 	te := td.Seconds()
 	if err != nil {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
-		span.AddLabels("error", true)
-		span.AddLabels("err", err.Error())
+		span.SetStatus(tracer.SpanStatusError, err.Error())
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Ping", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Ping", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
 		return err
 	} else {
@@ -359,7 +351,7 @@ func (w *wrapperConn) Query(query string, args []driver.Value) (driver.Rows, err
 		return nil, driver.ErrSkip
 	}
 
-	labels := []string{labelMethod, "Query", labelQuery, labelUnknown}
+	labels := []string{labelMethod, "Query", labelQuery, getCallerName()}
 	ts := time.Now()
 	rows, err := conn.Query(query, args)
 	td := time.Since(ts)
@@ -372,7 +364,7 @@ func (w *wrapperConn) Query(query string, args []driver.Value) (driver.Rows, err
 	w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Query", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Query", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
 	return rows, err
 }
@@ -381,21 +373,21 @@ func (w *wrapperConn) Query(query string, args []driver.Value) (driver.Rows, err
 func (w *wrapperConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
 	var nctx context.Context
 	var span tracer.Span
+
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "QueryContext")
+		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "QueryContext")
+		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	}
-	span.AddLabels("method", "QueryContext")
+	span.AddLabels("db.method", "QueryContext")
 	name := getQueryName(ctx)
-	if name != "" {
-		span.AddLabels("query", name)
-	} else {
-		name = labelUnknown
+	span.AddLabels("db.statement", name)
+	if id, ok := ctx.Value(requestid.XRequestIDKey).(string); ok {
+		span.AddLabels("x-request-id", id)
 	}
 	defer span.Finish()
 	if len(args) > 0 {
-		span.AddLabels("args", fmt.Sprintf("%v", namedValueToLabels(args)))
+		span.AddLabels("db.args", fmt.Sprintf("%v", namedValueToLabels(args)))
 	}
 	labels := []string{labelMethod, "QueryContext", labelQuery, name}
 	conn, ok := w.conn.(driver.QueryerContext)
@@ -409,15 +401,14 @@ func (w *wrapperConn) QueryContext(ctx context.Context, query string, args []dri
 	te := td.Seconds()
 	if err != nil {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
-		span.AddLabels("error", true)
-		span.AddLabels("err", err.Error())
+		span.SetStatus(tracer.SpanStatusError, err.Error())
 	} else {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelSuccess)...).Inc()
 	}
 	w.opts.Meter.Summary(meterRequestLatencyMicroseconds, labels...).Update(te)
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", getCallerName(), td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return rows, err

driver.go

@@ -24,16 +24,9 @@ type conn interface {
 
 // wrapperDriver defines a wrapper for driver.Driver
 type wrapperDriver struct {
-	driver    driver.Driver
-	connector driver.Connector
-	opts      Options
-	ctx       context.Context
-}
-
-type wrapperConnector struct {
 	driver driver.Driver
-	name   string
 	opts   Options
+	ctx    context.Context
 }
 
 // NewWrapper creates and returns a new SQL driver with passed capabilities
@@ -41,17 +34,26 @@ func NewWrapper(d driver.Driver, opts ...Option) driver.Driver {
 	return &wrapperDriver{driver: d, opts: NewOptions(opts...), ctx: context.Background()}
 }
 
-/*
+type wrappedConnector struct {
+	connector driver.Connector
+	name      string
+	opts      Options
+	ctx       context.Context
+}
+
+func NewWrapperConnector(c driver.Connector, opts ...Option) driver.Connector {
+	return &wrappedConnector{connector: c, opts: NewOptions(opts...), ctx: context.Background()}
+}
+
 // Connect implements driver.Driver Connect
-func (w *wrapperConnector) Connect(ctx context.Context) (driver.Conn, error) {
-	return w.driver.Connect(ctx)
+func (w *wrappedConnector) Connect(ctx context.Context) (driver.Conn, error) {
+	return w.connector.Connect(ctx)
 }
 
 // Driver implements driver.Driver Driver
-func (w *wrapperConnector) Driver() driver.Driver {
-	return w.driver
+func (w *wrappedConnector) Driver() driver.Driver {
+	return w.connector.Driver()
 }
-*/
 
 /*
 // Connect implements driver.Driver OpenConnector
@@ -78,7 +80,7 @@ func (w *wrapperDriver) Open(name string) (driver.Conn, error) {
 	td := time.Since(ts)
 
 	if w.opts.LoggerEnabled {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(w.ctx, "Open", labelUnknown, td, err)...).Log(w.ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(w.ctx, "Open", getCallerName(), td, err)...).Log(w.ctx, w.opts.LoggerLevel)
 	}
 	if err != nil {
 		return nil, err

gen.go

@@ -66,7 +66,7 @@ func main() {
 			continue
 		}
 		h := getHash(ifaces)
-		b.WriteString(fmt.Sprintf("\tif v, ok := dc.(wrapConn%04d_%s); ok {\n", n, h))
+		b.WriteString(fmt.Sprintf("\tif _, ok := dc.(wrapConn%04d_%s); ok {\n", n, h))
 		b.WriteString("\treturn struct {\n")
 		b.WriteString("\t\tdriver.Conn\n")
 		b.WriteString(fmt.Sprintf("\t\t\t%s", strings.Join(ifaces, "\n\t\t\t")))
@@ -74,14 +74,14 @@ func main() {
 		for idx := range ifaces {
 			if idx > 0 {
 				b.WriteString(", ")
-				b.WriteString("v")
+				b.WriteString("c")
 			} else if idx == 0 {
 				b.WriteString("c")
 			} else {
-				b.WriteString("v")
+				b.WriteString("c")
 			}
 		}
-		b.WriteString(", v}\n")
+		b.WriteString(", c}\n")
 		b.WriteString("}\n\n")
 	}
 	b.WriteString("return c\n")
@@ -112,7 +112,7 @@ func main() {
 			continue
 		}
 		h := getHash(ifaces)
-		b.WriteString(fmt.Sprintf("\tif v, ok := stmt.(wrapStmt%04d_%s); ok {\n", n, h))
+		b.WriteString(fmt.Sprintf("\tif _, ok := stmt.(wrapStmt%04d_%s); ok {\n", n, h))
 		b.WriteString("\treturn struct {\n")
 		b.WriteString("\t\tdriver.Stmt\n")
 		b.WriteString(fmt.Sprintf("\t\t\t%s", strings.Join(ifaces, "\n\t\t\t")))
@@ -120,14 +120,14 @@ func main() {
 		for idx := range ifaces {
 			if idx > 0 {
 				b.WriteString(", ")
-				b.WriteString("v")
+				b.WriteString("c")
 			} else if idx == 0 {
 				b.WriteString("c")
 			} else {
-				b.WriteString("v")
+				b.WriteString("c")
 			}
 		}
-		b.WriteString(", v}\n")
+		b.WriteString(", c}\n")
 		b.WriteString("}\n\n")
 	}
 	b.WriteString("return c\n")

go.mod

@@ -1,5 +1,8 @@
 module go.unistack.org/micro-wrapper-sql/v4
 
-go 1.19
+go 1.20
 
-require go.unistack.org/micro/v4 v4.0.3
+require (
+	go.unistack.org/micro-wrapper-requestid/v4 v4.0.3
+	go.unistack.org/micro/v4 v4.0.8
+)

go.sum

@@ -1,2 +1,4 @@
-go.unistack.org/micro/v4 v4.0.3 h1:AFr21ua3IrkuxH26kNYVrs7Kpsrm+4aylE/PfjLdCWM=
-go.unistack.org/micro/v4 v4.0.3/go.mod h1:+wBa98rSf+mRXb/MuSVFPXtDrqN0k8rzPQiC8wRCwCo=
+go.unistack.org/micro-wrapper-requestid/v4 v4.0.3 h1:LhloK8yLLsov4XiKw9i20wdBUfvWCG1TaBNgNVtNa8Q=
+go.unistack.org/micro-wrapper-requestid/v4 v4.0.3/go.mod h1:vRIkCMyhbBVus1xQlr/Fef65n07znrBGkpSCpjkEiqk=
+go.unistack.org/micro/v4 v4.0.8 h1:D5n18+fhyRjJkKSPdIcW1ratWUuzy9TzrS5ud/qImWg=
+go.unistack.org/micro/v4 v4.0.8/go.mod h1:QT3gOIE4qGgBiQGm2Pad/62Sl5R53QfrgYHD448aX14=

options.go

@@ -2,6 +2,8 @@ package wrapper
 
 import (
 	"context"
+	"database/sql"
+	"errors"
 	"fmt"
 	"time"
 
@@ -17,8 +19,8 @@ var (
 	DefaultMeterMetricPrefix = "micro_sql_"
 	// DefaultLoggerObserver used to prepare labels for logger
 	DefaultLoggerObserver = func(ctx context.Context, method string, query string, td time.Duration, err error) []interface{} {
-		labels := []interface{}{"method", method, "took", fmt.Sprintf("%v", td)}
-		if err != nil {
+		labels := []interface{}{"db.method", method, "took", fmt.Sprintf("%v", td)}
+		if err != nil && !errors.Is(err, sql.ErrNoRows) {
 			labels = append(labels, "error", err.Error())
 		}
 		if query != labelUnknown {
@@ -29,23 +31,23 @@ var (
 )
 
 var (
-	MaxOpenConnections = "max_open_connections"
-	OpenConnections    = "open_connections"
-	InuseConnections   = "inuse_connections"
-	IdleConnections    = "idle_connections"
-	WaitConnections    = "wait_connections"
+	MaxOpenConnections = "max_open_conn"
+	OpenConnections    = "open_conn"
+	InuseConnections   = "inuse_conn"
+	IdleConnections    = "idle_conn"
+	WaitConnections    = "waited_conn"
 	BlockedSeconds     = "blocked_seconds"
 	MaxIdleClosed      = "max_idle_closed"
-	MaxIdletimeClosed  = "max_idletime_closed"
-	MaxLifetimeClosed  = "max_lifetime_closed"
+	MaxIdletimeClosed  = "closed_max_idle"
+	MaxLifetimeClosed  = "closed_max_lifetime"
 
 	meterRequestTotal               = "request_total"
-	meterRequestLatencyMicroseconds = "request_latency_microseconds"
+	meterRequestLatencyMicroseconds = "latency_microseconds"
 	meterRequestDurationSeconds     = "request_duration_seconds"
 
 	labelUnknown  = "unknown"
-	labelQuery    = "query"
-	labelMethod   = "method"
+	labelQuery    = "db_statement"
+	labelMethod   = "db_method"
 	labelStatus   = "status"
 	labelSuccess  = "success"
 	labelFailure  = "failure"
@@ -78,7 +80,7 @@ func NewOptions(opts ...Option) Options {
 		Tracer:             tracer.DefaultTracer,
 		MeterStatsInterval: DefaultMeterStatsInterval,
 		MeterMetricPrefix:  DefaultMeterMetricPrefix,
-		LoggerLevel:        logger.DebugLevel,
+		LoggerLevel:        logger.ErrorLevel,
 		LoggerObserver:     DefaultLoggerObserver,
 	}
 	for _, o := range opts {
@@ -177,8 +179,8 @@ func QueryName(ctx context.Context, name string) context.Context {
 }
 
 func getQueryName(ctx context.Context) string {
-	if v, ok := ctx.Value(queryNameKey{}).(string); ok {
+	if v, ok := ctx.Value(queryNameKey{}).(string); ok && v != labelUnknown {
 		return v
 	}
-	return ""
+	return getCallerName()
 }

stats.go

@@ -1,4 +1,4 @@
-package wrapper // import "go.unistack.org/micro-wrapper-sql-1/v3"
+package wrapper // import "go.unistack.org/micro-wrapper-sql/v4"
 
 import (
 	"context"

stmt.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"time"
 
+	requestid "go.unistack.org/micro-wrapper-requestid/v4"
 	"go.unistack.org/micro/v4/tracer"
 )
 
@@ -46,7 +47,7 @@ func (w *wrapperStmt) Close() error {
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Close", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Close", getCallerName(), td, err)).Log(ctx, w.opts.LoggerLevel)
 	}
 	return err
 }
@@ -75,8 +76,7 @@ func (w *wrapperStmt) Exec(args []driver.Value) (driver.Result, error) {
 	}
 	labels := []string{labelMethod, "Exec"}
 	ts := time.Now()
-	// nolint:staticcheck
-	res, err := w.stmt.Exec(args)
+	res, err := w.stmt.Exec(args) // nolint:staticcheck
 	td := time.Since(ts)
 	te := td.Seconds()
 	if err != nil {
@@ -88,7 +88,7 @@ func (w *wrapperStmt) Exec(args []driver.Value) (driver.Result, error) {
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Exec", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Exec", getCallerName(), td, err)).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return res, err
@@ -104,8 +104,7 @@ func (w *wrapperStmt) Query(args []driver.Value) (driver.Rows, error) {
 	}
 	labels := []string{labelMethod, "Query"}
 	ts := time.Now()
-	// nolint:staticcheck
-	rows, err := w.stmt.Query(args)
+	rows, err := w.stmt.Query(args) // nolint:staticcheck
 	td := time.Since(ts)
 	te := td.Seconds()
 	if err != nil {
@@ -117,31 +116,40 @@ func (w *wrapperStmt) Query(args []driver.Value) (driver.Rows, error) {
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Query", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Query", getCallerName(), td, err)).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return rows, err
 }
 
+// ColumnConverter implements driver.ColumnConverter
+func (w *wrapperStmt) ColumnConverter(idx int) driver.ValueConverter {
+	s, ok := w.stmt.(driver.ColumnConverter) // nolint:staticcheck
+	if !ok {
+		return nil
+	}
+	return s.ColumnConverter(idx)
+}
+
 // ExecContext implements driver.StmtExecContext ExecContext
 func (w *wrapperStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
 	var nctx context.Context
 	var span tracer.Span
+
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "ExecContext")
+		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "ExecContext")
+		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	}
-	span.AddLabels("method", "ExecContext")
+	span.AddLabels("db.method", "ExecContext")
 	name := getQueryName(ctx)
-	if name != "" {
-		span.AddLabels("query", name)
-	} else {
-		name = labelUnknown
-	}
+	span.AddLabels("db.statement", name)
 	defer span.Finish()
 	if len(args) > 0 {
-		span.AddLabels("args", fmt.Sprintf("%v", namedValueToLabels(args)))
+		span.AddLabels("db.args", fmt.Sprintf("%v", namedValueToLabels(args)))
+	}
+	if id, ok := ctx.Value(requestid.XRequestIDKey).(string); ok {
+		span.AddLabels("x-request-id", id)
 	}
 	labels := []string{labelMethod, "ExecContext", labelQuery, name}
 
@@ -152,8 +160,7 @@ func (w *wrapperStmt) ExecContext(ctx context.Context, args []driver.NamedValue)
 		te := td.Seconds()
 		if err != nil {
 			w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
-			span.AddLabels("error", true)
-			span.AddLabels("err", err.Error())
+			span.SetStatus(tracer.SpanStatusError, err.Error())
 		} else {
 			w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelSuccess)...).Inc()
 		}
@@ -161,7 +168,7 @@ func (w *wrapperStmt) ExecContext(ctx context.Context, args []driver.NamedValue)
 		w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)).Log(ctx, w.opts.LoggerLevel)
 		}
 		return res, err
 	}
@@ -169,11 +176,10 @@ func (w *wrapperStmt) ExecContext(ctx context.Context, args []driver.NamedValue)
 	values, err := namedValueToValue(args)
 	if err != nil {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
-		span.AddLabels("error", true)
-		span.AddLabels("err", err.Error())
+		span.SetStatus(tracer.SpanStatusError, err.Error())
 
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, 0, err)...).Log(ctx, w.opts.LoggerLevel)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, 0, err)).Log(ctx, w.opts.LoggerLevel)
 		}
 		return nil, err
 	}
@@ -183,8 +189,7 @@ func (w *wrapperStmt) ExecContext(ctx context.Context, args []driver.NamedValue)
 	te := td.Seconds()
 	if err != nil {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
-		span.AddLabels("error", true)
-		span.AddLabels("err", err.Error())
+		span.SetStatus(tracer.SpanStatusError, err.Error())
 	} else {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelSuccess)...).Inc()
 	}
@@ -193,7 +198,7 @@ func (w *wrapperStmt) ExecContext(ctx context.Context, args []driver.NamedValue)
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return res, err
@@ -203,21 +208,21 @@ func (w *wrapperStmt) ExecContext(ctx context.Context, args []driver.NamedValue)
 func (w *wrapperStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
 	var nctx context.Context
 	var span tracer.Span
+
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "QueryContext")
+		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "QueryContext")
+		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	}
-	span.AddLabels("method", "QueryContext")
+	span.AddLabels("db.method", "QueryContext")
 	name := getQueryName(ctx)
-	if name != "" {
-		span.AddLabels("query", name)
-	} else {
-		name = labelUnknown
-	}
+	span.AddLabels("db.statement", name)
 	defer span.Finish()
 	if len(args) > 0 {
-		span.AddLabels("args", fmt.Sprintf("%v", namedValueToLabels(args)))
+		span.AddLabels("db.args", fmt.Sprintf("%v", namedValueToLabels(args)))
+	}
+	if id, ok := ctx.Value(requestid.XRequestIDKey).(string); ok {
+		span.AddLabels("x-request-id", id)
 	}
 	labels := []string{labelMethod, "QueryContext", labelQuery, name}
 	if conn, ok := w.stmt.(driver.StmtQueryContext); ok {
@@ -227,8 +232,7 @@ func (w *wrapperStmt) QueryContext(ctx context.Context, args []driver.NamedValue
 		te := td.Seconds()
 		if err != nil {
 			w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
-			span.AddLabels("error", true)
-			span.AddLabels("err", err.Error())
+			span.SetStatus(tracer.SpanStatusError, err.Error())
 		} else {
 			w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelSuccess)...).Inc()
 		}
@@ -237,7 +241,7 @@ func (w *wrapperStmt) QueryContext(ctx context.Context, args []driver.NamedValue
 		w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)).Log(ctx, w.opts.LoggerLevel)
 		}
 		return rows, err
 	}
@@ -246,11 +250,10 @@ func (w *wrapperStmt) QueryContext(ctx context.Context, args []driver.NamedValue
 	if err != nil {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
 
-		span.AddLabels("error", true)
-		span.AddLabels("err", err.Error())
+		span.SetStatus(tracer.SpanStatusError, err.Error())
 
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, 0, err)...).Log(ctx, w.opts.LoggerLevel)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, 0, err)).Log(ctx, w.opts.LoggerLevel)
 		}
 		return nil, err
 	}
@@ -260,8 +263,7 @@ func (w *wrapperStmt) QueryContext(ctx context.Context, args []driver.NamedValue
 	te := td.Seconds()
 	if err != nil {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
-		span.AddLabels("error", true)
-		span.AddLabels("err", err.Error())
+		span.SetStatus(tracer.SpanStatusError, err.Error())
 	} else {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelSuccess)...).Inc()
 	}
@@ -270,7 +272,7 @@ func (w *wrapperStmt) QueryContext(ctx context.Context, args []driver.NamedValue
 	w.opts.Meter.Histogram(meterRequestDurationSeconds, labels...).Update(te)
 
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)).Log(ctx, w.opts.LoggerLevel)
 	}
 
 	return rows, err

tx.go

@@ -26,14 +26,13 @@ func (w *wrapperTx) Commit() error {
 
 	if w.span != nil {
 		if err != nil {
-			w.span.AddLabels("error", true)
-			w.span.AddLabels("err", err.Error())
+			w.span.SetStatus(tracer.SpanStatusError, err.Error())
 		}
 		w.span.Finish()
 	}
 
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(w.ctx, "Commit", labelUnknown, td, err)...).Log(w.ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(w.ctx, "Commit", getCallerName(), td, err)).Log(w.ctx, w.opts.LoggerLevel)
 	}
 
 	w.ctx = nil
@@ -49,14 +48,13 @@ func (w *wrapperTx) Rollback() error {
 
 	if w.span != nil {
 		if err != nil {
-			w.span.AddLabels("error", true)
-			w.span.AddLabels("err", err.Error())
+			w.span.SetStatus(tracer.SpanStatusError, err.Error())
 		}
 		w.span.Finish()
 	}
 
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-		w.opts.Logger.Fields(w.opts.LoggerObserver(w.ctx, "Rollback", labelUnknown, td, err)...).Log(w.ctx, w.opts.LoggerLevel)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(w.ctx, "Rollback", getCallerName(), td, err)).Log(w.ctx, w.opts.LoggerLevel)
 	}
 
 	w.ctx = nil

wrap.go

@@ -11,118 +11,6 @@ func wrapDriver(d driver.Driver, opts Options) driver.Driver {
 	return struct{ driver.Driver }{&wrapperDriver{driver: d, opts: opts}}
 }
 
-/*
-func wrapStmt(stmt driver.Stmt, query string, opts Options) driver.Stmt {
-	var (
-		_, hasExeCtx     = stmt.(driver.StmtExecContext)
-		_, hasQryCtx     = stmt.(driver.StmtQueryContext)
-		wc, hasColConv   = stmt.(driver.ColumnConverter) //nolint:staticcheck
-		wn, hasNamValChk = stmt.(driver.NamedValueChecker)
-	)
-
-	ws := &wrapperStmt{stmt: stmt, query: query, opts: opts}
-	switch {
-	case !hasExeCtx && !hasQryCtx && !hasColConv && !hasNamValChk:
-		return struct {
-			driver.Stmt
-		}{ws}
-	case !hasExeCtx && hasQryCtx && !hasColConv && !hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtQueryContext
-		}{ws, ws}
-	case hasExeCtx && !hasQryCtx && !hasColConv && !hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtExecContext
-		}{ws, ws}
-	case hasExeCtx && hasQryCtx && !hasColConv && !hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtExecContext
-			driver.StmtQueryContext
-		}{ws, ws, ws}
-	case !hasExeCtx && !hasQryCtx && hasColConv && !hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.ColumnConverter
-		}{ws, wc}
-	case !hasExeCtx && hasQryCtx && hasColConv && !hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtQueryContext
-			driver.ColumnConverter
-		}{ws, ws, wc}
-	case hasExeCtx && !hasQryCtx && hasColConv && !hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtExecContext
-			driver.ColumnConverter
-		}{ws, ws, wc}
-	case hasExeCtx && hasQryCtx && hasColConv && !hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtExecContext
-			driver.StmtQueryContext
-			driver.ColumnConverter
-		}{ws, ws, ws, wc}
-	case !hasExeCtx && !hasQryCtx && !hasColConv && hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.NamedValueChecker
-		}{ws, wn}
-	case !hasExeCtx && hasQryCtx && !hasColConv && hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtQueryContext
-			driver.NamedValueChecker
-		}{ws, ws, wn}
-	case hasExeCtx && !hasQryCtx && !hasColConv && hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtExecContext
-			driver.NamedValueChecker
-		}{ws, ws, wn}
-	case hasExeCtx && hasQryCtx && !hasColConv && hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtExecContext
-			driver.StmtQueryContext
-			driver.NamedValueChecker
-		}{ws, ws, ws, wn}
-	case !hasExeCtx && !hasQryCtx && hasColConv && hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.ColumnConverter
-			driver.NamedValueChecker
-		}{ws, wc, wn}
-	case !hasExeCtx && hasQryCtx && hasColConv && hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtQueryContext
-			driver.ColumnConverter
-			driver.NamedValueChecker
-		}{ws, ws, wc, wn}
-	case hasExeCtx && !hasQryCtx && hasColConv && hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtExecContext
-			driver.ColumnConverter
-			driver.NamedValueChecker
-		}{ws, ws, wc, wn}
-	case hasExeCtx && hasQryCtx && hasColConv && hasNamValChk:
-		return struct {
-			driver.Stmt
-			driver.StmtExecContext
-			driver.StmtQueryContext
-			driver.ColumnConverter
-			driver.NamedValueChecker
-		}{ws, ws, ws, wc, wn}
-	}
-	panic("unreachable")
-}
-*/
-
 // WrapConn allows an existing driver.Conn to be wrapped.
 func WrapConn(c driver.Conn, opts ...Option) driver.Conn {
 	return wrapConn(c, NewOptions(opts...))