You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
491 lines
9.3 KiB
491 lines
9.3 KiB
// ------------------------------------------------------------------------
|
|
// Project active2
|
|
// Active Thing (activething.com) git.activething.com/go
|
|
//
|
|
// File name logger_manager.go
|
|
// Created by DEV
|
|
// Modified 26/04/2024
|
|
//
|
|
// Copyright 2024 activething.com
|
|
// ------------------------------------------------------------------------
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// ------------------------------------------------------------------------
|
|
|
|
package alogs
|
|
|
|
import (
|
|
"context"
|
|
"errs"
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"syncs/queue"
|
|
)
|
|
|
|
type (
|
|
|
|
ActiveLogger struct {
|
|
sync.RWMutex
|
|
|
|
filters EntryFilters
|
|
extenders EntryExtenders
|
|
|
|
queue queue.GQueue[*Entry]
|
|
|
|
scopes loggerScopes
|
|
loggers []Logger
|
|
|
|
|
|
ctx context.Context
|
|
asyncMode bool
|
|
entryChan chan *Entry
|
|
|
|
level Level
|
|
name string
|
|
state State
|
|
count int64
|
|
|
|
logErrors bool
|
|
errors errs.ErrorList
|
|
|
|
onErrorFn ActiveLoggerErrorFnc
|
|
onFatalFn ActiveLoggerEntryFnc
|
|
}
|
|
|
|
ActiveLoggerFnc func(manager *ActiveLogger)
|
|
|
|
ActiveLoggerErrorFnc func(manager *ActiveLogger, err error)
|
|
|
|
ActiveLoggerEntryFnc func(manager *ActiveLogger, entry *Entry)
|
|
)
|
|
|
|
|
|
func NewActiveManager(name string, level Level, options ...ActiveLoggerFnc) *ActiveLogger {
|
|
l := &ActiveLogger{
|
|
filters : *NewEntryFilters(),
|
|
level : level,
|
|
state : StateCreated,
|
|
logErrors: true,
|
|
queue : *queue.NewGQueue[*Entry](false),
|
|
}
|
|
for _,o := range options {
|
|
o(l)
|
|
}
|
|
|
|
if l.asyncMode {
|
|
if l.ctx == nil {
|
|
l.ctx = context.Background()
|
|
}
|
|
}
|
|
|
|
return l
|
|
}
|
|
|
|
|
|
|
|
func (l *ActiveLogger) Name() string {
|
|
return l.name }
|
|
|
|
|
|
func (l *ActiveLogger) Level() Level {
|
|
l.RLock()
|
|
lv := l.level
|
|
l.RUnlock()
|
|
return lv
|
|
}
|
|
|
|
func (l *ActiveLogger) Context() context.Context {
|
|
return l.ctx }
|
|
|
|
func (l *ActiveLogger) SetLevel (level Level) {
|
|
l.Lock()
|
|
l.level = level
|
|
l.Unlock()
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) Count () int64 {
|
|
return atomic.LoadInt64(&l.count) }
|
|
|
|
|
|
func (l *ActiveLogger) incCount () {
|
|
atomic.AddInt64(&l.count,1) }
|
|
|
|
|
|
func (l *ActiveLogger) State () State {
|
|
l.RLock()
|
|
s := l.state
|
|
l.RUnlock()
|
|
return s
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) Errors () errs.ErrorList {
|
|
l.RLock()
|
|
ls := l.errors
|
|
l.RUnlock()
|
|
return ls
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) Start () error {
|
|
l.Lock()
|
|
if l.state == StateStarted {
|
|
l.Unlock()
|
|
return G.ErrLoggerStarted
|
|
}
|
|
|
|
if l.state == StateStopped {
|
|
l.errors = l.errors.Reset()
|
|
}
|
|
|
|
|
|
if l.asyncMode {
|
|
if l.ctx.Err() != nil {
|
|
return errs.NewErrCause(G.ErrLoggerNotStarted,l.ctx.Err())
|
|
}
|
|
l.entryChan = make(chan *Entry)
|
|
go l.runLogger()
|
|
}
|
|
l.state = StateStarted
|
|
|
|
|
|
er := l.handleLoggers(nil,func(c Logger, _ *Entry) error { return c.Start() }, G.FmtMsgStartErr,)
|
|
if er != nil {
|
|
l.handleQueue()
|
|
}
|
|
|
|
l.Unlock()
|
|
return er
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) Stop () error {
|
|
l.Lock()
|
|
if l.state != StateStarted {
|
|
l.Unlock()
|
|
return G.ErrLoggerNotStarted
|
|
}
|
|
|
|
|
|
if l.asyncMode {
|
|
close(l.entryChan)
|
|
l.entryChan = nil
|
|
}
|
|
l.state = StateStopped
|
|
|
|
er := l.handleLoggers(nil,func(c Logger, _ *Entry) error { return c.Stop() }, G.FmtMsgStopErr)
|
|
if er != nil {
|
|
l.handleQueue()
|
|
}
|
|
|
|
l.Unlock()
|
|
return er
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (l *ActiveLogger) Flush () error {
|
|
l.Lock()
|
|
|
|
er := l.handleLoggers(nil,func(c Logger,_ *Entry) error { return c.Flush() }, G.FmtMsgFlushErr)
|
|
if er != nil {
|
|
l.handleQueue()
|
|
}
|
|
|
|
l.Unlock()
|
|
return er
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) GetLogger(name string) Logger {
|
|
l.RLock()
|
|
var co Logger
|
|
if p := l.findLogger(name); p != -1 {
|
|
co = l.loggers[p]
|
|
}
|
|
l.RUnlock()
|
|
return co
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) AddLogger(logger Logger) error {
|
|
l.Lock()
|
|
nm := logger.Name()
|
|
if p := l.findLogger(nm); p != -1 {
|
|
l.Unlock()
|
|
return G.ErrDuplicatedLogger.WrapWithFieldString(errFieldLogger,nm)
|
|
}
|
|
var er error
|
|
l.loggers = append(l.loggers,logger)
|
|
if l.state == StateStarted {
|
|
er = logger.Start()
|
|
}
|
|
l.Unlock()
|
|
return er
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) DelLogger(name string) error {
|
|
l.Lock()
|
|
p := l.findLogger(name)
|
|
if p != -1 {
|
|
l.Unlock()
|
|
return G.ErrNotExistsLogger.WrapWithFieldString(entryFieldLogger,name)
|
|
}
|
|
er := l.loggers[p].Stop()
|
|
l.loggers = append(l.loggers[:p],l.loggers[p+1:]...)
|
|
|
|
l.Unlock()
|
|
return er
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) GetScope(name string) *LoggerScope {
|
|
ns := strings.Split(G.ScopeNameTransforms.Transform(name),g.scopeSepStr)
|
|
l.RLock()
|
|
sc := l.scopes.getScope(ns[0])
|
|
if sc != nil && len(ns) > 1 {
|
|
sc = sc.getScope(ns[1:])
|
|
}
|
|
l.RUnlock()
|
|
return sc
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) AddScope(name string, options ...LoggerScopeFnc) (*LoggerScope,error) {
|
|
nm := G.ScopeNameTransforms.Transform(name)
|
|
ns := strings.Split(nm,g.scopeSepStr)
|
|
|
|
l.Lock()
|
|
sc := l.scopes.getScope(ns[0])
|
|
if sc == nil {
|
|
sc = newLoggerScope(nm,l.level,l,"",nil,options)
|
|
l.scopes = append(l.scopes,sc)
|
|
if len(ns) == 1 {
|
|
l.Unlock()
|
|
return sc,nil
|
|
}
|
|
} else if len(ns) == 1 {
|
|
l.Unlock()
|
|
return nil,G.ErrDuplicatedScope.WrapWithFieldString(errFieldScope,ns[0])
|
|
}
|
|
l.Unlock()
|
|
|
|
return sc.newScope(ns[1:],options)
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) Fatal(msg string, err error, ops ...EntryFnc){
|
|
l.log(LevelFatal,msg,err,ops) }
|
|
|
|
func (l *ActiveLogger) Error(msg string, err error, ops ...EntryFnc){
|
|
l.log(LevelError,msg,err,ops) }
|
|
|
|
func (l *ActiveLogger) Warn (msg string, ops ...EntryFnc){
|
|
l.log(LevelWarn,msg,nil,ops) }
|
|
|
|
func (l *ActiveLogger) Info (msg string, ops ...EntryFnc){
|
|
l.log(LevelInfo,msg,nil,ops) }
|
|
|
|
func (l *ActiveLogger) Debug(msg string, ops ...EntryFnc){
|
|
l.log(LevelDebug,msg,nil,ops) }
|
|
|
|
func (l *ActiveLogger) Data (msg string, data any, ops ...EntryFnc){
|
|
l.log(LevelData,msg,nil,[]EntryFnc{EntryWithData(data,ops...)}) }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func (l *ActiveLogger) Log (entry *Entry) error {
|
|
if entry == nil {
|
|
return nil
|
|
}
|
|
if entry.Logger == nil {
|
|
entry.Logger = l
|
|
}
|
|
return l.handleEntry(entry)
|
|
}
|
|
|
|
func (l *ActiveLogger) log (level Level, msg string, err error,options []EntryFnc) {
|
|
_ = l.handleEntry(AcquireEntry(l, level, msg, err, options...)) }
|
|
|
|
|
|
func (l *ActiveLogger) logEntry (entry *Entry) error {
|
|
l.Lock()
|
|
|
|
|
|
if l.state != StateStarted {
|
|
l.Unlock()
|
|
return G.ErrLoggerNotStarted
|
|
}
|
|
if !l.level.Has(entry.Level) {
|
|
l.Unlock()
|
|
return nil
|
|
}
|
|
// Extendermos la entrada antes de
|
|
// someterla a los filtros
|
|
l.extenders.ExtendEntry(entry)
|
|
if !l.filters.Filter(entry) {
|
|
l.Unlock()
|
|
return nil
|
|
}
|
|
|
|
if !l.asyncMode {
|
|
er := l.handleEntry(entry)
|
|
l.Unlock()
|
|
return er
|
|
}
|
|
|
|
l.entryChan <- entry
|
|
l.Unlock()
|
|
return nil
|
|
}
|
|
|
|
|
|
|
|
func (l *ActiveLogger) handleEntry(entry *Entry) error {
|
|
|
|
er := l.handleLoggers(entry,func(c Logger, e *Entry) error { return c.Log(e) },G.FmtMsgLogErr)
|
|
|
|
if entry.Logger == l {
|
|
if entry.Level == LevelFatal && l.onFatalFn != nil {
|
|
l.onFatalFn(l, entry)
|
|
}
|
|
ReleaseEntry(entry)
|
|
}
|
|
if er != nil {
|
|
l.handleQueue()
|
|
}
|
|
return er
|
|
}
|
|
|
|
|
|
|
|
|
|
func (l *ActiveLogger) handleError (err error, entry *Entry) {
|
|
if err == nil {
|
|
return
|
|
}
|
|
l.errors = l.errors.Append(err)
|
|
if l.logErrors {
|
|
if entry == nil {
|
|
entry = AcquireEntry(l,LevelError,err.Error(),err)
|
|
}
|
|
l.queue.Push(entry)
|
|
}
|
|
if l.onErrorFn != nil {
|
|
l.onErrorFn(l,err)
|
|
}
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) handleQueue() {
|
|
for en := l.queue.Pop(); en != nil; {
|
|
_ = l.handleEntry(en)
|
|
en = l.queue.Pop()
|
|
}
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) handleLoggers(entry *Entry, doFn func(c Logger, e *Entry) error, msg string) error {
|
|
var el errs.ErrorList
|
|
|
|
for _,co := range l.loggers {
|
|
if er := doFn(co,entry); er != nil {
|
|
var en *Entry
|
|
nm := co.Name()
|
|
ms := fmt.Sprintf(msg,nm)
|
|
ne := errs.NewErrMessage(er,msg)
|
|
if l.logErrors {
|
|
en = AcquireEntry(l,LevelError,ms,ne,
|
|
EntryWithExclude (nm),
|
|
EntryWithField (entryFieldLogger,nm,true))
|
|
}
|
|
l.handleError(er,en)
|
|
}
|
|
}
|
|
|
|
return errs.NewErrMultiIf(el)
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) findLogger(name string) int {
|
|
for i :=0; i < len(l.loggers); i++ {
|
|
if l.loggers[i].Name() == name {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
|
|
func (l *ActiveLogger) runLogger () {
|
|
var w sync.WaitGroup
|
|
for {
|
|
select {
|
|
case <- l.ctx.Done():
|
|
w.Wait()
|
|
//Esperamos que todas las entradas sean
|
|
//despachadas y llamamos a Stop
|
|
_ = l.Stop()
|
|
return
|
|
case e,ok := <- l.entryChan:
|
|
if !ok {
|
|
w.Wait()
|
|
return
|
|
}
|
|
w.Add(1)
|
|
l.Lock()
|
|
_ = l.handleEntry(e)
|
|
l.Unlock()
|
|
w.Done()
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
func ActiveLoggerWithFilters (configFilters EntryFiltersFnc) ActiveLoggerFnc {
|
|
return func(a *ActiveLogger) {
|
|
configFilters(&a.filters) } }
|
|
|
|
|
|
func ActiveLoggerWithOnFatal (onFatal ActiveLoggerEntryFnc) ActiveLoggerFnc {
|
|
return func(a *ActiveLogger) {
|
|
a.onFatalFn = onFatal } }
|
|
|
|
|
|
func ActiveLoggerWithOnError (onError ActiveLoggerErrorFnc) ActiveLoggerFnc {
|
|
return func(a *ActiveLogger) {
|
|
a.onErrorFn = onError } }
|
|
|
|
|
|
func ActiveLoggerWithExtender (extender ...EntryExtender) ActiveLoggerFnc {
|
|
return func(a *ActiveLogger) {
|
|
a.extenders = append(a.extenders,extender...) } }
|
|
|
|
|
|
func ActiveLoggerWithContext (ctx context.Context, asyncMode bool) ActiveLoggerFnc {
|
|
return func(a *ActiveLogger) {
|
|
a.ctx = ctx
|
|
if asyncMode {
|
|
a.asyncMode = true
|
|
}
|
|
}
|
|
} |