[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

@@ -3,244 +3,376 @@
 package log
 
 import (
-    "encoding/json"
+	"encoding/json"
-    "fmt"
+	"fmt"
-    "log"
+	"log"
-    "os"
+	"os"
-    "runtime/debug"
+	"runtime"
-    "strings"
+	"runtime/debug"
-    "sync"
+	"strings"
-    "time"
+	"sync"
+	"time"
 
-    "qoobing.com/gomod/str"
+	"qoobing.com/gomod/str"
 )
 
 const (
-    PANIC       LogLevel = 0
+	PANIC       LogLevel = 0
-    FATAL       LogLevel = 1
+	FATAL       LogLevel = 1
-    ERROR       LogLevel = 2
+	ERROR       LogLevel = 2
-    NOTICE      LogLevel = 3
+	NOTICE      LogLevel = 3
-    WARNING     LogLevel = 4
+	WARNING     LogLevel = 4
-    INFO        LogLevel = 5
+	INFO        LogLevel = 5
-    DEBUG       LogLevel = 9
+	DEBUG       LogLevel = 9
-    ErrLogLevel          = "~~~~~invalid loglevel~~~~~"
+	ErrLogLevel          = "~~~~~invalid loglevel~~~~~"
-    ErrLogPanic          = "~~~~panic~~~~~~"
+	ErrLogPanic          = "~~~~panic~~~~~~"
 )
 
 var (
-    mapStrToLevel = map[string]LogLevel{
+	mapStrToLevel = map[string]LogLevel{
-        "PANIC":   PANIC,
+		"PANIC":   PANIC,
-        "FATAL":   FATAL,
+		"FATAL":   FATAL,
-        "ERROR":   ERROR,
+		"ERROR":   ERROR,
-        "NOTICE":  NOTICE,
+		"NOTICE":  NOTICE,
-        "WARNING": WARNING,
+		"WARNING": WARNING,
-        "INFO":    INFO,
+		"INFO":    INFO,
-        "DEBUG":   DEBUG,
+		"DEBUG":   DEBUG,
-    }
+	}
-    mapLevelToStr = map[LogLevel]string{
+	mapLevelToStr = map[LogLevel]string{
-        PANIC:   "PANIC",
+		PANIC:   "PANIC",
-        FATAL:   "FATAL",
+		FATAL:   "FATAL",
-        ERROR:   "ERROR",
+		ERROR:   "ERROR",
-        NOTICE:  "NOTICE",
+		NOTICE:  "NOTICE",
-        WARNING: "WARNING",
+		WARNING: "WARNING",
-        INFO:    "INFO",
+		INFO:    "INFO",
-        DEBUG:   "DEBUG",
+		DEBUG:   "DEBUG",
-    }
+	}
 )
 
 var (
-    golog        *log.Logger        = nil
+	golog        *log.Logger        = nil
-    mylog        *Logger            = nil
+	mylog        *Logger            = nil
-    logidCreator LogidCreator       = nil
+	logidCreator LogidCreator       = nil
-    modulelogs   map[string]*Logger = map[string]*Logger{}
+	modulelogs   map[string]*Logger = map[string]*Logger{}
 )
 
 type LogLevel int
 type Logger struct {
-    module   string
+	module    string
-    golog    *log.Logger
+	golog     *log.Logger
-    loglevel LogLevel
+	loglevel  LogLevel
+	skipfunc  func(string) bool
+	calldepth int
 }
 
 type LogidCreator interface {
-    Cleanup()
+	Cleanup()
-    GetLogid() string
+	GetLogid() string
-    SetLogid(logid string)
+	SetLogid(logid string)
 }
 
 func New(module string) *Logger {
-    if module == "" {
+	if module == "" {
-        module = "undefine"
+		module = "undefine"
-    }
+	}
-    if _, ok := modulelogs[module]; ok {
+	if _, ok := modulelogs[module]; ok {
-        return modulelogs[module]
+		return modulelogs[module]
-    } else {
+	} else {
-        modulelogs[module] = &Logger{
+		modulelogs[module] = &Logger{
-            module:   module,
+			module:   module,
-            golog:    golog,
+			golog:    golog,
-            loglevel: DEBUG,
+			loglevel: DEBUG,
-        }
+		}
-        return modulelogs[module]
+		return modulelogs[module]
-    }
+	}
 }
 
 // SetLogLevel set new log level
 func (log *Logger) SetLogLevel(newlv LogLevel) (oldlv LogLevel) {
-    oldlv = log.loglevel
+	oldlv = log.loglevel
-    log.loglevel = newlv
+	log.loglevel = newlv
-    return oldlv
+	return oldlv
 }
 
 // SetLogLevelByName set new log level by level name
 func (log *Logger) SetLogLevelByName(newlv string) (oldlv string) {
-    if newlevel, ok := mapStrToLevel[newlv]; ok {
+	if newlevel, ok := mapStrToLevel[newlv]; ok {
-        oldlevel := log.loglevel
+		oldlevel := log.loglevel
-        log.loglevel = newlevel
+		log.loglevel = newlevel
-        return mapLevelToStr[oldlevel]
+		return mapLevelToStr[oldlevel]
-    }
+	}
-    return ErrLogLevel
+	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 = ""
+	var str = ""
-    if pkg, err := json.Marshal(v); err != nil {
+	if pkg, err := json.Marshal(v); err != nil {
-        str = err.Error()
+		str = err.Error()
-    } else {
+	} else {
-        str = string(pkg)
+		str = string(pkg)
-    }
+	}
-    log.logwrite(DEBUG, 3, prefix+"%s\n", str)
+	log.logwrite(DEBUG, 3, prefix+"%s\n", str)
 }
 
 func (log *Logger) PrintPretty(prefix string, v interface{}) {
-    var preety = ""
+	var preety = ""
-    if pkg, err := json.MarshalIndent(v, "==", "  "); err != nil {
+	if pkg, err := json.MarshalIndent(v, "==", "  "); err != nil {
-        preety = err.Error()
+		preety = err.Error()
-    } else {
+	} else {
-        preety = string(pkg)
+		preety = string(pkg)
-    }
+	}
-    log.logwrite(DEBUG, 3, prefix+"%s\n", preety)
+	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
+	calldepth += 3
-    log.logwrite(DEBUG, calldepth, format, v...)
+	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
+	calldepth += 3
-    log.logwrite(NOTICE, calldepth, format, v...)
+	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{}){
+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 {
+	if logidCreator != nil {
-        return fmt.Sprintf(format, logidCreator.GetLogid())
+		logid := logidCreator.GetLogid()
-    }
+		if logid != "" {
-    return ""
+			return fmt.Sprintf(format, logid)
+		}
+	}
+	return ""
 }
 
 func (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...interface{}) {
-    if typ > log.loglevel {
+	if typ > log.loglevel {
-        return
+		return
-    }
+	}
+	if mylog == log {
+		calldepth = calldepth + 1
+	}
+	calldepth += log.calldepth
+	var (
+		idstr  = log.GetLogidStr(" [%s]")
+		header = formatHeader(calldepth, log.skipfunc) + "$" + idstr
+	)
 
-    var (
+	format = strings.Trim(format, "\n")
-        idstr  = log.GetLogidStr("[%s] ")
+	switch typ {
-        prestr = idstr // + "[" + log.module + "] "
+	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" + " ")
+	}
 
-    format = strings.Trim(format, "\n")
+	if typ == WARNING || typ == ERROR {
-    switch typ {
+		log.golog.Output(calldepth, "\x1b[31m"+fmt.Sprintf(format, v...)+"\x1b[0m")
-    case PANIC:
+	} else if typ == INFO || typ == DEBUG {
-        log.golog.SetPrefix("\x1b[31m" + "PANI ")
+		log.golog.Output(calldepth, fmt.Sprintf(format, v...))
-    case FATAL:
+	} else if typ == NOTICE {
-        log.golog.SetPrefix("\x1b[31m" + "FATA ")
+		calldepth = calldepth + 2
-    case WARNING:
+		log.golog.Output(calldepth, fmt.Sprintf(format, v...))
-        log.golog.SetPrefix("\x1b[32m" + "WARN ")
+	} else if typ == FATAL {
-    case ERROR:
+		stackstr := strings.Replace(string(debug.Stack()), "\n", "\n==  ", -1)
-        log.golog.SetPrefix("\x1b[33m" + "ERRO ")
+		stackstr = "\n==  Fatal stack:\n" + str.SkipLine(stackstr, calldepth*2+1)
-    case INFO:
+		log.golog.Output(calldepth, fmt.Sprintf(format, v...)+stackstr)
-        log.golog.SetPrefix("INFO ")
+		os.Exit(1)
-    case NOTICE:
+	} else if typ == PANIC {
-        log.golog.SetPrefix("NOTI ")
+		stackstr := strings.Replace(string(debug.Stack()), "\n", "\n==  ", -1)
-    case DEBUG:
+		stackstr = "\n==  Panic stack:\n" + str.SkipLine(stackstr, calldepth*2+1)
-        log.golog.SetPrefix("DBUG ")
+		log.golog.Output(calldepth, fmt.Sprintf(format, v...)+stackstr)
-    default:
+		panic(fmt.Sprintf(format, v...))
-        log.golog.SetPrefix("UNKN ")
+	} else {
-    }
+		panic(ErrLogLevel)
+	}
+}
 
-    if mylog == log {
+func formatHeader(calldepth int, skipfunc func(string) bool) string {
-        calldepth = calldepth + 1
+	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 typ == FATAL || typ == WARNING || typ == ERROR {
+	// log position
-        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\x1b[0m\n", v...))
+	pcs := [13]uintptr{}
-    } else if typ == NOTICE {
+	cnt := runtime.Callers(calldepth+1, pcs[:])
-        calldepth = calldepth + 2
+	frames := runtime.CallersFrames(pcs[:cnt])
-        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\n", v...))
+	file, line := "???", 0
-    } else if typ == PANIC {
+	for i := 0; i < cnt; i++ {
-        stack := strings.Replace(string(debug.Stack()), "\n", "\n==    ", -1)
+		frame, more := frames.Next()
-        stack = str.SkipLine(stack, calldepth*2+1)
+		if !more || skipfunc == nil || !skipfunc(frame.File) {
-        v = append(v, stack)
+			file, line = frame.File, frame.Line
-        panicstr := fmt.Sprintf(prestr+format+"\x1b[0m. Panic stack:\n%s\n", v...)
+			break
-        log.golog.Output(calldepth, panicstr)
+		}
-        panic(ErrLogPanic)
+	}
-    } else {
+
-        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\n", v...))
+	// 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" {
+	if cls, ok := os.LookupEnv("QOOLOG_CLOSE_FILELOG"); ok && cls != "N" && cls != "n" {
-        return false
+		return false
-    } else if ink8s, ok := os.LookupEnv("KUBERNETES_PORT"); ok && ink8s != "" {
+	} else if ink8s, ok := os.LookupEnv("KUBERNETES_PORT"); ok && ink8s != "" {
-        return false
+		return false
-    }
+	}
-    return true
+	return true
 }
 
 func needWriteLogToStdout() bool {
-    if cls, ok := os.LookupEnv("QOOLOG_CLOSE_STDLOG"); ok && (cls == "Y" || cls == "y") {
+	if cls, ok := os.LookupEnv("QOOLOG_CLOSE_STDLOG"); ok && (cls == "Y" || cls == "y") {
-        return false
+		return false
-    }
+	}
-    return true
+	return true
 }
 
 // //////////////////////////////////////////////////////////////////////////////////
@@ -250,38 +382,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
+	// Step 1. create base writer & cache writer for ALL log
-    var (
+	var (
-        logDir          = "./logs/"
+		logDir          = "./logs/"
-        logName         = getExeFilename()
+		logName         = getExeFilename()
-        logDirsOptional = []string{"./log", "/var/log"}
+		logDirsOptional = []string{"./log", "/var/log"}
-        logSplitTag     = "20060102" //20060102150405
+		logSplitTag     = "20060102" //20060102150405
-        baseWriter      = NewBaseWriter(nil, os.Stdout, nil)
+		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
+	// Step 2.1 add stdout to base writer if need
-    if needWriteLogToStdout() {
+	if needWriteLogToStdout() {
-        baseWriter.stdw = os.Stdout
+		baseWriter.stdw = os.Stdout
-    }
+	}
-    // Step 2.2 rotate log(split log ) if need
+	// Step 2.2 rotate log(split log ) if need
-    if needWriteLogToFile() {
+	if needWriteLogToFile() {
-        baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
+		baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
-        go func() {
+		go func() {
-            for {
+			for {
-                tag := time.Now().Local().Format(logSplitTag)
+				tag := time.Now().Local().Format(logSplitTag)
-                baseWriter.TryBackupLogFile(tag)
+				baseWriter.TryBackupLogFile(tag)
-                time.Sleep(2 * time.Minute)
+				time.Sleep(2 * time.Minute)
-            }
+			}
-        }()
+		}()
-    }
+	}
 
-    // Step 3. init golog(golang std logger) & mylog(myself defined logger)
+	// Step 3. init golog(golang std logger) & mylog(myself defined logger)
-    golog = log.New(NewCacheWriter(baseWriter), "", gologFlags)
+	golog = log.New(NewCacheWriter(baseWriter), "", gologFlags)
-    mylog = New("system")
+	mylog = New("system")
 }

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)
+	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()