diff --git a/alogs/active.go b/alogs/active.go index 01f0be3..9ed5471 100644 --- a/alogs/active.go +++ b/alogs/active.go @@ -61,6 +61,8 @@ const ( var ( G = struct { + ErrInvalidContext errs.ErrCode + ErrInvalidState errs.ErrCode ErrInvalidLevel errs.ErrCode ErrDuplicatedScope errs.ErrCode ErrDuplicatedLogger errs.ErrCode @@ -79,6 +81,8 @@ var ( FmtMsgFlushErr string }{ + ErrInvalidContext : errs.ErrCode("invalid-context"), + ErrInvalidState : errs.ErrCode("invalid-state"), ErrInvalidLevel : errs.ErrCode("invalid-level"), ErrDuplicatedScope : errs.ErrCode("duplicated-scope" ), ErrDuplicatedLogger : errs.ErrCode("duplicated-nameLevel"), @@ -120,3 +124,6 @@ var ( ) + + + diff --git a/alogs/active_logger.go b/alogs/active_logger.go index 6417b65..d88f62f 100644 --- a/alogs/active_logger.go +++ b/alogs/active_logger.go @@ -60,36 +60,37 @@ type ( errors errs.ErrorList onErrorFn ActiveLoggerErrorFnc - onFatalFn ActiveLoggerEntryFnc + + onEntryErrorFn ActiveLoggerEntryFnc + onEntryFatalFn ActiveLoggerEntryFnc } - ActiveLoggerFnc func(manager *ActiveLogger) + ActiveLoggerFnc func(manager *ActiveLogger) error - ActiveLoggerErrorFnc func(manager *ActiveLogger, err error) + ActiveLoggerErrorFnc func(manager *ActiveLogger, err error, logger Logger) ActiveLoggerEntryFnc func(manager *ActiveLogger, entry *Entry) ) -func NewActiveManager(name string, level Level, options ...ActiveLoggerFnc) *ActiveLogger { +func NewActiveLogger(name string, level Level, options ...ActiveLoggerFnc) (*ActiveLogger,error) { l := &ActiveLogger{ - filters : *NewEntryFilters(), - level : level, - state : StateCreated, - logErrors: true, - queue : *queue.NewGQueue[*Entry](false), + level : level, + name : name, + state : StateCreated, + filters : *NewEntryFilters(), + queue : *queue.NewGQueue[*Entry](false), + ctx : context.Background(), + logErrors : true, + onEntryErrorFn: nopEntryHandler, + onEntryFatalFn: nopEntryHandler, } for _,o := range options { - o(l) - } - - if l.asyncMode { - if l.ctx == nil { - l.ctx = context.Background() + if er := o(l); er != nil { + return nil,er } } - - return l + return l,nil } @@ -366,8 +367,12 @@ func (l *ActiveLogger) dispatchEntry(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) + + if entry.Level == LevelFatal { + l.onEntryFatalFn(l, entry) + } + if entry.Level == LevelError { + l.onEntryErrorFn(l, entry) } ReleaseEntry(entry) } @@ -380,7 +385,7 @@ func (l *ActiveLogger) dispatchEntry(entry *Entry) error { -func (l *ActiveLogger) handleError (err error, entry *Entry) { +func (l *ActiveLogger) handleError (err error, entry *Entry, logger Logger) { if err == nil { return } @@ -392,7 +397,7 @@ func (l *ActiveLogger) handleError (err error, entry *Entry) { l.queue.Push(entry) } if l.onErrorFn != nil { - l.onErrorFn(l,err) + go l.onErrorFn(l,err,logger) } } @@ -419,7 +424,7 @@ func (l *ActiveLogger) handleLoggers(entry *Entry, doFn func(c Logger, e *Entry) EntryWithExclude (nm), EntryWithField (entryFieldLogger,nm,true)) } - l.handleError(er,en) + l.handleError(er,en,co) } } @@ -463,31 +468,101 @@ func (l *ActiveLogger) runLogger () { } + + func ActiveLoggerWithFilters (configFilters EntryFiltersFnc) ActiveLoggerFnc { - return func(a *ActiveLogger) { - configFilters(&a.filters) } } + return func(a *ActiveLogger) error { + if a.State() != StateCreated { + return G.ErrInvalidState.WrapWithMessage("config-active-logger-with-filters") + } + configFilters(&a.filters) + return nil + } +} func ActiveLoggerWithOnFatal (onFatal ActiveLoggerEntryFnc) ActiveLoggerFnc { - return func(a *ActiveLogger) { - a.onFatalFn = onFatal } } + return func(a *ActiveLogger) error { + if a.State() != StateCreated { + return G.ErrInvalidState.WrapWithMessage("config-active-logger-with-on-fatal") + } + a.onEntryFatalFn = onFatal + return nil + } +} func ActiveLoggerWithOnError (onError ActiveLoggerErrorFnc) ActiveLoggerFnc { - return func(a *ActiveLogger) { - a.onErrorFn = onError } } + return func(a *ActiveLogger) error { + if a.State() != StateCreated { + return G.ErrInvalidState.WrapWithMessage("config-active-logger-with-on-error") + } + a.onErrorFn = onError + return nil + } +} + + +func ActiveLoggerWithOnEntryError (onError ActiveLoggerEntryFnc) ActiveLoggerFnc { + return func(a *ActiveLogger) error { + if a.State() != StateCreated { + return G.ErrInvalidState.WrapWithMessage("config-active-logger-with-on-entry-error") + } + if onError == nil { + a.onEntryErrorFn = nopEntryHandler + } else { + a.onEntryErrorFn = onError + } + return nil + } +} + + +func ActiveLoggerWithOnEntryFatal (onError ActiveLoggerEntryFnc) ActiveLoggerFnc { + return func(a *ActiveLogger) error { + if a.State() != StateCreated { + return G.ErrInvalidState.WrapWithMessage("config-active-logger-with-on-entry-error") + } + if onError == nil { + a.onEntryFatalFn = nopEntryHandler + } else { + a.onEntryFatalFn = onError + } + return nil + } +} + + func ActiveLoggerWithExtender (extender ...EntryExtender) ActiveLoggerFnc { - return func(a *ActiveLogger) { - a.extenders = append(a.extenders,extender...) } } + return func(a *ActiveLogger) error { + if a.State() != StateCreated { + return G.ErrInvalidState.WrapWithMessage("config-active-logger-with-extender") + } + a.extenders = append(a.extenders,extender...) + return nil + } +} func ActiveLoggerWithContext (ctx context.Context, asyncMode bool) ActiveLoggerFnc { - return func(a *ActiveLogger) { + return func(a *ActiveLogger) error { + if a.State() != StateCreated { + return G.ErrInvalidState.WrapWithMessage("config-active-logger-with-context") + } + if ctx == nil { + ctx = context.Background() + } else if ctx.Err() != nil { + return *errs.NewErrCause(G.ErrInvalidContext.WrapWithMessage("config-active-logger-with-context"),ctx.Err()) + } a.ctx = ctx if asyncMode { a.asyncMode = true } + return nil } -} \ No newline at end of file +} + + +func nopEntryHandler (_ *ActiveLogger,_ *Entry) {} \ No newline at end of file diff --git a/app/main.go b/app/main.go index c5db3a3..7fac291 100644 --- a/app/main.go +++ b/app/main.go @@ -39,12 +39,25 @@ func Append2 (_ *alogs.Entry) error { func main() { cx,cl := context.WithCancel(context.Background()) - - l := alogs.NewActiveManager("Main",alogs.LevelAll, - alogs.ActiveLoggerWithContext(cx,true)) + //cl() + + l,er := alogs.NewActiveLogger("Main",alogs.LevelAll, + alogs.ActiveLoggerWithContext(cx,true), + alogs.ActiveLoggerWithOnError(func(a *alogs.ActiveLogger,err error, s alogs.Logger){ + if s != nil { + fmt.Printf("Error producido en logger %s se procede a su paro\n", s.Name()) + fmt.Print(errs.Encode(s.Stop(),nil)) + } + fmt.Print(errs.Encode(a.Stop(),nil)) + })) + if er != nil { + fmt.Print(errs.Encode(er,nil)) + time.Sleep(500*time.Millisecond) + return + } l.AddLogger(alogs.NewLoggerCore("MiLogger",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append)))) - //l.AddLogger(alogs.NewLoggerCore("LoggerProblematico",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append2)))) + l.AddLogger(alogs.NewLoggerCore("LoggerProblematico",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append2)))) for i:=0; i<3; i++ { diff --git a/core/errs/active.go b/core/errs/active.go index acbc714..3e54980 100644 --- a/core/errs/active.go +++ b/core/errs/active.go @@ -228,6 +228,12 @@ func WrapWithTrace(err error, offset int) error { return *NewErrTrace(err,offset) } +func WrapWithMessage (err error, message string) error { + if err == nil { return nil } + return *NewErrMessage(err,message) +} + + func WrapWithFieldString (err error, name, value string) error { if err == nil { return nil } return *errf.NewFieldString(err,name,value ) diff --git a/core/errs/collects/active.go b/core/errs/collects/active.go index 3050747..089dd78 100644 --- a/core/errs/collects/active.go +++ b/core/errs/collects/active.go @@ -64,7 +64,8 @@ var ( }{ - typeCollectors: make(map[reflect.Type]ErrorCollector), + typeCollectors : make(map[reflect.Type]ErrorCollector), + defaultCollectors: defaultCollectors(), } ) diff --git a/core/errs/err_code.go b/core/errs/err_code.go index 2db469e..755a3ca 100644 --- a/core/errs/err_code.go +++ b/core/errs/err_code.go @@ -65,7 +65,8 @@ func (e ErrCode) WrapWithTrace(offset int) error { func (e ErrCode) WrapWithFieldString (name, value string) error { return WrapWithFieldString(e,name,value) } - +func (e ErrCode) WrapWithMessage (msg string) error { + return WrapWithMessage(e,msg) } func (e ErrCode) String () string { return string(G.Encoder.EncodeError(e)) } diff --git a/core/errs/err_message.go b/core/errs/err_message.go index 7b14c0d..d8db6df 100644 --- a/core/errs/err_message.go +++ b/core/errs/err_message.go @@ -23,7 +23,7 @@ package errs - +import "errs/collects" type ( @@ -61,3 +61,10 @@ func (e ErrMessage) WrapWithTrace(offset int) error { return WrapWithTrace(e,offset) } + + + +func (e ErrMessage) Collect (collector collects.Collector) { + collector.AddFieldString(fieldNameMessage,e.message) + +} diff --git a/core/errs/etext/text_encoder.go b/core/errs/etext/text_encoder.go index 285347a..e5f63bc 100644 --- a/core/errs/etext/text_encoder.go +++ b/core/errs/etext/text_encoder.go @@ -70,6 +70,9 @@ func NewTextEncoder(options ...TextEncoderFnc) *TextEncoder { func (f *TextEncoder) EncodeError(err error) []byte { + if err == nil { + return nil + } b := newTextBuilder(f) defer func(tb *TextBuilder){ tb.reset()