levellogger/levellogger.go

package levellogger

import (
	"io"
	"log"

	"runtime/debug"
)

func NewLevelLogger(out io.Writer, level LogLevel) *LevelLogger {

	ll := &LevelLogger{}

	ll.CurrentLevel = level

	ll.panicLog = log.New(out, "[PANIC]\t", log.Ldate|log.Ltime|log.Llongfile)
	ll.traceLog = log.New(out, "[TRACE]\t", log.Ldate|log.Ltime|log.Llongfile)
	ll.debugLog = log.New(out, "[DEBUG]\t", log.Ldate|log.Ltime|log.Llongfile)
	ll.infoLog = log.New(out, "[INFO]\t", log.Ldate|log.Ltime)
	ll.securityLog = log.New(out, "[SECURITY]\t", log.Ldate|log.Ltime)
	ll.warnLog = log.New(out, "[WARN]\t", log.Ldate|log.Ltime)
	ll.errorLog = log.New(out, "[ERROR]\t", log.Ldate|log.Ltime|log.Llongfile)
	ll.fatalLog = log.New(out, "[FATAL]\t", log.Ldate|log.Ltime|log.Llongfile)
	ll.blankLog = log.New(out, "", 0)

	return ll
}

// It's a log -- line output
// so only use Println versions

// always print panic and fatal log messages
func (ll *LevelLogger) Panic(v ...any) {
	ll.panicLog.Panicln(v...)
}

func (ll *LevelLogger) Panicf(format string, v ...any) {
	ll.panicLog.Panicf(format, v...)
}

func (ll *LevelLogger) Trace(v ...any) {
	if TraceLevel >= ll.CurrentLevel {
		ll.traceLog.Println(v...)
		ll.traceLog.Println(debug.Stack())
	}
}

func (ll *LevelLogger) Tracef(format string, v ...any) {
	if TraceLevel >= ll.CurrentLevel {
		ll.traceLog.Printf(format, v...)
		ll.traceLog.Println(debug.Stack())
	}
}

func (ll *LevelLogger) Debug(v ...any) {
	if DebugLevel >= ll.CurrentLevel {
		ll.debugLog.Println(v...)
	}
}

func (ll *LevelLogger) Debugf(format string, v ...any) {
	if DebugLevel >= ll.CurrentLevel {
		ll.debugLog.Printf(format, v...)
	}
}

func (ll *LevelLogger) Info(v ...any) {

	if InfoLevel >= ll.CurrentLevel {
		ll.infoLog.Println(v...)
	}
}

func (ll *LevelLogger) Infof(format string, v ...any) {
	if InfoLevel >= ll.CurrentLevel {
		ll.infoLog.Printf(format, v...)

	}
}

func (ll *LevelLogger) Secure(v ...any) {

	if SecurityLevel >= ll.CurrentLevel {
		ll.securityLog.Println(v...)
	}
}

func (ll *LevelLogger) Securef(format string, v ...any) {
	if SecurityLevel >= ll.CurrentLevel {
		ll.securityLog.Printf(format, v...)

	}
}

func (ll *LevelLogger) Warn(v ...any) {
	if WarnLevel >= ll.CurrentLevel {
		ll.warnLog.Println(v...)
	}
}

func (ll *LevelLogger) Warnf(format string, v ...any) {
	if WarnLevel >= ll.CurrentLevel {
		ll.warnLog.Printf(format, v...)
	}
}

func (ll *LevelLogger) Error(v ...any) {
	if ErrorLevel >= ll.CurrentLevel {
		ll.errorLog.Println(v...)
	}
}

func (ll *LevelLogger) Errorf(format string, v ...any) {
	if ErrorLevel >= ll.CurrentLevel {
		ll.errorLog.Printf(format, v...)
	}
}

func (ll *LevelLogger) Fatal(v ...any) {
	ll.fatalLog.Fatalln(v...)
}

func (ll *LevelLogger) Fatalf(format string, v ...any) {
	ll.fatalLog.Fatalf(format, v...)
}

// spelling: Panic, Trace, Debug, Info, Warn, Error, Fatal
func (ll *LevelLogger) SetPrefix(logname string, prefix string) {
	switch {
	case logname == "Panic":
		ll.panicLog.SetPrefix(prefix)
	case logname == "Trace":
		ll.traceLog.SetPrefix(prefix)
	case logname == "Debug":
		ll.debugLog.SetPrefix(prefix)
	case logname == "Info":
		ll.infoLog.SetPrefix(prefix)
	case logname == "Security":
		ll.securityLog.SetPrefix(prefix)
	case logname == "Warn":
		ll.warnLog.SetPrefix(prefix)
	case logname == "Error":
		ll.errorLog.SetPrefix(prefix)
	case logname == "Fatal":
		ll.fatalLog.SetPrefix(prefix)
	}
}

func (ll *LevelLogger) SetOutput(logname string, newout io.Writer) {
	switch {
	case logname == "Panic":
		ll.panicLog.SetOutput(newout)
	case logname == "Trace":
		ll.traceLog.SetOutput(newout)
	case logname == "Debug":
		ll.debugLog.SetOutput(newout)
	case logname == "Info":
		ll.infoLog.SetOutput(newout)
	case logname == "Security":
		ll.securityLog.SetOutput(newout)
	case logname == "Warn":
		ll.warnLog.SetOutput(newout)
	case logname == "Error":
		ll.errorLog.SetOutput(newout)
	case logname == "Fatal":
		ll.fatalLog.SetOutput(newout)
	}
}

func (ll *LevelLogger) SetFlags(logname string, newFlags int) {
	switch {
	case logname == "Panic":
		ll.panicLog.SetFlags(newFlags)
	case logname == "Trace":
		ll.traceLog.SetFlags(newFlags)
	case logname == "Debug":
		ll.debugLog.SetFlags(newFlags)
	case logname == "Info":
		ll.infoLog.SetFlags(newFlags)
	case logname == "Security":
		ll.securityLog.SetFlags(newFlags)
	case logname == "Warn":
		ll.warnLog.SetFlags(newFlags)
	case logname == "Error":
		ll.errorLog.SetFlags(newFlags)
	case logname == "Fatal":
		ll.fatalLog.SetFlags(newFlags)
	}
}

func (ll *LevelLogger) SetLoggingLevel(l int) {
	if l < 0 || l > 8 {
		ll.CurrentLevel = 4 // default
	} else {
		switch l {
		case 0:
			ll.CurrentLevel = LevelLoggerOff
		case 1:
			ll.CurrentLevel = PanicLevel
		case 2:
			ll.CurrentLevel = TraceLevel
		case 3:
			ll.CurrentLevel = DebugLevel
		case 4:
			ll.CurrentLevel = InfoLevel
		case 5:
			ll.CurrentLevel = SecurityLevel
		case 6:
			ll.CurrentLevel = WarnLevel
		case 7:
			ll.CurrentLevel = ErrorLevel
		case 8:
			ll.CurrentLevel = FatalLevel
		default:
			ll.CurrentLevel = InfoLevel
		}
	}
}

func (ll *LevelLogger) Blank(n int) {
	outs := " "
	if n < 1 {
		n = 1
	} else if n > 6 {
		n = 5
	}
	for i := 0; i < n; i++ {
		outs = outs + "\n"
	}
	ll.blankLog.Print(outs)
}

func (ll *LevelLogger) CheckFerr(e error, msg string) {
	if e != nil {
		ll.Fatal(e, msg)
	}
}