go
/
active
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

incorporada la opcion de hacer el dispatcher asincrono

Browse Source
master
DEV 2 years ago
parent fad5bd3aca
commit fd822d1aeb
3 changed files with 138 additions and 135 deletions
Show Stats Download Patch File Download Diff File

236
alogs/logger_manager.go → alogs/active_logger.go
Unescape View File

@ -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 } }
func ActiveLoggerWithContext (ctx context.Context, asyncMode bool) ActiveLoggerFnc {
return func(a *ActiveLogger) {
a.ctx = ctx
if asyncMode {
a.asyncMode = true
}
}
}

35
app/main.go
Unescape View File

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

2
core/errs/err_multi.go
Unescape View File

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

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.