wip: user stuff

pkg/api/api.go

@@ -5,9 +5,9 @@ import (
 	"crypto/tls"
 	"fmt"
 	"loveuer/utodo/pkg/handler"
+	"loveuer/utodo/pkg/logger"
 	"net"
 
-	"gitea.loveuer.com/yizhisec/packages/logger"
 	"github.com/gofiber/fiber/v3"
 	l3 "github.com/gofiber/fiber/v3/middleware/logger"
 	r3 "github.com/gofiber/fiber/v3/middleware/recover"
@@ -80,6 +80,9 @@ func Start(ctx context.Context, opts ...Option) (func(context.Context) error, er
 	}
 
 	if opt.app == nil {
+		logger.WarnCtx(ctx, "app is nil, use default app!!!")
+		logger.WarnCtx(ctx, "app is nil, use default app!!!")
+		logger.WarnCtx(ctx, "app is nil, use default app!!!")
 		opt.app = fiber.New(fiber.Config{BodyLimit: 1024 * 1024 * 5})
 		opt.app.Use(l3.New())
 		opt.app.Use(r3.New())

pkg/logger/ctx.go

@@ -0,0 +1,56 @@
+package logger
+
+import (
+	"context"
+
+	uuid2 "github.com/google/uuid"
+)
+
+type ctxKey struct{}
+
+var (
+	CtxKey = ctxKey{}
+)
+
+func traceId(ctx context.Context) string {
+	if ctx == nil {
+		uuid, _ := uuid2.NewV7()
+		return uuid.String()
+	}
+
+	if id, _ := ctx.Value(CtxKey).(string); id != "" {
+		return id
+	}
+
+	uuid, _ := uuid2.NewV7()
+	return uuid.String()
+}
+
+func DebugCtx(ctx context.Context, msg string, data ...any) {
+	msg = traceId(ctx) + " | " + msg
+	DefaultLogger.Debug(msg, data...)
+}
+func InfoCtx(ctx context.Context, msg string, data ...any) {
+	msg = traceId(ctx) + " | " + msg
+	DefaultLogger.Info(msg, data...)
+}
+
+func WarnCtx(ctx context.Context, msg string, data ...any) {
+	msg = traceId(ctx) + " | " + msg
+	DefaultLogger.Warn(msg, data...)
+}
+
+func ErrorCtx(ctx context.Context, msg string, data ...any) {
+	msg = traceId(ctx) + " | " + msg
+	DefaultLogger.Error(msg, data...)
+}
+
+func PanicCtx(ctx context.Context, msg string, data ...any) {
+	msg = traceId(ctx) + " | " + msg
+	DefaultLogger.Panic(msg, data...)
+}
+
+func FatalCtx(ctx context.Context, msg string, data ...any) {
+	msg = traceId(ctx) + " | " + msg
+	DefaultLogger.Fatal(msg, data...)
+}

pkg/logger/default.go

@@ -0,0 +1,97 @@
+package logger
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+)
+
+var (
+	pool = &sync.Pool{
+		New: func() any {
+			return &strings.Builder{}
+		},
+	}
+	nilLogger    = func(prefix, timestamp, msg string, data ...any) {}
+	normalLogger = func(prefix, timestamp, msg string, data ...any) {
+		buf := pool.Get().(*strings.Builder)
+		buf.Reset()
+		buf.WriteString(prefix)
+		buf.WriteString(" | ")
+		buf.WriteString(timestamp)
+		buf.WriteString(" | ")
+		buf.WriteString(msg)
+		buf.WriteString("\n")
+		fmt.Printf(buf.String(), data...)
+	}
+
+	panicLogger = func(prefix, timestamp, msg string, data ...any) {
+		buf := pool.Get().(*strings.Builder)
+		buf.Reset()
+		buf.WriteString(prefix)
+		buf.WriteString(" | ")
+		buf.WriteString(timestamp)
+		buf.WriteString(" | ")
+		buf.WriteString(msg)
+		buf.WriteString("\n")
+		panic(buf.String())
+	}
+
+	fatalLogger = func(prefix, timestamp, msg string, data ...any) {
+		buf := pool.Get().(*strings.Builder)
+		buf.Reset()
+		buf.WriteString(prefix)
+		buf.WriteString(" | ")
+		buf.WriteString(timestamp)
+		buf.WriteString(" | ")
+		buf.WriteString(msg)
+		buf.WriteString("\n")
+		fmt.Printf(buf.String(), data...)
+		os.Exit(1)
+	}
+
+	DefaultLogger = &logger{
+		Mutex:      sync.Mutex{},
+		timeFormat: "2006-01-02T15:04:05",
+		writer:     os.Stdout,
+		level:      LogLevelInfo,
+		debug:      nilLogger,
+		info:       normalLogger,
+		warn:       normalLogger,
+		error:      normalLogger,
+		panic:      panicLogger,
+		fatal:      fatalLogger,
+	}
+)
+
+func SetTimeFormat(format string) {
+	DefaultLogger.SetTimeFormat(format)
+}
+
+func SetLogLevel(level LogLevel) {
+	DefaultLogger.SetLogLevel(level)
+}
+
+func Debug(msg string, data ...any) {
+	DefaultLogger.Debug(msg, data...)
+}
+func Info(msg string, data ...any) {
+	DefaultLogger.Info(msg, data...)
+}
+
+func Warn(msg string, data ...any) {
+	DefaultLogger.Warn(msg, data...)
+}
+
+func Error(msg string, data ...any) {
+	DefaultLogger.Error(msg, data...)
+}
+
+func Panic(msg string, data ...any) {
+	DefaultLogger.Panic(msg, data...)
+}
+
+func Fatal(msg string, data ...any) {
+	DefaultLogger.Fatal(msg, data...)
+}

pkg/logger/logger.go

@@ -0,0 +1,116 @@
+package logger
+
+import (
+	"io"
+	"sync"
+	"time"
+
+	"github.com/fatih/color"
+)
+
+type LogLevel uint32
+
+const (
+	LogLevelDebug = iota
+	LogLevelInfo
+	LogLevelWarn
+	LogLevelError
+	LogLevelPanic
+	LogLevelFatal
+)
+
+type logger struct {
+	sync.Mutex
+	timeFormat string
+	writer     io.Writer
+	level      LogLevel
+	debug      func(prefix, timestamp, msg string, data ...any)
+	info       func(prefix, timestamp, msg string, data ...any)
+	warn       func(prefix, timestamp, msg string, data ...any)
+	error      func(prefix, timestamp, msg string, data ...any)
+	panic      func(prefix, timestamp, msg string, data ...any)
+	fatal      func(prefix, timestamp, msg string, data ...any)
+}
+
+var (
+	red    = color.New(color.FgRed)
+	hired  = color.New(color.FgHiRed)
+	green  = color.New(color.FgGreen)
+	yellow = color.New(color.FgYellow)
+	white  = color.New(color.FgWhite)
+)
+
+func (l *logger) SetTimeFormat(format string) {
+	l.Lock()
+	defer l.Unlock()
+	l.timeFormat = format
+}
+
+func (l *logger) SetLogLevel(level LogLevel) {
+	l.Lock()
+	defer l.Unlock()
+
+	if level > LogLevelDebug {
+		l.debug = nilLogger
+	} else {
+		l.debug = normalLogger
+	}
+
+	if level > LogLevelInfo {
+		l.info = nilLogger
+	} else {
+		l.info = normalLogger
+	}
+
+	if level > LogLevelWarn {
+		l.warn = nilLogger
+	} else {
+		l.warn = normalLogger
+	}
+
+	if level > LogLevelError {
+		l.error = nilLogger
+	} else {
+		l.error = normalLogger
+	}
+
+	if level > LogLevelPanic {
+		l.panic = nilLogger
+	} else {
+		l.panic = panicLogger
+	}
+
+	if level > LogLevelFatal {
+		l.fatal = nilLogger
+	} else {
+		l.fatal = fatalLogger
+	}
+}
+
+func (l *logger) Debug(msg string, data ...any) {
+	l.debug(white.Sprint("Debug "), time.Now().Format(l.timeFormat), msg, data...)
+}
+
+func (l *logger) Info(msg string, data ...any) {
+	l.info(green.Sprint("Info  "), time.Now().Format(l.timeFormat), msg, data...)
+}
+
+func (l *logger) Warn(msg string, data ...any) {
+	l.warn(yellow.Sprint("Warn  "), time.Now().Format(l.timeFormat), msg, data...)
+}
+
+func (l *logger) Error(msg string, data ...any) {
+	l.error(red.Sprint("Error "), time.Now().Format(l.timeFormat), msg, data...)
+}
+
+func (l *logger) Panic(msg string, data ...any) {
+	l.panic(hired.Sprint("Panic "), time.Now().Format(l.timeFormat), msg, data...)
+}
+
+func (l *logger) Fatal(msg string, data ...any) {
+	l.fatal(hired.Sprint("Fatal "), time.Now().Format(l.timeFormat), msg, data...)
+}
+
+type WroteLogger interface {
+	Info(msg string, data ...any)
+}

pkg/logger/new.go

@@ -0,0 +1,21 @@
+package logger
+
+import (
+	"os"
+	"sync"
+)
+
+func New() *logger {
+	return &logger{
+		Mutex:      sync.Mutex{},
+		timeFormat: "2006-01-02T15:04:05",
+		writer:     os.Stdout,
+		level:      LogLevelInfo,
+		debug:      nilLogger,
+		info:       normalLogger,
+		warn:       normalLogger,
+		error:      normalLogger,
+		panic:      panicLogger,
+		fatal:      fatalLogger,
+	}
+}

pkg/middleware/logger/logger.go

@@ -0,0 +1,9 @@
+package logger
+
+import "github.com/gofiber/fiber/v3"
+
+func New() fiber.Handler {
+	return func(c fiber.Ctx) error {
+		return c.Next()
+	}
+}

pkg/middleware/trace/trace.go

@@ -0,0 +1,65 @@
+package trace
+
+import (
+	"context"
+	"loveuer/utodo/pkg/logger"
+	"strconv"
+	"time"
+
+	"github.com/gofiber/fiber/v3"
+	"github.com/google/uuid"
+)
+
+type Option func(*option)
+
+type option struct {
+	traceKey string
+	traceFn  func(c fiber.Ctx) string
+}
+
+func WithTraceKey(key string) Option {
+	return func(o *option) {
+		if key != "" {
+			o.traceKey = key
+		}
+	}
+}
+
+func WithTraceFn(fn func(c fiber.Ctx) string) Option {
+	return func(o *option) {
+		if fn != nil {
+			o.traceFn = fn
+		}
+	}
+}
+
+func New(opts ...Option) fiber.Handler {
+	opt := &option{
+		traceKey: "X-Trace-Id",
+		traceFn: func(c fiber.Ctx) string {
+			uid, err := uuid.NewV7()
+			if err != nil {
+				return strconv.FormatInt(time.Now().UnixNano(), 10)
+			}
+
+			return uid.String()
+		},
+	}
+
+	for _, o := range opts {
+		o(opt)
+	}
+
+	return func(c fiber.Ctx) error {
+		traceId := c.Get(opt.traceKey)
+		if traceId == "" {
+			traceId = opt.traceFn(c)
+			c.Request().Header.Set(opt.traceKey, traceId)
+		}
+
+		c.SetContext(context.WithValue(c.Context(), logger.CtxKey, traceId))
+		c.Set(opt.traceKey, traceId)
+
+		return c.Next()
+	}
+}