conn: change design of tarantool logger

- Used slog.
- Added events of logger.

Fixed #504

Author: New year

connection.go

@@ -8,7 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log"
+	"log/slog"
 	"math"
 	"net"
 	"runtime"
@@ -52,17 +52,17 @@ const (
 	Closed
 
 	// LogReconnectFailed is logged when reconnect attempt failed.
-	LogReconnectFailed ConnLogKind = iota + 1
+	//	LogReconnectFailed ConnLogKind = iota + 1
 	// LogLastReconnectFailed is logged when last reconnect attempt failed,
 	// connection will be closed after that.
-	LogLastReconnectFailed
+	//	LogLastReconnectFailed
 	// LogUnexpectedResultId is logged when response with unknown id was received.
 	// Most probably it is due to request timeout.
 	LogUnexpectedResultId
 	// LogWatchEventReadFailed is logged when failed to read a watch event.
-	LogWatchEventReadFailed
-	// LogBoxSessionPushUnsupported is logged when response type turned IPROTO_CHUNK.
-	LogBoxSessionPushUnsupported
+//	LogWatchEventReadFailed
+// LogBoxSessionPushUnsupported is logged when response type turned IPROTO_CHUNK.
+//	LogBoxSessionPushUnsupported
 )
 
 // ConnEvent is sent throw Notify channel specified in Opts.
@@ -80,50 +80,123 @@ type connWatchEvent struct {
 
 var epoch = time.Now()
 
+type ConnLogEvent interface{}
+
+// Events of logger
+type LogReconnectFailed struct {
+	Reconnects    uint
+	MaxReconnects uint
+	Err           error
+}
+
+type LogLastReconnectFailed struct {
+	Err error
+}
+type LogUnexpectedResultID struct {
+	Header Header
+}
+type LogWatchEventReadFailed struct {
+	Err error
+}
+type LogBoxSessionPushUnsupported struct {
+	Header Header
+}
+
 // Logger is logger type expected to be passed in options.
 type Logger interface {
-	Report(event ConnLogKind, conn *Connection, v ...interface{})
+	Report(event ConnLogEvent, conn *Connection)
+}
+
+type defaultSlogLogger struct {
+	l *slog.Logger
+}
+
+func NewDefaultSlogLogger(l *slog.Logger) Logger {
+	if l == nil {
+		l = slog.Default()
+	}
+	return &defaultSlogLogger{l: l}
 }
 
 type defaultLogger struct{}
 
-func (d defaultLogger) Report(event ConnLogKind, conn *Connection, v ...interface{}) {
-	switch event {
+func attrsToAny(attrs []slog.Attr) []any {
+	out := make([]any, 0, len(attrs)*2)
+	for _, a := range attrs {
+		out = append(out, a.Key, a.Value.Any())
+	}
+	return out
+}
+
+func (d *defaultSlogLogger) Report(event ConnLogEvent, conn *Connection) {
+	level, msg, attrs := eventToSlog(event, conn)
+	args := attrsToAny(attrs)
+	ctx := context.Background()
+	switch level {
+	case slog.LevelError:
+		d.l.Error(msg, args...)
+	case slog.LevelWarn:
+		d.l.Warn(msg, args...)
+	case slog.LevelInfo:
+		d.l.Info(msg, args...)
+	case slog.LevelDebug:
+		d.l.Debug(msg, args...)
+	default:
+		d.l.Log(ctx, level, msg, args...)
+	}
+}
+
+func eventToSlog(event ConnLogEvent, conn *Connection) (slog.Level, string, []slog.Attr) {
+	addr := "<nil>"
+	if conn != nil && conn.Addr() != nil {
+		addr = fmt.Sprintf("%s", conn.Addr())
+	}
+
+	switch e := event.(type) {
 	case LogReconnectFailed:
-		reconnects := v[0].(uint)
-		err := v[1].(error)
-		addr := conn.Addr()
-		if addr == nil {
-			log.Printf("tarantool: connect (%d/%d) failed: %s",
-				reconnects, conn.opts.MaxReconnects, err)
-		} else {
-			log.Printf("tarantool: reconnect (%d/%d) to %s failed: %s",
-				reconnects, conn.opts.MaxReconnects, addr, err)
+		msg := "tarantool: reconnect failed"
+		attrs := []slog.Attr{
+			slog.Int("reconnects", int(e.Reconnects)),
+			slog.Int("max_reconnects", int(e.MaxReconnects)),
+			slog.String("addr", addr),
+		}
+		if e.Err != nil {
+			attrs = append(attrs, slog.String("error", e.Err.Error()))
 		}
+		return slog.LevelWarn, msg, attrs
+
 	case LogLastReconnectFailed:
-		err := v[0].(error)
-		addr := conn.Addr()
-		if addr == nil {
-			log.Printf("tarantool: last connect failed: %s, giving it up",
-				err)
-		} else {
-			log.Printf("tarantool: last reconnect to %s failed: %s, giving it up",
-				addr, err)
+		msg := "tarantool: last reconnect failed, giving it up"
+		attrs := []slog.Attr{slog.String("addr", addr)}
+		if e.Err != nil {
+			attrs = append(attrs, slog.String("error", e.Err.Error()))
+		}
+		return slog.LevelError, msg, attrs
+
+	case LogUnexpectedResultID:
+		msg := "tarantool: unexpected response request id (probably cancelled request)"
+		attrs := []slog.Attr{
+			slog.String("addr", addr),
+			slog.Uint64("request_id", e.Header.RequestId),
 		}
-	case LogUnexpectedResultId:
-		header := v[0].(Header)
-		log.Printf("tarantool: connection %s got unexpected request ID (%d) in response "+
-			"(probably cancelled request)",
-			conn.Addr(), header.RequestId)
+		return slog.LevelWarn, msg, attrs
+
 	case LogWatchEventReadFailed:
-		err := v[0].(error)
-		log.Printf("tarantool: unable to parse watch event: %s", err)
+		msg := "tarantool: unable to parse watch event"
+		attrs := []slog.Attr{}
+		if e.Err != nil {
+			attrs = append(attrs, slog.String("error", e.Err.Error()))
+		}
+		return slog.LevelWarn, msg, attrs
+
 	case LogBoxSessionPushUnsupported:
-		header := v[0].(Header)
-		log.Printf("tarantool: unsupported box.session.push() for request %d", header.RequestId)
+		msg := "tarantool: unsupported box.session.push()"
+		attrs := []slog.Attr{slog.Uint64("request_id", e.Header.RequestId), slog.String("addr", addr)}
+		return slog.LevelInfo, msg, attrs
+
 	default:
-		args := append([]interface{}{"tarantool: unexpected event ", event, conn}, v...)
-		log.Print(args...)
+		// unknown event: log type and value
+		return slog.LevelInfo, "tarantool: unexpected event", []slog.Attr{slog.Any("event", event), slog.String("addr", addr)}
 	}
 }