feature: QOOLOG_CLOSE_STDLOG & Println & Fatal

global.go

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

@@ -16,16 +16,38 @@ 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
@@ -33,11 +55,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 {
@@ -62,20 +84,41 @@ 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{}) {
-	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)
 }
 
@@ -117,6 +160,15 @@ 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())
@@ -124,30 +176,34 @@ 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 idstr = log.GetLogidStr("[%s] ")
+    var (
+        idstr  = log.GetLogidStr("[%s] ")
+        prestr = idstr // + "[" + log.module + "] "
+    )
+
     format = strings.Trim(format, "\n")
     switch typ {
     case PANIC:
-		log.golog.SetPrefix("\x1b[31m" + "PANIC " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("\x1b[31m" + "PANI ")
     case FATAL:
-		log.golog.SetPrefix("\x1b[31m" + "FATAL " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("\x1b[31m" + "FATA ")
     case WARNING:
-		log.golog.SetPrefix("\x1b[32m" + "WARNING " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("\x1b[32m" + "WARN ")
     case ERROR:
-		log.golog.SetPrefix("\x1b[32m" + "ERROR " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("\x1b[33m" + "ERRO ")
     case INFO:
-		log.golog.SetPrefix("INFO " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("INFO ")
     case NOTICE:
-		log.golog.SetPrefix("NOTICE " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("NOTI ")
     case DEBUG:
-		log.golog.SetPrefix("DEBUG " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("DBUG ")
     default:
-		log.golog.SetPrefix("UNKNOWN " + idstr + "[" + log.module + "] ")
+        log.golog.SetPrefix("UNKN ")
     }
 
     if mylog == log {
@@ -155,25 +211,41 @@ func (log *Logger) logwrite(typ logLevel, calldepth int, format string, v ...int
     }
 
     if typ == FATAL || typ == WARNING || typ == ERROR {
-		log.golog.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.golog.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.golog.Output(calldepth, panicstr)
         panic(ErrLogPanic)
     } else {
-		log.golog.Output(calldepth, fmt.Sprintf(format+"\n", v...))
+        log.golog.Output(calldepth, prestr+fmt.Sprintf(format+"\n", v...))
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////////
+func needWriteLogToFile() bool {
-/////////////////////////Initialize/////////////////////////////////////////////////
+    if cls, ok := os.LookupEnv("QOOLOG_CLOSE_FILELOG"); ok && cls != "N" && cls != "n" {
-////////////////////////////////////////////////////////////////////////////////////
+        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
@@ -190,17 +262,16 @@ 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. init golog(golang std logger) & mylog(myself defined logger)
+    // Step 2.1 add stdout to base writer if need
-	golog = goSystemLog
+    if needWriteLogToStdout() {
-	mylog = New("system")
+        baseWriter.stdw = os.Stdout
+    }
+    // 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)
@@ -208,4 +279,9 @@ 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

@@ -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

@@ -1,4 +1,5 @@
 // +build glslogid
+
 package log
 
 import (

logid+runtimelogid.go

@@ -1,4 +1,5 @@
 // +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 = true
+	w.cacheing = false
 }