github.com/ssgreg/logf@v1.4.1/level.go (about)

     1  package logf
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  )
     7  
     8  // Level defines severity level of a log message.
     9  type Level int8
    10  
    11  // Severity levels.
    12  const (
    13  	// LevelError allows to log errors only.
    14  	LevelError Level = iota
    15  	// LevelWarn allows to log errors and warnings.
    16  	LevelWarn
    17  	// LevelInfo is the default logging level. Allows to log errors, warnings and infos.
    18  	LevelInfo
    19  	// LevelDebug allows to log messages with all severity levels.
    20  	LevelDebug
    21  )
    22  
    23  // Checker is the common way to get LevelChecker. Use it with every custom
    24  // implementation of Level.
    25  func (l Level) Checker() LevelChecker {
    26  	return func(o Level) bool {
    27  		return l.Enabled(o)
    28  	}
    29  }
    30  
    31  // LevelChecker implements LevelCheckerGetter.
    32  func (l Level) LevelChecker() LevelChecker {
    33  	return l.Checker()
    34  }
    35  
    36  // Enabled returns true if the given level is allowed within the current level.
    37  func (l Level) Enabled(o Level) bool {
    38  	return l >= o
    39  }
    40  
    41  // String implements fmt.Stringer.
    42  // String returns a lower-case string representation of the Level.
    43  func (l Level) String() string {
    44  	switch l {
    45  	case LevelDebug:
    46  		return "debug"
    47  	case LevelInfo:
    48  		return "info"
    49  	case LevelWarn:
    50  		return "warn"
    51  	case LevelError:
    52  		return "error"
    53  	default:
    54  		return "unknown"
    55  	}
    56  }
    57  
    58  // UpperCaseString returns an upper-case string representation of the Level.
    59  func (l Level) UpperCaseString() string {
    60  	switch l {
    61  	case LevelDebug:
    62  		return "DEBUG"
    63  	case LevelInfo:
    64  		return "INFO"
    65  	case LevelWarn:
    66  		return "WARN"
    67  	case LevelError:
    68  		return "ERROR"
    69  	default:
    70  		return "UNKNOWN"
    71  	}
    72  }
    73  
    74  // MarshalText marshals the Level to text.
    75  func (l Level) MarshalText() ([]byte, error) {
    76  	return []byte(l.String()), nil
    77  }
    78  
    79  // UnmarshalText unmarshals the Level from text.
    80  func (l *Level) UnmarshalText(text []byte) error {
    81  	s := string(text)
    82  	lvl, ok := LevelFromString(s)
    83  	if !ok {
    84  		return fmt.Errorf("invalid logging level %q", s)
    85  	}
    86  
    87  	*l = lvl
    88  
    89  	return nil
    90  }
    91  
    92  // LevelFromString creates the new Level with the given string.
    93  func LevelFromString(lvl string) (Level, bool) {
    94  	switch strings.ToLower(lvl) {
    95  	case "debug":
    96  		return LevelDebug, true
    97  	case "info", "information":
    98  		return LevelInfo, true
    99  	case "warn", "warning":
   100  		return LevelWarn, true
   101  	case "error":
   102  		return LevelError, true
   103  	}
   104  
   105  	return LevelError, false
   106  }
   107  
   108  // LevelChecker abstracts level checking process.
   109  type LevelChecker func(Level) bool
   110  
   111  // LevelCheckerGetter allows the implementor to act like a common Level
   112  // checker for the Logger.
   113  type LevelCheckerGetter interface {
   114  	LevelChecker() LevelChecker
   115  }
   116  
   117  // LevelCheckerGetterFunc defines a function that returns LevelChecker.
   118  type LevelCheckerGetterFunc func() LevelChecker
   119  
   120  // LevelChecker implements LevelCheckerGetter interface.
   121  func (fn LevelCheckerGetterFunc) LevelChecker() LevelChecker {
   122  	return fn()
   123  }
   124  
   125  // LevelEncoder is the function type to encode Level.
   126  type LevelEncoder func(Level, TypeEncoder)
   127  
   128  // DefaultLevelEncoder implements LevelEncoder by calling Level itself.
   129  func DefaultLevelEncoder(lvl Level, m TypeEncoder) {
   130  	m.EncodeTypeString(lvl.String())
   131  }
   132  
   133  // UpperCaseLevelEncoder implements LevelEncoder by calling Level itself.
   134  func UpperCaseLevelEncoder(lvl Level, m TypeEncoder) {
   135  	m.EncodeTypeString(lvl.UpperCaseString())
   136  }