incorporada la opcion de hacer el dispatcher asincrono

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 (
 )
 
 
+
+
+

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
 	}
 }
+
+
+func nopEntryHandler (_ *ActiveLogger,_ *Entry) {}

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++ {

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 )

core/errs/collects/active.go

@@ -64,7 +64,8 @@ var (
 
 	}{
 
-		typeCollectors: make(map[reflect.Type]ErrorCollector),
+		typeCollectors	 : make(map[reflect.Type]ErrorCollector),
+		defaultCollectors: defaultCollectors(),
 	}
 )
 

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

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

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