func getLogFormat(format string) log15.Format { switch format { case "console": if term.IsTty(os.Stdout.Fd()) { return log15.TerminalFormat() } return log15.LogfmtFormat() case "text": return log15.LogfmtFormat() case "json": return log15.JsonFormat() default: return log15.LogfmtFormat() } }
func newLogger() log15.Logger { l := log15.New() h := log15.StreamHandler(os.Stdout, log15.LogfmtFormat()) //h = log15.CallerStackHandler("%+n", h) l.SetHandler(log15.LazyHandler(h)) return l }
// create a FileLogWriter returning as LoggerInterface. func NewFileWriter() *FileLogWriter { w := &FileLogWriter{ Filename: "", Format: log15.LogfmtFormat(), Maxlines: 1000000, Maxsize: 1 << 28, //256 MB Daily: true, Maxdays: 7, Rotate: true, } // use MuxWriter instead direct use os.File for lock write when rotate w.mw = new(MuxWriter) return w }
// getMsg returns message which should be sent to Slack func (h *Handler) getMsg(r *log15.Record) *message { msg := &message{ Envelope: h.Envelope, } // Choose message color depending on log level // (this is imitating colors from log15.TerminalFormat) color := "#32C8C8" // blue switch r.Lvl { case log15.LvlInfo: color = "good" // green case log15.LvlWarn: color = "warning" // yellow case log15.LvlError: color = "danger" // red case log15.LvlCrit: color = "#C832C8" // purple } msg.Attachments[0].Color = color if h.Formatter != nil { txt := string(h.Formatter.Format(r)) msg.Attachments[0].Text = txt msg.Attachments[0].Fallback = txt } else { ctx := newCtxReader(r.Ctx) fields := make([]Field, 0, len(r.Ctx)/2) for ctx.Next() { v := ctx.Value() // See if value is a Field; if not, fill with defaults f, ok := v.(Field) if !ok { f.Value = fmt.Sprintf("%+v", v) f.Short = true } if f.Title == "" { f.Title = ctx.Key() } fields = append(fields, f) } msg.Attachments[0].Text = r.Msg msg.Attachments[0].Fallback = string(log15.LogfmtFormat().Format(r)) msg.Attachments[0].Fields = fields } return msg }
func newLogger(c *Context) (log15.Logger, error) { lvl := c.String(FlagLogLevel) l := log15.New() log.Println(fmt.Sprintf("Using log level %s", lvl)) v, err := log15.LvlFromString(lvl) if err != nil { return l, err } h := log15.LvlFilterHandler(v, log15.StreamHandler(os.Stdout, log15.LogfmtFormat())) if lvl == "debug" { h = log15.CallerFileHandler(h) } l.SetHandler(log15.LazyHandler(h)) return l, err }
func NewSyslog(sec *ini.Section, format log15.Format) *SysLogHandler { handler := &SysLogHandler{ Format: log15.LogfmtFormat(), } handler.Format = format handler.Network = sec.Key("network").MustString("") handler.Address = sec.Key("address").MustString("") handler.Facility = sec.Key("facility").MustString("local7") handler.Tag = sec.Key("tag").MustString("") if err := handler.Init(); err != nil { Root.Error("Failed to init syslog log handler", "error", err) os.Exit(1) } return handler }
// DebugContext returns a new Context with an additional handler with a more // verbose filter (using the Debug level) and a Buffer in which all logging // statements will be (also) written to. func (context *Context) DebugContext(logCtx ...interface{}) *Context { var buffer bytes.Buffer childContext := &Context{ Config: context.Config, Log: context.Log.New(logCtx...), logBuffer: &buffer, handler: log15.MultiHandler( log15.StreamHandler(&buffer, log15.LogfmtFormat()), context.handler, ), memoryCollector: NewMemoryEventCollector(), EventFactory: context.EventFactory, } childContext.EventCollector = NewMultiEventCollector( childContext.memoryCollector, context.EventCollector, ) childContext.EventFactory.Register(childContext.memoryCollector) childContext.Log.SetHandler(childContext.handler) return childContext }
func newLogger() log15.Logger { l := log15.New() h := log15.StreamHandler(os.Stdout, log15.LogfmtFormat()) l.SetHandler(log15.LazyHandler(h)) return l }
// NewContext creates a new Context from the specified Config. This also // creates a Logger. func NewContext(config *Config) (*Context, error) { var context = Context{ Config: *config, } // Logging context.Log = log15.New() if context.Config.Logging.File == "/dev/null" { context.handler = log15.DiscardHandler() } else if context.Config.Logging.File == "stderr" { context.handler = log15.StderrHandler } else { handler, err := log15.FileHandler( context.Config.Logging.File, log15.LogfmtFormat(), ) if err != nil { return nil, err } context.handler = handler } level, err := log15.LvlFromString(context.Config.Logging.Level) if err != nil { return nil, err } context.handler = log15.LvlFilterHandler(level, context.handler) context.Log.SetHandler(context.handler) // Tracing if context.Config.Tracing.Enabled { s, err := os.Stat(context.Config.Tracing.File) if os.IsNotExist(err) || s.Size() == 0 { context.tracingFd, err = os.Create(context.Config.Tracing.File) if err != nil { return nil, err } context.EventCollector, err = NewWriterEventCollector( context.tracingFd, false, ) if err != nil { return nil, err } } else { context.tracingFd, err = os.OpenFile( context.Config.Tracing.File, os.O_WRONLY|os.O_APPEND, 0664, ) if err != nil { return nil, err } context.EventCollector, err = NewWriterEventCollector( context.tracingFd, true, ) if err != nil { return nil, err } } } else { context.EventCollector = &NullEventCollector{} } hostname, err := os.Hostname() if err != nil { hostname = "main" } context.EventFactory = NewEventFactory(hostname, "main") context.EventFactory.Register(context.EventCollector) return &context, nil }
func nullLogger() log15.Logger { l := log15.New() h := log15.StreamHandler(ioutil.Discard, log15.LogfmtFormat()) l.SetHandler(h) return l }
func NewSyslog() *SysLogHandler { return &SysLogHandler{ Format: log15.LogfmtFormat(), } }