global.go

@@ -1,99 +0,0 @@
-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,8 +2,4 @@ module qoobing.com/gomod/log
 
 go 1.16
 
-require (
+require qoobing.com/gomod/str v1.0.1
-	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,10 +3,13 @@
 package log
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"log"
 	"os"
+	"path/filepath"
+	"runtime"
 	"runtime/debug"
 	"strings"
 	"sync"
@@ -15,273 +18,274 @@ import (
 	"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~~~~~~"
-)
-
 var (
-    mapStrToLevel = map[string]LogLevel{
+	glogger     *log.Logger        = nil
-        "PANIC":   PANIC,
+	once        sync.Once          = sync.Once{}
-        "FATAL":   FATAL,
+	mylogger    *Logger            = nil
-        "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{}
+	logidSetter func(string)       = nil
+	logidGetter func() string      = nil
 )
 
-type LogLevel int
+const ErrLogPanic = "~~~~panic~~~~~~"
+
+//////////////global log//////////////////begin///////////////////
+
+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 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 Logger struct {
 	module string
-    golog    *log.Logger
+	logger *log.Logger
-    loglevel LogLevel
 }
 
-type LogidCreator interface {
+func New(module string) (logger *Logger) {
-    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{
+		modulelogs[module] = &Logger{module: module, logger: glogger}
-            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
-}
-
-// 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{}) {
-    var str = ""
+	preety, _ := json.Marshal(v)
-    if pkg, err := json.Marshal(v); err != nil {
+	log.logwrite("DEBUGE", 3, prefix+"%s\n", preety)
-        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 = ""
+	preety, _ := json.MarshalIndent(v, "==", "    ")
-    if pkg, err := json.MarshalIndent(v, "==", "  "); err != nil {
+	log.logwrite("DEBUGE", 3, prefix+"%s\n", preety)
-        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("DEBUGE", 3, format, v...)
 }
 
 func (log *Logger) DebugfWithDepth(calldepth int, format string, v ...interface{}) {
 	calldepth += 3
-    log.logwrite(DEBUG, calldepth, format, v...)
+	log.logwrite("DEBUGE", 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...)
+	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...)
 }
 
 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 GetLogid() string {
-    log.logwrite(FATAL, 3, "%s", fmt.Sprintln(v...))
+	if logidGetter != nil {
-}
+		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 (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...interface{}) {
+func SetLogid(logid string) {
-    if typ > log.loglevel {
+	if logidSetter != nil {
-        return
+		logidSetter(logid)
 	}
+}
 
-    var (
+func (log *Logger) logwrite(typ string, calldepth int, format string, v ...interface{}) {
-        idstr  = log.GetLogidStr("[%s] ")
+	var idstr = ""
-        prestr = idstr // + "[" + log.module + "] "
+	if id := GetLogid(); id != "" {
-    )
+		idstr = "[" + id + "] "
+	}
 
 	format = strings.Trim(format, "\n")
 	switch typ {
-    case PANIC:
+	case "PANIC":
-        log.golog.SetPrefix("\x1b[31m" + "PANI ")
+		log.logger.SetPrefix("\x1b[31m" + "PANIC " + idstr + "[" + log.module + "] ")
-    case FATAL:
+	case "FATAL":
-        log.golog.SetPrefix("\x1b[31m" + "FATA ")
+		log.logger.SetPrefix("\x1b[31m" + "FATAL  " + idstr + "[" + log.module + "] ")
-    case WARNING:
+	case "WARNING":
-        log.golog.SetPrefix("\x1b[32m" + "WARN ")
+		log.logger.SetPrefix("\x1b[32m" + "WARNING  " + idstr + "[" + log.module + "] ")
-    case ERROR:
+	case "ERROR":
-        log.golog.SetPrefix("\x1b[33m" + "ERRO ")
+		log.logger.SetPrefix("\x1b[32m" + "ERROR " + idstr + "[" + log.module + "] ")
-    case INFO:
+	case "NOTICE":
-        log.golog.SetPrefix("INFO ")
+		log.logger.SetPrefix("NOTICE  " + idstr + "[" + log.module + "] ")
-    case NOTICE:
+	case "DEBUGE":
-        log.golog.SetPrefix("NOTI ")
+		log.logger.SetPrefix("DEBUGE  " + idstr + "[" + log.module + "] ")
-    case DEBUG:
-        log.golog.SetPrefix("DBUG ")
 	default:
-        log.golog.SetPrefix("UNKN ")
+		log.logger.SetPrefix("UNKNOWN  " + idstr + "[" + log.module + "] ")
 	}
 
-    if mylog == log {
+	if mylogger == log {
 		calldepth = calldepth + 1
 	}
 
-    if typ == FATAL || typ == WARNING || typ == ERROR {
+	if typ == "FATAL" || typ == "WARNING" || typ == "ERROR" {
-        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\x1b[0m\n", v...))
+		log.logger.Output(calldepth, fmt.Sprintf(format+"\x1b[0m\n", v...))
-    } else if typ == NOTICE {
+	} else if typ == "NOTICE" {
 		calldepth = calldepth + 2
-        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\n", v...))
+		log.logger.Output(calldepth, fmt.Sprintf(format+"\n", v...))
-    } else if typ == PANIC {
+	} 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...)
+		panicstr := fmt.Sprintf(format+"\x1b[0m. Panic stack:\n%s\n", v...)
-        log.golog.Output(calldepth, panicstr)
+		log.logger.Output(calldepth, panicstr)
 		panic(ErrLogPanic)
 	} else {
-        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\n", v...))
+		log.logger.Output(calldepth, fmt.Sprintf(format+"\n", v...))
 	}
 }
 
-func needWriteLogToFile() bool {
+//////////////global log trace//////////////////begin///////////////////
-    if cls, ok := os.LookupEnv("QOOLOG_CLOSE_FILELOG"); ok && cls != "N" && cls != "n" {
+
-        return false
+func TRACE_INTO(format string, v ...interface{}) string {
-    } else if ink8s, ok := os.LookupEnv("KUBERNETES_PORT"); ok && ink8s != "" {
+	_, fn, line, _ := runtime.Caller(1)
-        return false
+	strfn := fmt.Sprintf("%s:%d", fn, line)
-    }
+	Debugf("TRACE into ["+strfn+"]"+format+"...\r\n", v...)
-    return true
+
+	return strfn
 }
 
-func needWriteLogToStdout() bool {
+func TRACE_EXIT(strfn string, format string, v ...interface{}) {
-    if cls, ok := os.LookupEnv("QOOLOG_CLOSE_STDLOG"); ok && (cls == "Y" || cls == "y") {
+	Debugf("TRACE exit ["+strfn+"]"+format+"...\r\n", v...)
-        return false
-    }
-    return true
 }
 
-// //////////////////////////////////////////////////////////////////////////////////
+type mWriter struct {
-// ///////////////////////Initialize/////////////////////////////////////////////////
+	logw *os.File
-// //////////////////////////////////////////////////////////////////////////////////
+	stdw *os.File
-var once sync.Once = sync.Once{}
+}
 
-// init
+func (w mWriter) Write(p []byte) (n int, err error) {
+	if flagcachelog {
+		logCache.Write(p)
+	}
+	w.stdw.Write(p)
+	return w.logw.Write(p)
+}
+
+var cacheLogLock = new(sync.Mutex)
+var flagcachelog = false
+var logCache = bytes.Buffer{}
+
+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()
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////Initialize/////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////
 func init() {
 	once.Do(initlog)
 }
 
-// initlog
 func initlog() {
-    // Step 1. create base writer & cache writer for ALL log
+	var mwriter mWriter
-    var (
+	var openlog = func(logname string) *log.Logger {
-        logDir          = "./logs/"
+		fp, err := os.OpenFile(logname, os.O_APPEND|os.O_CREATE|os.O_WRONLY, os.ModePerm)
-        logName         = getExeFilename()
+		if err != nil {
-        logDirsOptional = []string{"./log", "/var/log"}
+			panic("open log file failed:" + err.Error())
-        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
+		mwriter.logw.Close()
-    if needWriteLogToFile() {
+		mwriter.logw = fp
-        baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
+		mwriter.stdw = os.Stdout
+		glogger = log.New(mwriter, "", log.Ldate|log.Lmicroseconds|log.Lshortfile)
+		return glogger
+	}
+
+	_, logfilename := filepath.Split(os.Args[0])
+	LOGSPLITTIME := "20060102" //20060102150405
+	LOGFILENAME := logfilename + ".log"
+	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
+	}
+
+	glogger = openlog(LOGFILENAME)
+	mylogger = New("system")
+	curhourtime := time.Now().Local().Format(LOGSPLITTIME)
+	prehourtime := curhourtime
+
 	go func() {
+		intva := 2 * time.Minute
+		timer := time.NewTimer(1 * time.Second)
+
 		for {
-                tag := time.Now().Local().Format(logSplitTag)
+			select {
-                baseWriter.TryBackupLogFile(tag)
+			case <-timer.C:
-                time.Sleep(2 * time.Minute)
+				curhourtime := time.Now().Local().Format(LOGSPLITTIME)
+				//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

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

logid+glslogid.go

@@ -1,39 +0,0 @@
-// +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

@@ -1,22 +0,0 @@
-// +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

@@ -1,82 +0,0 @@
-// 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

@@ -1,41 +0,0 @@
-// 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

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

@@ -1,134 +0,0 @@
-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
-}