global.go

@@ -25,14 +25,10 @@ func Cleanup() {
 	}
 }
 
-func SetLogLevel(newlv LogLevel) (oldlv LogLevel) {
+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)
 }
@@ -62,7 +58,7 @@ func Warningf(format string, v ...interface{}) {
 }
 
 func Errorf(format string, v ...interface{}) {
-	mylog.Errorf(format, v...)
+	mylog.Warningf(format, v...)
 }
 
 func Panicf(format string, v ...interface{}) {
@@ -73,14 +69,6 @@ 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)

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

@@ -16,38 +16,16 @@ import (
 )
 
 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
@@ -55,11 +33,11 @@ var (
 	modulelogs   map[string]*Logger = map[string]*Logger{}
 )
 
-type LogLevel int
+type logLevel int
 type Logger struct {
 	module   string
 	golog    *log.Logger
-    loglevel LogLevel
+	loglevel logLevel
 }
 
 type LogidCreator interface {
@@ -84,41 +62,20 @@ func New(module string) *Logger {
 	}
 }
 
-// SetLogLevel set new log level
+//////////////////////////////////////////////////////////////////
-func (log *Logger) SetLogLevel(newlv LogLevel) (oldlv LogLevel) {
+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(DEBUG, 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 {
-        preety = err.Error()
-    } else {
-        preety = string(pkg)
-    }
 	log.logwrite(DEBUG, 3, prefix+"%s\n", preety)
 }
 
@@ -160,15 +117,6 @@ func (log *Logger) Panicf(format string, v ...interface{}) {
 	log.logwrite(PANIC, 3, format, v...)
 }
 
-func (log *Logger) Fatal(v ...interface{}){
-    log.logwrite(FATAL, 3, "%s", fmt.Sprintln(v...))
-}
-
-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())
@@ -176,34 +124,30 @@ func (log *Logger) GetLogidStr(format string) string {
 	return ""
 }
 
-func (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...interface{}) {
+func (log *Logger) logwrite(typ logLevel, calldepth int, format string, v ...interface{}) {
 	if typ > log.loglevel {
 		return
 	}
 
-    var (
+	var idstr = log.GetLogidStr("[%s] ")
-        idstr  = log.GetLogidStr("[%s] ")
-        prestr = idstr // + "[" + log.module + "] "
-    )
-
 	format = strings.Trim(format, "\n")
 	switch typ {
 	case PANIC:
-        log.golog.SetPrefix("\x1b[31m" + "PANI ")
+		log.golog.SetPrefix("\x1b[31m" + "PANIC " + idstr + "[" + log.module + "] ")
 	case FATAL:
-        log.golog.SetPrefix("\x1b[31m" + "FATA ")
+		log.golog.SetPrefix("\x1b[31m" + "FATAL " + idstr + "[" + log.module + "] ")
 	case WARNING:
-        log.golog.SetPrefix("\x1b[32m" + "WARN ")
+		log.golog.SetPrefix("\x1b[32m" + "WARNING " + idstr + "[" + log.module + "] ")
 	case ERROR:
-        log.golog.SetPrefix("\x1b[33m" + "ERRO ")
+		log.golog.SetPrefix("\x1b[32m" + "ERROR " + idstr + "[" + log.module + "] ")
 	case INFO:
-        log.golog.SetPrefix("INFO ")
+		log.golog.SetPrefix("INFO " + idstr + "[" + log.module + "] ")
 	case NOTICE:
-        log.golog.SetPrefix("NOTI ")
+		log.golog.SetPrefix("NOTICE " + idstr + "[" + log.module + "] ")
 	case DEBUG:
-        log.golog.SetPrefix("DBUG ")
+		log.golog.SetPrefix("DEBUG " + idstr + "[" + log.module + "] ")
 	default:
-        log.golog.SetPrefix("UNKN ")
+		log.golog.SetPrefix("UNKNOWN " + idstr + "[" + log.module + "] ")
 	}
 
 	if mylog == log {
@@ -211,41 +155,25 @@ func (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...int
 	}
 
 	if typ == FATAL || typ == WARNING || typ == ERROR {
-        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\x1b[0m\n", v...))
+		log.golog.Output(calldepth, 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+"\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...)
+		panicstr := fmt.Sprintf(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...))
+		log.golog.Output(calldepth, fmt.Sprintf(format+"\n", v...))
 	}
 }
 
-func needWriteLogToFile() bool {
+////////////////////////////////////////////////////////////////////////////////////
-    if cls, ok := os.LookupEnv("QOOLOG_CLOSE_FILELOG"); ok && cls != "N" && cls != "n" {
+/////////////////////////Initialize/////////////////////////////////////////////////
-        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
-}
-
-// //////////////////////////////////////////////////////////////////////////////////
-// ///////////////////////Initialize/////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////////////////////
 var once sync.Once = sync.Once{}
 
 // init
@@ -262,16 +190,17 @@ func initlog() {
 		logDirsOptional = []string{"./log", "/var/log"}
 		logSplitTag     = "20060102" //20060102150405
 		baseWriter      = NewBaseWriter(nil, os.Stdout, nil)
+		cacheWriter     = NewCacheWriter(baseWriter)
 		gologFlags      = log.Ldate | log.Lmicroseconds | log.Lshortfile
+		goSystemLog     = log.New(cacheWriter, "", gologFlags)
 	)
 
-    // Step 2.1 add stdout to base writer if need
+	// Step 2. init golog(golang std logger) & mylog(myself defined logger)
-    if needWriteLogToStdout() {
+	golog = goSystemLog
-        baseWriter.stdw = os.Stdout
+	mylog = New("system")
-    }
-    // Step 2.2 rotate log(split log ) if need
-    if needWriteLogToFile() {
 	baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
+
+	// Step 3. backgroud split log (log rotate)
 	go func() {
 		for {
 			tag := time.Now().Local().Format(logSplitTag)
@@ -279,9 +208,4 @@ func initlog() {
 			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")
 }

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,5 +1,4 @@
 // +build glslogid
-
 package log
 
 import (

logid+runtimelogid.go

@@ -1,5 +1,4 @@
 // +build runtimelogid
-
 package log
 
 //// Format writes the source file path and line number of the record to the buf.

writer.go

@@ -130,5 +130,5 @@ func (w *cacheWriter) StartCacheLog() {
 
 func (w *cacheWriter) StopCacheLog() {
 	w.cacheLock.Unlock()
-	w.cacheing = false
+	w.cacheing = true
 }