From 790529267a8c0bc367fc7970fdd3145809820e8e Mon Sep 17 00:00:00 2001 From: grumbulon Date: Fri, 16 Sep 2022 18:48:34 -0400 Subject: [PATCH] logawl cleanup --- pkg/logawl/logawl.go | 18 +++++------ pkg/logawl/logger.go | 74 ++++++++++++++++++++++---------------------- 2 files changed, 46 insertions(+), 46 deletions(-) diff --git a/pkg/logawl/logawl.go b/pkg/logawl/logawl.go index ee5032b..b14a0ad 100644 --- a/pkg/logawl/logawl.go +++ b/pkg/logawl/logawl.go @@ -25,22 +25,22 @@ type ( ) // SetLevel stores whatever input value is in mem address of l.level. -func (l *Logger) SetLevel(level Level) { - atomic.StoreInt32((*int32)(&l.Level), int32(level)) +func (logger *Logger) SetLevel(level Level) { + atomic.StoreInt32((*int32)(&logger.Level), int32(level)) } // GetLevel gets the logger level. -func (l *Logger) GetLevel() Level { - return l.level() +func (logger *Logger) GetLevel() Level { + return logger.level() } // Retrieves whatever was stored in mem address of l.level. -func (l *Logger) level() Level { - return Level(atomic.LoadInt32((*int32)(&l.Level))) +func (logger *Logger) level() Level { + return Level(atomic.LoadInt32((*int32)(&logger.Level))) } // UnMarshalLevel unmarshalls the int value of level for writing the header. -func (l *Logger) UnMarshalLevel(lv Level) (string, error) { +func (logger *Logger) UnMarshalLevel(lv Level) (string, error) { switch lv { case ErrLevel: return "ERROR ", nil @@ -56,8 +56,8 @@ func (l *Logger) UnMarshalLevel(lv Level) (string, error) { } // IsLevel returns true if the logger level is above the level given. -func (l *Logger) IsLevel(level Level) bool { - return l.level() >= level +func (logger *Logger) IsLevel(level Level) bool { + return logger.level() >= level } // AllLevels is an array of all valid log levels. diff --git a/pkg/logawl/logger.go b/pkg/logawl/logger.go index b0993ea..5aaad39 100644 --- a/pkg/logawl/logger.go +++ b/pkg/logawl/logger.go @@ -20,28 +20,28 @@ func New() *Logger { } // Println takes any and prints it out to Logger -> Out (io.Writer (default is std.Err)). -func (l *Logger) Println(level Level, v ...any) { - if atomic.LoadInt32(&l.isDiscard) != 0 { +func (logger *Logger) Println(level Level, in ...any) { + if atomic.LoadInt32(&logger.isDiscard) != 0 { return } // If verbose is not set --debug etc print _nothing_ - if l.IsLevel(level) { + if logger.IsLevel(level) { switch level { // Goes through log levels and does stuff based on them (currently nothing) case ErrLevel: - if err := l.Printer(ErrLevel, fmt.Sprintln(v...)); err != nil { - fmt.Fprintln(os.Stderr, "Logger failed: ", err) + if err := logger.Printer(ErrLevel, fmt.Sprintln(in...)); err != nil { + fmt.Fprintln(logger.Out, "Logger failed: ", err) } case WarnLevel: - if err := l.Printer(WarnLevel, fmt.Sprintln(v...)); err != nil { - fmt.Fprintln(os.Stderr, "Logger failed: ", err) + if err := logger.Printer(WarnLevel, fmt.Sprintln(in...)); err != nil { + fmt.Fprintln(logger.Out, "Logger failed: ", err) } case InfoLevel: - if err := l.Printer(InfoLevel, fmt.Sprintln(v...)); err != nil { - fmt.Fprintln(os.Stderr, "Logger failed: ", err) + if err := logger.Printer(InfoLevel, fmt.Sprintln(in...)); err != nil { + fmt.Fprintln(logger.Out, "Logger failed: ", err) } case DebugLevel: - if err := l.Printer(DebugLevel, fmt.Sprintln(v...)); err != nil { - fmt.Fprintln(os.Stderr, "Logger failed: ", err) + if err := logger.Printer(DebugLevel, fmt.Sprintln(in...)); err != nil { + fmt.Fprintln(logger.Out, "Logger failed: ", err) } default: break @@ -50,8 +50,8 @@ func (l *Logger) Println(level Level, v ...any) { } // FormatHeader formats the log header as such YYYY/MM/DD HH:MM:SS (local time) . -func (l *Logger) FormatHeader(buf *[]byte, t time.Time, line int, level Level) error { - if lvl, err := l.UnMarshalLevel(level); err == nil { +func (logger *Logger) FormatHeader(buf *[]byte, t time.Time, line int, level Level) error { + if lvl, err := logger.UnMarshalLevel(level); err == nil { // This is ugly but functional // maybe there can be an append func or something in the future *buf = append(*buf, lvl...) @@ -81,27 +81,27 @@ func (l *Logger) FormatHeader(buf *[]byte, t time.Time, line int, level Level) e } // Printer prints the formatted message directly to stdErr. -func (l *Logger) Printer(level Level, s string) error { +func (logger *Logger) Printer(level Level, s string) error { now := time.Now() var line int - l.Mu.Lock() - defer l.Mu.Unlock() + logger.Mu.Lock() + defer logger.Mu.Unlock() - l.buf = l.buf[:0] + logger.buf = logger.buf[:0] - if err := l.FormatHeader(&l.buf, now, line, level); err != nil { + if err := logger.FormatHeader(&logger.buf, now, line, level); err != nil { return err } - l.buf = append(l.buf, s...) + logger.buf = append(logger.buf, s...) if len(s) == 0 || s[len(s)-1] != '\n' { - l.buf = append(l.buf, '\n') + logger.buf = append(logger.buf, '\n') } - _, err := l.Out.Write(l.buf) + _, err := logger.Out.Write(logger.buf) if err != nil { return fmt.Errorf("logger printing: %w", err) } @@ -135,41 +135,41 @@ func formatter(buf *[]byte, i int, wid int) { } // Debug calls print directly with Debug level. -func (l *Logger) Debug(v ...any) { - l.Println(DebugLevel, v...) +func (logger *Logger) Debug(in ...any) { + logger.Println(DebugLevel, in...) } // Debugf calls print after formatting the string with Debug level. -func (l *Logger) Debugf(format string, v ...any) { - l.Println(ErrLevel, fmt.Sprintf(format, v...)) +func (logger *Logger) Debugf(format string, in ...any) { + logger.Println(ErrLevel, fmt.Sprintf(format, in...)) } // Info calls print directly with Info level. -func (l *Logger) Info(v ...any) { - l.Println(InfoLevel, v...) +func (logger *Logger) Info(in ...any) { + logger.Println(InfoLevel, in...) } // Infof calls print after formatting the string with Info level. -func (l *Logger) Infof(format string, v ...any) { - l.Println(ErrLevel, fmt.Sprintf(format, v...)) +func (logger *Logger) Infof(format string, in ...any) { + logger.Println(ErrLevel, fmt.Sprintf(format, in...)) } // Warn calls print directly with Warn level. -func (l *Logger) Warn(v ...any) { - l.Println(WarnLevel, v...) +func (logger *Logger) Warn(in ...any) { + logger.Println(WarnLevel, in...) } // Warnf calls print after formatting the string with Warn level. -func (l *Logger) Warnf(format string, v ...any) { - l.Println(WarnLevel, fmt.Sprintf(format, v...)) +func (logger *Logger) Warnf(format string, in ...any) { + logger.Println(WarnLevel, fmt.Sprintf(format, in...)) } // Error calls print directly with Error level. -func (l *Logger) Error(v ...any) { - l.Println(ErrLevel, v...) +func (logger *Logger) Error(in ...any) { + logger.Println(ErrLevel, in...) } // Errorf calls print after formatting the string with Error level. -func (l *Logger) Errorf(format string, v ...any) { - l.Println(ErrLevel, fmt.Sprintf(format, v...)) +func (logger *Logger) Errorf(format string, in ...any) { + logger.Println(ErrLevel, fmt.Sprintf(format, in...)) }