common.go

@@ -4,7 +4,6 @@ import (
 	"database/sql/driver"
 	"errors"
 	"fmt"
-	"runtime"
 )
 
 //go:generate sh -c "go run gen.go > wrap_gen.go"
@@ -32,20 +31,7 @@ func namedValueToLabels(named []driver.NamedValue) []interface{} {
 		} else {
 			name = fmt.Sprintf("$%d", param.Ordinal)
 		}
-		largs = append(largs, fmt.Sprintf("%s=%v", name, param.Value))
+		largs = append(largs, fmt.Sprintf("%s=%s", 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,7 +6,6 @@ import (
 	"fmt"
 	"time"
 
-	requestid "go.unistack.org/micro-wrapper-requestid/v3"
 	"go.unistack.org/micro/v3/tracer"
 )
 
@@ -16,9 +15,9 @@ var (
 	_ driver.ConnPrepareContext = (*wrapperConn)(nil)
 	_ driver.Pinger             = (*wrapperConn)(nil)
 	_ driver.Validator          = (*wrapperConn)(nil)
-	_ driver.Queryer            = (*wrapperConn)(nil) // nolint:staticcheck
+	_ driver.Queryer            = (*wrapperConn)(nil)
 	_ driver.QueryerContext     = (*wrapperConn)(nil)
-	_ driver.Execer             = (*wrapperConn)(nil) // nolint:staticcheck
+	_ driver.Execer             = (*wrapperConn)(nil)
 	_ driver.ExecerContext      = (*wrapperConn)(nil)
 	//	_ driver.Connector
 	//	_ driver.Driver
@@ -43,7 +42,7 @@ func (w *wrapperConn) Close() error {
 	} else {
 		ctx = context.Background()
 	}
-	_ = ctx
+
 	labels := []string{labelMethod, "Close"}
 	ts := time.Now()
 	err := w.conn.Close()
@@ -56,11 +55,11 @@ func (w *wrapperConn) Close() 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Close", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Close", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	return err
 }
 
@@ -82,32 +81,30 @@ func (w *wrapperConn) Begin() (driver.Tx, 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Begin", getCallerName(), td, err)...)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Begin", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
-		*/
 		return nil, err
 	}
 	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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Begin", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Begin", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	return &wrapperTx{tx: tx, opts: w.opts, ctx: ctx}, nil
 }
 
 // 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")
 	name := getQueryName(ctx)
-	nctx, span := w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+	if name != "" {
-	span.AddLabels("db.method", "BeginTx")
+		span.AddLabels("query", name)
-	span.AddLabels("db.statement", name)
+	} else {
-	if id, ok := ctx.Value(requestid.XRequestIDKey{}).(string); ok {
+		name = labelUnknown
-		span.AddLabels("x-request-id", id)
 	}
 	labels := []string{labelMethod, "BeginTx", labelQuery, name}
 
@@ -124,20 +121,17 @@ 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.SetStatus(tracer.SpanStatusError, err.Error())
+		span.AddLabels("error", true)
-		/*
+		span.AddLabels("err", err.Error())
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-				w.opts.Logger.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "BeginTx", getCallerName(), td, err)...)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "BeginTx", name, 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "BeginTx", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "BeginTx", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
 	return &wrapperTx{tx: tx, opts: w.opts, ctx: ctx, span: span}, nil
 }
 
@@ -149,8 +143,8 @@ func (w *wrapperConn) Prepare(query string) (driver.Stmt, error) {
 	} else {
 		ctx = context.Background()
 	}
-	_ = ctx
+
-	labels := []string{labelMethod, "Prepare", labelQuery, getCallerName()}
+	labels := []string{labelMethod, "Prepare", labelQuery, labelUnknown}
 	ts := time.Now()
 	stmt, err := w.conn.Prepare(query)
 	td := time.Since(ts)
@@ -159,21 +153,20 @@ 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Prepare", getCallerName(), td, err)...)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Prepare", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
-		*/
 		return nil, err
 	}
 	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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Prepare", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Prepare", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	return wrapStmt(stmt, query, w.opts), nil
 }
 
@@ -181,18 +174,19 @@ 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
-
-	name := getQueryName(ctx)
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(w.ctx, "PrepareContext")
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(ctx, "PrepareContext")
 	}
-	span.AddLabels("db.method", "PrepareContext")
+	span.AddLabels("method", "PrepareContext")
-	span.AddLabels("db.statement", name)
+	name := getQueryName(ctx)
-	if id, ok := ctx.Value(requestid.XRequestIDKey{}).(string); ok {
+	if name != "" {
-		span.AddLabels("x-request-id", id)
+		span.AddLabels("query", name)
+	} else {
+		name = labelUnknown
 	}
+
 	labels := []string{labelMethod, "PrepareContext", labelQuery, name}
 	conn, ok := w.conn.(driver.ConnPrepareContext)
 	if !ok {
@@ -207,22 +201,20 @@ 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.SetStatus(tracer.SpanStatusError, err.Error())
+		span.AddLabels("error", true)
-		/*
+		span.AddLabels("err", err.Error())
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-				w.opts.Logger.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "PrepareContext", getCallerName(), td, err)...)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "PrepareContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
-		*/
 		return nil, err
 	}
 	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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "PrepareContext", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "PrepareContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	return wrapStmt(stmt, query, w.opts), nil
 }
 
@@ -234,8 +226,7 @@ func (w *wrapperConn) Exec(query string, args []driver.Value) (driver.Result, er
 	} else {
 		ctx = context.Background()
 	}
-	_ = ctx
+	labels := []string{labelMethod, "Exec", labelQuery, labelUnknown}
-	labels := []string{labelMethod, "Exec", labelQuery, getCallerName()}
 
 	// nolint:staticcheck
 	conn, ok := w.conn.(driver.Execer)
@@ -254,11 +245,9 @@ 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Exec", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Exec", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
 	return res, err
 }
 
@@ -267,22 +256,24 @@ func (w *wrapperConn) ExecContext(ctx context.Context, query string, args []driv
 	var nctx context.Context
 	var span tracer.Span
 
-	name := getQueryName(ctx)
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(w.ctx, "ExecContext")
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(ctx, "ExecContext")
 	}
-	span.AddLabels("db.method", "ExecContext")
+	span.AddLabels("method", "ExecContext")
-	span.AddLabels("db.statement", name)
+	name := getQueryName(ctx)
-	if id, ok := ctx.Value(requestid.XRequestIDKey{}).(string); ok {
+	if name != "" {
-		span.AddLabels("x-request-id", id)
+		span.AddLabels("query", name)
+	} else {
+		name = labelUnknown
 	}
 	defer span.Finish()
 	if len(args) > 0 {
-		span.AddLabels("db.args", fmt.Sprintf("%v", namedValueToLabels(args)))
+		span.AddLabels("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 {
@@ -296,18 +287,18 @@ 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.SetStatus(tracer.SpanStatusError, err.Error())
+		span.AddLabels("error", true)
+		span.AddLabels("err", err.Error())
 	} else {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelSuccess)...).Inc()
 	}
 	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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "ExecContext", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	return res, err
 }
 
@@ -325,17 +316,13 @@ func (w *wrapperConn) Ping(ctx context.Context) error {
 	}
 
 	var nctx context.Context
-	nctx = ctx
-	/*
 	var span tracer.Span
 	if w.ctx != nil {
-			nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(w.ctx, "Ping")
 	} else {
-			nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(ctx, "Ping")
 	}
-		span.AddLabels("db.method", "Ping")
 	defer span.Finish()
-	*/
 	labels := []string{labelMethod, "Ping"}
 	ts := time.Now()
 	err := conn.Ping(nctx)
@@ -343,12 +330,11 @@ 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.SetStatus(tracer.SpanStatusError, err.Error())
+		span.AddLabels("error", true)
-		/*
+		span.AddLabels("err", err.Error())
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-				w.opts.Logger.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Ping", getCallerName(), td, err)...)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Ping", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
-		*/
 		return err
 	} else {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelSuccess)...).Inc()
@@ -367,14 +353,13 @@ func (w *wrapperConn) Query(query string, args []driver.Value) (driver.Rows, err
 	} else {
 		ctx = context.Background()
 	}
-	_ = ctx
 	// nolint:staticcheck
 	conn, ok := w.conn.(driver.Queryer)
 	if !ok {
 		return nil, driver.ErrSkip
 	}
 
-	labels := []string{labelMethod, "Query", labelQuery, getCallerName()}
+	labels := []string{labelMethod, "Query", labelQuery, labelUnknown}
 	ts := time.Now()
 	rows, err := conn.Query(query, args)
 	td := time.Since(ts)
@@ -386,11 +371,9 @@ 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Query", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Query", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
 	return rows, err
 }
 
@@ -398,21 +381,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
-
-	name := getQueryName(ctx)
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(w.ctx, "QueryContext")
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(ctx, "QueryContext")
 	}
-	span.AddLabels("db.method", "QueryContext")
+	span.AddLabels("method", "QueryContext")
-	span.AddLabels("db.statement", name)
+	name := getQueryName(ctx)
-	if id, ok := ctx.Value(requestid.XRequestIDKey{}).(string); ok {
+	if name != "" {
-		span.AddLabels("x-request-id", id)
+		span.AddLabels("query", name)
+	} else {
+		name = labelUnknown
 	}
 	defer span.Finish()
 	if len(args) > 0 {
-		span.AddLabels("db.args", fmt.Sprintf("%v", namedValueToLabels(args)))
+		span.AddLabels("args", fmt.Sprintf("%v", namedValueToLabels(args)))
 	}
 	labels := []string{labelMethod, "QueryContext", labelQuery, name}
 	conn, ok := w.conn.(driver.QueryerContext)
@@ -426,17 +409,17 @@ 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.SetStatus(tracer.SpanStatusError, err.Error())
+		span.AddLabels("error", true)
+		span.AddLabels("err", 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "QueryContext", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	return rows, err
 }
 

driver.go

@@ -25,35 +25,33 @@ 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
+}
+
 // NewWrapper creates and returns a new SQL driver with passed capabilities
 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 *wrappedConnector) Connect(ctx context.Context) (driver.Conn, error) {
+func (w *wrapperConnector) Connect(ctx context.Context) (driver.Conn, error) {
-	return w.connector.Connect(ctx)
+	return w.driver.Connect(ctx)
 }
 
 // Driver implements driver.Driver Driver
-func (w *wrappedConnector) Driver() driver.Driver {
+func (w *wrapperConnector) Driver() driver.Driver {
-	return w.connector.Driver()
+	return w.driver
 }
+*/
 
 /*
 // Connect implements driver.Driver OpenConnector
@@ -78,12 +76,10 @@ func (w *wrapperDriver) Open(name string) (driver.Conn, error) {
 	ts := time.Now()
 	c, err := w.driver.Open(name)
 	td := time.Since(ts)
-	/*
+
 	if w.opts.LoggerEnabled {
-			w.opts.Logger.Log(w.ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(w.ctx, "Open", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(w.ctx, "Open", labelUnknown, td, err)...).Log(w.ctx, w.opts.LoggerLevel)
 	}
-	*/
-	_ = td
 	if err != nil {
 		return nil, err
 	}

gen.go

@@ -66,7 +66,7 @@ func main() {
 			continue
 		}
 		h := getHash(ifaces)
-		b.WriteString(fmt.Sprintf("\tif _, ok := dc.(wrapConn%04d_%s); ok {\n", n, h))
+		b.WriteString(fmt.Sprintf("\tif v, 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("c")
+				b.WriteString("v")
 			} else if idx == 0 {
 				b.WriteString("c")
 			} else {
-				b.WriteString("c")
+				b.WriteString("v")
 			}
 		}
-		b.WriteString(", c}\n")
+		b.WriteString(", v}\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 _, ok := stmt.(wrapStmt%04d_%s); ok {\n", n, h))
+		b.WriteString(fmt.Sprintf("\tif v, 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("c")
+				b.WriteString("v")
 			} else if idx == 0 {
 				b.WriteString("c")
 			} else {
-				b.WriteString("c")
+				b.WriteString("v")
 			}
 		}
-		b.WriteString(", c}\n")
+		b.WriteString(", v}\n")
 		b.WriteString("}\n\n")
 	}
 	b.WriteString("return c\n")

go.mod

@@ -1,18 +1,5 @@
 module go.unistack.org/micro-wrapper-sql/v3
 
-go 1.22
+go 1.19
 
-toolchain go1.23.2
+require go.unistack.org/micro/v3 v3.10.25
-
-require (
-	go.unistack.org/micro-wrapper-requestid/v3 v3.9.2
-	go.unistack.org/micro/v3 v3.10.97
-)
-
-require (
-	go.unistack.org/micro-proto/v3 v3.4.1 // indirect
-	golang.org/x/sys v0.26.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 // indirect
-	google.golang.org/grpc v1.67.1 // indirect
-	google.golang.org/protobuf v1.35.1 // indirect
-)

go.sum

@@ -1,39 +1,2 @@
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+go.unistack.org/micro/v3 v3.10.25 h1:A0epdZHOqjnXx103wwFhPKgmvVVbScvfbmn3HmHz1wE=
-go.unistack.org/micro-proto/v3 v3.4.1 h1:UTjLSRz2YZuaHk9iSlVqqsA50JQNAEK2ZFboGqtEa9Q=
+go.unistack.org/micro/v3 v3.10.25/go.mod h1:ALkeXpqChYDjx8KPi7tz9mmIyOnob6nlNswsg8BnZjQ=
-go.unistack.org/micro-proto/v3 v3.4.1/go.mod h1:okx/cnOhzuCX0ggl/vToatbCupi0O44diiiLLsZ93Zo=
-go.unistack.org/micro-wrapper-requestid/v3 v3.8.10 h1:9QZy6w1HU2RCppZ1t8wJsDg1pk9RbvzUFYurq3Ai29Y=
-go.unistack.org/micro-wrapper-requestid/v3 v3.8.10/go.mod h1:3tY5+DwQM7l07chnpu/Wzwnne/ZV75VsUwXR54/WYzo=
-go.unistack.org/micro-wrapper-requestid/v3 v3.9.2 h1:Wu0oIGJieH37xroCjlaPivuqTGmv5l5KWgVaRQWEQMY=
-go.unistack.org/micro-wrapper-requestid/v3 v3.9.2/go.mod h1:cqgjdSSASTnOLjvwndP9bi0b8DbuoKbDII884R5puwU=
-go.unistack.org/micro/v3 v3.10.57 h1:VxG7Cs7kBOgxgQlP+K8TvTxIgh2pmqAwmAaKdTAQNtQ=
-go.unistack.org/micro/v3 v3.10.57/go.mod h1:erMgt3Bl7vQQ0e9UpQyR5NlLiZ9pKeEJ9+1tfYFaqUg=
-go.unistack.org/micro/v3 v3.10.91 h1:vuJY4tXwpqimwIkEJ3TozMYNVQQs+C5QMlQWPgSY/YM=
-go.unistack.org/micro/v3 v3.10.91/go.mod h1:erMgt3Bl7vQQ0e9UpQyR5NlLiZ9pKeEJ9+1tfYFaqUg=
-go.unistack.org/micro/v3 v3.10.97 h1:8l7fv+i06/PjPrBBhRC/ZQkWGIOuHPg3jJN0vktYE78=
-go.unistack.org/micro/v3 v3.10.97/go.mod h1:YzMldzHN9Ei+zy5t/Psu7RUWDZwUfrNYiStSQtTz90g=
-golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
-golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
-golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
-golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
-golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240401170217-c3f982113cda h1:LI5DOvAxUPMv/50agcLLoo+AdWc1irS9Rzz4vPuD1V4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240401170217-c3f982113cda/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 h1:pPJltXNxVzT4pK9yD8vR9X75DaWYYmLGMsEvBfFQZzQ=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 h1:QCqS/PdaHTSWGvupk2F/ehwHtGc0/GYkT+3GAcR1CCc=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI=
-google.golang.org/grpc v1.63.2 h1:MUeiw1B2maTVZthpU5xvASfTh3LDbxHd6IJ6QQVU+xM=
-google.golang.org/grpc v1.63.2/go.mod h1:WAX/8DgncnokcFUldAxq7GeB5DXHDbMF+lLvDomNkRA=
-google.golang.org/grpc v1.67.0 h1:IdH9y6PF5MPSdAntIcpjQ+tXO41pcQsfZV2RxtQgVcw=
-google.golang.org/grpc v1.67.0/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
-google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E=
-google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
-google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
-google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
-google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
-google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=

options.go

@@ -13,9 +13,11 @@ import (
 var (
 	// DefaultMeterStatsInterval holds default stats interval
 	DefaultMeterStatsInterval = 5 * time.Second
+	// DefaultMeterMetricPrefix holds default metric prefix
+	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{}{"db.method", method, "took", fmt.Sprintf("%v", td)}
+		labels := []interface{}{"method", method, "took", fmt.Sprintf("%v", td)}
 		if err != nil {
 			labels = append(labels, "error", err.Error())
 		}
@@ -27,23 +29,23 @@ var (
 )
 
 var (
-	MaxOpenConnections = "micro_sql_max_open_conn"
+	MaxOpenConnections = "max_open_connections"
-	OpenConnections    = "micro_sql_open_conn"
+	OpenConnections    = "open_connections"
-	InuseConnections   = "micro_sql_inuse_conn"
+	InuseConnections   = "inuse_connections"
-	IdleConnections    = "micro_sql_idle_conn"
+	IdleConnections    = "idle_connections"
-	WaitConnections    = "micro_sql_waited_conn"
+	WaitConnections    = "wait_connections"
-	BlockedSeconds     = "micro_sql_blocked_seconds"
+	BlockedSeconds     = "blocked_seconds"
-	MaxIdleClosed      = "micro_sql_max_idle_closed"
+	MaxIdleClosed      = "max_idle_closed"
-	MaxIdletimeClosed  = "micro_sql_closed_max_idle"
+	MaxIdletimeClosed  = "max_idletime_closed"
-	MaxLifetimeClosed  = "micro_sql_closed_max_lifetime"
+	MaxLifetimeClosed  = "max_lifetime_closed"
 
-	meterRequestTotal               = "micro_sql_request_total"
+	meterRequestTotal               = "request_total"
-	meterRequestLatencyMicroseconds = "micro_sql_latency_microseconds"
+	meterRequestLatencyMicroseconds = "request_latency_microseconds"
-	meterRequestDurationSeconds     = "micro_sql_request_duration_seconds"
+	meterRequestDurationSeconds     = "request_duration_seconds"
 
 	labelUnknown  = "unknown"
-	labelQuery    = "db_statement"
+	labelQuery    = "query"
-	labelMethod   = "db_method"
+	labelMethod   = "method"
 	labelStatus   = "status"
 	labelSuccess  = "success"
 	labelFailure  = "failure"
@@ -58,6 +60,7 @@ type Options struct {
 	Tracer             tracer.Tracer
 	DatabaseHost       string
 	DatabaseName       string
+	MeterMetricPrefix  string
 	MeterStatsInterval time.Duration
 	LoggerLevel        logger.Level
 	LoggerEnabled      bool
@@ -74,7 +77,8 @@ func NewOptions(opts ...Option) Options {
 		Meter:              meter.DefaultMeter,
 		Tracer:             tracer.DefaultTracer,
 		MeterStatsInterval: DefaultMeterStatsInterval,
-		LoggerLevel:        logger.ErrorLevel,
+		MeterMetricPrefix:  DefaultMeterMetricPrefix,
+		LoggerLevel:        logger.DebugLevel,
 		LoggerObserver:     DefaultLoggerObserver,
 	}
 	for _, o := range opts {
@@ -82,13 +86,14 @@ func NewOptions(opts ...Option) Options {
 	}
 
 	options.Meter = options.Meter.Clone(
+		meter.MetricPrefix(options.MeterMetricPrefix),
 		meter.Labels(
 			labelHost, options.DatabaseHost,
 			labelDatabase, options.DatabaseName,
 		),
 	)
 
-	options.Logger = options.Logger.Clone(logger.WithAddCallerSkipCount(1))
+	options.Logger = options.Logger.Clone(logger.WithCallerSkipCount(1))
 
 	return options
 }
@@ -100,6 +105,13 @@ func MetricInterval(td time.Duration) Option {
 	}
 }
 
+// MetricPrefix specifies prefix for each metric
+func MetricPrefix(pref string) Option {
+	return func(o *Options) {
+		o.MeterMetricPrefix = pref
+	}
+}
+
 func DatabaseHost(host string) Option {
 	return func(o *Options) {
 		o.DatabaseHost = host
@@ -165,8 +177,8 @@ func QueryName(ctx context.Context, name string) context.Context {
 }
 
 func getQueryName(ctx context.Context) string {
-	if v, ok := ctx.Value(queryNameKey{}).(string); ok && v != labelUnknown {
+	if v, ok := ctx.Value(queryNameKey{}).(string); ok {
 		return v
 	}
-	return getCallerName()
+	return ""
 }

stmt.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"time"
 
-	requestid "go.unistack.org/micro-wrapper-requestid/v3"
 	"go.unistack.org/micro/v3/tracer"
 )
 
@@ -33,7 +32,6 @@ func (w *wrapperStmt) Close() error {
 	} else {
 		ctx = context.Background()
 	}
-	_ = ctx
 	labels := []string{labelMethod, "Close"}
 	ts := time.Now()
 	err := w.stmt.Close()
@@ -46,11 +44,10 @@ func (w *wrapperStmt) Close() 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Close", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Close", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
 	return err
 }
 
@@ -76,7 +73,6 @@ func (w *wrapperStmt) Exec(args []driver.Value) (driver.Result, error) {
 	} else {
 		ctx = context.Background()
 	}
-	_ = ctx
 	labels := []string{labelMethod, "Exec"}
 	ts := time.Now()
 	res, err := w.stmt.Exec(args) // nolint:staticcheck
@@ -89,11 +85,11 @@ func (w *wrapperStmt) Exec(args []driver.Value) (driver.Result, 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Exec", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Exec", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	return res, err
 }
 
@@ -105,10 +101,10 @@ func (w *wrapperStmt) Query(args []driver.Value) (driver.Rows, error) {
 	} else {
 		ctx = context.Background()
 	}
-	_ = ctx
 	labels := []string{labelMethod, "Query"}
 	ts := time.Now()
-	rows, err := w.stmt.Query(args) // nolint:staticcheck
+	// nolint:staticcheck
+	rows, err := w.stmt.Query(args)
 	td := time.Since(ts)
 	te := td.Seconds()
 	if err != nil {
@@ -118,42 +114,33 @@ func (w *wrapperStmt) Query(args []driver.Value) (driver.Rows, 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "Query", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "Query", labelUnknown, td, err)...).Log(ctx, w.opts.LoggerLevel)
-		}
-	*/
-	return rows, err
 	}
 
-// ColumnConverter implements driver.ColumnConverter
+	return rows, err
-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
-
-	name := getQueryName(ctx)
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(w.ctx, "ExecContext")
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(ctx, "ExecContext")
+	}
+	span.AddLabels("method", "ExecContext")
+	name := getQueryName(ctx)
+	if name != "" {
+		span.AddLabels("query", name)
+	} else {
+		name = labelUnknown
 	}
-	span.AddLabels("db.method", "ExecContext")
-	span.AddLabels("db.statement", name)
 	defer span.Finish()
 	if len(args) > 0 {
-		span.AddLabels("db.args", fmt.Sprintf("%v", namedValueToLabels(args)))
+		span.AddLabels("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}
 
@@ -164,29 +151,29 @@ 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.SetStatus(tracer.SpanStatusError, err.Error())
+			span.AddLabels("error", true)
+			span.AddLabels("err", 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)...)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
-		*/
 		return res, err
 	}
 
 	values, err := namedValueToValue(args)
 	if err != nil {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
-		span.SetStatus(tracer.SpanStatusError, err.Error())
+		span.AddLabels("error", true)
-		/*
+		span.AddLabels("err", err.Error())
+
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-				w.opts.Logger.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "ExecContext", name, 0, err)...)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, 0, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
-		*/
 		return nil, err
 	}
 	ts := time.Now()
@@ -195,18 +182,19 @@ 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.SetStatus(tracer.SpanStatusError, err.Error())
+		span.AddLabels("error", true)
+		span.AddLabels("err", 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "ExecContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	return res, err
 }
 
@@ -214,21 +202,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
-
-	name := getQueryName(ctx)
 	if w.ctx != nil {
-		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(w.ctx, "QueryContext")
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
+		nctx, span = w.opts.Tracer.Start(ctx, "QueryContext")
+	}
+	span.AddLabels("method", "QueryContext")
+	name := getQueryName(ctx)
+	if name != "" {
+		span.AddLabels("query", name)
+	} else {
+		name = labelUnknown
 	}
-	span.AddLabels("db.method", "QueryContext")
-	span.AddLabels("db.statement", name)
 	defer span.Finish()
 	if len(args) > 0 {
-		span.AddLabels("db.args", fmt.Sprintf("%v", namedValueToLabels(args)))
+		span.AddLabels("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 {
@@ -238,18 +226,18 @@ 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.SetStatus(tracer.SpanStatusError, err.Error())
+			span.AddLabels("error", true)
+			span.AddLabels("err", 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)...)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
-		*/
 		return rows, err
 	}
 
@@ -257,12 +245,12 @@ func (w *wrapperStmt) QueryContext(ctx context.Context, args []driver.NamedValue
 	if err != nil {
 		w.opts.Meter.Counter(meterRequestTotal, append(labels, labelStatus, labelFailure)...).Inc()
 
-		span.SetStatus(tracer.SpanStatusError, err.Error())
+		span.AddLabels("error", true)
-		/*
+		span.AddLabels("err", err.Error())
+
 		if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-				w.opts.Logger.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "QueryContext", name, 0, err)...)
+			w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, 0, err)...).Log(ctx, w.opts.LoggerLevel)
 		}
-		*/
 		return nil, err
 	}
 	ts := time.Now()
@@ -271,17 +259,18 @@ 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.SetStatus(tracer.SpanStatusError, err.Error())
+		span.AddLabels("error", true)
+		span.AddLabels("err", 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.Log(ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(ctx, "QueryContext", name, td, err)...).Log(ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	return rows, err
 }

tx.go

@@ -23,18 +23,19 @@ func (w *wrapperTx) Commit() error {
 	ts := time.Now()
 	err := w.tx.Commit()
 	td := time.Since(ts)
-	_ = td
+
 	if w.span != nil {
 		if err != nil {
-			w.span.SetStatus(tracer.SpanStatusError, err.Error())
+			w.span.AddLabels("error", true)
+			w.span.AddLabels("err", err.Error())
 		}
 		w.span.Finish()
 	}
-	/*
+
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Log(w.ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(w.ctx, "Commit", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(w.ctx, "Commit", labelUnknown, td, err)...).Log(w.ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	w.ctx = nil
 
 	return err
@@ -45,18 +46,19 @@ func (w *wrapperTx) Rollback() error {
 	ts := time.Now()
 	err := w.tx.Rollback()
 	td := time.Since(ts)
-	_ = td
+
 	if w.span != nil {
 		if err != nil {
-			w.span.SetStatus(tracer.SpanStatusError, err.Error())
+			w.span.AddLabels("error", true)
+			w.span.AddLabels("err", err.Error())
 		}
 		w.span.Finish()
 	}
-	/*
+
 	if w.opts.LoggerEnabled && w.opts.Logger.V(w.opts.LoggerLevel) {
-			w.opts.Logger.Log(w.ctx, w.opts.LoggerLevel, w.opts.LoggerObserver(w.ctx, "Rollback", getCallerName(), td, err)...)
+		w.opts.Logger.Fields(w.opts.LoggerObserver(w.ctx, "Rollback", labelUnknown, td, err)...).Log(w.ctx, w.opts.LoggerLevel)
 	}
-	*/
+
 	w.ctx = nil
 
 	return err