exported.go

Documentation: github.com/sirupsen/logrus

     1  package logrus
     2  
     3  import (
     4  	"context"
     5  	"io"
     6  	"time"
     7  )
     8  
     9  var (
    10  	// std is the name of the standard logger in stdlib `log`
    11  	std = New()
    12  )
    13  
    14  func StandardLogger() *Logger {
    15  	return std
    16  }
    17  
    18  // SetOutput sets the standard logger output.
    19  func SetOutput(out io.Writer) {
    20  	std.SetOutput(out)
    21  }
    22  
    23  // SetFormatter sets the standard logger formatter.
    24  func SetFormatter(formatter Formatter) {
    25  	std.SetFormatter(formatter)
    26  }
    27  
    28  // SetReportCaller sets whether the standard logger will include the calling
    29  // method as a field.
    30  func SetReportCaller(include bool) {
    31  	std.SetReportCaller(include)
    32  }
    33  
    34  // SetLevel sets the standard logger level.
    35  func SetLevel(level Level) {
    36  	std.SetLevel(level)
    37  }
    38  
    39  // GetLevel returns the standard logger level.
    40  func GetLevel() Level {
    41  	return std.GetLevel()
    42  }
    43  
    44  // IsLevelEnabled checks if the log level of the standard logger is greater than the level param
    45  func IsLevelEnabled(level Level) bool {
    46  	return std.IsLevelEnabled(level)
    47  }
    48  
    49  // AddHook adds a hook to the standard logger hooks.
    50  func AddHook(hook Hook) {
    51  	std.AddHook(hook)
    52  }
    53  
    54  // WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key.
    55  func WithError(err error) *Entry {
    56  	return std.WithField(ErrorKey, err)
    57  }
    58  
    59  // WithContext creates an entry from the standard logger and adds a context to it.
    60  func WithContext(ctx context.Context) *Entry {
    61  	return std.WithContext(ctx)
    62  }
    63  
    64  // WithField creates an entry from the standard logger and adds a field to
    65  // it. If you want multiple fields, use `WithFields`.
    66  //
    67  // Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
    68  // or Panic on the Entry it returns.
    69  func WithField(key string, value interface{}) *Entry {
    70  	return std.WithField(key, value)
    71  }
    72  
    73  // WithFields creates an entry from the standard logger and adds multiple
    74  // fields to it. This is simply a helper for `WithField`, invoking it
    75  // once for each field.
    76  //
    77  // Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
    78  // or Panic on the Entry it returns.
    79  func WithFields(fields Fields) *Entry {
    80  	return std.WithFields(fields)
    81  }
    82  
    83  // WithTime creates an entry from the standard logger and overrides the time of
    84  // logs generated with it.
    85  //
    86  // Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
    87  // or Panic on the Entry it returns.
    88  func WithTime(t time.Time) *Entry {
    89  	return std.WithTime(t)
    90  }
    91  
    92  // Trace logs a message at level Trace on the standard logger.
    93  func Trace(args ...interface{}) {
    94  	std.Trace(args...)
    95  }
    96  
    97  // Debug logs a message at level Debug on the standard logger.
    98  func Debug(args ...interface{}) {
    99  	std.Debug(args...)
   100  }
   101  
   102  // Print logs a message at level Info on the standard logger.
   103  func Print(args ...interface{}) {
   104  	std.Print(args...)
   105  }
   106  
   107  // Info logs a message at level Info on the standard logger.
   108  func Info(args ...interface{}) {
   109  	std.Info(args...)
   110  }
   111  
   112  // Warn logs a message at level Warn on the standard logger.
   113  func Warn(args ...interface{}) {
   114  	std.Warn(args...)
   115  }
   116  
   117  // Warning logs a message at level Warn on the standard logger.
   118  func Warning(args ...interface{}) {
   119  	std.Warning(args...)
   120  }
   121  
   122  // Error logs a message at level Error on the standard logger.
   123  func Error(args ...interface{}) {
   124  	std.Error(args...)
   125  }
   126  
   127  // Panic logs a message at level Panic on the standard logger.
   128  func Panic(args ...interface{}) {
   129  	std.Panic(args...)
   130  }
   131  
   132  // Fatal logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
   133  func Fatal(args ...interface{}) {
   134  	std.Fatal(args...)
   135  }
   136  
   137  // TraceFn logs a message from a func at level Trace on the standard logger.
   138  func TraceFn(fn LogFunction) {
   139  	std.TraceFn(fn)
   140  }
   141  
   142  // DebugFn logs a message from a func at level Debug on the standard logger.
   143  func DebugFn(fn LogFunction) {
   144  	std.DebugFn(fn)
   145  }
   146  
   147  // PrintFn logs a message from a func at level Info on the standard logger.
   148  func PrintFn(fn LogFunction) {
   149  	std.PrintFn(fn)
   150  }
   151  
   152  // InfoFn logs a message from a func at level Info on the standard logger.
   153  func InfoFn(fn LogFunction) {
   154  	std.InfoFn(fn)
   155  }
   156  
   157  // WarnFn logs a message from a func at level Warn on the standard logger.
   158  func WarnFn(fn LogFunction) {
   159  	std.WarnFn(fn)
   160  }
   161  
   162  // WarningFn logs a message from a func at level Warn on the standard logger.
   163  func WarningFn(fn LogFunction) {
   164  	std.WarningFn(fn)
   165  }
   166  
   167  // ErrorFn logs a message from a func at level Error on the standard logger.
   168  func ErrorFn(fn LogFunction) {
   169  	std.ErrorFn(fn)
   170  }
   171  
   172  // PanicFn logs a message from a func at level Panic on the standard logger.
   173  func PanicFn(fn LogFunction) {
   174  	std.PanicFn(fn)
   175  }
   176  
   177  // FatalFn logs a message from a func at level Fatal on the standard logger then the process will exit with status set to 1.
   178  func FatalFn(fn LogFunction) {
   179  	std.FatalFn(fn)
   180  }
   181  
   182  // Tracef logs a message at level Trace on the standard logger.
   183  func Tracef(format string, args ...interface{}) {
   184  	std.Tracef(format, args...)
   185  }
   186  
   187  // Debugf logs a message at level Debug on the standard logger.
   188  func Debugf(format string, args ...interface{}) {
   189  	std.Debugf(format, args...)
   190  }
   191  
   192  // Printf logs a message at level Info on the standard logger.
   193  func Printf(format string, args ...interface{}) {
   194  	std.Printf(format, args...)
   195  }
   196  
   197  // Infof logs a message at level Info on the standard logger.
   198  func Infof(format string, args ...interface{}) {
   199  	std.Infof(format, args...)
   200  }
   201  
   202  // Warnf logs a message at level Warn on the standard logger.
   203  func Warnf(format string, args ...interface{}) {
   204  	std.Warnf(format, args...)
   205  }
   206  
   207  // Warningf logs a message at level Warn on the standard logger.
   208  func Warningf(format string, args ...interface{}) {
   209  	std.Warningf(format, args...)
   210  }
   211  
   212  // Errorf logs a message at level Error on the standard logger.
   213  func Errorf(format string, args ...interface{}) {
   214  	std.Errorf(format, args...)
   215  }
   216  
   217  // Panicf logs a message at level Panic on the standard logger.
   218  func Panicf(format string, args ...interface{}) {
   219  	std.Panicf(format, args...)
   220  }
   221  
   222  // Fatalf logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
   223  func Fatalf(format string, args ...interface{}) {
   224  	std.Fatalf(format, args...)
   225  }
   226  
   227  // Traceln logs a message at level Trace on the standard logger.
   228  func Traceln(args ...interface{}) {
   229  	std.Traceln(args...)
   230  }
   231  
   232  // Debugln logs a message at level Debug on the standard logger.
   233  func Debugln(args ...interface{}) {
   234  	std.Debugln(args...)
   235  }
   236  
   237  // Println logs a message at level Info on the standard logger.
   238  func Println(args ...interface{}) {
   239  	std.Println(args...)
   240  }
   241  
   242  // Infoln logs a message at level Info on the standard logger.
   243  func Infoln(args ...interface{}) {
   244  	std.Infoln(args...)
   245  }
   246  
   247  // Warnln logs a message at level Warn on the standard logger.
   248  func Warnln(args ...interface{}) {
   249  	std.Warnln(args...)
   250  }
   251  
   252  // Warningln logs a message at level Warn on the standard logger.
   253  func Warningln(args ...interface{}) {
   254  	std.Warningln(args...)
   255  }
   256  
   257  // Errorln logs a message at level Error on the standard logger.
   258  func Errorln(args ...interface{}) {
   259  	std.Errorln(args...)
   260  }
   261  
   262  // Panicln logs a message at level Panic on the standard logger.
   263  func Panicln(args ...interface{}) {
   264  	std.Panicln(args...)
   265  }
   266  
   267  // Fatalln logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
   268  func Fatalln(args ...interface{}) {
   269  	std.Fatalln(args...)
   270  }
   271
View as plain text