gtsocial-umbx

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README | LICENSE

exported.go (7239B)

      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 }