Compare commits

..

No commits in common. "main" and "v1.1.1" have entirely different histories.
main ... v1.1.1

7 changed files with 144 additions and 234 deletions

View File

@ -25,14 +25,10 @@ func Cleanup() {
} }
} }
func SetLogLevel(newlv LogLevel) (oldlv LogLevel) { func SetLogLevel(newlv logLevel) (oldlv logLevel) {
return mylog.SetLogLevel(newlv) return mylog.SetLogLevel(newlv)
} }
func SetLogLevelByName(newlv string) (oldlv string) {
return mylog.SetLogLevelByName(newlv)
}
func PrintPretty(prefix string, v interface{}) { func PrintPretty(prefix string, v interface{}) {
mylog.PrintPretty(prefix, v) mylog.PrintPretty(prefix, v)
} }
@ -62,7 +58,7 @@ func Warningf(format string, v ...interface{}) {
} }
func Errorf(format string, v ...interface{}) { func Errorf(format string, v ...interface{}) {
mylog.Errorf(format, v...) mylog.Warningf(format, v...)
} }
func Panicf(format string, v ...interface{}) { func Panicf(format string, v ...interface{}) {
@ -73,14 +69,6 @@ func Fatalf(format string, v ...interface{}) {
mylog.Fatalf(format, v...) 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 { func TraceInto(format string, v ...interface{}) string {
_, fn, line, _ := runtime.Caller(1) _, fn, line, _ := runtime.Caller(1)
strfn := fmt.Sprintf("%s:%d", fn, line) strfn := fmt.Sprintf("%s:%d", fn, line)

6
go.mod
View File

@ -2,8 +2,4 @@ module qoobing.com/gomod/log
go 1.16 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
)

107
log.go
View File

@ -16,38 +16,16 @@ import (
) )
const ( 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~~~~~~" 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 ( var (
golog *log.Logger = nil golog *log.Logger = nil
mylog *Logger = nil mylog *Logger = nil
@ -55,11 +33,11 @@ var (
modulelogs map[string]*Logger = map[string]*Logger{} modulelogs map[string]*Logger = map[string]*Logger{}
) )
type LogLevel int type logLevel int
type Logger struct { type Logger struct {
module string module string
golog *log.Logger golog *log.Logger
loglevel LogLevel loglevel logLevel
} }
type LogidCreator interface { 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 oldlv = log.loglevel
log.loglevel = newlv log.loglevel = newlv
return oldlv 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{}) { 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{}) { 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) 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...) 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 { func (log *Logger) GetLogidStr(format string) string {
if logidCreator != nil { if logidCreator != nil {
return fmt.Sprintf(format, logidCreator.GetLogid()) return fmt.Sprintf(format, logidCreator.GetLogid())
@ -176,7 +124,7 @@ func (log *Logger) GetLogidStr(format string) string {
return "" 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 { if typ > log.loglevel {
return return
} }
@ -195,7 +143,7 @@ func (log *Logger) logwrite(typ LogLevel, calldepth int, format string, v ...int
case WARNING: case WARNING:
log.golog.SetPrefix("\x1b[32m" + "WARN ") log.golog.SetPrefix("\x1b[32m" + "WARN ")
case ERROR: case ERROR:
log.golog.SetPrefix("\x1b[33m" + "ERRO ") log.golog.SetPrefix("\x1b[32m" + "ERRO ")
case INFO: case INFO:
log.golog.SetPrefix("INFO ") log.golog.SetPrefix("INFO ")
case NOTICE: case NOTICE:
@ -236,13 +184,6 @@ func needWriteLogToFile() bool {
return true return true
} }
func needWriteLogToStdout() bool {
if cls, ok := os.LookupEnv("QOOLOG_CLOSE_STDLOG"); ok && (cls == "Y" || cls == "y") {
return false
}
return true
}
// ////////////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////////////
// ///////////////////////Initialize///////////////////////////////////////////////// // ///////////////////////Initialize/////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////////////
@ -265,14 +206,14 @@ func initlog() {
gologFlags = log.Ldate | log.Lmicroseconds | log.Lshortfile gologFlags = log.Ldate | log.Lmicroseconds | log.Lshortfile
) )
// Step 2.1 add stdout to base writer if need // Step 2. init golog(golang std logger) & mylog(myself defined logger)
if needWriteLogToStdout() { golog = log.New(NewCacheWriter(baseWriter), "", gologFlags)
baseWriter.stdw = os.Stdout mylog = New("system")
}
// Step 2.2 rotate log(split log ) if need // Step 3. backgroud split log (log rotate) if need
if needWriteLogToFile() { if needWriteLogToFile() {
baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
go func() { go func() {
baseWriter.OpenLogFile(logDir, logName, logDirsOptional)
for { for {
tag := time.Now().Local().Format(logSplitTag) tag := time.Now().Local().Format(logSplitTag)
baseWriter.TryBackupLogFile(tag) baseWriter.TryBackupLogFile(tag)
@ -280,8 +221,4 @@ func initlog() {
} }
}() }()
} }
// Step 3. init golog(golang std logger) & mylog(myself defined logger)
golog = log.New(NewCacheWriter(baseWriter), "", gologFlags)
mylog = New("system")
} }

View File

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

View File

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

View File

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

View File

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