gologger/main.go

// Package gologger provides a simple logging implementation with multiple appenders and formatters.
// It supports console, file, and HTTP logging with customizable formats.
package gologger

import (
	"strings"
	"time"
)

const (
	NoLog = iota
	Error
	Warn
	Info
	Debug
	Trace
)

var logLevelMap map[string]int = map[string]int{
	"off":   NoLog,
	"error": Error,
	"warn":  Warn,
	"info":  Info,
	"debug": Debug,
	"trace": Trace,
}
var loggerMap map[string]*Logger = map[string]*Logger{}
var appenderFactoryMap map[string]func(LogAppenderConfig) *LoggerAppender = map[string]func(LogAppenderConfig) *LoggerAppender{}
var appenders map[string]*LoggerAppender = map[string]*LoggerAppender{}
var loggerConfig LoggersConfig = LoggersConfig{
	Appenders: map[string]LogAppenderConfig{
		"console": {
			Type:      "console",
			Formatter: "text",
			Options:   map[string]interface{}{},
		},
	},
	Categories: map[string]LogConfig{
		"default": {
			Level:     "error",
			Appenders: []string{"console"},
		},
	},
}

type LogAppenderConfig struct {
	Type      string                 `json:"type"`
	Formatter string                 `json:"formatter"`
	Options   map[string]interface{} `json:"options"`
}
type LogConfig struct {
	Level     string   `json:"level"`
	Appenders []string `json:"appenders"`
}

type LoggersConfig struct {
	Appenders  map[string]LogAppenderConfig `json:"appenders"`
	Categories map[string]LogConfig         `json:"categories"`
}
// Logger represents a logger instance for a specific category.
// It maintains the log level and appenders for that category.
// Example:
//  logger := GetLogger("mycategory")
//  logger.Info("This is an info message")
//  logger.Error("This is an error message")
type Logger struct {
	category  string
	level     int
	appenders []*LoggerAppender
}

type LogEvent struct {
	Category string        `json:"category"`
	Ts       time.Time     `json:"ts"`
	Level    int           `json:"level"`
	Data     []interface{} `json:"data"`
}

type LoggerAppender interface {
	GetName() string
	Append(logEvent LogEvent)
	Close()
}

var consoleAppender LoggerAppender = *makeConsoleAppender(LogAppenderConfig{})
var defaultLogger = &Logger{

	level:     Error,
	appenders: []*LoggerAppender{&consoleAppender},
}

func (l *Logger) log(Level int, msg []interface{}) {

	if Level <= l.level {
		now := time.Now()
		logEvent := LogEvent{l.category, now, Level, msg}
		for _, appender := range l.appenders {
			(*appender).Append(logEvent)
		}
		// l.Appender.Append(logEvent)
		// fmt.Println(now.Format("2006-01-02 15:04:05"), " ", l.Name, ": ", msg)
	}
}

func (l *Logger) Error(msg ...interface{}) {
	l.log(Error, msg)
}

func (l *Logger) Warn(msg ...interface{}) {
	l.log(Warn, msg)
}

func (l *Logger) Info(msg ...interface{}) {
	l.log(Info, msg)
}

func (l *Logger) Debug(msg ...interface{}) {
	l.log(Debug, msg)
}

func (l *Logger) Trace(msg ...interface{}) {
	l.log(Trace, msg)
}
func GetLogger(name string) *Logger {
	if logger, ok := loggerMap[name]; ok {
		return logger
	} else {
		logConfig, ok := loggerConfig.Categories[name]
		if ok {
			return makeLogger(name, logConfig)
		}
		logConfig, ok = loggerConfig.Categories["default"]
		l := makeLogger(name, logConfig)
		l.category = name
		loggerMap[name] = l
		return l
	}
}

func makeLogger(name string, config LogConfig) *Logger {
	logger := &Logger{category: name}
	levelstr := strings.ToLower(config.Level)
	logger.level = logLevelMap[levelstr]

	if len(config.Appenders) == 0 {
		logger.appenders = []*LoggerAppender{&consoleAppender}
	} else {
		logger.appenders = make([]*LoggerAppender, len(config.Appenders))
		for i, appenderName := range config.Appenders {
			logger.appenders[i] = appenders[appenderName]
		}
	}
	loggerMap[name] = logger
	return logger
}

func ReconfigLoggers(config LoggersConfig) {
	validateConfig(config)
	loggerConfig = config
	for name, appenderConfig := range loggerConfig.Appenders {
		oldappender, ok := appenders[name]
		if ok {
			(*oldappender).Close()
		}
		appenderFactory, ok := appenderFactoryMap[appenderConfig.Type]
		if ok {
			appenders[name] = appenderFactory(appenderConfig)
		} else {
			appenders[name] = &consoleAppender
		}
	}
	for name, logger := range loggerMap {
		logConfig, ok := loggerConfig.Categories[name]
		if !ok {
			logConfig, _ = loggerConfig.Categories["default"]
		}
		logger.level = logLevelMap[strings.ToLower(logConfig.Level)]
		if len(logConfig.Appenders) == 0 {
			logger.appenders = []*LoggerAppender{&consoleAppender}
		} else {
			logger.appenders = make([]*LoggerAppender, len(logConfig.Appenders))
			for i, appenderName := range logConfig.Appenders {
				logger.appenders[i] = appenders[appenderName]
			}
		}
	}
}
func validateConfig(config LoggersConfig) {
	_, ok := loggerConfig.Categories["default"]
	if !ok {
		panic("default logger config not found")
	}
}
func Configure(config LoggersConfig) {
	validateConfig(config)
	ReconfigLoggers(config)
}

func RegistAppender(typeName string, appenderCreatCb func(LogAppenderConfig) *LoggerAppender) {

	appenderFactoryMap[typeName] = appenderCreatCb
}

func init() {
	loggerMap["default"] = defaultLogger
}