revel: github.com/revel/revel/logger Index | Files

package logger

import "github.com/revel/revel/logger"

Package logger contains filters and handles for the logging utilities in Revel. These facilities all currently use the logging library called log15 at https://github.com/inconshreveable/log15

Wrappers for the handlers are written here to provide a kind of isolation layer for Revel in case sometime in the future we would like to switch to another source to implement logging

Index

Package Files

doc.go format.go handlers.go logger.go utils.go

Constants

const (
    LvlDebug = LogLevel(log15.LvlDebug)
    LvlInfo  = LogLevel(log15.LvlInfo)
    LvlWarn  = LogLevel(log15.LvlWarn)
    LvlError = LogLevel(log15.LvlError)
    LvlCrit  = LogLevel(log15.LvlCrit)
)

Variables

var LogFunctionMap = map[string]func(*CompositeMultiHandler, *LogOptions){

    "off": func(c *CompositeMultiHandler, logOptions *LogOptions) {

        if logOptions.HandlerWrap != nil {
            for _, l := range logOptions.Levels {
                c.SetHandler(logOptions.HandlerWrap.SetChild(NilHandler()), logOptions.ReplaceExistingHandler, l)
            }
        }
    },

    "": func(*CompositeMultiHandler, *LogOptions) {},

    "stdout": func(c *CompositeMultiHandler, logOptions *LogOptions) {
        if logOptions.Ctx != nil {
            logOptions.SetExtendedOptions(
                "noColor", !logOptions.Ctx.BoolDefault("log.colorize", true),
                "smallDate", logOptions.Ctx.BoolDefault("log.smallDate", true))
        }

        c.SetTerminal(os.Stdout, logOptions)
    },

    "stderr": func(c *CompositeMultiHandler, logOptions *LogOptions) {
        c.SetTerminal(os.Stderr, logOptions)
    },
}

The log function map can be added to, so that you can specify your own logging mechanism

var LvlAllList = []LogLevel{LvlDebug, LvlInfo, LvlWarn, LvlError, LvlCrit}

A list of all the log levels

func GetLogger Uses

func GetLogger(name string, logger MultiLogger) (l *log.Logger)

func NewCallStack Uses

func NewCallStack() interface{}

For logging purposes the call stack can be used to record the stack trace of a bad error simply pass it as a context field in your log statement like `controller.Log.Critc("This should not occur","stack",revel.NewCallStack())`

func SetDefaultLog Uses

func SetDefaultLog(fromLog MultiLogger)

Set the systems default logger Default logs will be captured and handled by revel at level info

type CompositeMultiHandler Uses

type CompositeMultiHandler struct {
    DebugHandler    LogHandler
    InfoHandler     LogHandler
    WarnHandler     LogHandler
    ErrorHandler    LogHandler
    CriticalHandler LogHandler
}

func InitializeFromConfig Uses

func InitializeFromConfig(basePath string, config *config.Context) (c *CompositeMultiHandler)

Get all handlers based on the Config (if available)

func NewCompositeMultiHandler Uses

func NewCompositeMultiHandler() (*CompositeMultiHandler, LogHandler)

func (*CompositeMultiHandler) Disable Uses

func (h *CompositeMultiHandler) Disable(levels ...LogLevel)

func (*CompositeMultiHandler) Log Uses

func (h *CompositeMultiHandler) Log(r *log15.Record) (err error)

func (*CompositeMultiHandler) SetHandler Uses

func (h *CompositeMultiHandler) SetHandler(handler LogHandler, replace bool, level LogLevel)

func (*CompositeMultiHandler) SetHandlers Uses

func (h *CompositeMultiHandler) SetHandlers(handler LogHandler, options *LogOptions)

func (*CompositeMultiHandler) SetJson Uses

func (h *CompositeMultiHandler) SetJson(writer io.Writer, options *LogOptions)

func (*CompositeMultiHandler) SetJsonFile Uses

func (h *CompositeMultiHandler) SetJsonFile(filePath string, options *LogOptions)

Use built in rolling function

func (*CompositeMultiHandler) SetTerminal Uses

func (h *CompositeMultiHandler) SetTerminal(writer io.Writer, options *LogOptions)

func (*CompositeMultiHandler) SetTerminalFile Uses

func (h *CompositeMultiHandler) SetTerminalFile(filePath string, options *LogOptions)

Use built in rolling function

type ListLogHandler Uses

type ListLogHandler struct {
    // contains filtered or unexported fields
}

func NewListLogHandler Uses

func NewListLogHandler(h1, h2 LogHandler) *ListLogHandler

func (*ListLogHandler) Add Uses

func (ll *ListLogHandler) Add(h LogHandler)

func (*ListLogHandler) Del Uses

func (ll *ListLogHandler) Del(h LogHandler)

func (*ListLogHandler) Log Uses

func (ll *ListLogHandler) Log(r *log15.Record) (err error)

type LogFormat Uses

type LogFormat interface {
    log15.Format
}

The LogHandler defines the interface to handle the log records

func TerminalFormatHandler Uses

func TerminalFormatHandler(noColor bool, smallDate bool) LogFormat

Outputs to the terminal in a format like below INFO 09:11:32 server-engine.go:169: Request Stats

type LogHandler Uses

type LogHandler interface {
    log15.Handler
}

The LogHandler defines the interface to handle the log records

func CallerFileHandler Uses

func CallerFileHandler(h LogHandler) LogHandler

Adds in a context called `caller` to the record (contains file name and line number like `foo.go:12`) Uses the `log15.CallerFileHandler` to perform this task

func CallerFuncHandler Uses

func CallerFuncHandler(h LogHandler) LogHandler

Adds in a context called `caller` to the record (contains file name and line number like `foo.go:12`) Uses the `log15.CallerFuncHandler` to perform this task

func FilterHandler Uses

func FilterHandler(fn func(r *log15.Record) bool, h LogHandler) LogHandler

Filter handler, this is the only Uses the `log15.FilterHandler` to perform this task

func LevelHandler Uses

func LevelHandler(lvl LogLevel, h LogHandler) LogHandler

Filters out records which do not match the level Uses the `log15.FilterHandler` to perform this task

func MatchAbHandler Uses

func MatchAbHandler(key string, value interface{}, a, b LogHandler) LogHandler

If match then A handler is called otherwise B handler is called

func MatchHandler Uses

func MatchHandler(key string, value interface{}, h LogHandler) LogHandler

Filters out records which match the key value pair Uses the `log15.MatchFilterHandler` to perform this task

func MatchMapHandler Uses

func MatchMapHandler(matchMap map[string]interface{}, a LogHandler) LogHandler

Match all values in map to log

func MinLevelHandler Uses

func MinLevelHandler(lvl LogLevel, h LogHandler) LogHandler

Filters out records which do not match the level Uses the `log15.FilterHandler` to perform this task

func MultiHandler Uses

func MultiHandler(hs ...LogHandler) LogHandler

func NilHandler Uses

func NilHandler() LogHandler

The nil handler is used if logging for a specific request needs to be turned off

func NotLevelHandler Uses

func NotLevelHandler(lvl LogLevel, h LogHandler) LogHandler

Filters out records which match the level Uses the `log15.FilterHandler` to perform this task

func NotMatchHandler Uses

func NotMatchHandler(key string, value interface{}, h LogHandler) LogHandler

Filters out records which do not match the key value pair Uses the `log15.FilterHandler` to perform this task

func NotMatchMapHandler Uses

func NotMatchMapHandler(matchMap map[string]interface{}, a LogHandler) LogHandler

Match !(Match all values in map to log) The inverse of MatchMapHandler

func StreamHandler Uses

func StreamHandler(wr io.Writer, fmtr LogFormat) LogHandler

Outputs the records to the passed in stream Uses the `log15.StreamHandler` to perform this task

type LogLevel Uses

type LogLevel log15.Lvl

The LogHandler defines the interface to handle the log records

type LogOptions Uses

type LogOptions struct {
    Ctx                    *config.Context
    ReplaceExistingHandler bool
    HandlerWrap            ParentLogHandler
    Levels                 []LogLevel
    ExtendedOptions        map[string]interface{}
}

Used for the callback to LogFunctionMap

func NewLogOptions Uses

func NewLogOptions(cfg *config.Context, replaceHandler bool, phandler ParentLogHandler, lvl ...LogLevel) (logOptions *LogOptions)

Create a new log options

func (*LogOptions) GetBoolDefault Uses

func (l *LogOptions) GetBoolDefault(option string, value bool) bool

func (*LogOptions) GetIntDefault Uses

func (l *LogOptions) GetIntDefault(option string, value int) int

func (*LogOptions) GetStringDefault Uses

func (l *LogOptions) GetStringDefault(option, value string) string

func (*LogOptions) SetExtendedOptions Uses

func (l *LogOptions) SetExtendedOptions(options ...interface{})

Assumes options will be an even number and have a string, value syntax

type LogStackHandler Uses

type LogStackHandler interface {
    LogHandler
    GetStack() int
}

The LogHandler defines the interface to handle the log records

type MultiLogger Uses

type MultiLogger interface {
    //log15.Logger
    //// New returns a new Logger that has this logger's context plus the given context
    New(ctx ...interface{}) MultiLogger
    //
    //// SetHandler updates the logger to write records to the specified handler.
    SetHandler(h LogHandler)
    SetStackDepth(int) MultiLogger
    //
    //// Log a message at the given level with context key/value pairs
    Debug(msg string, ctx ...interface{})
    Debugf(msg string, params ...interface{})
    Info(msg string, ctx ...interface{})
    Infof(msg string, params ...interface{})
    Warn(msg string, ctx ...interface{})
    Warnf(msg string, params ...interface{})
    Error(msg string, ctx ...interface{})
    Errorf(msg string, params ...interface{})
    Crit(msg string, ctx ...interface{})
    Critf(msg string, params ...interface{})

    //// Logs a message as an Crit and exits
    Fatal(msg string, ctx ...interface{})
    Fatalf(msg string, params ...interface{})
    //// Logs a message as an Crit and panics
    Panic(msg string, ctx ...interface{})
    Panicf(msg string, params ...interface{})
}

The Multilogger reduces the number of exposed defined logging variables, and allows the output to be easily refined

func New Uses

func New(ctx ...interface{}) MultiLogger

Create a new logger

type ParentLogHandler Uses

type ParentLogHandler interface {
    SetChild(handler LogHandler) LogHandler
}

The LogHandler defines the interface to handle the log records

func NewParentLogHandler Uses

func NewParentLogHandler(callBack func(child LogHandler) LogHandler) ParentLogHandler

type RevelLogger Uses

type RevelLogger struct {
    log15.Logger
}

The LogHandler defines the interface to handle the log records

func (*RevelLogger) Critf Uses

func (rl *RevelLogger) Critf(msg string, param ...interface{})

func (*RevelLogger) Debugf Uses

func (rl *RevelLogger) Debugf(msg string, param ...interface{})

func (*RevelLogger) Errorf Uses

func (rl *RevelLogger) Errorf(msg string, param ...interface{})

func (*RevelLogger) Fatal Uses

func (rl *RevelLogger) Fatal(msg string, ctx ...interface{})

func (*RevelLogger) Fatalf Uses

func (rl *RevelLogger) Fatalf(msg string, param ...interface{})

func (*RevelLogger) Infof Uses

func (rl *RevelLogger) Infof(msg string, param ...interface{})

func (*RevelLogger) New Uses

func (rl *RevelLogger) New(ctx ...interface{}) MultiLogger

Override log15 method

func (*RevelLogger) Panic Uses

func (rl *RevelLogger) Panic(msg string, ctx ...interface{})

func (*RevelLogger) Panicf Uses

func (rl *RevelLogger) Panicf(msg string, param ...interface{})

func (*RevelLogger) SetHandler Uses

func (rl *RevelLogger) SetHandler(h LogHandler)

Set the handler in the Logger

func (*RevelLogger) SetStackDepth Uses

func (rl *RevelLogger) SetStackDepth(amount int) MultiLogger

Set the stack level to check for the caller

func (*RevelLogger) Warnf Uses

func (rl *RevelLogger) Warnf(msg string, param ...interface{})

Package logger imports 16 packages (graph) and is imported by 5 packages. Updated 2018-02-08. Refresh now. Tools for package owners.