b612/starlog
1
0
Fork 0
Code Issues Pull Requests Projects Releases 5 Wiki Activity

newgen

Browse Source
This commit is contained in:
兔子 2020-10-22 16:42:21 +08:00
parent a5e148d6b8
commit ecba5e76ff
2 changed files with 164 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
starlog.go
View File

@ -13,6 +13,8 @@ import (
"sync"
"time"
"b612.me/starmap"
"github.com/mattn/go-colorable"
)
@ -48,6 +50,8 @@ var (
LvPanic: []Attr{FgRed, Bold},
LvFatal: []Attr{FgRed},
}
stdLock sync.Mutex
logmaps sync.Map
)
type StarLogger struct {
@ -63,14 +67,21 @@ type StarLogger struct {
DoShow bool
switching bool
isStd bool
//HandleFunc
waiting chan int
//handleFunc
stopChan chan int
setChan chan int
outshow io.Writer
LogLevel int
HandleFunc func([]Attr, string)
handleFunc func([]Attr, string)
StdFuncColor bool
logbuf string
BufSize int
stacks starmap.StarStack
}
type logTran struct {
color []Attr
log string
}
var Std = New(nil)
@ -80,7 +91,9 @@ func init() {
Std.DoShow = true
Std.Flag = "MAN"
Std.isStd = true
logmaps.Store("std", Std)
}
func Close() error {
if StdFile == nil {
return errors.New("File not Open")
@ -107,9 +120,23 @@ func New(out io.Writer) *StarLogger {
logger.StdFuncColor = true
logger.BufSize = 0
logger.Flag = "MAN"
logger.stopChan, logger.setChan = make(chan int), make(chan int)
go logger.runTransfer()
logmaps.Store(fmt.Sprint(time.Now().UnixNano()), logger)
return logger
}
func (logger *StarLogger) SetHandleFunc(funcs func([]Attr, string)) {
if logger.handleFunc == nil {
logger.setChan <- 1
}
logger.handleFunc = funcs
}
func (logger *StarLogger) GetHandleFunc() func([]Attr, string) {
return logger.handleFunc
}
func (logger *StarLogger) Flush() error {
logger.mu.Lock()
defer logger.mu.Unlock()
@ -118,6 +145,46 @@ func (logger *StarLogger) Flush() error {
return nil
}
func (logger *StarLogger) Close() error {
logger.stopChan <- 1
logmaps.Range(func(k, v interface{}) bool {
if v.(*StarLogger) == logger {
logmaps.Delete(k)
return false
}
return true
})
logger = nil
return nil
}
func (logger *StarLogger) runTransfer() {
if logger.handleFunc == nil {
select {
case <-logger.stopChan:
return
case <-logger.setChan:
}
}
for {
select {
case <-logger.stopChan:
return
default:
}
if logger.handleFunc == nil {
time.Sleep(time.Millisecond * 100)
continue
}
poped := logger.stacks.MustPop()
if poped == nil {
time.Sleep(time.Millisecond * 20)
continue
}
val := poped.(logTran)
logger.handleFunc(val.color, val.log)
}
}
func NewFlag() *StarLogger {
return Std.NewFlag()
}
@ -135,9 +202,13 @@ func (logger *StarLogger) NewFlag() *StarLogger {
logger2.mu = logger.mu
logger2.lock = logger.lock
logger2.Flag = string([]byte{uint8(rand.Intn(26) + 65), uint8(rand.Intn(26) + 65), uint8(rand.Intn(26) + 65)})
logger2.stopChan, logger2.setChan = make(chan int), make(chan int)
logger2.handleFunc = logger.handleFunc
go logger2.runTransfer()
if logger2.Flag == "MAN" {
logger2.Flag = "RYZ"
}
logmaps.Store(fmt.Sprint(time.Now().UnixNano()), logger2)
return logger2
}
@ -202,8 +273,9 @@ func (logger *StarLogger) output(level int, logstr string) {
logcolor := NewColor(Colors[level]...)
logcolor.Fprint(logger.outshow, logs)
}
if logger.HandleFunc != nil {
go logger.HandleFunc(Colors[level], logs)
if logger.handleFunc != nil {
//logger.handleFunc(Colors[level], logs)
logger.stacks.Push(logTran{Colors[level], logs})
}
if logger.DoWrite {
if logger.BufSize == 0 {
@ -223,6 +295,8 @@ func (logger *StarLogger) Debug(str ...interface{}) {
}
func Debug(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Debug(str...)
}
@ -233,6 +307,8 @@ func (logger *StarLogger) Debugf(format string, str ...interface{}) {
}
func Debugf(format string, str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Debugf(format, str...)
}
@ -243,6 +319,8 @@ func (logger *StarLogger) Debugln(str ...interface{}) {
}
func Debugln(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Debugln(str...)
}
@ -253,6 +331,8 @@ func (logger *StarLogger) Info(str ...interface{}) {
}
func Info(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Info(str...)
}
@ -263,6 +343,8 @@ func (logger *StarLogger) Infof(format string, str ...interface{}) {
}
func Infof(format string, str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Infof(format, str...)
}
@ -273,6 +355,8 @@ func (logger *StarLogger) Infoln(str ...interface{}) {
}
func Infoln(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Infoln(str...)
}
@ -283,6 +367,8 @@ func (logger *StarLogger) Notice(str ...interface{}) {
}
func Notice(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Notice(str...)
}
@ -293,6 +379,8 @@ func (logger *StarLogger) Noticef(format string, str ...interface{}) {
}
func Noticef(format string, str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Noticef(format, str...)
}
@ -303,6 +391,8 @@ func (logger *StarLogger) Noticeln(str ...interface{}) {
}
func Noticeln(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Noticeln(str...)
}
@ -313,6 +403,8 @@ func (logger *StarLogger) Warning(str ...interface{}) {
}
func Warning(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Warning(str...)
}
@ -323,6 +415,8 @@ func (logger *StarLogger) Warningf(format string, str ...interface{}) {
}
func Warningf(format string, str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Warningf(format, str...)
}
@ -333,6 +427,8 @@ func (logger *StarLogger) Warningln(str ...interface{}) {
}
func Warningln(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Warningln(str...)
}
@ -343,6 +439,8 @@ func (logger *StarLogger) Error(str ...interface{}) {
}
func Error(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Error(str...)
}
@ -353,6 +451,8 @@ func (logger *StarLogger) Errorf(format string, str ...interface{}) {
}
func Errorf(format string, str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Errorf(format, str...)
}
@ -363,6 +463,8 @@ func (logger *StarLogger) Errorln(str ...interface{}) {
}
func Errorln(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Errorln(str...)
}
@ -373,6 +475,8 @@ func (logger *StarLogger) Critical(str ...interface{}) {
}
func Critical(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Critical(str...)
}
@ -383,6 +487,8 @@ func (logger *StarLogger) Criticalf(format string, str ...interface{}) {
}
func Criticalf(format string, str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Criticalf(format, str...)
}
@ -393,6 +499,8 @@ func (logger *StarLogger) Criticalln(str ...interface{}) {
}
func Criticalln(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Criticalln(str...)
}
@ -404,6 +512,8 @@ func (logger *StarLogger) Fatal(str ...interface{}) {
}
func Fatal(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Fatal(str...)
}
@ -415,6 +525,8 @@ func (logger *StarLogger) Fatalf(format string, str ...interface{}) {
}
func Fatalf(format string, str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Fatalf(format, str...)
}
@ -426,6 +538,8 @@ func (logger *StarLogger) Fatalln(str ...interface{}) {
}
func Fatalln(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Fatalln(str...)
}
@ -437,6 +551,8 @@ func (logger *StarLogger) Panic(str ...interface{}) {
}
func Panic(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Panic(str...)
}
@ -448,6 +564,8 @@ func (logger *StarLogger) Panicf(format string, str ...interface{}) {
}
func Panicf(format string, str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Panicf(format, str...)
}
@ -459,6 +577,8 @@ func (logger *StarLogger) Panicln(str ...interface{}) {
}
func Panicln(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Panicln(str...)
}
@ -471,6 +591,8 @@ func (logger *StarLogger) Print(str ...interface{}) {
}
func Print(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Print(str...)
}
@ -483,6 +605,8 @@ func (logger *StarLogger) Printf(format string, str ...interface{}) {
}
func Printf(format string, str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Printf(format, str...)
}
@ -495,6 +619,8 @@ func (logger *StarLogger) Println(str ...interface{}) {
}
func Println(str ...interface{}) {
stdLock.Lock()
defer stdLock.Unlock()
Std.isStd = true
Std.Println(str...)
}
@ -504,8 +630,8 @@ func StdPrint(c []Attr, str ...interface{}) {
defer Std.lock.Unlock()
colorstr := NewColor(c...)
colorstr.Print(str...)
if Std.StdFuncColor && Std.HandleFunc != nil {
go Std.HandleFunc(c, fmt.Sprint(str...))
if Std.StdFuncColor && Std.handleFunc != nil {
go Std.handleFunc(c, fmt.Sprint(str...))
}
}
@ -514,8 +640,8 @@ func StdPrintf(c []Attr, format string, str ...interface{}) {
defer Std.lock.Unlock()
colorstr := NewColor(c...)
colorstr.Printf(format, str...)
if Std.StdFuncColor && Std.HandleFunc != nil {
go Std.HandleFunc(c, fmt.Sprintf(format, str...))
if Std.StdFuncColor && Std.handleFunc != nil {
go Std.handleFunc(c, fmt.Sprintf(format, str...))
}
}
@ -524,8 +650,8 @@ func StdPrintln(c []Attr, str ...interface{}) {
defer Std.lock.Unlock()
colorstr := NewColor(c...)
colorstr.Println(str...)
if Std.StdFuncColor && Std.HandleFunc != nil {
go Std.HandleFunc(c, fmt.Sprintln(str...))
if Std.StdFuncColor && Std.handleFunc != nil {
go Std.handleFunc(c, fmt.Sprintln(str...))
}
}
@ -537,6 +663,33 @@ func (logger *StarLogger) SwitchOut(out io.Writer) {
logger.switching = false
}
func (logger *StarLogger) SetSwitching(out bool) {
logger.lock.Lock()
defer logger.lock.Unlock()
logger.switching = out
}
func SetSwitchingAll(out bool) {
logmaps.Range(func(k, v interface{}) bool {
v.(*StarLogger).SetSwitching(out)
return true
})
}
func SwitchOutAll(out io.Writer) {
logmaps.Range(func(k, v interface{}) bool {
v.(*StarLogger).SwitchOut(out)
return true
})
}
func SethandleFuncAll(fn func([]Attr, string)) {
logmaps.Range(func(k, v interface{}) bool {
v.(*StarLogger).handleFunc = fn
return true
})
}
func SetLogFile(path string) error {
var err error
StdFile, err = os.Create(path)

1
starlog_test.go
View File

@ -5,5 +5,4 @@ import (
)
func Test_LOG(t *testing.T) {
}