logawl cleanup

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.

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 <LogLevel> YYYY/MM/DD HH:MM:SS (local time) <the message to log>.
-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...))
 }