slog/slog.go

package slog

import (
	"fmt"
	"io"
	"path/filepath"
	"runtime"
	"time"
)

type SLogLogI interface {
	io.WriteCloser
	WriteE(p []byte) (int, error)
}

type SLogFormatFct func(level SLogLevel, verbose bool, timeformat string, format string, a ...interface{}) string

func defaultSLogFormatFct(level SLogLevel, verbose bool, timeformat string, format string, a ...interface{}) string {
	msg := fmt.Sprintf("%s - ", SLogLevelToString(level))
	if timeformat != "" {
		t := time.Now()
		msg = fmt.Sprintf("%s - %s", t.Format(timeformat), msg)
	}
	if verbose {
		if fct, file, line, ok := runtime.Caller(3); ok {
			msg = msg + fmt.Sprintf("{File: %s, Line: %d, Function: %s} - ", filepath.Base(file), line, runtime.FuncForPC(fct).Name())
		}
	}

	msg = fmt.Sprintf(msg+format, a...)
	return msg
}

type SLogLevel int

const (
	ERROR SLogLevel = iota
	WARN
	INFO
	DEBUG
)

func GetSLogLevel(level string) SLogLevel {
	switch level {
	case "ERROR":
		return ERROR
	case "WARN":
		return WARN
	case "INFO":
		return INFO
	case "DEBUG":
		return DEBUG
	default:
		return ERROR
	}
}

func SLogLevelToString(level SLogLevel) string {
	switch level {
	case ERROR:
		return "ERROR"
	case WARN:
		return "WARN"
	case INFO:
		return "INFO"
	case DEBUG:
		return "DEBUG"
	default:
		return "ERROR"
	}
}

type SLogger struct {
	level      SLogLevel
	verbose    bool
	formatfct  SLogFormatFct
	timeformat string
	loggers    []SLogLogI
}

func NewSLogger() (ret *SLogger) {
	ret = &SLogger{}
	ret.level = ERROR
	ret.verbose = false
	ret.timeformat = "2006-01-02 15:04:05 MST"
	ret.formatfct = defaultSLogFormatFct
	ret.loggers = []SLogLogI{NewStdoutLogger()}

	return ret
}

var defaultSLog = NewSLogger()

func (sl *SLogger) log(level SLogLevel, format string, a ...interface{}) {
	if level > sl.level {
		return
	}
	msg := sl.formatfct(level, sl.verbose, sl.timeformat, format, a...)

	for _, l := range sl.loggers {
		if level == ERROR {
			l.WriteE([]byte(msg))
		} else {
			l.Write([]byte(msg))
		}
	}
}

func LOG_ERRORF(format string, a ...interface{}) {
	defaultSLog.log(ERROR, format, a...)
}

func LOG_ERRORFLN(format string, a ...interface{}) {
	defaultSLog.log(ERROR, fmt.Sprintf(format+"\n", a...))
}

func LOG_ERROR(a ...interface{}) {
	defaultSLog.log(ERROR, fmt.Sprint(a...))
}

func LOG_ERRORLN(a ...interface{}) {
	defaultSLog.log(ERROR, fmt.Sprintln(a...))
}

func LOG_WARNF(format string, a ...interface{}) {
	defaultSLog.log(WARN, format, a...)
}

func LOG_WARNFLN(format string, a ...interface{}) {
	defaultSLog.log(WARN, fmt.Sprintf(format+"\n", a...))
}

func LOG_WARN(a ...interface{}) {
	defaultSLog.log(WARN, fmt.Sprint(a...))
}

func LOG_WARNLN(a ...interface{}) {
	defaultSLog.log(WARN, fmt.Sprintln(a...))
}

func LOG_INFOF(format string, a ...interface{}) {
	defaultSLog.log(INFO, format, a...)
}

func LOG_INFOFLN(format string, a ...interface{}) {
	defaultSLog.log(INFO, fmt.Sprintf(format+"\n", a...))
}

func LOG_INFO(a ...interface{}) {
	defaultSLog.log(INFO, fmt.Sprint(a...))
}

func LOG_INFOLN(a ...interface{}) {
	defaultSLog.log(INFO, fmt.Sprintln(a...))
}

func LOG_DEBUGF(format string, a ...interface{}) {
	defaultSLog.log(DEBUG, format, a...)
}

func LOG_DEBUGFLN(format string, a ...interface{}) {
	defaultSLog.log(DEBUG, fmt.Sprintf(format+"\n", a...))
}

func LOG_DEBUG(a ...interface{}) {
	defaultSLog.log(DEBUG, fmt.Sprint(a...))
}

func LOG_DEBUGLN(a ...interface{}) {
	defaultSLog.log(DEBUG, fmt.Sprintln(a...))
}

func SET_LEVEL(level SLogLevel) {
	defaultSLog.SetLevel(level)
}

func SET_FORMAT(fct SLogFormatFct) {
	defaultSLog.SetFormat(fct)
}

func SET_VERBOSE(verbose bool) {
	defaultSLog.SetVerbose(verbose)
}

func SET_TIMEFORMAT(timeformat string) {
	defaultSLog.SetTimeFormat(timeformat)
}

func ADD_LOGGER(logger SLogLogI) {
	defaultSLog.AddLogger(logger)
}

func SET_LOGGERS(loggers []SLogLogI) {
	defaultSLog.SetLoggers(loggers)
}

func CLEAR_LOGGERS() {
	defaultSLog.ClearLoggers()
}

func FINISH() {
	defaultSLog.Finish()
}

func (sl *SLogger) SetLevel(level SLogLevel) {
	sl.level = level
}

func (sl *SLogger) SetVerbose(verbose bool) {
	sl.verbose = verbose
}

func (sl *SLogger) SetFormat(fct SLogFormatFct) {
	sl.formatfct = fct
}

func (sl *SLogger) SetTimeFormat(format string) {
	sl.timeformat = format
}

func (sl *SLogger) AddLogger(logger SLogLogI) {
	sl.loggers = append(sl.loggers, logger)
}

func (sl *SLogger) SetLoggers(loggers []SLogLogI) {
	sl.loggers = loggers
}

func (sl *SLogger) ClearLoggers() {
	sl.loggers = []SLogLogI{}
}

func (sl *SLogger) Finish() {
	for _, l := range sl.loggers {
		l.Close()
	}
}