log.go

package log

import (
	"context"
	"errors"
	"fmt"
	"path/filepath"
	"strings"
	"sync"

	"github.com/gogf/gf/v2/os/glog"
)

type LogLevel int

const (
	LEVEL_ALL  LogLevel = LEVEL_DEBU | LEVEL_INFO | LEVEL_NOTI | LEVEL_WARN | LEVEL_ERRO | LEVEL_CRIT
	LEVEL_DEV  LogLevel = LEVEL_ALL
	LEVEL_PROD LogLevel = LEVEL_WARN | LEVEL_ERRO | LEVEL_CRIT
	LEVEL_NONE LogLevel = 0
	LEVEL_DEBU LogLevel = 1 << iota // 16
	LEVEL_INFO                      // 32
	LEVEL_NOTI                      // 64
	LEVEL_WARN                      // 128
	LEVEL_ERRO                      // 256
	LEVEL_CRIT                      // 512
	LEVEL_PANI                      // 1024
	LEVEL_FATA                      // 2048
)

var DebugMode bool

type LogCtx string

const (
	CtxMark LogCtx = "mark"
)

var ctx = context.Background()

// 添加一个简单的LRU缓存来存储具有相同mark的Log实例
type simpleLRUCache struct {
	mu    sync.RWMutex
	cache map[string]*Log
	cap   int
}

func newSimpleLRUCache(cap int) *simpleLRUCache {
	return &simpleLRUCache{
		cache: make(map[string]*Log),
		cap:   cap,
	}
}

func (c *simpleLRUCache) get(key string) (*Log, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	log, ok := c.cache[key]
	return log, ok
}

func (c *simpleLRUCache) put(key string, log *Log) {
	c.mu.Lock()
	defer c.mu.Unlock()

	if len(c.cache) >= c.cap && !c.contains(key) {
		// 简单地删除第一个元素，实际LRU会更复杂，但这里简化处理
		for k := range c.cache {
			delete(c.cache, k)
			break
		}
	}

	c.cache[key] = log
}

func (c *simpleLRUCache) contains(key string) bool {
	_, ok := c.cache[key]
	return ok
}

// 创建一个容量为100的LRU缓存
var logCache = newSimpleLRUCache(100)

type Log struct {
	ctx    context.Context
	logger *glog.Logger
}

func (l *Log) Ctx(ctx context.Context) *Log {
	var mark string
	if l.ctx != nil {
		mark, _ = ctx.Value(CtxMark).(string)
	}
	if mark != "" {
		l.ctx = context.WithValue(ctx, CtxMark, mark)
	} else {
		l.ctx = ctx
	}
	return l
}

func (l *Log) Debug(args ...any) {
	l.logger.Debug(l.ctx, args...)
}

func (l *Log) Debugln(args ...any) {
	l.logger.Debug(l.ctx, args...)
}

func (l *Log) Debugf(format string, args ...any) {
	format = trimFormat(format)
	l.logger.Debugf(l.ctx, format, args...)
}

func (l *Log) Print(args ...any) {
	l.logger.Info(l.ctx, args...)
}

func (l *Log) Println(args ...any) {
	l.logger.Info(l.ctx, args...)
}

func (l *Log) Printf(format string, args ...any) {
	format = trimFormat(format)
	l.logger.Infof(l.ctx, format, args...)
}

func (l *Log) Info(args ...any) {
	l.logger.Info(l.ctx, args...)
}

func (l *Log) Infoln(args ...any) {
	l.logger.Info(l.ctx, args...)
}

func (l *Log) Infof(format string, args ...any) {
	format = trimFormat(format)
	l.logger.Infof(l.ctx, format, args...)
}

func (l *Log) Notice(args ...any) {
	l.logger.Notice(l.ctx, args...)
}

func (l *Log) Noticeln(args ...any) {
	l.logger.Notice(l.ctx, args...)
}

func (l *Log) Noticef(format string, args ...any) {
	format = trimFormat(format)
	l.logger.Noticef(l.ctx, format, args...)
}

func (l *Log) Fatal(args ...any) {
	l.logger.Fatal(l.ctx, args...)
}

func (l *Log) Fatalln(args ...any) {
	l.logger.Fatal(l.ctx, args...)
}

func (l *Log) Fatalf(format string, args ...any) {
	format = trimFormat(format)
	l.logger.Fatalf(l.ctx, format, args...)
}

func (l *Log) Panic(args ...any) {
	l.logger.Panic(l.ctx, args...)
}

func (l *Log) Panicln(args ...any) {
	l.logger.Panic(l.ctx, args...)
}

func (l *Log) Panicf(format string, args ...any) {
	format = trimFormat(format)
	l.logger.Panicf(l.ctx, format, args...)
}

func (l *Log) Critical(args ...any) {
	l.logger.Critical(l.ctx, args...)
}

func (l *Log) Criticalln(args ...any) {
	l.logger.Critical(l.ctx, args...)
}

func (l *Log) Criticalf(format string, args ...any) {
	format = trimFormat(format)
	l.logger.Criticalf(l.ctx, format, args...)
}

func (l *Log) Trace(traceID string) *Log {
	l.ctx = context.WithValue(ctx, CtxMark, traceID)
	return l
}

func (l *Log) Error(args ...any) error {
	l.logger.Error(l.ctx, args...)
	return errors.New(fmt.Sprint(args...))
}

func (l *Log) Errorln(args ...any) error {
	l.logger.Error(l.ctx, args...)
	return errors.New(fmt.Sprint(args...))
}

func (l *Log) Errorf(format string, args ...any) error {
	format = trimFormat(format)
	l.logger.Errorf(l.ctx, format, args...)
	return fmt.Errorf(format, args...)
}

func (l *Log) Warn(args ...any) {
	l.logger.Warning(l.ctx, args...)
}

func (l *Log) Warnln(args ...any) {
	l.logger.Warning(l.ctx, args...)
}

func (l *Log) Warnf(format string, args ...any) {
	format = trimFormat(format)
	l.logger.Warningf(l.ctx, format, args...)
}

func (l *Log) IsError(err error) bool {
	if err != nil {
		glog.Error(l.ctx, err)
	}
	return err != nil
}

func (l *Log) Logger(logger *glog.Logger) *Log {
	l.logger = logger
	return l
}

func (l *Log) File(file string) *Log {
	l.logger.SetFile(file + "-{Y-m-d}.log")
	registerLogPaths.Store(filepath.Join(l.logger.GetPath(), file), true)
	return l
}

func (l *Log) NoStd() *Log {
	l.logger.SetStdoutPrint(false)
	return l
}

func (l *Log) SetLevel(level LogLevel) *Log {
	l.logger.SetLevel(int(level))
	return l
}

func (l *Log) Write(p []byte) (n int, err error) {
	for _, line := range strings.Split(string(p), "\n") {
		l.logger.Info(l.ctx, line)
	}
	return len(p), nil
}

func (l *Log) SetLogDir(logDir string) {
	l.logger.SetPath(logDir)
}

func (l *Log) SetLogFileName(logName string) {
	l.logger.SetFile(logName + "-{Y-m-d}.log")
	registerLogPaths.Store(filepath.Join(l.logger.GetPath(), logName), true)
}

func (l *Log) Skip(skip int) *Log {
	l.logger.SetStackSkip(skip)
	return l
}

func (l *Log) SetStack(enabled bool) *Log {
	l.logger.SetStack(enabled)
	return l
}

func (l *Log) PrintStack(ctx context.Context, skip ...int) {
	l.logger.PrintStack(ctx, skip...)
}

type LogOption struct {
	Debug    bool
	LogDir   string
	LogMark  string
	NoStdout bool
}

// 自动初始化基础配置
func init() {
	glog.SetCtxKeys(CtxMark)
	glog.SetFlags(glog.F_FILE_SHORT | glog.F_CALLER_FN)
	glog.DefaultLogger().SetStackSkip(1)
}

func Init(opt *LogOption) {
	if opt.Debug {
		DebugMode = true
		glog.DefaultLogger().SetLevel(glog.LEVEL_ALL)
	}
	if opt.LogMark == "" {
		opt.LogMark = "log"
	}
	glog.SetFile(opt.LogMark + "-{Y-m-d}.log")
	if opt.LogDir == "" {
		return
	}
	glog.DefaultLogger().SetStdoutPrint(!opt.NoStdout)
	glog.DefaultLogger().SetPath(opt.LogDir)
	registerLogPaths.Store(filepath.Join(opt.LogDir, opt.LogMark), true)
}

func SetDebug(debug bool) {
	if debug {
		DebugMode = true
		glog.DefaultLogger().SetLevel(glog.LEVEL_ALL)
	} else {
		DebugMode = false
		glog.DefaultLogger().SetLevel(glog.LEVEL_INFO)
	}
}

func SetLevel(level LogLevel) {
	glog.DefaultLogger().SetLevel(int(level))
}

func SetLogDir(logDir string) {
	glog.DefaultLogger().SetPath(logDir)
}

func SetLogFileName(logName string) {
	glog.DefaultLogger().SetFile(logName + "-{Y-m-d}.log")
}

func SetStack(enabled bool) {
	glog.SetStack(enabled)
}

func IsError(err error) bool {
	if err != nil {
		glog.Error(ctx, err)
	}
	return err != nil
}

func New(mark ...string) *Log {
	if len(mark) == 0 {
		return Ctx(ctx)
	}

	markStr := mark[0]

	// 尝试从缓存中获取Log实例
	if logInstance, ok := logCache.get(markStr); ok {
		return logInstance
	}

	// 如果缓存中没有，则创建新的Log实例
	newCtx := context.WithValue(ctx, CtxMark, markStr)
	logInstance := Ctx(newCtx)

	// 将新创建的Log实例放入缓存
	logCache.put(markStr, logInstance)

	return logInstance
}

func Trace(traceID string) *Log {
	return New(traceID)
}

func Skip(skip int) *Log {
	return New().Skip(skip)
}

func trimFormat(format string) string {
	if format == "" {
		return ""
	}
	if format[len(format)-1] == '\n' {
		return format[:len(format)-1]
	}
	return format
}

func PrintStack(ctx context.Context, skip ...int) {
	glog.PrintStack(ctx, skip...)
}