refactor: core pkg uses slog

cli/root.go

@@ -23,7 +23,6 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/yomorun/yomo/cli/serverless"
 	"github.com/yomorun/yomo/pkg/file"
-	"github.com/yomorun/yomo/pkg/logger"
 )
 
 var (
@@ -35,13 +34,9 @@ var (
 
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
-	Use:     "yomo",
-	Version: GetVersion(),
-	PersistentPreRun: func(cmd *cobra.Command, args []string) {
-		if verbose {
-			logger.EnableDebug()
-		}
-	},
+	Use:              "yomo",
+	Version:          GetVersion(),
+	PersistentPreRun: func(cmd *cobra.Command, args []string) {},
 	// Run: func(cmd *cobra.Command, args []string) { },
 }
 

core/client.go

@@ -12,9 +12,9 @@ import (
 
 	"github.com/lucas-clemente/quic-go"
 	"github.com/yomorun/yomo/core/frame"
-	"github.com/yomorun/yomo/core/log"
 	"github.com/yomorun/yomo/core/yerr"
 	"github.com/yomorun/yomo/pkg/id"
+	"golang.org/x/exp/slog"
 )
 
 // ClientOption YoMo client options
@@ -37,7 +37,7 @@ type Client struct {
 	mu         sync.Mutex
 	opts       *clientOptions
 	localAddr  string // client local addr, it will be changed on reconnect
-	logger     log.Logger
+	logger     *slog.Logger
 	errc       chan error
 }
 
@@ -48,15 +48,18 @@ func NewClient(appName string, connType ClientType, opts ...ClientOption) *Clien
 	for _, o := range opts {
 		o(option)
 	}
+	clientID := id.New()
+
+	logger := option.logger.With("component", "client", "client_type", connType.String(), "client_id", clientID, "client_name", appName)
 
 	return &Client{
 		name:       appName,
-		clientID:   id.New(),
+		clientID:   clientID,
 		clientType: connType,
 		state:      ConnStateReady,
 		opts:       option,
 		errc:       make(chan error),
-		logger:     option.logger,
+		logger:     logger,
 	}
 }
 
@@ -121,12 +124,12 @@ func (c *Client) connect(ctx context.Context, addr string) error {
 	c.state = ConnStateConnected
 	c.localAddr = c.conn.LocalAddr().String()
 
-	c.logger.Printf("%s❤️  [%s][%s](%s) is connected to YoMo-Zipper %s", ClientLogPrefix, c.name, c.clientID, c.localAddr, addr)
+	c.logger.Debug("connected to YoMo-Zipper")
 
 	// receiving frames
 	go func() {
 		closeConn, closeClient, err := c.handleFrame()
-		c.logger.Debugf("%shandleFrame: %v, %v, %T, %v", ClientLogPrefix, closeConn, closeClient, err, err)
+		c.logger.Debug("connected to YoMo-Zipper", "close_conn", closeConn, "close_client", closeClient, "error", err)
 
 		c.mu.Lock()
 		defer c.mu.Unlock()
@@ -164,7 +167,7 @@ func (c *Client) handleFrame() (bool, bool, error) {
 			if err == io.EOF {
 				return true, false, err
 			} else if strings.HasPrefix(err.Error(), "unknown frame type") {
-				c.logger.Warnf("%s%v", ClientLogPrefix, err)
+				c.logger.Warn("unknown frame type", "error", err)
 				continue
 			} else if e, ok := err.(*quic.IdleTimeoutError); ok {
 				return false, false, e
@@ -179,7 +182,7 @@ func (c *Client) handleFrame() (bool, bool, error) {
 		// read frame
 		// first, get frame type
 		frameType := f.Type()
-		c.logger.Debugf("%shandleFrame: %v", ClientLogPrefix, frameType)
+		c.logger.Debug("handleFrame", "frame_type", frameType)
 		switch frameType {
 		case frame.TagOfRejectedFrame:
 			if v, ok := f.(*frame.RejectedFrame); ok {
@@ -192,21 +195,21 @@ func (c *Client) handleFrame() (bool, bool, error) {
 		case frame.TagOfDataFrame: // DataFrame carries user's data
 			if v, ok := f.(*frame.DataFrame); ok {
 				if c.processor == nil {
-					c.logger.Warnf("%sprocessor is nil", ClientLogPrefix)
+					c.logger.Warn("processor is nil")
 				} else {
 					c.processor(v)
 				}
 			}
 		case frame.TagOfBackflowFrame:
 			if v, ok := f.(*frame.BackflowFrame); ok {
 				if c.receiver == nil {
-					c.logger.Warnf("%sreceiver is nil", ClientLogPrefix)
+					c.logger.Warn("receiver is nil")
 				} else {
 					c.receiver(v)
 				}
 			}
 		default:
-			c.logger.Warnf("%sunknown or unsupported frame %#x", ClientLogPrefix, frameType)
+			c.logger.Warn("unknown or unsupported frame", "frame_type", frameType)
 		}
 	}
 }
@@ -228,7 +231,7 @@ func (c *Client) Close() error {
 }
 
 func (c *Client) close() error {
-	c.logger.Printf("%s💔 close the connection, name:%s, id:%s, addr:%s", ClientLogPrefix, c.name, c.clientID, c.addr)
+	c.logger.Info("close the connection")
 
 	// close error channel so that close handler function will be called
 	close(c.errc)
@@ -239,7 +242,7 @@ func (c *Client) close() error {
 
 // WriteFrame writes a frame to the connection, gurantee threadsafe.
 func (c *Client) WriteFrame(frm frame.Frame) error {
-	c.logger.Debugf("%s[%s](%s)@%s WriteFrame() will write frame: %s", ClientLogPrefix, c.name, c.localAddr, c.State(), frm.Type())
+	c.logger.Debug("close the connection", "client_state", c.State(), "frame_type", frm.Type().String())
 
 	if c.state != ConnStateConnected {
 		return errors.New("client connection isn't connected")
@@ -255,13 +258,13 @@ func (c *Client) WriteFrame(frm frame.Frame) error {
 // SetDataFrameObserver sets the data frame handler.
 func (c *Client) SetDataFrameObserver(fn func(*frame.DataFrame)) {
 	c.processor = fn
-	c.logger.Debugf("%sSetDataFrameObserver(%v)", ClientLogPrefix, c.processor)
+	c.logger.Debug("SetDataFrameObserver")
 }
 
 // SetBackflowFrameObserver sets the backflow frame handler.
 func (c *Client) SetBackflowFrameObserver(fn func(*frame.BackflowFrame)) {
 	c.receiver = fn
-	c.logger.Debugf("%sSetBackflowFrameObserver(%v)", ClientLogPrefix, c.receiver)
+	c.logger.Debug("SetBackflowFrameObserver")
 }
 
 // reconnect the connection between client and server.
@@ -272,7 +275,7 @@ func (c *Client) reconnect(ctx context.Context, addr string) {
 	for {
 		select {
 		case <-ctx.Done():
-			c.logger.Debugf("%s[%s](%s) context.Done()", ClientLogPrefix, c.name, c.localAddr)
+			c.logger.Debug("context.Done", "error", ctx.Err())
 			return
 		case err, ok := <-c.errc:
 			if c.errorfn != nil && err != nil {
@@ -287,10 +290,10 @@ func (c *Client) reconnect(ctx context.Context, addr string) {
 			state := c.state
 			c.mu.Unlock()
 			if state == ConnStateDisconnected {
-				c.logger.Printf("%s[%s][%s](%s) is reconnecting to YoMo-Zipper %s...", ClientLogPrefix, c.name, c.clientID, c.localAddr, addr)
+				c.logger.Info("reconnecting to YoMo-Zipper")
 				err := c.connect(ctx, addr)
 				if err != nil {
-					c.logger.Errorf("%s[%s][%s](%s) reconnect error:%v", ClientLogPrefix, c.name, c.clientID, c.localAddr, err)
+					c.logger.Error("reconnecting to YoMo-Zipper", err)
 				}
 			}
 		}
@@ -307,7 +310,7 @@ func (c *Client) SetObserveDataTags(tag ...frame.Tag) {
 }
 
 // Logger get client's logger instance, you can customize this using `yomo.WithLogger`
-func (c *Client) Logger() log.Logger {
+func (c *Client) Logger() *slog.Logger {
 	return c.logger
 }
 

core/client_options.go

@@ -7,9 +7,9 @@ import (
 	"github.com/lucas-clemente/quic-go"
 	"github.com/yomorun/yomo/core/auth"
 	"github.com/yomorun/yomo/core/frame"
-	"github.com/yomorun/yomo/core/log"
-	"github.com/yomorun/yomo/pkg/logger"
+	"github.com/yomorun/yomo/core/ylog"
 	pkgtls "github.com/yomorun/yomo/pkg/tls"
+	"golang.org/x/exp/slog"
 )
 
 // clientOptions are the options for YoMo client.
@@ -18,11 +18,11 @@ type clientOptions struct {
 	quicConfig      *quic.Config
 	tlsConfig       *tls.Config
 	credential      *auth.Credential
-	logger          log.Logger
+	logger          *slog.Logger
 }
 
 func defaultClientOption() *clientOptions {
-	logger := logger.Default()
+	logger := ylog.Default()
 
 	defalutQuicConfig := &quic.Config{
 		Versions:                       []quic.VersionNumber{quic.Version2},
@@ -45,7 +45,7 @@ func defaultClientOption() *clientOptions {
 	}
 
 	if opts.credential != nil {
-		logger.Printf("%suse credential: [%s]", ClientLogPrefix, opts.credential.Name())
+		logger.Info("use credential", "component", "client", "credential_name", opts.credential.Name())
 	}
 
 	return opts
@@ -82,7 +82,7 @@ func WithClientQuicConfig(qc *quic.Config) ClientOption {
 }
 
 // WithLogger sets logger for the client.
-func WithLogger(logger log.Logger) ClientOption {
+func WithLogger(logger *slog.Logger) ClientOption {
 	return func(o *clientOptions) {
 		o.logger = logger
 	}

core/client_test.go

@@ -12,8 +12,8 @@ import (
 	"github.com/yomorun/yomo/core/frame"
 	"github.com/yomorun/yomo/core/metadata"
 	"github.com/yomorun/yomo/core/router"
+	"github.com/yomorun/yomo/core/ylog"
 	"github.com/yomorun/yomo/pkg/config"
-	"github.com/yomorun/yomo/pkg/logger"
 )
 
 const testaddr = "127.0.0.1:19999"
@@ -64,7 +64,7 @@ func TestFrameRoundTrip(t *testing.T) {
 		WithObserveDataTags(obversedTag),
 		WithClientQuicConfig(DefalutQuicConfig),
 		WithClientTLSConfig(nil),
-		WithLogger(logger.Default()),
+		WithLogger(ylog.Default()),
 	)
 
 	source.SetBackflowFrameObserver(func(bf *frame.BackflowFrame) {

core/connection.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/yomorun/yomo/core/frame"
 	"github.com/yomorun/yomo/core/metadata"
-	"github.com/yomorun/yomo/pkg/logger"
+	"golang.org/x/exp/slog"
 )
 
 // Connection wraps the specific io connections (typically quic.Connection) to transfer y3 frames
@@ -36,9 +36,19 @@ type connection struct {
 	observed   []frame.Tag // observed data tags
 	mu         sync.Mutex
 	closed     bool
+	logger     *slog.Logger
 }
 
-func newConnection(name string, clientID string, clientType ClientType, metadata metadata.Metadata, stream io.ReadWriteCloser, observed []frame.Tag) Connection {
+func newConnection(
+	name string,
+	clientID string,
+	clientType ClientType,
+	metadata metadata.Metadata,
+	stream io.ReadWriteCloser,
+	observed []frame.Tag,
+	logger *slog.Logger,
+) Connection {
+	logger.Debug("new connecton")
 	return &connection{
 		name:       name,
 		clientID:   clientID,
@@ -82,7 +92,7 @@ func (c *connection) Write(f frame.Frame) error {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	if c.closed {
-		logger.Warnf("%sclient stream is closed: %s", ServerLogPrefix, c.clientID)
+		c.logger.Warn("client stream is closed")
 		return nil
 	}
 	_, err := c.stream.Write(f.Encode())

core/connector.go

@@ -4,7 +4,7 @@ import (
 	"sync"
 
 	"github.com/yomorun/yomo/core/frame"
-	"github.com/yomorun/yomo/pkg/logger"
+	"golang.org/x/exp/slog"
 )
 
 var _ Connector = &connector{}
@@ -26,22 +26,23 @@ type Connector interface {
 }
 
 type connector struct {
-	conns sync.Map
+	conns  sync.Map
+	logger *slog.Logger
 }
 
-func newConnector() Connector {
-	return &connector{conns: sync.Map{}}
+func newConnector(logger *slog.Logger) Connector {
+	return &connector{conns: sync.Map{}, logger: logger}
 }
 
 // Add a connection.
 func (c *connector) Add(connID string, conn Connection) {
-	logger.Debugf("%sconnector add: connID=%s", ServerLogPrefix, connID)
+	c.logger.Debug("connector add connection", "conn_id", connID)
 	c.conns.Store(connID, conn)
 }
 
 // Remove a connection.
 func (c *connector) Remove(connID string) {
-	logger.Debugf("%sconnector remove: connID=%s", ServerLogPrefix, connID)
+	c.logger.Debug("connector remove connection", "conn_id", connID)
 	c.conns.Delete(connID)
 }