feature: QOOLOG_CLOSE_STDLOG & Println & Fatal

global.go

@@ -0,0 +1,99 @@
+package log
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+)
+
+func GetLogid() string {
+	if logidCreator != nil {
+		return logidCreator.GetLogid()
+	}
+	return ""
+}
+
+func SetLogid(logid string) {
+	if logidCreator != nil {
+		logidCreator.SetLogid(logid)
+	}
+}
+
+func Cleanup() {
+	if logidCreator != nil {
+		logidCreator.Cleanup()
+	}
+}
+
+func SetLogLevel(newlv LogLevel) (oldlv LogLevel) {
+	return mylog.SetLogLevel(newlv)
+}
+
+func SetLogLevelByName(newlv string) (oldlv string) {
+	return mylog.SetLogLevelByName(newlv)
+}
+
+func PrintPretty(prefix string, v interface{}) {
+	mylog.PrintPretty(prefix, v)
+}
+
+func DebugfWithDepth(calldepth int, format string, v ...interface{}) {
+	mylog.DebugfWithDepth(calldepth, format, v...)
+}
+
+func Debugf(format string, v ...interface{}) {
+	mylog.Debugf(format, v...)
+}
+
+func Noticef(format string, v ...interface{}) {
+	mylog.Noticef(format, v...)
+}
+
+func NoticefWithDepth(calldepth int, format string, v ...interface{}) {
+	mylog.NoticefWithDepth(calldepth, format, v...)
+}
+
+func Infof(format string, v ...interface{}) {
+	mylog.Infof(format, v...)
+}
+
+func Warningf(format string, v ...interface{}) {
+	mylog.Warningf(format, v...)
+}
+
+func Errorf(format string, v ...interface{}) {
+	mylog.Errorf(format, v...)
+}
+
+func Panicf(format string, v ...interface{}) {
+	mylog.Panicf(format, v...)
+}
+
+func Fatalf(format string, v ...interface{}) {
+	mylog.Fatalf(format, v...)
+}
+
+func Fatal(v ...interface{}){
+	mylog.Fatal(v...)
+}
+
+func Println(v ...interface{}){
+	mylog.Println(v...)
+}
+
+func TraceInto(format string, v ...interface{}) string {
+	_, fn, line, _ := runtime.Caller(1)
+	strfn := fmt.Sprintf("%s:%d", fn, line)
+	Debugf("TRACE into ["+strfn+"]"+format+"...\r\n", v...)
+
+	return strfn
+}
+
+func TraceExit(strfn string, format string, v ...interface{}) {
+	Debugf("TRACE exit ["+strfn+"]"+format+"...\r\n", v...)
+}
+
+func RegisterLogidCreator(idc LogidCreator) {
+	logidCreator = idc
+	SetLogid(fmt.Sprintf("sysinit(%d)", os.Getpid()))
+}

go.mod

@@ -2,4 +2,8 @@ module qoobing.com/gomod/log
 
 go 1.16
 
-require qoobing.com/gomod/str v1.0.1
+require (
+	github.com/tylerb/gls v0.0.0-20150407001822-e606233f194d
+	github.com/tylerb/is v2.1.4+incompatible // indirect
+	qoobing.com/gomod/str v1.0.1
+)

log.go

@@ -3,13 +3,10 @@
 package log
 
 import (
-	"bytes"
     "encoding/json"
     "fmt"
     "log"
     "os"
-	"path/filepath"
-	"runtime"
     "runtime/debug"
     "strings"
     "sync"
@@ -18,73 +15,60 @@ import (
     "qoobing.com/gomod/str"
 )
 
-var (
-	glogger     *log.Logger        = nil
-	once        sync.Once          = sync.Once{}
-	mylogger    *Logger            = nil
-	modulelogs  map[string]*Logger = map[string]*Logger{}
-	logidSetter func(string)       = nil
-	logidGetter func() string      = nil
-)
-
-const ErrLogPanic = "~~~~panic~~~~~~"
-
-//////////////global log//////////////////begin///////////////////
-func SetLogLevel(newlv logLevel) (oldlv logLevel) {
-	return mylogger.SetLogLevel(newlv)
-}
-func PrintPretty(prefix string, v interface{}) {
-	mylogger.PrintPretty(prefix, v)
-}
-func DebugfWithDepth(calldepth int, format string, v ...interface{}) {
-	mylogger.DebugfWithDepth(calldepth, format, v...)
-}
-func Debugf(format string, v ...interface{}) {
-	mylogger.Debugf(format, v...)
-}
-func Noticef(format string, v ...interface{}) {
-	mylogger.Noticef(format, v...)
-}
-func NoticefWithDepth(calldepth int, format string, v ...interface{}) {
-	mylogger.NoticefWithDepth(calldepth, format, v...)
-}
-func Infof(format string, v ...interface{}) {
-	mylogger.Infof(format, v...)
-}
-func Warningf(format string, v ...interface{}) {
-	mylogger.Warningf(format, v...)
-}
-func Errorf(format string, v ...interface{}) {
-	mylogger.Warningf(format, v...)
-}
-func Panicf(format string, v ...interface{}) {
-	mylogger.Panicf(format, v...)
-}
-func Fatalf(format string, v ...interface{}) {
-	mylogger.Fatalf(format, v...)
-}
-
-//////////////////////////////////////////////////////////////////
-
-type logLevel int
-
 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~~~~~"
+    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",
+    }
+)
+
+var (
+    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
-	loglevel logLevel
+    golog    *log.Logger
-	logger   *log.Logger
+    loglevel LogLevel
 }
 
-func New(module string) (logger *Logger) {
+type LogidCreator interface {
+    Cleanup()
+    GetLogid() string
+    SetLogid(logid string)
+}
+
+func New(module string) *Logger {
     if module == "" {
         module = "undefine"
     }
@@ -93,26 +77,48 @@ func New(module string) (logger *Logger) {
     } else {
         modulelogs[module] = &Logger{
             module:   module,
-			logger:   glogger,
+            golog:    golog,
             loglevel: DEBUG,
         }
         return modulelogs[module]
     }
 }
 
-func (log *Logger) SetLogLevel(newlv logLevel) (oldlv logLevel) {
+// SetLogLevel set new log level
+func (log *Logger) SetLogLevel(newlv LogLevel) (oldlv LogLevel) {
     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
+}
+
+
 func (log *Logger) Print(prefix string, v interface{}) {
-	preety, _ := json.Marshal(v)
+    var str = ""
-	log.logwrite(DEBUG, 3, prefix+"%s\n", preety)
+    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{}) {
-	preety, _ := json.MarshalIndent(v, "==", "    ")
+    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)
 }
 
@@ -154,178 +160,128 @@ func (log *Logger) Panicf(format string, v ...interface{}) {
     log.logwrite(PANIC, 3, format, v...)
 }
 
-func GetLogid() string {
+func (log *Logger) Fatal(v ...interface{}){
-	if logidGetter != nil {
+    log.logwrite(FATAL, 3, "%s", fmt.Sprintln(v...))
-		return logidGetter()
+}
+
+func (log *Logger) Println(v ...interface{}){
+    log.logwrite(DEBUG, 3, "%s", fmt.Sprintln(v...))
+}
+
+
+func (log *Logger) GetLogidStr(format string) string {
+    if logidCreator != nil {
+        return fmt.Sprintf(format, logidCreator.GetLogid())
     }
     return ""
 }
 
-func SetLogid(logid string) {
+func (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...interface{}) {
-	if logidSetter != nil {
-		logidSetter(logid)
-	}
-}
-
-func (log *Logger) logwrite(typ logLevel, calldepth int, format string, v ...interface{}) {
     if typ > log.loglevel {
         return
     }
 
-	var idstr = ""
+    var (
-	if id := GetLogid(); id != "" {
+        idstr  = log.GetLogidStr("[%s] ")
-		idstr = "[" + id + "] "
+        prestr = idstr // + "[" + log.module + "] "
-	}
+    )
 
     format = strings.Trim(format, "\n")
     switch typ {
     case PANIC:
-		log.logger.SetPrefix("\x1b[31m" + "PANIC " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("\x1b[31m" + "PANI ")
     case FATAL:
-		log.logger.SetPrefix("\x1b[31m" + "FATAL " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("\x1b[31m" + "FATA ")
     case WARNING:
-		log.logger.SetPrefix("\x1b[32m" + "WARNING " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("\x1b[32m" + "WARN ")
     case ERROR:
-		log.logger.SetPrefix("\x1b[32m" + "ERROR " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("\x1b[33m" + "ERRO ")
     case INFO:
-		log.logger.SetPrefix("INFO " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("INFO ")
     case NOTICE:
-		log.logger.SetPrefix("NOTICE " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("NOTI ")
     case DEBUG:
-		log.logger.SetPrefix("DEBUG " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("DBUG ")
     default:
-		log.logger.SetPrefix("UNKNOWN " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("UNKN ")
     }
 
-	if mylogger == log {
+    if mylog == log {
         calldepth = calldepth + 1
     }
 
     if typ == FATAL || typ == WARNING || typ == ERROR {
-		log.logger.Output(calldepth, fmt.Sprintf(format+"\x1b[0m\n", v...))
+        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\x1b[0m\n", v...))
     } else if typ == NOTICE {
         calldepth = calldepth + 2
-		log.logger.Output(calldepth, fmt.Sprintf(format+"\n", v...))
+        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(format+"\x1b[0m. Panic stack:\n%s\n", v...)
+        panicstr := fmt.Sprintf(prestr+format+"\x1b[0m. Panic stack:\n%s\n", v...)
-		log.logger.Output(calldepth, panicstr)
+        log.golog.Output(calldepth, panicstr)
         panic(ErrLogPanic)
     } else {
-		log.logger.Output(calldepth, fmt.Sprintf(format+"\n", v...))
+        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\n", v...))
     }
 }
 
-//////////////global log trace//////////////////begin///////////////////
+func needWriteLogToFile() bool {
-
+    if cls, ok := os.LookupEnv("QOOLOG_CLOSE_FILELOG"); ok && cls != "N" && cls != "n" {
-func TRACE_INTO(format string, v ...interface{}) string {
+        return false
-	_, fn, line, _ := runtime.Caller(1)
+    } else if ink8s, ok := os.LookupEnv("KUBERNETES_PORT"); ok && ink8s != "" {
-	strfn := fmt.Sprintf("%s:%d", fn, line)
+        return false
-	Debugf("TRACE into ["+strfn+"]"+format+"...\r\n", v...)
-
-	return strfn
-}
-
-func TRACE_EXIT(strfn string, format string, v ...interface{}) {
-	Debugf("TRACE exit ["+strfn+"]"+format+"...\r\n", v...)
-}
-
-type mWriter struct {
-	logw *os.File
-	stdw *os.File
-}
-
-func (w mWriter) Write(p []byte) (n int, err error) {
-	if flagcachelog {
-		logCache.Write(p)
     }
-	w.stdw.Write(p)
+    return true
-	return w.logw.Write(p)
 }
 
-var cacheLogLock = new(sync.Mutex)
+func needWriteLogToStdout() bool {
-var flagcachelog = false
+    if cls, ok := os.LookupEnv("QOOLOG_CLOSE_STDLOG"); ok && (cls == "Y" || cls == "y") {
-var logCache = bytes.Buffer{}
+        return false
-
-func StartCacheLog() {
-	cacheLogLock.Lock()
-	flagcachelog = true
-	logCache.Reset()
-}
-func StopCacheLog() {
-	cacheLogLock.Unlock()
-	flagcachelog = false
-}
-func GetCacheLog() string {
-	if flagcachelog != true {
-		panic("GetCacheLog MUST call after StartCacheLog called")
     }
-	return logCache.String()
+    return true
 }
 
-////////////////////////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////////////////////
-/////////////////////////Initialize/////////////////////////////////////////////////
+// ///////////////////////Initialize/////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////////////////////
+var once sync.Once = sync.Once{}
+
+// init
 func init() {
     once.Do(initlog)
 }
 
+// initlog
 func initlog() {
-	var mwriter mWriter
+    // Step 1. create base writer & cache writer for ALL log
-	var openlog = func(logname string) *log.Logger {
+    var (
-		fp, err := os.OpenFile(logname, os.O_APPEND|os.O_CREATE|os.O_WRONLY, os.ModePerm)
+        logDir          = "./logs/"
-		if err != nil {
+        logName         = getExeFilename()
-			panic("open log file failed:" + err.Error())
+        logDirsOptional = []string{"./log", "/var/log"}
-		}
+        logSplitTag     = "20060102" //20060102150405
-		mwriter.logw.Close()
+        baseWriter      = NewBaseWriter(nil, os.Stdout, nil)
-		mwriter.logw = fp
+        gologFlags      = log.Ldate | log.Lmicroseconds | log.Lshortfile
-		mwriter.stdw = os.Stdout
+    )
-		glogger = log.New(mwriter, "", log.Ldate|log.Lmicroseconds|log.Lshortfile)
-		return glogger
-	}
 
-	_, logfilename := filepath.Split(os.Args[0])
+    // Step 2.1 add stdout to base writer if need
-	LOGSPLITTIME := "20060102" //20060102150405
+    if needWriteLogToStdout() {
-	LOGFILENAME := logfilename + ".log"
+        baseWriter.stdw = os.Stdout
-	if _, err := os.Stat("log/"); err == nil {
-		LOGFILENAME = "log/" + LOGFILENAME
-	} else if _, err := os.Stat("logs/"); err == nil {
-		LOGFILENAME = "logs/" + LOGFILENAME
-	} else {
-		LOGFILENAME = "logs/" + LOGFILENAME
     }
-
+    // Step 2.2 rotate log(split log ) if need
-	glogger = openlog(LOGFILENAME)
+    if needWriteLogToFile() {
-	mylogger = New("system")
+        baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
-	curhourtime := time.Now().Local().Format(LOGSPLITTIME)
-	prehourtime := curhourtime
-
         go func() {
-		intva := 2 * time.Minute
-		timer := time.NewTimer(1 * time.Second)
-
             for {
-			select {
+                tag := time.Now().Local().Format(logSplitTag)
-			case <-timer.C:
+                baseWriter.TryBackupLogFile(tag)
-				curhourtime := time.Now().Local().Format(LOGSPLITTIME)
+                time.Sleep(2 * time.Minute)
-				//Debugf("check logfile: prehourtime:%s,curhourtime:%s", prehourtime, curhourtime)
-				if prehourtime != curhourtime {
-					// close old logger & move log to backup file.
-					PREFILENAME := LOGFILENAME + "." + prehourtime
-					os.Rename(LOGFILENAME, PREFILENAME)
-					prehourtime = curhourtime
-
-					glogger = openlog(LOGFILENAME)
-					mylogger = New("system")
-					for _, l := range modulelogs {
-						l.logger = glogger
-					}
-				}
-
-				timer.Reset(intva)
-			}
             }
         }()
+    }
+
+    // Step 3. init golog(golang std logger) & mylog(myself defined logger)
+    golog = log.New(NewCacheWriter(baseWriter), "", gologFlags)
+    mylog = New("system")
 }

log_test.go

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

logid+glslogid.go

@@ -0,0 +1,39 @@
+// +build glslogid
+
+package log
+
+import (
+	"fmt"
+	"github.com/tylerb/gls"
+)
+
+type glsLogidCreator struct {
+	idkey string
+}
+
+func (creator *glsLogidCreator) GetLogid() string {
+	id := gls.Get(creator.idkey)
+	if id == nil {
+		return ""
+	}
+	if logid, ok := id.(string); ok {
+		return logid
+	} else {
+		return fmt.Sprintf("%s", id)
+	}
+}
+
+func (creator *glsLogidCreator) SetLogid(logid string) {
+	gls.Set(creator.idkey, logid)
+}
+
+func (creator *glsLogidCreator) Cleanup() {
+	gls.Cleanup()
+}
+
+func init() {
+	idc := &glsLogidCreator{
+		idkey: "logidkey",
+	}
+	RegisterLogidCreator(idc)
+}

logid+runtimelogid.go

@@ -0,0 +1,22 @@
+// +build runtimelogid
+
+package log
+
+//// Format writes the source file path and line number of the record to the buf.
+//func (p *LogidFormatPart) Format(r *Record, buf *bytes.Buffer) {
+//	logid := p.GetLogid()
+//	logidstr := strconv.FormatInt(logid, 10)
+//	buf.WriteString(logidstr)
+//}
+//
+//func (p *LogidFormatPart) GetLogid() int64 {
+//	return runtime.GetLogid()
+//}
+//
+//func (p *LogidFormatPart) SetLogid(newid int64) (oldid int64) {
+//	return runtime.SetLogid(newid)
+//}
+//
+//func init() {
+//	LogidSupporter = &LogidFormatPart{}
+//}

logid-runtime-patch/unknown/debug.go

@@ -0,0 +1,82 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import (
+	"runtime/internal/atomic"
+	"unsafe"
+)
+
+// GOMAXPROCS sets the maximum number of CPUs that can be executing
+// simultaneously and returns the previous setting. If n < 1, it does not
+// change the current setting.
+// The number of logical CPUs on the local machine can be queried with NumCPU.
+// This call will go away when the scheduler improves.
+func GOMAXPROCS(n int) int {
+	if GOARCH == "wasm" && n > 1 {
+		n = 1 // WebAssembly has no threads yet, so only one CPU is possible.
+	}
+
+	lock(&sched.lock)
+	ret := int(gomaxprocs)
+	unlock(&sched.lock)
+	if n <= 0 || n == ret {
+		return ret
+	}
+
+	stopTheWorld("GOMAXPROCS")
+
+	// newprocs will be processed by startTheWorld
+	newprocs = int32(n)
+
+	startTheWorld()
+	return ret
+}
+
+// NumCPU returns the number of logical CPUs usable by the current process.
+//
+// The set of available CPUs is checked by querying the operating system
+// at process startup. Changes to operating system CPU allocation after
+// process startup are not reflected.
+func NumCPU() int {
+	return int(ncpu)
+}
+
+// NumCgoCall returns the number of cgo calls made by the current process.
+func NumCgoCall() int64 {
+	var n int64
+	for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
+		n += int64(mp.ncgocall)
+	}
+	return n
+}
+
+// NumGoroutine returns the number of goroutines that currently exist.
+func NumGoroutine() int {
+	return int(gcount())
+}
+
+// GetLogid get a goroutine log, the logid is setted by SetLogid,
+// or it is succesed from parents goroutine.
+// add for test by q.bryant@live.com @ 2020.09.10
+func GetLogid()int64{
+     _g_ := getg()
+     return _g_.logid
+}
+
+// SetLogid get a goroutine log, you can get the logid by GetLogid,
+// it will return the old logid for trace call stack.
+// add for test by q.bryant@live.com @ 2020.09.10
+func SetLogid(newid int64)(oldid int64){
+     _g_ := getg()
+     oldid = _g_.logid
+     _g_.logid = newid
+     return oldid
+}
+
+//go:linkname debug_modinfo runtime/debug.modinfo
+func debug_modinfo() string {
+	return modinfo
+}

logid-runtime-patch/unknown/sizeof_test.go

@@ -0,0 +1,41 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime_test
+
+import (
+	"reflect"
+	"runtime"
+	"testing"
+	"unsafe"
+)
+
+// Assert that the size of important structures do not change unexpectedly.
+
+func TestSizeof(t *testing.T) {
+	const _64bit = unsafe.Sizeof(uintptr(0)) == 8
+
+	var tests = []struct {
+		val    interface{} // type as a value
+		_32bit uintptr     // size on 32bit platforms
+		_64bit uintptr     // size on 64bit platforms
+	}{
+		////// Add by q.bryant@live.com for logid @2020.09.10 ///////begain//////
+		// {runtime.G{}, 216, 376}, // g, but exported for testing
+		///////////////////// replace by ///////////////////////////
+		{runtime.G{}, 224, 384}, // g, but exported for testing
+		////// Add by q.bryant@live.com for logid @2020.09.10 ///////end/////////
+	}
+
+	for _, tt := range tests {
+		want := tt._32bit
+		if _64bit {
+			want = tt._64bit
+		}
+		got := reflect.TypeOf(tt.val).Size()
+		if want != got {
+			t.Errorf("unsafe.Sizeof(%T) = %d, want %d", tt.val, got, want)
+		}
+	}
+}

util.go

@@ -0,0 +1,29 @@
+package log
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// getExeFilename
+func getExeFilename() string {
+	_, logfilename := filepath.Split(os.Args[0])
+	if logfilename == "" {
+		panic("get exe filename failed")
+	}
+	return logfilename
+}
+
+// tryOptLogDirs
+func tryOptLogDirs(optLogDirs []string) (string, error) {
+	optionDirsStr := ""
+	for i, d := range optLogDirs {
+		dir := fmt.Sprintf("%s/", d)
+		optionDirsStr += fmt.Sprintf("%d.[%s];", i, dir)
+		if _, err := os.Stat(dir); err == nil {
+			return dir, nil
+		}
+	}
+	return "", fmt.Errorf("all optional dir are not exist: %s", optionDirsStr)
+}

writer.go

@@ -0,0 +1,134 @@
+package log
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+type baseWriter struct {
+	logw *os.File
+	stdw *os.File
+	errw *os.File
+
+	logFilename     string
+	logPreBackupTag string
+}
+
+type cacheWriter struct {
+	cache      bytes.Buffer
+	cacheing   bool
+	cacheLock  *sync.Mutex
+	baseWriter io.Writer
+}
+
+func NewBaseWriter(logw, stdw, errw *os.File) *baseWriter {
+	return &baseWriter{
+		logw: logw,
+		stdw: stdw,
+		errw: errw,
+	}
+}
+
+// OpenLogFile
+func (w *baseWriter) OpenLogFile(logDir, logName string, optLogDirs []string) {
+	// Step 1. try get available log 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 {
+		logDir = logDir
+	} else {
+		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(logDir, logName+".log")
+	w.logFilename = filename
+	w.logPreBackupTag = ""
+	w.ReopenLogFile()
+}
+
+// ReopenLogFile
+func (w *baseWriter) ReopenLogFile() {
+	var fil, err = os.OpenFile(w.logFilename,
+		os.O_APPEND|os.O_CREATE|os.O_WRONLY, os.ModePerm)
+	if err != nil {
+		panic("open log file failed:" + err.Error())
+	}
+	w.logw.Close()
+	w.logw = fil
+}
+
+// BackupLogFile
+func (w *baseWriter) TryBackupLogFile(tag string) bool {
+	if w.logPreBackupTag == "" {
+		w.logPreBackupTag = tag
+		return false
+	} else if w.logPreBackupTag == tag {
+		return false
+	}
+
+	w.logPreBackupTag = tag
+	newname := w.logFilename + "." + tag
+	if err := os.Rename(w.logFilename, newname); err != nil {
+		return false
+	}
+
+	w.ReopenLogFile()
+	return true
+}
+
+func NewCacheWriter(basewriter io.Writer) *cacheWriter {
+	return &cacheWriter{
+		cache:      bytes.Buffer{},
+		cacheing:   false,
+		cacheLock:  new(sync.Mutex),
+		baseWriter: basewriter,
+	}
+}
+
+func (w *baseWriter) Write(p []byte) (n int, err error) {
+	if w.errw != nil {
+		n, err = w.errw.Write(p)
+	}
+	if w.stdw != nil {
+		n, err = w.stdw.Write(p)
+	}
+	if w.logw != nil {
+		n, err = w.logw.Write(p)
+	}
+	return n, err
+}
+
+func (w *cacheWriter) Write(p []byte) (n int, err error) {
+	if w.cacheing {
+		w.cache.Write(p)
+	}
+	return w.baseWriter.Write(p)
+}
+
+func (w *cacheWriter) GetCacheLog() string {
+	if w.cacheing != true {
+		panic("GetCacheLog MUST call after StartCacheLog called")
+	}
+	return w.cache.String()
+}
+
+func (w *cacheWriter) StartCacheLog() {
+	w.cacheLock.Lock()
+	w.cacheing = true
+	w.cache.Reset()
+}
+
+func (w *cacheWriter) StopCacheLog() {
+	w.cacheLock.Unlock()
+	w.cacheing = false
+}