[DEV] fatal exit 1

go.sum

@@ -0,0 +1,6 @@
+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=

log.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"runtime"
 	"runtime/debug"
 	"strings"
 	"sync"
@@ -60,6 +61,8 @@ type Logger struct {
 	module    string
 	golog     *log.Logger
 	loglevel  LogLevel
+	skipfunc  func(string) bool
+	calldepth int
 }
 
 type LogidCreator interface {
@@ -101,6 +104,15 @@ func (log *Logger) SetLogLevelByName(newlv string) (oldlv string) {
 	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 = ""
@@ -160,18 +172,24 @@ func (log *Logger) Panicf(format string, v ...interface{}) {
 	log.logwrite(PANIC, 3, format, v...)
 }
 
-func (log *Logger) Fatal(v ...interface{}){
+func (log *Logger) Fatal(v ...interface{}) {
-    log.logwrite(FATAL, 3, "%s", fmt.Sprintln(v...))
+	log.logwrite(FATAL, 3, "%s", fmt.Sprint(v...))
 }
 
-func (log *Logger) Println(v ...interface{}){
+func (log *Logger) Printf(format string, v ...interface{}) {
-    log.logwrite(DEBUG, 3, "%s", fmt.Sprintln(v...))
+	log.logwrite(DEBUG, 3, format, 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 {
-        return fmt.Sprintf(format, logidCreator.GetLogid())
+		logid := logidCreator.GetLogid()
+		if logid != "" {
+			return fmt.Sprintf(format, logid)
+		}
 	}
 	return ""
 }
@@ -180,53 +198,167 @@ func (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...int
 	if typ > log.loglevel {
 		return
 	}
-
+	if mylog == log {
+		calldepth = calldepth + 1
+	}
+	calldepth += log.calldepth
 	var (
-        idstr  = log.GetLogidStr("[%s] ")
+		idstr  = log.GetLogidStr(" [%s]")
-        prestr = idstr // + "[" + log.module + "] "
+		header = formatHeader(calldepth, log.skipfunc) + "$" + idstr
 	)
 
 	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 ")
+		log.golog.SetPrefix("\x1b[2m" + "INFO " + header + "\x1b[0m" + " ")
 	case NOTICE:
-        log.golog.SetPrefix("NOTI ")
+		log.golog.SetPrefix("\x1b[2m" + "NOTI " + header + "\x1b[0m" + " ")
 	case DEBUG:
-        log.golog.SetPrefix("DBUG ")
+		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("UNKN ")
+		log.golog.SetPrefix("\x1b[33m" + "UNKN " + header + "\x1b[0m" + " ")
 	}
 
-    if mylog == log {
+	if typ == WARNING || typ == ERROR {
-        calldepth = calldepth + 1
+		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...))
-    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...))
+		log.golog.Output(calldepth, fmt.Sprintf(format, v...))
+	} else if typ == FATAL {
+		stackstr := strings.Replace(string(debug.Stack()), "\n", "\n==  ", -1)
+		stackstr = "\n==  Fatal stack:\n" + str.SkipLine(stackstr, calldepth*2+1)
+		log.golog.Output(calldepth, fmt.Sprintf(format, v...)+stackstr)
+		os.Exit(1)
 	} else if typ == PANIC {
-        stack := strings.Replace(string(debug.Stack()), "\n", "\n==    ", -1)
+		stackstr := strings.Replace(string(debug.Stack()), "\n", "\n==  ", -1)
-        stack = str.SkipLine(stack, calldepth*2+1)
+		stackstr = "\n==  Panic stack:\n" + str.SkipLine(stackstr, calldepth*2+1)
-        v = append(v, stack)
+		log.golog.Output(calldepth, fmt.Sprintf(format, v...)+stackstr)
-        panicstr := fmt.Sprintf(prestr+format+"\x1b[0m. Panic stack:\n%s\n", v...)
+		panic(fmt.Sprintf(format, v...))
-        log.golog.Output(calldepth, panicstr)
-        panic(ErrLogPanic)
 	} else {
-        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\n", v...))
+		panic(ErrLogLevel)
 	}
 }
 
+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)
+
+	// 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
+}
+
 func needWriteLogToFile() bool {
 	if cls, ok := os.LookupEnv("QOOLOG_CLOSE_FILELOG"); ok && cls != "N" && cls != "n" {
 		return false
@@ -262,7 +394,7 @@ func initlog() {
 		logDirsOptional = []string{"./log", "/var/log"}
 		logSplitTag     = "20060102" //20060102150405
 		baseWriter      = NewBaseWriter(nil, os.Stdout, nil)
-        gologFlags      = log.Ldate | log.Lmicroseconds | log.Lshortfile
+		gologFlags      = 0 /* log.Ldate | log.Lmicroseconds | log.Lshortfile */
 	)
 
 	// Step 2.1 add stdout to base writer if need

log_test.go

@@ -3,7 +3,8 @@ package log
 import "testing"
 
 func TestLog(t *testing.T) {
-    Println("aaa", 1,3)
+	Println("aaa", 1, 3, 6)
-    Fatal("aaa", 1,3)
+	Fatal("aaa", 1, 3)
 	Fatalf("aaa=%d", 1)
+	Panicf("aaa=%d", 1)
 }

util.go

@@ -21,9 +21,19 @@ func tryOptLogDirs(optLogDirs []string) (string, error) {
 	for i, d := range optLogDirs {
 		dir := fmt.Sprintf("%s/", d)
 		optionDirsStr += fmt.Sprintf("%d.[%s];", i, dir)
-		if _, err := os.Stat(dir); err == nil {
+		if ok := canWriteByTest(dir); ok {
 			return dir, nil
 		}
 	}
-	return "", fmt.Errorf("all optional dir are not exist: %s", optionDirsStr)
+	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
 }

writer.go

@@ -35,22 +35,23 @@ 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 {
+	if _, err := os.Stat(logDir); err == nil && canWriteByTest(logDir) {
-		logDir = logDir
+		realDir = logDir
-	} else if dir, err := tryOptLogDirs(optLogDirs); err == nil {
+	} else if dir, tryOptErr := tryOptLogDirs(optLogDirs); tryOptErr == nil {
-		logDir = dir
+		realDir = dir
 	} else if err := os.Mkdir(logDir, 0755); err == nil {
-		logDir = logDir
+		realDir = logDir
 	} else {
-		errstr := fmt.Sprintf("all path not exist:\n "+
+		errstr := fmt.Sprintf("all path not exist or writeable:\n "+
-			"a.[%s]\n b.[%s]\n c.[%s]\n",
+			"logDir = %s, optLogDirs = %v\n",
-			logDir, "./log/", "./logs/")
+			logDir, optLogDirs)
 		panic("failed initlog:" + errstr)
 	}
 
 	// Step 2. open base writer logfile
-	filename := filepath.Join(logDir, logName+".log")
+	filename := filepath.Join(realDir, logName+".log")
 	w.logFilename = filename
 	w.logPreBackupTag = ""
 	w.ReopenLogFile()