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

	Defining handlers happens as follows
	1) ALL handlers (log.all.output) replace any existing handlers
	2) Output handlers (log.error.output) replace any existing handlers
	3) Filter handlers (log.xxx.filter, log.xxx.nfilter) append to existing handlers,
	   note log.all.filter is treated as a filter handler, so it will NOT replace existing ones

Index

Package Files

composite_multihandler.go doc.go handlers.go init.go log_function_map.go logger.go revel_logger.go terminal_format.go utils.go wrap_handlers.go

Constants

const (
    // The test mode flag overrides the default log level and shows only errors
    TEST_MODE_FLAG = "testModeFlag"
    // The special use flag enables showing messages when the logger is setup
    SPECIAL_USE_FLAG = "specialUseFlag"
)

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)
            }
        } else {

            c.SetHandlers(NilHandler(), logOptions)
        }
    },

    "": 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 it has defaults for off, stdout, stderr

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)

Returns the logger for the name

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.Crit("This should not occur","stack",revel.NewCallStack())`

func NewCompositeMultiHandler Uses

func NewCompositeMultiHandler() (*CompositeMultiHandler, LogHandler)

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 CallStack Uses

type CallStack interface {
    fmt.Formatter // Requirement
}

Currently the only requirement for the callstack is to support the Formatter method which stack.Call does so we use that

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)

func (*CompositeMultiHandler) Disable Uses

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

func (*CompositeMultiHandler) Log Uses

func (h *CompositeMultiHandler) Log(r *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)

For the multi handler set the handler, using the LogOptions defined

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 ContextMap Uses

type ContextMap map[string]interface{}

Internally used contextMap, allows conversion of map to map[string]string

func (ContextMap) Add Uses

func (m ContextMap) Add(key string, value interface{})

func (ContextMap) StringMap Uses

func (m ContextMap) StringMap() (newMap map[string]string)

Convert the context map to be string only values, any non string values are ignored

type Lazy Uses

type Lazy struct {
    Fn interface{} // the function
}

The lazy structure to implement a function to be invoked only if needed

type LevelFilterHandler Uses

type LevelFilterHandler struct {
    Level LogLevel
    // contains filtered or unexported fields
}

func (LevelFilterHandler) Log Uses

func (h LevelFilterHandler) Log(r *Record) error

The implementation of the Log

type ListLogHandler Uses

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

List log handler handles a list of LogHandlers

func NewListLogHandler Uses

func NewListLogHandler(h1, h2 LogHandler) *ListLogHandler

Create a new list of log handlers

func (*ListLogHandler) Add Uses

func (ll *ListLogHandler) Add(h LogHandler)

Add another log handler

func (*ListLogHandler) Del Uses

func (ll *ListLogHandler) Del(h LogHandler)

Remove a log handler

func (*ListLogHandler) Log Uses

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

Log the record

type LogFormat Uses

type LogFormat interface {
    Format(r *Record) []byte
}

The log format interface

func FormatFunc Uses

func FormatFunc(f func(*Record) []byte) LogFormat

FormatFunc returns a new Format object which uses the given function to perform record formatting.

func JsonFormatEx Uses

func JsonFormatEx(pretty, lineSeparated bool) LogFormat

JsonFormatEx formats log records as JSON objects. If pretty is true, records will be pretty-printed. If lineSeparated is true, records will be logged with a new line between each record.

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 {
    Log(*Record) error
}

The log handler interface

func CallerFileHandler Uses

func CallerFileHandler(h LogHandler) LogHandler

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 *Record) bool, h LogHandler) LogHandler

Filter handler

func FuncHandler Uses

func FuncHandler(fn func(r *Record) error) LogHandler

Function handler wraps the declared function and returns the handler for it

func HandlerFunc Uses

func HandlerFunc(log func(message string, time time.Time, level LogLevel, call CallStack, context ContextMap) error) LogHandler

This function allows you to do a full declaration for the log, it is recommended you use FuncHandler instead

func LazyHandler Uses

func LazyHandler(h LogHandler) LogHandler

LazyHandler writes all values to the wrapped handler after evaluating any lazy functions in the record's context. It is already wrapped around StreamHandler and SyslogHandler in this library, you'll only need it if you write your own Handler.

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 MatchFilterHandler Uses

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

MatchFilterHandler returns a Handler that only writes records to the wrapped Handler if the given key in the logged context matches the value. For example, to only log records from your ui package:

log.MatchFilterHandler("pkg", "app/ui", log.StdoutHandler)

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

StreamHandler writes log records to an io.Writer with the given format. StreamHandler can be used to easily begin writing log records to other outputs.

StreamHandler wraps itself with LazyHandler and SyncHandler to evaluate Lazy objects and perform safe concurrent writes.

func SyncHandler Uses

func SyncHandler(h LogHandler) LogHandler

SyncHandler can be wrapped around a handler to guarantee that only a single Log operation can proceed at a time. It's necessary for thread-safe concurrent writes.

type LogLevel Uses

type LogLevel int

The log level type

const (
    LvlCrit  LogLevel = iota // Critical
    LvlError                 // Error
    LvlWarn                  // Warning
    LvlInfo                  // Information
    LvlDebug                 // Debug
)

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

Gets a boolean option with default

func (*LogOptions) GetIntDefault Uses

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

Gets an int option with default

func (*LogOptions) GetStringDefault Uses

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

Gets a string option with default

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 log stack handler interface

type MultiLogger Uses

type MultiLogger interface {
    // 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)

    // Set the stack depth for the logger
    SetStackDepth(int) MultiLogger

    // Log a message at the given level with context key/value pairs
    Debug(msg string, ctx ...interface{})

    // Log a message at the given level formatting message with the parameters
    Debugf(msg string, params ...interface{})

    // Log a message at the given level with context key/value pairs
    Info(msg string, ctx ...interface{})

    // Log a message at the given level formatting message with the parameters
    Infof(msg string, params ...interface{})

    // Log a message at the given level with context key/value pairs
    Warn(msg string, ctx ...interface{})

    // Log a message at the given level formatting message with the parameters
    Warnf(msg string, params ...interface{})

    // Log a message at the given level with context key/value pairs
    Error(msg string, ctx ...interface{})

    // Log a message at the given level formatting message with the parameters
    Errorf(msg string, params ...interface{})

    // Log a message at the given level with context key/value pairs
    Crit(msg string, ctx ...interface{})

    // Log a message at the given level formatting message with the parameters
    Critf(msg string, params ...interface{})

    // Log a message at the given level with context key/value pairs and exits
    Fatal(msg string, ctx ...interface{})

    // Log a message at the given level formatting message with the parameters and exits
    Fatalf(msg string, params ...interface{})

    // Log a message at the given level with context key/value pairs and panics
    Panic(msg string, ctx ...interface{})

    // Log a message at the given level formatting message with the parameters and panics
    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 log handler interface which has child logs

func NewParentLogHandler Uses

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

Create a new parent log handler

type Record Uses

type Record struct {
    Message string     // The message
    Time    time.Time  // The time
    Level   LogLevel   //The level
    Call    CallStack  // The call stack if built
    Context ContextMap // The context
}

The log record

func NewRecord Uses

func NewRecord(message string, level LogLevel) *Record

type RevelLogger Uses

type RevelLogger struct {
    log15.Logger
}

This type implements the MultiLogger

func (*RevelLogger) Critf Uses

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

Print a formatted critical message

func (*RevelLogger) Debugf Uses

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

func (*RevelLogger) Errorf Uses

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

Print a formatted error message

func (*RevelLogger) Fatal Uses

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

Print a critical message and call os.Exit(1)

func (*RevelLogger) Fatalf Uses

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

Print a formatted fatal message

func (*RevelLogger) Infof Uses

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

Print a formatted info message

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{})

Print a critical message and panic

func (*RevelLogger) Panicf Uses

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

Print a formatted panic message

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{})

Print a formatted warn message

Package logger imports 17 packages (graph) and is imported by 9 packages. Updated 2018-10-30. Refresh now. Tools for package owners.