Corregido el packer y cambiado el nombre del interface de Builder a PackBuilder.

alogs/logger_manager.go

@@ -24,6 +24,7 @@
 package alogs
 
 import (
+	"context"
 	"errs"
 	"fmt"
 	"strings"
@@ -45,8 +46,10 @@ type (
 		scopes  	loggerScopes
 		loggers 	[]Logger
 
-		async 		bool
-		chanLog		chan *Entry
+		ctxParent 	context.Context
+		ctx 		context.Context
+		Async   	bool
+		chanLog 	chan *Entry
 
 		level 		Level
 		name 		string
@@ -79,6 +82,14 @@ func NewLoggerManager(name string, level Level, options ...LoggerManagerFnc) *Lo
 	for _,o := range options {
 		o(l)
 	}
+
+	if l.Async {
+		if l.ctxParent != nil {
+			l.ctxParent = context.Background()
+		}
+		l.ctx = context.WithoutCancel(l.ctxParent)
+	}
+
 	return l
 }
 
@@ -95,6 +106,12 @@ func (l *LoggerManager) Level() Level {
 	return lv
 }
 
+func (l *LoggerManager) Context() context.Context {
+	l.RLock()
+	cx := l.ctx
+	l.RUnlock()
+	return cx
+}
 
 func (l *LoggerManager) SetLevel (level Level) {
 	l.Lock()
@@ -133,11 +150,18 @@ func (l *LoggerManager) Start () error {
 		l.Unlock()
 		return G.ErrLoggerStarted
 	}
+
+
 	if l.state == StateStopped {
 		l.errors = l.errors.Reset()
 	}
 	l.state = StateStarted
 
+	if l.Async {
+		l.chanLog = make(chan *Entry)
+		go l.runLogger()
+	}
+
 	er := l.handleLoggers(nil,func(c Logger, _ *Entry) error { return c.Start() }, G.FmtMsgStartErr,)
 	if er != nil {
 		l.handleQueue()
@@ -154,7 +178,11 @@ func (l *LoggerManager) Stop () error {
 		l.Unlock()
 		return G.ErrLoggerNotStarted
 	}
+
 	l.state = StateStopped
+	if l.Async {
+		close(l.chanLog)
+	}
 
 	er := l.handleLoggers(nil,func(c Logger, _ *Entry) error { return c.Stop() }, G.FmtMsgStopErr)
 	if er != nil {
@@ -291,9 +319,11 @@ func (l *LoggerManager) Log  (entry *Entry) error {
 		return nil
 	}
 
-	er := l.logEntry(entry,false)
-	if er != nil {
-		l.handleQueue()
+	var er error
+	if !l.Async {
+		er = l.logEntry(entry, false)
+	} else {
+		l.chanLog <- entry
 	}
 
 	l.Unlock()
@@ -309,11 +339,13 @@ func (l *LoggerManager) log (level Level, msg string, err error,options []EntryF
 		return
 	}
 
-	er := l.logEntry(AcquireEntry(l,level,msg,err,options...),true)
-	if er != nil {
-		l.handleQueue()
+	if !l.Async {
+		_ = l.logEntry(AcquireEntry(l,level,msg,err,options...),true)
+	} else {
+		l.chanLog <- AcquireEntry(l,level,msg,err,options...)
 	}
 
+
 	l.Unlock()
 	return
 
@@ -342,6 +374,10 @@ func (l *LoggerManager) logEntry(entry *Entry, self bool)  error {
 		ReleaseEntry(entry)
 	}
 
+	if er != nil {
+		l.handleQueue()
+	}
+
 	return er
 }
 
@@ -407,10 +443,24 @@ func (l *LoggerManager) findLogger(name string) int {
 
 
 func (l *LoggerManager) runLogger () {
+	var w sync.WaitGroup
 	for {
 		select {
-		case e := <- l.chanLog :
-			//todo
+		case  <- l.ctx.Done():
+			w.Wait()
+			fmt.Print("Cancelando logger por cancelacion de contexto padre\n")
+			break
+		case e,ok := <- l.chanLog :
+			if !ok {
+				w.Wait()
+				break
+				//return
+			}
+			l.Lock()
+			w.Add(1)
+			_ = l.logEntry(e,false)
+			w.Done()
+			l.Unlock()
 		}
 	}
 }
@@ -436,3 +486,6 @@ func LoggerManagerWithExtender (extender ...EntryExtender) LoggerManagerFnc {
 		a.extenders = append(a.extenders,extender...) } }
 
 
+func LoggerManagerWithContext  (ctx context.Context) LoggerManagerFnc {
+	return func(a *LoggerManager) {
+		a.ctxParent = ctx } }

app/main.go

@@ -3,9 +3,11 @@ package main
 import (
 	"alogs"
 	"alogs/ejson"
+	"context"
 	"errs"
 	"fmt"
 	"os"
+	"time"
 )
 
 
@@ -36,7 +38,11 @@ func Append2 (_ *alogs.Entry) error {
 
 func main() {
 
-	l := alogs.NewLoggerManager("Main",alogs.LevelAll)
+	cx,cl := context.WithCancel(context.Background())
+
+	l := alogs.NewLoggerManager("Main",alogs.LevelAll,
+		func(m *alogs.LoggerManager){ m.Async = true },
+		alogs.LoggerManagerWithContext(cx))
 
 	l.AddLogger(alogs.NewLoggerCore("MiLogger",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append))))
 	l.AddLogger(alogs.NewLoggerCore("LoggerProblematico",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append2))))
@@ -49,9 +55,14 @@ func main() {
 
 
 
+	if l.Context().Done() != nil {
+		<-l.Context().Done()
+	}
 
+	time.Sleep(2 * time.Second)
 
+	//l.Stop()
+	cl()
 
-
-
+	time.Sleep(2 * time.Second)
 }

core/syncs/signaler.go

@@ -0,0 +1,27 @@
+package syncs
+
+
+
+type 	(
+
+	// Signaler
+	// Channel type
+	//
+	//
+	Signaler chan struct{}
+)
+
+// MakeSignaler
+// Function constructor -> Signaler
+//
+//
+func MakeSignaler(buf int) Signaler { return make(Signaler,1) }
+
+
+func (c Signaler) Send (){ c <- struct{}{}}
+
+
+func (c Signaler) Wait () <- chan struct{} { return c }
+
+
+func (c Signaler) Close(){ close(c) }