diff --git a/alogs/logger_manager.go b/alogs/active_logger.go
similarity index 62%
rename from alogs/logger_manager.go
rename to alogs/active_logger.go
index 009fc91..fa07462 100644
--- a/alogs/logger_manager.go
+++ b/alogs/active_logger.go
@@ -35,7 +35,7 @@ import (
 
 type (
 
-	LoggerManager struct {
+	ActiveLogger 	struct {
 		sync.RWMutex
 
 		filters 	EntryFilters
@@ -46,10 +46,10 @@ type (
 		scopes  	loggerScopes
 		loggers 	[]Logger
 
-		ctxParent 	context.Context
-		ctx 		context.Context
-		Async   	bool
-		chanLog 	chan *Entry
+
+		ctx       	context.Context
+		asyncMode 	bool
+		entryChan 	chan *Entry
 
 		level 		Level
 		name 		string
@@ -59,20 +59,20 @@ type (
 		logErrors 	bool
 		errors    	errs.ErrorList
 
-		onErrorFn 	LoggerManagerErrorFnc
-		onFatalFn 	LoggerManagerEntryFnc
+		onErrorFn 	ActiveLoggerErrorFnc
+		onFatalFn 	ActiveLoggerEntryFnc
 	}
 
-	LoggerManagerFnc 	  func(manager *LoggerManager)
+	ActiveLoggerFnc 	 func(manager *ActiveLogger)
 
-	LoggerManagerErrorFnc func(manager *LoggerManager, err error)
+	ActiveLoggerErrorFnc func(manager *ActiveLogger, err error)
 
-	LoggerManagerEntryFnc func(manager *LoggerManager, entry *Entry)
+	ActiveLoggerEntryFnc func(manager *ActiveLogger, entry *Entry)
 )
 
 
-func NewLoggerManager(name string, level Level, options ...LoggerManagerFnc) *LoggerManager {
-	l := &LoggerManager{
+func NewActiveManager(name string, level Level, options ...ActiveLoggerFnc) *ActiveLogger {
+	l := &ActiveLogger{
 		filters  : *NewEntryFilters(),
 		level	 : level,
 		state	 : StateCreated,
@@ -83,11 +83,10 @@ func NewLoggerManager(name string, level Level, options ...LoggerManagerFnc) *Lo
 		o(l)
 	}
 
-	if l.Async {
-		if l.ctxParent != nil {
-			l.ctxParent = context.Background()
+	if l.asyncMode {
+		if l.ctx == nil {
+			l.ctx = context.Background()
 		}
-		l.ctx = context.WithoutCancel(l.ctxParent)
 	}
 
 	return l
@@ -95,40 +94,36 @@ func NewLoggerManager(name string, level Level, options ...LoggerManagerFnc) *Lo
 
 
 
-func (l *LoggerManager) Name() string {
+func (l *ActiveLogger) Name() string {
 	return l.name }
 
 
-func (l *LoggerManager) Level() Level {
+func (l *ActiveLogger) Level() Level {
 	l.RLock()
 	lv := l.level
 	l.RUnlock()
 	return lv
 }
 
-func (l *LoggerManager) Context() context.Context {
-	l.RLock()
-	cx := l.ctx
-	l.RUnlock()
-	return cx
-}
+func (l *ActiveLogger) Context() context.Context {
+	return l.ctx  }
 
-func (l *LoggerManager) SetLevel (level Level) {
+func (l *ActiveLogger) SetLevel (level Level) {
 	l.Lock()
 	l.level = level
 	l.Unlock()
 }
 
 
-func (l *LoggerManager) Count () int64 {
+func (l *ActiveLogger) Count () int64 {
 	return atomic.LoadInt64(&l.count) }
 
 
-func (l *LoggerManager) incCount () {
+func (l *ActiveLogger) incCount () {
 	atomic.AddInt64(&l.count,1) }
 
 
-func (l *LoggerManager) State () State {
+func (l *ActiveLogger) State () State {
 	l.RLock()
 	s := l.state
 	l.RUnlock()
@@ -136,7 +131,7 @@ func (l *LoggerManager) State () State {
 }
 
 
-func (l *LoggerManager) Errors () errs.ErrorList {
+func (l *ActiveLogger) Errors () errs.ErrorList {
 	l.RLock()
 	ls := l.errors
 	l.RUnlock()
@@ -144,23 +139,27 @@ func (l *LoggerManager) Errors () errs.ErrorList {
 }
 
 
-func (l *LoggerManager) Start () error {
+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()
 	}
-	l.state = StateStarted
 
-	if l.Async {
-		l.chanLog = make(chan *Entry)
+
+	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 {
@@ -172,17 +171,19 @@ func (l *LoggerManager) Start () error {
 }
 
 
-func (l *LoggerManager) Stop () error {
+func (l *ActiveLogger) Stop () error {
 	l.Lock()
 	if l.state != StateStarted {
 		l.Unlock()
 		return G.ErrLoggerNotStarted
 	}
 
-	l.state = StateStopped
-	if l.Async {
-		close(l.chanLog)
+
+	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 {
@@ -194,7 +195,10 @@ func (l *LoggerManager) Stop () error {
 }
 
 
-func (l *LoggerManager) Flush () error {
+
+
+
+func (l *ActiveLogger) Flush () error {
 	l.Lock()
 
 	er := l.handleLoggers(nil,func(c Logger,_ *Entry) error { return c.Flush() }, G.FmtMsgFlushErr)
@@ -207,7 +211,7 @@ func (l *LoggerManager) Flush () error {
 }
 
 
-func (l *LoggerManager) GetLogger(name string) Logger {
+func (l *ActiveLogger) GetLogger(name string) Logger {
 	l.RLock()
 	var co Logger
 	if p := l.findLogger(name); p != -1 {
@@ -218,7 +222,7 @@ func (l *LoggerManager) GetLogger(name string) Logger {
 }
 
 
-func (l *LoggerManager) AddLogger(logger Logger) error {
+func (l *ActiveLogger) AddLogger(logger Logger) error {
 	l.Lock()
 	nm := logger.Name()
 	if p := l.findLogger(nm); p != -1 {
@@ -235,7 +239,7 @@ func (l *LoggerManager) AddLogger(logger Logger) error {
 }
 
 
-func (l *LoggerManager) DelLogger(name string) error {
+func (l *ActiveLogger) DelLogger(name string) error {
 	l.Lock()
 	 p := l.findLogger(name)
 	 if p != -1 {
@@ -250,7 +254,7 @@ func (l *LoggerManager) DelLogger(name string) error {
 }
 
 
-func (l *LoggerManager) GetScope(name string) *LoggerScope {
+func (l *ActiveLogger) GetScope(name string) *LoggerScope {
 	ns := strings.Split(G.ScopeNameTransforms.Transform(name),g.scopeSepStr)
 	l.RLock()
 	sc := l.scopes.getScope(ns[0])
@@ -262,7 +266,7 @@ func (l *LoggerManager) GetScope(name string) *LoggerScope {
 }
 
 
-func (l *LoggerManager) AddScope(name string, options ...LoggerScopeFnc) (*LoggerScope,error) {
+func (l *ActiveLogger) AddScope(name string, options ...LoggerScopeFnc) (*LoggerScope,error) {
 	nm := G.ScopeNameTransforms.Transform(name)
 	ns := strings.Split(nm,g.scopeSepStr)
 
@@ -285,31 +289,47 @@ func (l *LoggerManager) AddScope(name string, options ...LoggerScopeFnc) (*Logge
 }
 
 
-func (l *LoggerManager) Fatal(msg string, err error, ops ...EntryFnc){
+func (l *ActiveLogger) Fatal(msg string, err error, ops ...EntryFnc){
 	l.log(LevelFatal,msg,err,ops) }
 
-func (l *LoggerManager) Error(msg string, err error, ops ...EntryFnc){
+func (l *ActiveLogger) Error(msg string, err error, ops ...EntryFnc){
 	l.log(LevelError,msg,err,ops) }
 
-func (l *LoggerManager) Warn (msg string, ops ...EntryFnc){
+func (l *ActiveLogger) Warn (msg string, ops ...EntryFnc){
 	l.log(LevelWarn,msg,nil,ops) }
 
-func (l *LoggerManager) Info (msg string, ops ...EntryFnc){
+func (l *ActiveLogger) Info (msg string, ops ...EntryFnc){
 	l.log(LevelInfo,msg,nil,ops) }
 
-func (l *LoggerManager) Debug(msg string, ops ...EntryFnc){
+func (l *ActiveLogger) Debug(msg string, ops ...EntryFnc){
 	l.log(LevelDebug,msg,nil,ops) }
 
-func (l *LoggerManager) Data (msg string, data any, ops ...EntryFnc){
+func (l *ActiveLogger) Data (msg string, data any, ops ...EntryFnc){
 	l.log(LevelData,msg,nil,[]EntryFnc{EntryWithData(data,ops...)}) }
 
 
-func (l *LoggerManager) Log  (entry *Entry) error {
+
+
+
+
+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
@@ -318,75 +338,50 @@ func (l *LoggerManager) Log  (entry *Entry) error {
 		l.Unlock()
 		return nil
 	}
-
-	var er error
-	if !l.Async {
-		er = l.logEntry(entry, false)
-	} else {
-		l.chanLog <- entry
-	}
-
-	l.Unlock()
-	return er
-}
-
-
-func (l *LoggerManager) log (level Level, msg string, err error,options []EntryFnc) {
-	l.Lock()
-
-	if l.state != StateStarted || !l.level.Has(level){
+	// Extendermos la entrada antes de
+	// someterla a los filtros
+	l.extenders.ExtendEntry(entry)
+	if !l.filters.Filter(entry) {
 		l.Unlock()
-		return
+		return nil
 	}
 
-	if !l.Async {
-		_ = l.logEntry(AcquireEntry(l,level,msg,err,options...),true)
-	} else {
-		l.chanLog <- AcquireEntry(l,level,msg,err,options...)
+	if !l.asyncMode {
+		er := l.handleEntry(entry)
+		l.Unlock()
+		return er
 	}
 
-
+	l.entryChan <- entry
 	l.Unlock()
-	return
-
+	return nil
 }
 
 
-func (l *LoggerManager) logEntry(entry *Entry, self bool)  error {
-	if !l.filters.Filter(entry) {
-		return nil
-	}
-
-	if self {
-		l.incCount()
-	} else if entry.Logger == nil {
-		entry.Logger = l
-	}
-	l.extenders.ExtendEntry(entry)
 
+func (l *ActiveLogger) handleEntry(entry *Entry)  error {
 
 	er := l.handleLoggers(entry,func(c Logger, e *Entry) error { return c.Log(e) },G.FmtMsgLogErr)
 
-	if self {
+	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 *LoggerManager) handleError (err error, entry *Entry) {
+
+
+func (l *ActiveLogger) handleError (err error, entry *Entry) {
 	if err == nil {
 		return
 	}
-
 	l.errors = l.errors.Append(err)
 	if l.logErrors {
 		if entry == nil {
@@ -394,22 +389,21 @@ func (l *LoggerManager) handleError (err error, entry *Entry) {
 		}
 		l.queue.Push(entry)
 	}
-
 	if l.onErrorFn != nil {
 		l.onErrorFn(l,err)
 	}
 }
 
 
-func (l *LoggerManager) handleQueue() {
+func (l *ActiveLogger) handleQueue() {
 	for en := l.queue.Pop(); en != nil; {
-		_ = l.logEntry(en,true)
+		_ = l.handleEntry(en)
 		en = l.queue.Pop()
 	}
 }
 
 
-func (l *LoggerManager) handleLoggers(entry *Entry, doFn func(c Logger, e *Entry) error, msg string) error {
+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 {
@@ -420,7 +414,6 @@ func (l *LoggerManager) handleLoggers(entry *Entry, doFn func(c Logger, e *Entry
 			ne := errs.NewErrMessage(er,msg)
 			if l.logErrors {
 				en = AcquireEntry(l,LevelError,ms,ne,
-					EntryWithExtender(l.extenders),
 					EntryWithExclude (nm),
 					EntryWithField   (entryFieldLogger,nm,true))
 			}
@@ -432,7 +425,7 @@ func (l *LoggerManager) handleLoggers(entry *Entry, doFn func(c Logger, e *Entry
 }
 
 
-func (l *LoggerManager) findLogger(name string) int {
+func (l *ActiveLogger) findLogger(name string) int {
 	for i :=0; i < len(l.loggers); i++ {
 		if l.loggers[i].Name() == name {
 			return i
@@ -442,50 +435,57 @@ func (l *LoggerManager) findLogger(name string) int {
 }
 
 
-func (l *LoggerManager) runLogger () {
+func (l *ActiveLogger) runLogger () {
 	var w sync.WaitGroup
 	for {
 		select {
 		case  <- l.ctx.Done():
 			w.Wait()
-			fmt.Print("Cancelando logger por cancelacion de contexto padre\n")
-			break
-		case e,ok := <- l.chanLog :
+			//Esperamos que todas las entradas sean
+			//despachadas y llamamos a Stop
+			_ = l.Stop()
+			return
+		case e,ok := <- l.entryChan:
 			if !ok {
 				w.Wait()
-				break
-				//return
+				return
 			}
-			l.Lock()
 			w.Add(1)
-			_ = l.logEntry(e,false)
-			w.Done()
+			l.Lock()
+			_ = l.handleEntry(e)
 			l.Unlock()
+			w.Done()
+
 		}
 	}
 }
 
 
-func LoggerManagerWithFilters (configFilters EntryFiltersFnc) LoggerManagerFnc {
-	return func(a *LoggerManager) {
+func ActiveLoggerWithFilters (configFilters EntryFiltersFnc) ActiveLoggerFnc {
+	return func(a *ActiveLogger) {
 		configFilters(&a.filters) } }
 
 
-func LoggerManagerWithOnFatal (onFatal LoggerManagerEntryFnc) LoggerManagerFnc {
-	return func(a *LoggerManager) {
+func ActiveLoggerWithOnFatal (onFatal ActiveLoggerEntryFnc) ActiveLoggerFnc {
+	return func(a *ActiveLogger) {
 		a.onFatalFn = onFatal } }
 
 
-func LoggerManagerWithOnError (onError LoggerManagerErrorFnc) LoggerManagerFnc {
-	return func(a *LoggerManager) {
+func ActiveLoggerWithOnError (onError ActiveLoggerErrorFnc) ActiveLoggerFnc {
+	return func(a *ActiveLogger) {
 		a.onErrorFn = onError } }
 
 
-func LoggerManagerWithExtender (extender ...EntryExtender) LoggerManagerFnc {
-	return func(a *LoggerManager) {
+func ActiveLoggerWithExtender (extender ...EntryExtender) ActiveLoggerFnc {
+	return func(a *ActiveLogger) {
 		a.extenders = append(a.extenders,extender...) } }
 
 
-func LoggerManagerWithContext  (ctx context.Context) LoggerManagerFnc {
-	return func(a *LoggerManager) {
-		a.ctxParent = ctx } }
\ No newline at end of file
+func ActiveLoggerWithContext  (ctx context.Context, asyncMode bool) ActiveLoggerFnc {
+	return func(a *ActiveLogger) {
+		a.ctx = ctx
+		if asyncMode {
+			a.asyncMode = true
+		}
+	}
+}
\ No newline at end of file
diff --git a/app/main.go b/app/main.go
index 4faf0ea..c5db3a3 100644
--- a/app/main.go
+++ b/app/main.go
@@ -40,29 +40,32 @@ func main() {
 
 	cx,cl := context.WithCancel(context.Background())
 
-	l := alogs.NewLoggerManager("Main",alogs.LevelAll,
-		func(m *alogs.LoggerManager){ m.Async = true },
-		alogs.LoggerManagerWithContext(cx))
+	l := alogs.NewActiveManager("Main",alogs.LevelAll,
+		alogs.ActiveLoggerWithContext(cx,true))
 
 	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))))
 
-	l.Start()
 
-	l.Warn("Esto es un mensage")
-	//l.Error("Esto es un mensage",errs.ErrCode("UnError"))
-	//l.Fatal("Fatalidad",errs.NewErrPanic(errs.ErrCode("unca cauisa")))
+	for i:=0; i<3; i++ {
+		if er := l.Start(); er != nil {
+			e := errs.Encode(er,nil)
+			fmt.Printf("saluiend\n %s\n%s",e,er.Error())
+			break
+		}
 
+		l.Warn("Esto es un mensage")
+		//l.Error("Esto es un mensage",errs.ErrCode("UnError"))
+		//l.Fatal("Fatalidad",errs.NewErrPanic(errs.ErrCode("unca cauisa")))
 
+		//go func() {
+		time.Sleep(1 * time.Second)
+			cl()
+		//}()
+		l.Stop()
 
-	if l.Context().Done() != nil {
-		<-l.Context().Done()
-	}
-
-	time.Sleep(2 * time.Second)
 
-	//l.Stop()
+	}
+	time.Sleep(1 * time.Second)
 	cl()
-
-	time.Sleep(2 * time.Second)
 }
diff --git a/core/errs/err_multi.go b/core/errs/err_multi.go
index 0c84b24..bd7b5c8 100644
--- a/core/errs/err_multi.go
+++ b/core/errs/err_multi.go
@@ -36,7 +36,7 @@ type (
 func NewErrMulti (err ...error) *ErrMulti {
 	return &ErrMulti{ ErrorList : ErrorList(err).Clean() } }
 
-func NewErrMultiIf (errors []error) *ErrMulti {
+func NewErrMultiIf (errors []error) error {
 	if len(errors) == 0 {
 		return nil
 	}