Compare commits

...

12 Commits
v1.0.4 ... main

Author Message Date
a73906b74f feature: QOOLOG_CLOSE_STDLOG & Println & Fatal 2024-07-25 00:38:06 +08:00
bryanqiu
edecd4a8d7 add SetLogLevelByName 2023-07-21 11:40:48 +08:00
bryanqiu
ec1b3b298f add SetLogLevelByName 2023-07-21 11:27:44 +08:00
bryanqiu
6126b66f6a add SetLogLevelByName 2023-07-21 11:24:30 +08:00
bryanqiu
e27ea9f370 v1.2.3 add error output when printpretty 2023-04-27 11:16:31 +08:00
bryanqiu
d93e63ab09 v1.1.1 donot write to file when in k8s/docker 2023-04-10 17:12:23 +08:00
bryanqiu
be4c2164c8 v1.2.1 remove module log 2023-04-10 15:15:26 +08:00
bryanqiu
2455ca35b2 v1.2.0 2023-04-10 11:50:25 +08:00
bryanqiu
e6efed682b v1.1.0 2022-12-05 10:55:44 +08:00
bryanqiu
a2043ae99c v1.1.0 2022-12-05 10:55:24 +08:00
admin
7400653848 add logid 2022-12-04 18:58:35 +08:00
bryanqiu
71b00c8a37 add Infof & logLevel 2022-11-15 15:19:18 +08:00
12 changed files with 7146 additions and 223 deletions

99
global.go Normal file
View File

@ -0,0 +1,99 @@
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()))
}

6
go.mod
View File

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

440
log.go
View File

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

9
log_test.go Normal file
View File

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

39
logid+glslogid.go Normal file
View File

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

22
logid+runtimelogid.go Normal file
View File

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

View File

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

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

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

29
util.go Normal file
View File

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

134
writer.go Normal file
View File

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