fixup metrics and tracing

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

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(2)
+	details := runtime.FuncForPC(pc)
+	var callerName string
+	if ok && details != nil {
+		callerName = details.Name()
+	} else {
+		callerName = labelUnknown
+	}
+	return callerName
+}

conn.go

@@ -15,9 +15,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 +57,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 +82,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 +90,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 +98,13 @@ 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")
+	nctx, span := w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	span.AddLabels("method", "BeginTx")
 	name := getQueryName(ctx)
 	if name != "" {
-		span.AddLabels("query", name)
+		span.AddLabels("db.query", name)
 	} else {
-		name = labelUnknown
+		name = getCallerName()
 	}
 	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,17 +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")
+		nctx, span = w.opts.Tracer.Start(w.ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	} else {
-		nctx, span = w.opts.Tracer.Start(ctx, "PrepareContext")
+		nctx, span = w.opts.Tracer.Start(ctx, "sdk.database", tracer.WithSpanKind(tracer.SpanKindClient))
 	}
 	span.AddLabels("method", "PrepareContext")
 	name := getQueryName(ctx)
 	if name != "" {
-		span.AddLabels("query", name)
+		span.AddLabels("db.query", name)
 	} else {
-		name = labelUnknown
+		name = getCallerName()
 	}
 
 	labels := []string{labelMethod, "PrepareContext", labelQuery, name}
@@ -201,10 +200,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 +210,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 +224,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 +244,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 +255,22 @@ 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")
 	name := getQueryName(ctx)
 	if name != "" {
-		span.AddLabels("query", name)
+		span.AddLabels("db.query", name)
 	} else {
-		name = labelUnknown
+		name = getCallerName()
 	}
 	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 +284,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 +292,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 +314,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 +326,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 +354,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 +367,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 +376,22 @@ 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")
 	name := getQueryName(ctx)
 	if name != "" {
-		span.AddLabels("query", name)
+		span.AddLabels("db.statement", name)
 	} else {
-		name = labelUnknown
+		name = getCallerName()
 	}
 	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 +405,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,5 @@
-module go.unistack.org/micro-wrapper-sql/v3
+module gitlab.mtsbank.ru/service-platform/framework/framework-modules/micro-wrapper-sql
 
-go 1.19
+go 1.18
 
 require go.unistack.org/micro/v3 v3.10.25

options.go

@@ -29,18 +29,18 @@ 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"
@@ -78,7 +78,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,7 +177,7 @@ 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 ""

stmt.go

@@ -46,7 +46,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
 }
@@ -87,7 +87,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
@@ -103,8 +103,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 {
@@ -116,31 +115,41 @@ 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")
 	name := getQueryName(ctx)
 	if name != "" {
-		span.AddLabels("query", name)
+		span.AddLabels("db.query", name)
 	} else {
-		name = labelUnknown
+		name = getCallerName()
 	}
 	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}
 
@@ -151,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()
 		}
@@ -160,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
 	}
@@ -168,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
 	}
@@ -182,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()
 	}
@@ -192,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
@@ -202,21 +208,22 @@ 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")
 	name := getQueryName(ctx)
 	if name != "" {
-		span.AddLabels("query", name)
+		span.AddLabels("db.query", name)
 	} else {
-		name = labelUnknown
+		name = getCallerName()
 	}
 	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}
 	if conn, ok := w.stmt.(driver.StmtQueryContext); ok {
@@ -226,8 +233,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()
 		}
@@ -236,7 +242,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
 	}
@@ -245,11 +251,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
 	}
@@ -259,8 +264,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()
 	}
@@ -269,7 +273,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