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

Empezado la adaptacion del modulos de logs

Browse Source
master
DEV 2 years ago
parent b714acbc5b
commit 9eea209602
6 changed files with 97 additions and 80 deletions
Show Stats Download Patch File Download Diff File

5
hecate/appender.go
Unescape View File

@ -38,3 +38,8 @@ type (
func (f AppendFnc) Append (entry *Entry) error {
return f(entry) }
func getNopAppender () AppendFnc {
return func (_ *Entry) error { return nil } }

18
hecate/logger_core.go
Unescape View File

@ -23,18 +23,20 @@
package logs
import "errs"
import (
"errs"
)
type (
LoggerCore struct {
loggerLevel
LoggerLevel
Filters
Aggregators
Appender
state State
count int
state State
count int
errors errs.ErrorList
@ -48,5 +50,13 @@ type (
func NewLoggerCore (name string, level Level, options ...LoggerCoreFnc) *LoggerCore {
l := &LoggerCore{
LoggerLevel: *newLoggerLevel(name,level),
Filters : *NewFilters(),
Appender : getNopAppender(),
state : StateCreated,
}
}

35
hecate/logger_level.go
Unescape View File

@ -28,8 +28,8 @@ import "sync"
type (
loggerLevel struct {
mux sync.RWMutex
LoggerLevel struct {
sync.RWMutex
name string
level Level
logFn LogFnc
@ -38,51 +38,52 @@ type (
)
func newLoggerLevel (name string, level Level) *loggerLevel {
return &loggerLevel{
func newLoggerLevel (name string, level Level) *LoggerLevel {
return &LoggerLevel{
name : name,
level: level } }
func (l *loggerLevel) Name () string {
func (l *LoggerLevel) Name () string {
return l.name }
func (l *loggerLevel) Level() (lv Level) {
l.mux.RLock()
func (l *LoggerLevel) Level() (lv Level) {
l.RLock()
lv = l.level
l.mux.RUnlock()
l.RUnlock()
return
}
func (l *loggerLevel) SetLevel (level Level) {
l.mux.Lock()
func (l *LoggerLevel) SetLevel (level Level) {
l.Lock()
l.level = level
l.mux.Unlock()
l.Unlock()
}
func (l *loggerLevel) Fatal (msg string, err error, ops ...EntryFnc){
func (l *LoggerLevel) Fatal (msg string, err error, ops ...EntryFnc){
l.logFn(LevelFatal,msg,err,ops ...) }
func (l *loggerLevel) Error (msg string, err error, ops ...EntryFnc){
func (l *LoggerLevel) Error (msg string, err error, ops ...EntryFnc){
l.logFn(LevelError,msg,err,ops ...) }
func (l *loggerLevel) Warn (msg string, ops ...EntryFnc){
func (l *LoggerLevel) Warn (msg string, ops ...EntryFnc){
l.logFn(LevelWarn,msg,nil,ops ...) }
func (l *loggerLevel) Info (msg string, ops ...EntryFnc){
func (l *LoggerLevel) Info (msg string, ops ...EntryFnc){
l.logFn(LevelInfo,msg,nil,ops...) }
func (l *loggerLevel) Debug (msg string, ops ...EntryFnc){
func (l *LoggerLevel) Debug (msg string, ops ...EntryFnc){
l.logFn(LevelDebug,msg,nil,ops...) }
func (l *loggerLevel) Data (msg string, data any, ops ...EntryFnc){
func (l *LoggerLevel) Data (msg string, data any, ops ...EntryFnc){
l.logFn(LevelData,msg,nil,func (e *Entry) {
e.Data = data
for _,o := range ops {

84
hecate/scope.go → hecate/logger_scope.go
Unescape View File

@ -31,8 +31,8 @@ import (
type (
Scope struct {
loggerLevel
LoggerScope struct {
LoggerLevel
Aggregators
path string
@ -43,22 +43,22 @@ type (
scopes Scopes
}
ScopeFnc func (s *Scope)
LoggerScopeFnc func (s *LoggerScope)
)
func newScope(name string, level Level, parent Loggable, path string, nodes [][]byte, options []ScopeFnc) *Scope {
func newLoggerScope(name string, level Level, parent Loggable, path string, nodes [][]byte, options []LoggerScopeFnc) *LoggerScope {
if path != "" {
path = fmt.Sprintf("%s%c%s",path,G.ScopeSep,name)
} else {
path = name
}
sc := &Scope {
loggerLevel: *newLoggerLevel(name,level),
parent: parent,
nodes : append(nodes,[]byte(name)),
path : path,
sc := &LoggerScope{
LoggerLevel: *newLoggerLevel(name,level),
parent: parent,
nodes : append(nodes,[]byte(name)),
path : path,
}
sc.logFn = sc.log
for _,o := range options {
@ -68,91 +68,91 @@ func newScope(name string, level Level, parent Loggable, path string, nodes [][]
}
func (s *Scope) Nodes() [][]byte {
func (s *LoggerScope) Nodes() [][]byte {
return s.nodes }
func (s *Scope) Path () string {
func (s *LoggerScope) Path () string {
return s.path }
func (s *Scope) Mode () (m ScopeMode) {
s.mux.RLock()
func (s *LoggerScope) Mode () (m ScopeMode) {
s.RLock()
m = s.mode
s.mux.RUnlock()
s.RUnlock()
return
}
func (s *Scope) SetMode (mode ScopeMode) {
func (s *LoggerScope) SetMode (mode ScopeMode) {
if !mode.isValid() {
panic(G.ErrInvalidScopeMode)
}
s.mux.Lock()
s.Lock()
s.mode = mode
s.mux.Unlock()
s.Unlock()
}
func (s *Scope) GetScope (name string) *Scope {
func (s *LoggerScope) GetScope (name string) *LoggerScope {
return s.getScope(strings.Split(strings.ToLower(name),g.scopeSepStr)) }
func (s *Scope) getScope (nodes []string)( sc *Scope) {
s.mux.RLock()
func (s *LoggerScope) getScope (nodes []string)( sc *LoggerScope) {
s.RLock()
if sc = s.scopes.getScope(nodes[0]); sc != nil {
if len(nodes) > 1 {
sc = sc.getScope(nodes[:1])
}
}
s.mux.RUnlock()
s.RUnlock()
return
}
func (s *Scope) NewScope (path string, options ...ScopeFnc) (*Scope,error) {
func (s *LoggerScope) NewScope (path string, options ...LoggerScopeFnc) (*LoggerScope,error) {
return s.newScope(strings.Split(strings.ToLower(path),g.scopeSepStr),options) }
func (s *Scope) newScope (path []string, options []ScopeFnc) (sc *Scope, er error) {
s.mux.Lock()
func (s *LoggerScope) newScope (path []string, options []LoggerScopeFnc) (sc *LoggerScope, er error) {
s.Lock()
if sc = s.scopes.getScope(path[0]); sc == nil {
sc = newScope(path[0], s.level, s, s.path, s.nodes,options)
sc = newLoggerScope(path[0], s.level, s, s.path, s.nodes,options)
s.scopes = append(s.scopes, sc)
if len(path) == 1 {
s.mux.Unlock()
s.Unlock()
return
}
} else if len(path) == 1 {
s.mux.Unlock()
s.Unlock()
return nil,G.ErrDuplicatedScope
}
sc,er = sc.newScope(path[1:],options)
s.mux.Unlock()
s.Unlock()
return
}
func (s *Scope) Log(ent *Entry) error {
s.mux.Lock()
func (s *LoggerScope) Log(ent *Entry) error {
s.Lock()
if s.mode & ScopeFilter != 0 && !s.level.Has(ent.Level) {
s.mux.Unlock()
s.Unlock()
return nil
}
if s.mode.IsCascade() {
s.Apply(ent)
}
s.mux.Unlock()
s.Unlock()
return s.parent.Log(ent)
}
func (s *Scope) log(lvl Level, msg string, err error,ops ...EntryFnc){
s.mux.Lock()
func (s *LoggerScope) log(lvl Level, msg string, err error,ops ...EntryFnc){
s.Lock()
if !s.level.Has(lvl) {
s.mux.Unlock()
s.Unlock()
return
}
en := s.Apply(AcquireEntry(nil,lvl,msg,err,ops...))
en.Scope = s.path
en.Scopes= s.nodes
s.mux.Unlock()
s.Unlock()
s.parent.Log(en)
ReleaseEntry(en)
@ -160,8 +160,8 @@ func (s *Scope) log(lvl Level, msg string, err error,ops ...EntryFnc){
}
func ScopeWithMode (mode ScopeMode) ScopeFnc {
return func(s *Scope) {
func LoggerScopeWithMode(mode ScopeMode) LoggerScopeFnc {
return func(s *LoggerScope) {
if !mode.isValid() {
panic(G.ErrInvalidScopeMode)
}
@ -174,8 +174,8 @@ func ScopeWithMode (mode ScopeMode) ScopeFnc {
}
func ScopeWithLevel (level Level) ScopeFnc {
return func(s *Scope) {
func LoggerScopeWithLevel(level Level) LoggerScopeFnc {
return func(s *LoggerScope) {
if !level.isValid() {
panic(G.ErrInvalidLevel)
}
@ -183,8 +183,8 @@ func ScopeWithLevel (level Level) ScopeFnc {
}
}
func ScopeWithAggregator (aggregator ...EntryFnc) ScopeFnc {
return func(s *Scope) {
func LoggerScopeWithAggregator(aggregator ...EntryFnc) LoggerScopeFnc {
return func(s *LoggerScope) {
for _,a := range aggregator {
s.Aggregators = s.Aggregators.Append(a)
}

6
hecate/scopes.go
Unescape View File

@ -27,11 +27,11 @@ package logs
type (
Scopes []*Scope
Scopes []*LoggerScope
)
func (s Scopes) getScope (name string) *Scope {
func (s Scopes) getScope (name string) *LoggerScope {
if ps := s.find(name); ps != -1 {
return s[ps]
}
@ -49,7 +49,7 @@ func (s Scopes) find (name string) int {
}
func (s Scopes) walk(walkfn func(sc *Scope) bool) bool {
func (s Scopes) walk(walkfn func(sc *LoggerScope) bool) bool {
ex := true
for i:=0; i<len(s) && ex; i++ {
e := s[i]

29
hecate/alogger.go → hecate/temp/alogger.go
Unescape View File

@ -21,26 +21,27 @@
// limitations under the License.
// ------------------------------------------------------------------------
package logs
package temp
import (
"errs"
"hecate"
"syncs/queue"
)
type (
ALogger struct {
loggerLevel
Aggregators
Filters
logs.loggerLevel
logs.Aggregators
logs.Filters
scopes Scopes
scopes logs.Scopes
queue queue.GQueue[*Entry]
queue queue.GQueue[*logs.Entry]
state State
count int
state logs.State
count int
logErrors bool
errors errs.ErrorList
@ -53,12 +54,12 @@ type (
)
func NewALogger(name string, level Level, options ...ManagerFnc) *ALogger {
func NewALogger(name string, level logs.Level, options ...ManagerFnc) *ALogger {
m := &ALogger{
loggerLevel : *newLoggerLevel(name,level),
Filters : *NewFilters(),
loggerLevel : *logs.newLoggerLevel(name,level),
Filters : *logs.NewFilters(),
state : StateCreated,
state : logs.StateCreated,
logErrors : true,
}
m.logFn = m.log
@ -71,13 +72,13 @@ func NewALogger(name string, level Level, options ...ManagerFnc) *ALogger {
func (l *ALogger) Start (all bool) error {
l.mux.Lock()
if l.state == StateStarted {
if l.state == logs.StateStarted {
l.mux.Unlock()
return nil
}
l.errors = l.errors[:0]
l.state = StateStarted
l.state = logs.StateStarted
if !all {
l.mux.Unlock()
Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.