Merge pull request #2 from osspkg/dev

fix performance and add adapter for slog

Author: markus621

.golangci.yml

@@ -371,5 +371,5 @@ linters:
     - exportloopref
     - gci
     - gosec
-    - lll
+#    - lll
   fast: false

adapter_slog.go

@@ -0,0 +1,82 @@
+package logx
+
+import (
+	"context"
+	"io"
+	"log/slog"
+	"os"
+)
+
+var slogLevelMap = map[uint32]slog.Level{
+	LevelError: slog.LevelError,
+	LevelWarn:  slog.LevelWarn,
+	LevelInfo:  slog.LevelInfo,
+	LevelDebug: slog.LevelDebug,
+}
+
+type adapterSlog struct {
+	level   slog.Level
+	handler func(w io.Writer, level slog.Level) slog.Handler
+	log     *slog.Logger
+}
+
+func NewSLogJsonAdapter() Logger {
+	obj := &adapterSlog{
+		level: slog.LevelDebug,
+		handler: func(w io.Writer, level slog.Level) slog.Handler {
+			return slog.NewJSONHandler(w, &slog.HandlerOptions{
+				Level: level,
+			})
+		},
+	}
+	obj.SetOutput(os.Stdout)
+	return obj
+}
+
+func NewSLogStringAdapter() Logger {
+	obj := &adapterSlog{
+		level: slog.LevelDebug,
+		handler: func(w io.Writer, level slog.Level) slog.Handler {
+			return slog.NewTextHandler(w, &slog.HandlerOptions{
+				Level: level,
+			})
+		},
+	}
+	obj.SetOutput(os.Stdout)
+	return obj
+}
+
+func (v *adapterSlog) SetOutput(out io.Writer) {
+	v.log = slog.New(v.handler(out, v.level))
+}
+
+func (v *adapterSlog) SetFormatter(_ Formatter) {}
+
+func (v *adapterSlog) SetLevel(l uint32) {
+	level, ok := slogLevelMap[l]
+	if !ok {
+		level = slog.LevelDebug
+	}
+	v.log.Enabled(context.TODO(), level)
+}
+
+func (v *adapterSlog) Fatal(message string, args ...interface{}) {
+	v.log.Error(message, args...)
+	os.Exit(1)
+}
+
+func (v *adapterSlog) Error(message string, args ...interface{}) {
+	v.log.Error(message, args...)
+}
+
+func (v *adapterSlog) Warn(message string, args ...interface{}) {
+	v.log.Warn(message, args...)
+}
+
+func (v *adapterSlog) Info(message string, args ...interface{}) {
+	v.log.Info(message, args...)
+}
+
+func (v *adapterSlog) Debug(message string, args ...interface{}) {
+	v.log.Debug(message, args...)
+}

common.go

@@ -16,34 +16,22 @@ const (
 )
 
 var levels = map[uint32]string{
-	levelFatal: "FAT",
-	LevelError: "ERR",
-	LevelWarn:  "WRN",
-	LevelInfo:  "INF",
-	LevelDebug: "DBG",
-}
-
-type Sender interface {
-	SendMessage(level uint32, call func(v *Message))
-	Close()
-}
-
-// Writer interface
-type Writer interface {
-	Fatal(format string, args ...interface{})
-	Error(format string, args ...interface{})
-	Warn(format string, args ...interface{})
-	Info(format string, args ...interface{})
-	Debug(format string, args ...interface{})
+	levelFatal: "FATAL",
+	LevelError: "ERROR",
+	LevelWarn:  "WARN",
+	LevelInfo:  "INFO",
+	LevelDebug: "DEBUG",
 }
 
 // Logger base interface
 type Logger interface {
 	SetOutput(out io.Writer)
 	SetFormatter(f Formatter)
 	SetLevel(v uint32)
-	GetLevel() uint32
-	Close()
 
-	Writer
+	Fatal(message string, args ...interface{})
+	Error(message string, args ...interface{})
+	Warn(message string, args ...interface{})
+	Info(message string, args ...interface{})
+	Debug(message string, args ...interface{})
 }

default.go

@@ -5,9 +5,15 @@
 
 package logx
 
-import "io"
+import (
+	"io"
+)
 
-var std = New()
+var std Logger = New()
+
+func SetDefault(log Logger) {
+	std = log
+}
 
 // Default logger
 func Default() Logger {
@@ -23,21 +29,11 @@ func SetFormatter(f Formatter) {
 	std.SetFormatter(f)
 }
 
-// SetLevel change log level
+// SetLevel change Log level
 func SetLevel(v uint32) {
 	std.SetLevel(v)
 }
 
-// GetLevel getting log level
-func GetLevel() uint32 {
-	return std.GetLevel()
-}
-
-// Close waiting for all messages to finish recording
-func Close() {
-	std.Close()
-}
-
 // Info message
 func Info(format string, args ...interface{}) {
 	std.Info(format, args...)

formatter.go

@@ -7,93 +7,17 @@ package logx
 
 import (
 	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
+	"io"
 
 	"go.osspkg.com/ioutils/pool"
 )
 
-type Formatter interface {
-	Encode(m *Message) ([]byte, error)
-}
-
 var newLine = []byte("\n")
 
-// //////////////////////////////////////////////////////////////////////////////
-
-type FormatJSON struct{}
-
-func NewFormatJSON() *FormatJSON {
-	return &FormatJSON{}
-}
-
-func (*FormatJSON) Encode(m *Message) ([]byte, error) {
-	m.CtxToMap()
-	b, err := json.Marshal(m)
-	if err != nil {
-		return nil, err
-	}
-	return append(b, '\n'), nil
-}
-
-// //////////////////////////////////////////////////////////////////////////////
-
-var poolBuff = pool.New[*bytes.Buffer](func() *bytes.Buffer {
+var poolBuffer = pool.New[*bytes.Buffer](func() *bytes.Buffer {
 	return bytes.NewBuffer(make([]byte, 0, 1024))
 })
 
-type FormatString struct {
-	delim string
-}
-
-func NewFormatString() *FormatString {
-	return &FormatString{delim: "\t"}
-}
-
-func (v *FormatString) SetDelimiter(d string) {
-	v.delim = d
-}
-
-func (v *FormatString) Encode(m *Message) ([]byte, error) {
-	buff := poolBuff.Get()
-	defer func() {
-		poolBuff.Put(buff)
-	}()
-
-	fmt.Fprintf(buff, "time=%s%slvl=%s%smsg=%#v",
-		m.Time.Format(time.RFC3339), v.delim, m.Level, v.delim, m.Message)
-
-	if count := len(m.Ctx); count > 0 {
-		if count%2 != 0 {
-			m.Ctx = append(m.Ctx, nil)
-			count++
-		}
-		for i := 0; i < count; i = i + 2 {
-			fmt.Fprintf(buff, "%s%s=\"%s\"", v.delim, typing(m.Ctx[i]), typing(m.Ctx[i+1]))
-		}
-	}
-	buff.Write(newLine)
-
-	return append(make([]byte, 0, buff.Len()), buff.Bytes()...), nil
-}
-
-func typing(v interface{}) (s string) {
-	if v == nil {
-		s = "null"
-		return
-	}
-	switch vv := v.(type) {
-	case error:
-		s = vv.Error()
-	case fmt.GoStringer:
-		s = vv.GoString()
-	case fmt.Stringer:
-		s = vv.String()
-	default:
-		s = fmt.Sprintf("%#v", v)
-	}
-	s = strings.Trim(s, "\"")
-	return
+type Formatter interface {
+	Encode(w io.Writer, m *Message) error
 }

formatter_json.go

@@ -0,0 +1,51 @@
+package logx
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"go.osspkg.com/ioutils/pool"
+)
+
+type FormatJSON struct{}
+
+func NewFormatJSON() *FormatJSON {
+	return &FormatJSON{}
+}
+
+func (*FormatJSON) Encode(out io.Writer, m *Message) error {
+	m.CtxToMap()
+
+	w := poolJson.Get()
+	defer func() {
+		poolJson.Put(w)
+	}()
+
+	if err := w.Encoder.Encode(m); err != nil {
+		return fmt.Errorf("logx json encode: %w", err)
+	}
+	w.Buffer.Write(newLine)
+	if _, err := w.Buffer.WriteTo(out); err != nil {
+		return fmt.Errorf("logx json write: %w", err)
+	}
+	return nil
+}
+
+var poolJson = pool.New[*jsonWriter](func() *jsonWriter {
+	obj := &jsonWriter{
+		Buffer: bytes.NewBuffer(nil),
+	}
+	obj.Encoder = json.NewEncoder(obj.Buffer)
+	return obj
+})
+
+type jsonWriter struct {
+	Buffer  *bytes.Buffer
+	Encoder *json.Encoder
+}
+
+func (v *jsonWriter) Reset() {
+	v.Buffer.Reset()
+}