github.com/micro/go-micro/v2@v2.9.1/logger/level.go (about)

     1  package logger
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  )
     7  
     8  type Level int8
     9  
    10  const (
    11  	// TraceLevel level. Designates finer-grained informational events than the Debug.
    12  	TraceLevel Level = iota - 2
    13  	// DebugLevel level. Usually only enabled when debugging. Very verbose logging.
    14  	DebugLevel
    15  	// InfoLevel is the default logging priority.
    16  	// General operational entries about what's going on inside the application.
    17  	InfoLevel
    18  	// WarnLevel level. Non-critical entries that deserve eyes.
    19  	WarnLevel
    20  	// ErrorLevel level. Logs. Used for errors that should definitely be noted.
    21  	ErrorLevel
    22  	// FatalLevel level. Logs and then calls `logger.Exit(1)`. highest level of severity.
    23  	FatalLevel
    24  )
    25  
    26  func (l Level) String() string {
    27  	switch l {
    28  	case TraceLevel:
    29  		return "trace"
    30  	case DebugLevel:
    31  		return "debug"
    32  	case InfoLevel:
    33  		return "info"
    34  	case WarnLevel:
    35  		return "warn"
    36  	case ErrorLevel:
    37  		return "error"
    38  	case FatalLevel:
    39  		return "fatal"
    40  	}
    41  	return ""
    42  }
    43  
    44  // Enabled returns true if the given level is at or above this level.
    45  func (l Level) Enabled(lvl Level) bool {
    46  	return lvl >= l
    47  }
    48  
    49  // GetLevel converts a level string into a logger Level value.
    50  // returns an error if the input string does not match known values.
    51  func GetLevel(levelStr string) (Level, error) {
    52  	switch levelStr {
    53  	case TraceLevel.String():
    54  		return TraceLevel, nil
    55  	case DebugLevel.String():
    56  		return DebugLevel, nil
    57  	case InfoLevel.String():
    58  		return InfoLevel, nil
    59  	case WarnLevel.String():
    60  		return WarnLevel, nil
    61  	case ErrorLevel.String():
    62  		return ErrorLevel, nil
    63  	case FatalLevel.String():
    64  		return FatalLevel, nil
    65  	}
    66  	return InfoLevel, fmt.Errorf("Unknown Level String: '%s', defaulting to InfoLevel", levelStr)
    67  }
    68  
    69  func Info(args ...interface{}) {
    70  	DefaultLogger.Log(InfoLevel, args...)
    71  }
    72  
    73  func Infof(template string, args ...interface{}) {
    74  	DefaultLogger.Logf(InfoLevel, template, args...)
    75  }
    76  
    77  func Trace(args ...interface{}) {
    78  	DefaultLogger.Log(TraceLevel, args...)
    79  }
    80  
    81  func Tracef(template string, args ...interface{}) {
    82  	DefaultLogger.Logf(TraceLevel, template, args...)
    83  }
    84  
    85  func Debug(args ...interface{}) {
    86  	DefaultLogger.Log(DebugLevel, args...)
    87  }
    88  
    89  func Debugf(template string, args ...interface{}) {
    90  	DefaultLogger.Logf(DebugLevel, template, args...)
    91  }
    92  
    93  func Warn(args ...interface{}) {
    94  	DefaultLogger.Log(WarnLevel, args...)
    95  }
    96  
    97  func Warnf(template string, args ...interface{}) {
    98  	DefaultLogger.Logf(WarnLevel, template, args...)
    99  }
   100  
   101  func Error(args ...interface{}) {
   102  	DefaultLogger.Log(ErrorLevel, args...)
   103  }
   104  
   105  func Errorf(template string, args ...interface{}) {
   106  	DefaultLogger.Logf(ErrorLevel, template, args...)
   107  }
   108  
   109  func Fatal(args ...interface{}) {
   110  	DefaultLogger.Log(FatalLevel, args...)
   111  	os.Exit(1)
   112  }
   113  
   114  func Fatalf(template string, args ...interface{}) {
   115  	DefaultLogger.Logf(FatalLevel, template, args...)
   116  	os.Exit(1)
   117  }
   118  
   119  // Returns true if the given level is at or lower the current logger level
   120  func V(lvl Level, log Logger) bool {
   121  	l := DefaultLogger
   122  	if log != nil {
   123  		l = log
   124  	}
   125  	return l.Options().Level <= lvl
   126  }