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 (
-	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
-)
+require qoobing.com/gomod/str v1.0.1

log.go

@@ -16,50 +16,29 @@ import (
 )
 
 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~~~~~"
+	PANIC       logLevel = 0
+	FATAL       logLevel = 1
+	ERROR       logLevel = 2
+	NOTICE      logLevel = 3
+	WARNING     logLevel = 4
+	INFO        logLevel = 5
+	DEBUG       logLevel = 9
 	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
+	logWriter    *cacheWriter       = nil
 	logidCreator LogidCreator       = nil
 	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 +63,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 = ""
-    if pkg, err := json.Marshal(v); err != nil {
-        str = err.Error()
-    } else {
-        str = string(pkg)
-    }
-    log.logwrite(DEBUG, 3, prefix+"%s\n", str)
+	preety, _ := json.Marshal(v)
+	log.logwrite(DEBUG, 3, prefix+"%s\n", preety)
 }
 
 func (log *Logger) PrintPretty(prefix string, v interface{}) {
-    var preety = ""
-    if pkg, err := json.MarshalIndent(v, "==", "  "); err != nil {
-        preety = err.Error()
-    } else {
-        preety = string(pkg)
-    }
+	preety, _ := json.MarshalIndent(v, "==", "    ")
 	log.logwrite(DEBUG, 3, prefix+"%s\n", preety)
 }
 
@@ -160,15 +118,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,14 +125,14 @@ 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] ")
-        prestr = idstr // + "[" + log.module + "] "
+		prestr = idstr + "[" + log.module + "] "
 	)
 
 	format = strings.Trim(format, "\n")
@@ -195,7 +144,7 @@ func (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...int
 	case WARNING:
 		log.golog.SetPrefix("\x1b[32m" + "WARN ")
 	case ERROR:
-        log.golog.SetPrefix("\x1b[33m" + "ERRO ")
+		log.golog.SetPrefix("\x1b[32m" + "ERRO ")
 	case INFO:
 		log.golog.SetPrefix("INFO ")
 	case NOTICE:
@@ -227,22 +176,6 @@ func (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...int
 	}
 }
 
-func needWriteLogToFile() bool {
-    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/////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////////////////////
@@ -265,13 +198,13 @@ func initlog() {
 		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
-    if needWriteLogToFile() {
+	// Step 2. init golog(golang std logger) & mylog(myself defined logger)
+	logWriter = NewCacheWriter(baseWriter)
+	golog = log.New(logWriter, "", gologFlags)
+	mylog = New("system")
 	baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
+
+	// Step 3. backgroud split log (log rotate)
 	go func() {
 		for {
 			tag := time.Now().Local().Format(logSplitTag)
@@ -280,8 +213,3 @@ func initlog() {
 		}
 	}()
 }
-
-    // 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
 }