golib/log/log.go

package log

import (
	"fmt"
	"io"
	"log"
	"os"
)

const (
	LevelError uint8 = iota
	LevelWarning
	LevelInfo
	LevelDebug
)

const (
	Flag = log.LstdFlags | log.Llongfile

	callDepth = 2
)

const (
	PrefixDebug   = "[D] "
	PrefixInfo    = "[I] "
	PrefixWarning = "[W] "
	PrefixError   = "[E] "
)

var (
	console      bool
	defaultLevel uint8
	closer       io.Closer
	client       *Client
)

var (
	socketDebug   = log.New(os.Stdout, PrefixDebug, Flag)
	socketInfo    = log.New(os.Stdout, PrefixInfo, Flag)
	socketWarning = log.New(os.Stderr, PrefixWarning, Flag)
	socketError   = log.New(os.Stderr, PrefixError, Flag)
)

func SetLevel(level uint8) {
	defaultLevel = level
}

func SetServerMod(address string) {
	var err error
	client, err = NewClient(address)
	if err != nil {
		panic(err)
	}
	client.CallDepth = callDepth + 1
	closer = client
}

func SetOutput(run, err io.WriteCloser) {
	lw := &loggerWrite{
		run: run,
		err: err,
	}
	socketDebug.SetOutput(lw)
	socketInfo.SetOutput(lw)
	socketWarning.SetOutput(lw)
	socketError.SetOutput(lw)
	closer = lw
}

func SetConsole(r bool) {
	console = r
}

func Close() error {
	if closer == nil {
		return nil
	}
	return closer.Close()
}

func Debug(f string, v ...any) {
	if defaultLevel < LevelDebug {
		return
	}
	if client != nil {
		client.Debug(f, v...)
	} else {
		_ = socketDebug.Output(callDepth, fmt.Sprintf(f, v...))
	}
}

func Info(f string, v ...any) {
	if defaultLevel < LevelInfo {
		return
	}
	if client != nil {
		client.Info(f, v...)
	} else {
		_ = socketInfo.Output(callDepth, fmt.Sprintf(f, v...))
	}
}

func Warning(f string, v ...any) {
	if defaultLevel < LevelWarning {
		return
	}
	if client != nil {
		client.Warning(f, v...)
	} else {
		_ = socketWarning.Output(callDepth, fmt.Sprintf(f, v...))
	}
}

func Error(f string, v ...any) {
	if defaultLevel < LevelError {
		return
	}
	if client != nil {
		client.Error(f, v...)
	} else {
		_ = socketError.Output(callDepth, fmt.Sprintf(f, v...))
	}
}

func Panic(f string, v ...any) {
	s := fmt.Sprintf(f, v...)
	if client != nil {
		client.Error(f, v...)
	} else {
		_ = socketError.Output(callDepth, s)
	}
	_ = Close()
	panic(s)
}

func Fatal(f string, v ...any) {
	if client != nil {
		client.Error(f, v...)
	} else {
		_ = socketError.Output(callDepth, fmt.Sprintf(f, v...))
	}
	_ = Close()
	os.Exit(1)
}

type loggerWrite struct {
	closed bool
	run    io.WriteCloser
	err    io.WriteCloser
}

func (l *loggerWrite) Write(p []byte) (n int, err error) {
	if l.closed {
		return 0, nil
	}
	if console {
		_, _ = os.Stdout.Write(p)
	}

	n, err = l.run.Write(p)

	level := string(p[:4])
	if level == PrefixWarning || level == PrefixError {
		n, err = l.err.Write(p)
	}
	return
}

func (l *loggerWrite) Close() error {
	if l.closed {
		return nil
	}
	_ = l.run.Close()
	_ = l.err.Close()
	return nil
}

func init() {
	console = true
	defaultLevel = LevelDebug
}