github.com/tickoalcantara12/micro/v3@v3.0.0-20221007104245-9d75b9bcbab9/service/logger/level.go (about)

     1  // Licensed under the Apache License, Version 2.0 (the "License");
     2  // you may not use this file except in compliance with the License.
     3  // You may obtain a copy of the License at
     4  //
     5  //     https://www.apache.org/licenses/LICENSE-2.0
     6  //
     7  // Unless required by applicable law or agreed to in writing, software
     8  // distributed under the License is distributed on an "AS IS" BASIS,
     9  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    10  // See the License for the specific language governing permissions and
    11  // limitations under the License.
    12  //
    13  // Original source: github.com/micro/go-micro/v3/logger/level.go
    14  
    15  package logger
    16  
    17  import (
    18  	"fmt"
    19  	"os"
    20  )
    21  
    22  type Level int8
    23  
    24  const (
    25  	// TraceLevel level. Designates finer-grained informational events than the Debug.
    26  	TraceLevel Level = iota - 2
    27  	// DebugLevel level. Usually only enabled when debugging. Very verbose logging.
    28  	DebugLevel
    29  	// InfoLevel is the default logging priority.
    30  	// General operational entries about what's going on inside the application.
    31  	InfoLevel
    32  	// WarnLevel level. Non-critical entries that deserve eyes.
    33  	WarnLevel
    34  	// ErrorLevel level. Logs. Used for errors that should definitely be noted.
    35  	ErrorLevel
    36  	// FatalLevel level. Logs and then calls `logger.Exit(1)`. highest level of severity.
    37  	FatalLevel
    38  )
    39  
    40  func (l Level) String() string {
    41  	switch l {
    42  	case TraceLevel:
    43  		return "trace"
    44  	case DebugLevel:
    45  		return "debug"
    46  	case InfoLevel:
    47  		return "info"
    48  	case WarnLevel:
    49  		return "warn"
    50  	case ErrorLevel:
    51  		return "error"
    52  	case FatalLevel:
    53  		return "fatal"
    54  	}
    55  	return ""
    56  }
    57  
    58  // Enabled returns true if the given level is at or above this level.
    59  func (l Level) Enabled(lvl Level) bool {
    60  	return lvl >= l
    61  }
    62  
    63  // GetLevel converts a level string into a logger Level value.
    64  // returns an error if the input string does not match known values.
    65  func GetLevel(levelStr string) (Level, error) {
    66  	switch levelStr {
    67  	case TraceLevel.String():
    68  		return TraceLevel, nil
    69  	case DebugLevel.String():
    70  		return DebugLevel, nil
    71  	case InfoLevel.String():
    72  		return InfoLevel, nil
    73  	case WarnLevel.String():
    74  		return WarnLevel, nil
    75  	case ErrorLevel.String():
    76  		return ErrorLevel, nil
    77  	case FatalLevel.String():
    78  		return FatalLevel, nil
    79  	}
    80  	return InfoLevel, fmt.Errorf("Unknown Level String: '%s', defaulting to InfoLevel", levelStr)
    81  }
    82  
    83  func Info(args ...interface{}) {
    84  	DefaultLogger.Log(InfoLevel, args...)
    85  }
    86  
    87  func Infof(template string, args ...interface{}) {
    88  	DefaultLogger.Logf(InfoLevel, template, args...)
    89  }
    90  
    91  func Trace(args ...interface{}) {
    92  	DefaultLogger.Log(TraceLevel, args...)
    93  }
    94  
    95  func Tracef(template string, args ...interface{}) {
    96  	DefaultLogger.Logf(TraceLevel, template, args...)
    97  }
    98  
    99  func Debug(args ...interface{}) {
   100  	DefaultLogger.Log(DebugLevel, args...)
   101  }
   102  
   103  func Debugf(template string, args ...interface{}) {
   104  	DefaultLogger.Logf(DebugLevel, template, args...)
   105  }
   106  
   107  func Warn(args ...interface{}) {
   108  	DefaultLogger.Log(WarnLevel, args...)
   109  }
   110  
   111  func Warnf(template string, args ...interface{}) {
   112  	DefaultLogger.Logf(WarnLevel, template, args...)
   113  }
   114  
   115  func Error(args ...interface{}) {
   116  	DefaultLogger.Log(ErrorLevel, args...)
   117  }
   118  
   119  func Errorf(template string, args ...interface{}) {
   120  	DefaultLogger.Logf(ErrorLevel, template, args...)
   121  }
   122  
   123  func Fatal(args ...interface{}) {
   124  	DefaultLogger.Log(FatalLevel, args...)
   125  	os.Exit(1)
   126  }
   127  
   128  func Fatalf(template string, args ...interface{}) {
   129  	DefaultLogger.Logf(FatalLevel, template, args...)
   130  	os.Exit(1)
   131  }
   132  
   133  // Returns true if the given level is at or lower the current logger level
   134  func V(lvl Level, log Logger) bool {
   135  	l := DefaultLogger
   136  	if log != nil {
   137  		l = log
   138  	}
   139  	return l.Options().Level <= lvl
   140  }