Compare commits
No commits in common. "v1.4.1" and "main" have entirely different histories.
6
go.sum
6
go.sum
@ -1,6 +0,0 @@
|
||||
github.com/tylerb/gls v0.0.0-20150407001822-e606233f194d h1:yYYPFFlbqxF5mrj5sEfETtM/Ssz2LTy0/VKlDdXYctc=
|
||||
github.com/tylerb/gls v0.0.0-20150407001822-e606233f194d/go.mod h1:0MwyId/pXK5wkYYEXe7NnVknX+aNBuF73fLV3U0reU8=
|
||||
github.com/tylerb/is v2.1.4+incompatible h1:BMf2zP0kY2Ykzx2W1fDrjwKj1x1B4E0mELkpjaNy1tM=
|
||||
github.com/tylerb/is v2.1.4+incompatible/go.mod h1:3Bw2NWEEe8Kx7/etYqgm9ug53iNDgabnloch75jjOSc=
|
||||
qoobing.com/gomod/str v1.0.1 h1:X+JOigE9xA6cTNph7/s1KeD4zLYM9XTLPPHQcpHFoog=
|
||||
qoobing.com/gomod/str v1.0.1/go.mod h1:gbhN2dba/P5gFRGVJvEI57KEJLlMHHAd6Kuuxn4GlMY=
|
||||
493
log.go
493
log.go
@ -3,371 +3,244 @@
|
||||
package log
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"runtime"
|
||||
"runtime/debug"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"runtime/debug"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"qoobing.com/gomod/str"
|
||||
"qoobing.com/gomod/str"
|
||||
)
|
||||
|
||||
const (
|
||||
PANIC LogLevel = 0
|
||||
FATAL LogLevel = 1
|
||||
ERROR LogLevel = 2
|
||||
NOTICE LogLevel = 3
|
||||
WARNING LogLevel = 4
|
||||
INFO LogLevel = 5
|
||||
DEBUG LogLevel = 9
|
||||
ErrLogLevel = "~~~~~invalid loglevel~~~~~"
|
||||
ErrLogPanic = "~~~~panic~~~~~~"
|
||||
PANIC LogLevel = 0
|
||||
FATAL LogLevel = 1
|
||||
ERROR LogLevel = 2
|
||||
NOTICE LogLevel = 3
|
||||
WARNING LogLevel = 4
|
||||
INFO LogLevel = 5
|
||||
DEBUG LogLevel = 9
|
||||
ErrLogLevel = "~~~~~invalid loglevel~~~~~"
|
||||
ErrLogPanic = "~~~~panic~~~~~~"
|
||||
)
|
||||
|
||||
var (
|
||||
mapStrToLevel = map[string]LogLevel{
|
||||
"PANIC": PANIC,
|
||||
"FATAL": FATAL,
|
||||
"ERROR": ERROR,
|
||||
"NOTICE": NOTICE,
|
||||
"WARNING": WARNING,
|
||||
"INFO": INFO,
|
||||
"DEBUG": DEBUG,
|
||||
}
|
||||
mapLevelToStr = map[LogLevel]string{
|
||||
PANIC: "PANIC",
|
||||
FATAL: "FATAL",
|
||||
ERROR: "ERROR",
|
||||
NOTICE: "NOTICE",
|
||||
WARNING: "WARNING",
|
||||
INFO: "INFO",
|
||||
DEBUG: "DEBUG",
|
||||
}
|
||||
mapStrToLevel = map[string]LogLevel{
|
||||
"PANIC": PANIC,
|
||||
"FATAL": FATAL,
|
||||
"ERROR": ERROR,
|
||||
"NOTICE": NOTICE,
|
||||
"WARNING": WARNING,
|
||||
"INFO": INFO,
|
||||
"DEBUG": DEBUG,
|
||||
}
|
||||
mapLevelToStr = map[LogLevel]string{
|
||||
PANIC: "PANIC",
|
||||
FATAL: "FATAL",
|
||||
ERROR: "ERROR",
|
||||
NOTICE: "NOTICE",
|
||||
WARNING: "WARNING",
|
||||
INFO: "INFO",
|
||||
DEBUG: "DEBUG",
|
||||
}
|
||||
)
|
||||
|
||||
var (
|
||||
golog *log.Logger = nil
|
||||
mylog *Logger = nil
|
||||
logidCreator LogidCreator = nil
|
||||
modulelogs map[string]*Logger = map[string]*Logger{}
|
||||
golog *log.Logger = nil
|
||||
mylog *Logger = nil
|
||||
logidCreator LogidCreator = nil
|
||||
modulelogs map[string]*Logger = map[string]*Logger{}
|
||||
)
|
||||
|
||||
type LogLevel int
|
||||
type Logger struct {
|
||||
module string
|
||||
golog *log.Logger
|
||||
loglevel LogLevel
|
||||
skipfunc func(string) bool
|
||||
calldepth int
|
||||
module string
|
||||
golog *log.Logger
|
||||
loglevel LogLevel
|
||||
}
|
||||
|
||||
type LogidCreator interface {
|
||||
Cleanup()
|
||||
GetLogid() string
|
||||
SetLogid(logid string)
|
||||
Cleanup()
|
||||
GetLogid() string
|
||||
SetLogid(logid string)
|
||||
}
|
||||
|
||||
func New(module string) *Logger {
|
||||
if module == "" {
|
||||
module = "undefine"
|
||||
}
|
||||
if _, ok := modulelogs[module]; ok {
|
||||
return modulelogs[module]
|
||||
} else {
|
||||
modulelogs[module] = &Logger{
|
||||
module: module,
|
||||
golog: golog,
|
||||
loglevel: DEBUG,
|
||||
}
|
||||
return modulelogs[module]
|
||||
}
|
||||
if module == "" {
|
||||
module = "undefine"
|
||||
}
|
||||
if _, ok := modulelogs[module]; ok {
|
||||
return modulelogs[module]
|
||||
} else {
|
||||
modulelogs[module] = &Logger{
|
||||
module: module,
|
||||
golog: golog,
|
||||
loglevel: DEBUG,
|
||||
}
|
||||
return modulelogs[module]
|
||||
}
|
||||
}
|
||||
|
||||
// SetLogLevel set new log level
|
||||
func (log *Logger) SetLogLevel(newlv LogLevel) (oldlv LogLevel) {
|
||||
oldlv = log.loglevel
|
||||
log.loglevel = newlv
|
||||
return oldlv
|
||||
oldlv = log.loglevel
|
||||
log.loglevel = newlv
|
||||
return oldlv
|
||||
}
|
||||
|
||||
// SetLogLevelByName set new log level by level name
|
||||
func (log *Logger) SetLogLevelByName(newlv string) (oldlv string) {
|
||||
if newlevel, ok := mapStrToLevel[newlv]; ok {
|
||||
oldlevel := log.loglevel
|
||||
log.loglevel = newlevel
|
||||
return mapLevelToStr[oldlevel]
|
||||
}
|
||||
return ErrLogLevel
|
||||
if newlevel, ok := mapStrToLevel[newlv]; ok {
|
||||
oldlevel := log.loglevel
|
||||
log.loglevel = newlevel
|
||||
return mapLevelToStr[oldlevel]
|
||||
}
|
||||
return ErrLogLevel
|
||||
}
|
||||
|
||||
// SetCalldepth adjust the call depth
|
||||
func (log *Logger) SetCalldepth(calldepth int) {
|
||||
log.calldepth = calldepth
|
||||
}
|
||||
|
||||
// SetSkipfunc set skip func to skip stack filename
|
||||
func (log *Logger) SetSkipfunc(skipfunc func(string) bool) {
|
||||
log.skipfunc = skipfunc
|
||||
}
|
||||
|
||||
func (log *Logger) Print(prefix string, v interface{}) {
|
||||
var str = ""
|
||||
if pkg, err := json.Marshal(v); err != nil {
|
||||
str = err.Error()
|
||||
} else {
|
||||
str = string(pkg)
|
||||
}
|
||||
log.logwrite(DEBUG, 3, prefix+"%s\n", str)
|
||||
var str = ""
|
||||
if pkg, err := json.Marshal(v); err != nil {
|
||||
str = err.Error()
|
||||
} else {
|
||||
str = string(pkg)
|
||||
}
|
||||
log.logwrite(DEBUG, 3, prefix+"%s\n", str)
|
||||
}
|
||||
|
||||
func (log *Logger) PrintPretty(prefix string, v interface{}) {
|
||||
var preety = ""
|
||||
if pkg, err := json.MarshalIndent(v, "==", " "); err != nil {
|
||||
preety = err.Error()
|
||||
} else {
|
||||
preety = string(pkg)
|
||||
}
|
||||
log.logwrite(DEBUG, 3, prefix+"%s\n", preety)
|
||||
var preety = ""
|
||||
if pkg, err := json.MarshalIndent(v, "==", " "); err != nil {
|
||||
preety = err.Error()
|
||||
} else {
|
||||
preety = string(pkg)
|
||||
}
|
||||
log.logwrite(DEBUG, 3, prefix+"%s\n", preety)
|
||||
}
|
||||
|
||||
func (log *Logger) Debugf(format string, v ...interface{}) {
|
||||
log.logwrite(DEBUG, 3, format, v...)
|
||||
log.logwrite(DEBUG, 3, format, v...)
|
||||
}
|
||||
|
||||
func (log *Logger) DebugfWithDepth(calldepth int, format string, v ...interface{}) {
|
||||
calldepth += 3
|
||||
log.logwrite(DEBUG, calldepth, format, v...)
|
||||
calldepth += 3
|
||||
log.logwrite(DEBUG, calldepth, format, v...)
|
||||
}
|
||||
|
||||
func (log *Logger) Noticef(format string, v ...interface{}) {
|
||||
log.logwrite(NOTICE, 3, format, v...)
|
||||
log.logwrite(NOTICE, 3, format, v...)
|
||||
}
|
||||
|
||||
func (log *Logger) NoticefWithDepth(calldepth int, format string, v ...interface{}) {
|
||||
calldepth += 3
|
||||
log.logwrite(NOTICE, calldepth, format, v...)
|
||||
calldepth += 3
|
||||
log.logwrite(NOTICE, calldepth, format, v...)
|
||||
}
|
||||
|
||||
func (log *Logger) Warningf(format string, v ...interface{}) {
|
||||
log.logwrite(WARNING, 3, format, v...)
|
||||
log.logwrite(WARNING, 3, format, v...)
|
||||
}
|
||||
|
||||
func (log *Logger) Infof(format string, v ...interface{}) {
|
||||
log.logwrite(INFO, 3, format, v...)
|
||||
log.logwrite(INFO, 3, format, v...)
|
||||
}
|
||||
|
||||
func (log *Logger) Errorf(format string, v ...interface{}) {
|
||||
log.logwrite(ERROR, 3, format, v...)
|
||||
log.logwrite(ERROR, 3, format, v...)
|
||||
}
|
||||
|
||||
func (log *Logger) Fatalf(format string, v ...interface{}) {
|
||||
log.logwrite(FATAL, 3, format, v...)
|
||||
log.logwrite(FATAL, 3, format, v...)
|
||||
}
|
||||
|
||||
func (log *Logger) Panicf(format string, v ...interface{}) {
|
||||
log.logwrite(PANIC, 3, format, v...)
|
||||
log.logwrite(PANIC, 3, format, v...)
|
||||
}
|
||||
|
||||
func (log *Logger) Fatal(v ...interface{}) {
|
||||
log.logwrite(FATAL, 3, "%s", fmt.Sprint(v...))
|
||||
func (log *Logger) Fatal(v ...interface{}){
|
||||
log.logwrite(FATAL, 3, "%s", fmt.Sprintln(v...))
|
||||
}
|
||||
|
||||
func (log *Logger) Printf(format string, v ...interface{}) {
|
||||
log.logwrite(DEBUG, 3, format, v...)
|
||||
func (log *Logger) Println(v ...interface{}){
|
||||
log.logwrite(DEBUG, 3, "%s", fmt.Sprintln(v...))
|
||||
}
|
||||
|
||||
func (log *Logger) Println(v ...interface{}) {
|
||||
log.logwrite(DEBUG, 3, "%s", fmt.Sprint(v...))
|
||||
}
|
||||
|
||||
func (log *Logger) GetLogidStr(format string) string {
|
||||
if logidCreator != nil {
|
||||
logid := logidCreator.GetLogid()
|
||||
if logid != "" {
|
||||
return fmt.Sprintf(format, logid)
|
||||
}
|
||||
}
|
||||
return ""
|
||||
if logidCreator != nil {
|
||||
return fmt.Sprintf(format, logidCreator.GetLogid())
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...interface{}) {
|
||||
if typ > log.loglevel {
|
||||
return
|
||||
}
|
||||
if mylog == log {
|
||||
calldepth = calldepth + 1
|
||||
}
|
||||
calldepth += log.calldepth
|
||||
var (
|
||||
idstr = log.GetLogidStr(" [%s]")
|
||||
header = formatHeader(calldepth, log.skipfunc) + "$" + idstr
|
||||
)
|
||||
if typ > log.loglevel {
|
||||
return
|
||||
}
|
||||
|
||||
format = strings.Trim(format, "\n")
|
||||
switch typ {
|
||||
case INFO:
|
||||
log.golog.SetPrefix("\x1b[2m" + "INFO " + header + "\x1b[0m" + " ")
|
||||
case NOTICE:
|
||||
log.golog.SetPrefix("\x1b[2m" + "NOTI " + header + "\x1b[0m" + " ")
|
||||
case DEBUG:
|
||||
log.golog.SetPrefix("\x1b[2m" + "DBUG " + header + "\x1b[0m" + " ")
|
||||
case PANIC:
|
||||
log.golog.SetPrefix("\x1b[31m" + "PANI " + header + "\x1b[0m" + " ")
|
||||
case FATAL:
|
||||
log.golog.SetPrefix("\x1b[31m" + "FATA " + header + "\x1b[0m" + " ")
|
||||
case ERROR:
|
||||
log.golog.SetPrefix("\x1b[41m" + "ERRO " + header + "\x1b[0m" + " ")
|
||||
case WARNING:
|
||||
log.golog.SetPrefix("\x1b[33m" + "WARN " + header + "\x1b[0m" + " ")
|
||||
default:
|
||||
log.golog.SetPrefix("\x1b[33m" + "UNKN " + header + "\x1b[0m" + " ")
|
||||
}
|
||||
var (
|
||||
idstr = log.GetLogidStr("[%s] ")
|
||||
prestr = idstr // + "[" + log.module + "] "
|
||||
)
|
||||
|
||||
if typ == FATAL || typ == WARNING || typ == ERROR {
|
||||
log.golog.Output(calldepth, "\x1b[31m"+fmt.Sprintf(format, v...)+"\x1b[0m")
|
||||
} else if typ == INFO || typ == DEBUG {
|
||||
log.golog.Output(calldepth, fmt.Sprintf(format, v...))
|
||||
} else if typ == NOTICE {
|
||||
calldepth = calldepth + 2
|
||||
log.golog.Output(calldepth, fmt.Sprintf(format, v...))
|
||||
} else if typ == PANIC {
|
||||
stackstr := strings.Replace(string(debug.Stack()), "\n", "\n== ", -1)
|
||||
stackstr = "\n== Panic stack:\n" + str.SkipLine(stackstr, calldepth*2+1)
|
||||
log.golog.Output(calldepth, fmt.Sprintf(format, v...)+stackstr)
|
||||
panic(fmt.Sprintf(format, v...))
|
||||
} else {
|
||||
panic(ErrLogLevel)
|
||||
}
|
||||
}
|
||||
format = strings.Trim(format, "\n")
|
||||
switch typ {
|
||||
case PANIC:
|
||||
log.golog.SetPrefix("\x1b[31m" + "PANI ")
|
||||
case FATAL:
|
||||
log.golog.SetPrefix("\x1b[31m" + "FATA ")
|
||||
case WARNING:
|
||||
log.golog.SetPrefix("\x1b[32m" + "WARN ")
|
||||
case ERROR:
|
||||
log.golog.SetPrefix("\x1b[33m" + "ERRO ")
|
||||
case INFO:
|
||||
log.golog.SetPrefix("INFO ")
|
||||
case NOTICE:
|
||||
log.golog.SetPrefix("NOTI ")
|
||||
case DEBUG:
|
||||
log.golog.SetPrefix("DBUG ")
|
||||
default:
|
||||
log.golog.SetPrefix("UNKN ")
|
||||
}
|
||||
|
||||
func formatHeader(calldepth int, skipfunc func(string) bool) string {
|
||||
const MAX_LENGTH = 35 /* + 22 */
|
||||
// log time
|
||||
now := time.Now()
|
||||
year, month, day := now.Date()
|
||||
hour, min, sec := now.Clock()
|
||||
nowstr := fmt.Sprintf("%4d%02d%02dT%02d:%02d:%02d.%03d ",
|
||||
year, month, day, hour, min, sec, now.Nanosecond()/1e6)
|
||||
if mylog == log {
|
||||
calldepth = calldepth + 1
|
||||
}
|
||||
|
||||
// log position
|
||||
pcs := [13]uintptr{}
|
||||
cnt := runtime.Callers(calldepth+1, pcs[:])
|
||||
frames := runtime.CallersFrames(pcs[:cnt])
|
||||
file, line := "???", 0
|
||||
for i := 0; i < cnt; i++ {
|
||||
frame, more := frames.Next()
|
||||
if !more || skipfunc == nil || !skipfunc(frame.File) {
|
||||
file, line = frame.File, frame.Line
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// Case 1: too short path, return directly
|
||||
i, header, linestr := 0, "", fmt.Sprintf("%d", line)
|
||||
if len(file)+len(linestr) < MAX_LENGTH {
|
||||
header = file + ":" + linestr
|
||||
return nowstr + header
|
||||
}
|
||||
|
||||
// Case 2: filename long enough, just return filename
|
||||
var fileline = ""
|
||||
for i = len(file) - 1; i >= 0; i-- {
|
||||
if file[i] == '/' {
|
||||
fileline = file[i:] + ":" + linestr
|
||||
i--
|
||||
break
|
||||
}
|
||||
}
|
||||
if len(fileline) >= MAX_LENGTH && i > 0 {
|
||||
//fileline = fileline[:4] + "*" + fileline[len(fileline)-MAX_LENGTH+6:]
|
||||
return nowstr + fileline
|
||||
} else if len(fileline) >= MAX_LENGTH && i <= 0 {
|
||||
//fileline = fileline[:4] + "…" + fileline[len(fileline)-MAX_LENGTH+5:]
|
||||
return nowstr + fileline
|
||||
}
|
||||
|
||||
// Case 3: try complex middle path
|
||||
header = fileline
|
||||
tempheader := formatHeaderPath(file, i, 20, 2) + header
|
||||
if len(tempheader) > MAX_LENGTH {
|
||||
//tempheader = "…" + tempheader[len(tempheader)-MAX_LENGTH+1:]
|
||||
tempheader = tempheader[len(tempheader)-MAX_LENGTH:]
|
||||
return nowstr + tempheader
|
||||
}
|
||||
|
||||
// Case 4: try complex middle path
|
||||
tempheader = formatHeaderPath(file, i, 20, 3) + header
|
||||
if len(tempheader) > MAX_LENGTH {
|
||||
//tempheader = "…" + tempheader[len(tempheader)-MAX_LENGTH+1:]
|
||||
tempheader = tempheader[len(tempheader)-MAX_LENGTH:]
|
||||
return nowstr + tempheader
|
||||
}
|
||||
|
||||
// Case 5: try complex middle path
|
||||
tempheader = formatHeaderPath(file, i, 20, 4) + header
|
||||
if len(tempheader) > MAX_LENGTH {
|
||||
//tempheader = "…" + tempheader[len(tempheader)-MAX_LENGTH+1:]
|
||||
tempheader = tempheader[len(tempheader)-MAX_LENGTH:]
|
||||
return nowstr + tempheader
|
||||
}
|
||||
|
||||
// Case 6: try complex middle path
|
||||
tempheader = formatHeaderPath(file, i, 20, 5) + header
|
||||
if len(tempheader) > MAX_LENGTH {
|
||||
//tempheader = "…" + tempheader[len(tempheader)-MAX_LENGTH+1:]
|
||||
tempheader = tempheader[len(tempheader)-MAX_LENGTH:]
|
||||
return nowstr + tempheader
|
||||
}
|
||||
|
||||
// Case 7: fallback
|
||||
return nowstr + tempheader
|
||||
}
|
||||
|
||||
func formatHeaderPath(file string, i, maxwidth, fullstep int) (paths string) {
|
||||
ii, iw, step := i, i, 1
|
||||
for i := ii; i >= 0; i-- {
|
||||
if file[i] == '/' {
|
||||
step++
|
||||
if step < fullstep {
|
||||
// dirname should not cut
|
||||
paths = file[i:iw+1] + paths
|
||||
} else if iw-i > maxwidth {
|
||||
// dirname lenght more then width
|
||||
paths = file[i:i+maxwidth] + paths // paths = file[i:i+width] + "..." + paths
|
||||
} else {
|
||||
// dirname lenght less then width
|
||||
paths = file[i:iw+1] + paths
|
||||
}
|
||||
//fmt.Println("w", iw-i, "width", width, "paths", paths)
|
||||
if step >= fullstep {
|
||||
// decrease width
|
||||
maxwidth = 2
|
||||
}
|
||||
iw = i - 1
|
||||
continue
|
||||
}
|
||||
}
|
||||
return paths
|
||||
if typ == FATAL || typ == WARNING || typ == ERROR {
|
||||
log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\x1b[0m\n", v...))
|
||||
} else if typ == NOTICE {
|
||||
calldepth = calldepth + 2
|
||||
log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\n", v...))
|
||||
} else if typ == PANIC {
|
||||
stack := strings.Replace(string(debug.Stack()), "\n", "\n== ", -1)
|
||||
stack = str.SkipLine(stack, calldepth*2+1)
|
||||
v = append(v, stack)
|
||||
panicstr := fmt.Sprintf(prestr+format+"\x1b[0m. Panic stack:\n%s\n", v...)
|
||||
log.golog.Output(calldepth, panicstr)
|
||||
panic(ErrLogPanic)
|
||||
} else {
|
||||
log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\n", v...))
|
||||
}
|
||||
}
|
||||
|
||||
func needWriteLogToFile() bool {
|
||||
if cls, ok := os.LookupEnv("QOOLOG_CLOSE_FILELOG"); ok && cls != "N" && cls != "n" {
|
||||
return false
|
||||
} else if ink8s, ok := os.LookupEnv("KUBERNETES_PORT"); ok && ink8s != "" {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
if cls, ok := os.LookupEnv("QOOLOG_CLOSE_FILELOG"); ok && cls != "N" && cls != "n" {
|
||||
return false
|
||||
} else if ink8s, ok := os.LookupEnv("KUBERNETES_PORT"); ok && ink8s != "" {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func needWriteLogToStdout() bool {
|
||||
if cls, ok := os.LookupEnv("QOOLOG_CLOSE_STDLOG"); ok && (cls == "Y" || cls == "y") {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
if cls, ok := os.LookupEnv("QOOLOG_CLOSE_STDLOG"); ok && (cls == "Y" || cls == "y") {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// //////////////////////////////////////////////////////////////////////////////////
|
||||
@ -377,38 +250,38 @@ var once sync.Once = sync.Once{}
|
||||
|
||||
// init
|
||||
func init() {
|
||||
once.Do(initlog)
|
||||
once.Do(initlog)
|
||||
}
|
||||
|
||||
// initlog
|
||||
func initlog() {
|
||||
// Step 1. create base writer & cache writer for ALL log
|
||||
var (
|
||||
logDir = "./logs/"
|
||||
logName = getExeFilename()
|
||||
logDirsOptional = []string{"./log", "/var/log"}
|
||||
logSplitTag = "20060102" //20060102150405
|
||||
baseWriter = NewBaseWriter(nil, os.Stdout, nil)
|
||||
gologFlags = 0 /* log.Ldate | log.Lmicroseconds | log.Lshortfile */
|
||||
)
|
||||
// Step 1. create base writer & cache writer for ALL log
|
||||
var (
|
||||
logDir = "./logs/"
|
||||
logName = getExeFilename()
|
||||
logDirsOptional = []string{"./log", "/var/log"}
|
||||
logSplitTag = "20060102" //20060102150405
|
||||
baseWriter = NewBaseWriter(nil, os.Stdout, nil)
|
||||
gologFlags = log.Ldate | log.Lmicroseconds | log.Lshortfile
|
||||
)
|
||||
|
||||
// Step 2.1 add stdout to base writer if need
|
||||
if needWriteLogToStdout() {
|
||||
baseWriter.stdw = os.Stdout
|
||||
}
|
||||
// Step 2.2 rotate log(split log ) if need
|
||||
if needWriteLogToFile() {
|
||||
baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
|
||||
go func() {
|
||||
for {
|
||||
tag := time.Now().Local().Format(logSplitTag)
|
||||
baseWriter.TryBackupLogFile(tag)
|
||||
time.Sleep(2 * time.Minute)
|
||||
}
|
||||
}()
|
||||
}
|
||||
// Step 2.1 add stdout to base writer if need
|
||||
if needWriteLogToStdout() {
|
||||
baseWriter.stdw = os.Stdout
|
||||
}
|
||||
// Step 2.2 rotate log(split log ) if need
|
||||
if needWriteLogToFile() {
|
||||
baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
|
||||
go func() {
|
||||
for {
|
||||
tag := time.Now().Local().Format(logSplitTag)
|
||||
baseWriter.TryBackupLogFile(tag)
|
||||
time.Sleep(2 * time.Minute)
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// Step 3. init golog(golang std logger) & mylog(myself defined logger)
|
||||
golog = log.New(NewCacheWriter(baseWriter), "", gologFlags)
|
||||
mylog = New("system")
|
||||
// Step 3. init golog(golang std logger) & mylog(myself defined logger)
|
||||
golog = log.New(NewCacheWriter(baseWriter), "", gologFlags)
|
||||
mylog = New("system")
|
||||
}
|
||||
|
||||
@ -3,8 +3,7 @@ package log
|
||||
import "testing"
|
||||
|
||||
func TestLog(t *testing.T) {
|
||||
Println("aaa", 1, 3, 6)
|
||||
Fatal("aaa", 1, 3)
|
||||
Fatalf("aaa=%d", 1)
|
||||
Panicf("aaa=%d", 1)
|
||||
Println("aaa", 1,3)
|
||||
Fatal("aaa", 1,3)
|
||||
Fatalf("aaa=%d", 1)
|
||||
}
|
||||
|
||||
14
util.go
14
util.go
@ -21,19 +21,9 @@ func tryOptLogDirs(optLogDirs []string) (string, error) {
|
||||
for i, d := range optLogDirs {
|
||||
dir := fmt.Sprintf("%s/", d)
|
||||
optionDirsStr += fmt.Sprintf("%d.[%s];", i, dir)
|
||||
if ok := canWriteByTest(dir); ok {
|
||||
if _, err := os.Stat(dir); err == nil {
|
||||
return dir, nil
|
||||
}
|
||||
}
|
||||
return "", fmt.Errorf("all optional dir are not exist or writeable: %s", optionDirsStr)
|
||||
}
|
||||
|
||||
// canWriteByTest
|
||||
func canWriteByTest(dir string) bool {
|
||||
testFile := filepath.Join(dir, ".write_test.log.tmp")
|
||||
if err := os.WriteFile(testFile, []byte("test"), 0644); err != nil {
|
||||
return false
|
||||
}
|
||||
os.Remove(testFile)
|
||||
return true
|
||||
return "", fmt.Errorf("all optional dir are not exist: %s", optionDirsStr)
|
||||
}
|
||||
|
||||
19
writer.go
19
writer.go
@ -35,23 +35,22 @@ func NewBaseWriter(logw, stdw, errw *os.File) *baseWriter {
|
||||
|
||||
// OpenLogFile
|
||||
func (w *baseWriter) OpenLogFile(logDir, logName string, optLogDirs []string) {
|
||||
realDir := ""
|
||||
// Step 1. try get available log dir
|
||||
if _, err := os.Stat(logDir); err == nil && canWriteByTest(logDir) {
|
||||
realDir = logDir
|
||||
} else if dir, tryOptErr := tryOptLogDirs(optLogDirs); tryOptErr == nil {
|
||||
realDir = dir
|
||||
if _, err := os.Stat(logDir); err == nil {
|
||||
logDir = logDir
|
||||
} else if dir, err := tryOptLogDirs(optLogDirs); err == nil {
|
||||
logDir = dir
|
||||
} else if err := os.Mkdir(logDir, 0755); err == nil {
|
||||
realDir = logDir
|
||||
logDir = logDir
|
||||
} else {
|
||||
errstr := fmt.Sprintf("all path not exist or writeable:\n "+
|
||||
"logDir = %s, optLogDirs = %v\n",
|
||||
logDir, optLogDirs)
|
||||
errstr := fmt.Sprintf("all path not exist:\n "+
|
||||
"a.[%s]\n b.[%s]\n c.[%s]\n",
|
||||
logDir, "./log/", "./logs/")
|
||||
panic("failed initlog:" + errstr)
|
||||
}
|
||||
|
||||
// Step 2. open base writer logfile
|
||||
filename := filepath.Join(realDir, logName+".log")
|
||||
filename := filepath.Join(logDir, logName+".log")
|
||||
w.logFilename = filename
|
||||
w.logPreBackupTag = ""
|
||||
w.ReopenLogFile()
|
||||
|
||||
Loading…
Reference in New Issue
Block a user