src/foundation/api/revel/logger/composite_multihandler.go

   1 package logger
   2
   3 import (
   4         "github.com/mattn/go-colorable"
   5         "gopkg.in/natefinch/lumberjack.v2"
   6         "io"
   7         "os"
   8 )
   9
  10 type CompositeMultiHandler struct {
  11         DebugHandler    LogHandler
  12         InfoHandler     LogHandler
  13         WarnHandler     LogHandler
  14         ErrorHandler    LogHandler
  15         CriticalHandler LogHandler
  16 }
  17
  18 func NewCompositeMultiHandler() (*CompositeMultiHandler, LogHandler) {
  19         cw := &CompositeMultiHandler{}
  20         return cw, cw
  21 }
  22 func (h *CompositeMultiHandler) Log(r *Record) (err error) {
  23
  24         var handler LogHandler
  25
  26         switch r.Level {
  27         case LvlInfo:
  28                 handler = h.InfoHandler
  29         case LvlDebug:
  30                 handler = h.DebugHandler
  31         case LvlWarn:
  32                 handler = h.WarnHandler
  33         case LvlError:
  34                 handler = h.ErrorHandler
  35         case LvlCrit:
  36                 handler = h.CriticalHandler
  37         }
  38
  39         // Embed the caller function in the context
  40         if handler != nil {
  41                 handler.Log(r)
  42         }
  43         return
  44 }
  45
  46 func (h *CompositeMultiHandler) SetHandler(handler LogHandler, replace bool, level LogLevel) {
  47         if handler == nil {
  48                 // Ignore empty handler
  49                 return
  50         }
  51         source := &h.DebugHandler
  52         switch level {
  53         case LvlDebug:
  54                 source = &h.DebugHandler
  55         case LvlInfo:
  56                 source = &h.InfoHandler
  57         case LvlWarn:
  58                 source = &h.WarnHandler
  59         case LvlError:
  60                 source = &h.ErrorHandler
  61         case LvlCrit:
  62                 source = &h.CriticalHandler
  63         }
  64
  65         if !replace && *source != nil {
  66                 // If we are not replacing the source make sure that the level handler is applied first
  67                 if _, isLevel := (*source).(*LevelFilterHandler); !isLevel {
  68                         *source = LevelHandler(level, *source)
  69                 }
  70                 // If this already was a list add a new logger to it
  71                 if ll, found := (*source).(*ListLogHandler); found {
  72                         ll.Add(handler)
  73                 } else {
  74                         *source = NewListLogHandler(*source, handler)
  75                 }
  76         } else {
  77                 *source = handler
  78         }
  79 }
  80
  81 // For the multi handler set the handler, using the LogOptions defined
  82 func (h *CompositeMultiHandler) SetHandlers(handler LogHandler, options *LogOptions) {
  83         if len(options.Levels) == 0 {
  84                 options.Levels = LvlAllList
  85         }
  86
  87         // Set all levels
  88         for _, lvl := range options.Levels {
  89                 h.SetHandler(handler, options.ReplaceExistingHandler, lvl)
  90         }
  91
  92 }
  93 func (h *CompositeMultiHandler) SetJson(writer io.Writer, options *LogOptions) {
  94         handler := CallerFileHandler(StreamHandler(writer, JsonFormatEx(
  95                 options.GetBoolDefault("pretty", false),
  96                 options.GetBoolDefault("lineSeparated", true),
  97         )))
  98         if options.HandlerWrap != nil {
  99                 handler = options.HandlerWrap.SetChild(handler)
 100         }
 101         h.SetHandlers(handler, options)
 102 }
 103
 104 // Use built in rolling function
 105 func (h *CompositeMultiHandler) SetJsonFile(filePath string, options *LogOptions) {
 106         writer := &lumberjack.Logger{
 107                 Filename:   filePath,
 108                 MaxSize:    options.GetIntDefault("maxSizeMB", 1024), // megabytes
 109                 MaxAge:     options.GetIntDefault("maxAgeDays", 7),   //days
 110                 MaxBackups: options.GetIntDefault("maxBackups", 7),
 111                 Compress:   options.GetBoolDefault("compress", true),
 112         }
 113         h.SetJson(writer, options)
 114 }
 115
 116 func (h *CompositeMultiHandler) SetTerminal(writer io.Writer, options *LogOptions) {
 117         streamHandler := StreamHandler(
 118                 writer,
 119                 TerminalFormatHandler(
 120                         options.GetBoolDefault("noColor", false),
 121                         options.GetBoolDefault("smallDate", true)))
 122
 123         if os.Stdout == writer {
 124                 streamHandler = StreamHandler(
 125                         colorable.NewColorableStdout(),
 126                         TerminalFormatHandler(
 127                                 options.GetBoolDefault("noColor", false),
 128                                 options.GetBoolDefault("smallDate", true)))
 129         } else if os.Stderr == writer {
 130                 streamHandler = StreamHandler(
 131                         colorable.NewColorableStderr(),
 132                         TerminalFormatHandler(
 133                                 options.GetBoolDefault("noColor", false),
 134                                 options.GetBoolDefault("smallDate", true)))
 135         }
 136         handler := CallerFileHandler(streamHandler)
 137
 138         if options.HandlerWrap != nil {
 139                 handler = options.HandlerWrap.SetChild(handler)
 140         }
 141         h.SetHandlers(handler, options)
 142 }
 143
 144 // Use built in rolling function
 145 func (h *CompositeMultiHandler) SetTerminalFile(filePath string, options *LogOptions) {
 146         writer := &lumberjack.Logger{
 147                 Filename:   filePath,
 148                 MaxSize:    options.GetIntDefault("maxSizeMB", 1024), // megabytes
 149                 MaxAge:     options.GetIntDefault("maxAgeDays", 7),   //days
 150                 MaxBackups: options.GetIntDefault("maxBackups", 7),
 151                 Compress:   options.GetBoolDefault("compress", true),
 152         }
 153         h.SetTerminal(writer, options)
 154 }
 155
 156 func (h *CompositeMultiHandler) Disable(levels ...LogLevel) {
 157         if len(levels) == 0 {
 158                 levels = LvlAllList
 159         }
 160         for _, level := range levels {
 161                 switch level {
 162                 case LvlDebug:
 163                         h.DebugHandler = nil
 164                 case LvlInfo:
 165                         h.InfoHandler = nil
 166                 case LvlWarn:
 167                         h.WarnHandler = nil
 168                 case LvlError:
 169                         h.ErrorHandler = nil
 170                 case LvlCrit:
 171                         h.CriticalHandler = nil
 172                 }
 173         }
 174 }