factorlog: github.com/kdar/factorlog Index | Files

package factorlog

import "github.com/kdar/factorlog"

FactorLog is a logging infrastructure for Go that provides numerous logging functions for whatever your style may be. It could easily be a replacement for Go's log in the standard library (though it doesn't support functions such as `SetFlags()`).

Basic usage:

import log "github.com/kdar/factorlog"
log.Print("Hello there!")

Setting your own format:

import os
import "github.com/kdar/factorlog"
log := factorlog.New(os.Stdout, factorlog.NewStdFormatter("%{Date} %{Time} %{File}:%{Line} %{Message}"))
log.Print("Hello there!")

Setting the verbosity and testing against it:

import os
import "github.com/kdar/factorlog"
log := factorlog.New(os.Stdout, factorlog.NewStdFormatter("%{Date} %{Time} %{File}:%{Line} %{Message}"))
log.SetVerbosity(2)
log.V(1).Print("Will print")
log.V(3).Print("Will not print")

If you care about performance, you can test for verbosity this way:

if log.IsV(1) {
  log.Print("Hello there!")
}

For more usage examples, check the examples/ directory.

Format verbs:

%{SEVERITY} - TRACE, DEBUG, INFO, WARN, ERROR, CRITICAL, STACK, FATAL, PANIC
%{Severity} - Trace, Debug, Info, Warn, Error, Critical, Stack, Fatal, Panic
%{severity} - trace, debug, info, warn, error, critical, stack, fatal, panic
%{SEV} - TRAC, DEBG, INFO, WARN, EROR, CRIT, STAK, FATL, PANC
%{Sev} - Trac, Debg, Info, Warn, Eror, Crit, Stak, Fatl, Panc
%{sev} - trac, debg, info, warn, eror, crit, stak, fatl, panc
%{S} - T, D, I, W, E, C, S, F, P
%{s} - t, d, i, w, e, c, s, f, p
%{Date} - Shorthand for 2006-01-02
%{Time} - Shorthand for 15:04:05
%{Time "<fmt>"} - Specify a format (read time.Format for details).
                  Optimized formats: 2006/01/02, 15:04:05.000, 15:04:05.000000, 15:04:05.000000000
%{Unix} - Returns the number of seconds elapsed since January 1, 1970 UTC.
%{UnixNano} - Returns the number of nanoseconds elapsed since January 1, 1970 UTC.
%{FullFile} - Full source file path (e.g. /dev/project/file.go).
%{File} - The source file name (e.g. file.go).
%{ShortFile} - The short source file name (file without .go).
%{Line} - The source line number.
%{FullFunction} - The full source function including path. (e.g. /dev/project.(*Type).Function)
%{PkgFunction} - The source package and function (e.g. project.(*Type).Function)
%{Function} - The source function name (e.g. (*Type).Function)
%{Color "<fmt>"} - Specify a color (uses https://github.com/mgutz/ansi)
%{Color "<fmt>" "<severity>"} - Specify a color for a given severity (e.g. %{Color "red" "ERROR"})
%{Message} - The message.
%{SafeMessage} - Safe message. It will escape any character below ASCII 32. This helps prevent
                 attacks like using 0x08 to backspace log entries.

Example colors (see https://github.com/mgutz/ansi for more examples):

Added to mgutz/ansi:
  %{Color "reset"}          - reset colors
Supported by mgutz/ansi
  %{Color "red"}            - red
  %{Color "red+b"}          - red bold
  %{Color "red+B"}          - red blinking
  %{Color "red+u"}          - red underline
  %{Color "red+bh"}         - red bold bright
  %{Color "red:white"}      - red on white
  %{Color "red+b:white+h"}  - red bold on white bright
  %{Color "red+B:white+h"}  - red blink on white bright

All logging functions ending in "ln" are merely convenience functions and won't actually output another newline. This allows the formatters to handle a newline however they like (e.g. if you wanted to make a formatter that would output a streamed format without newlines).

Index

Package Files

doc.go factorlog.go format.go formatter_std.go stack.go

Variables

var CapSeverityStrings = [...]string{
    "None",
    "Trace",
    "Debug",
    "Info",
    "Warn",
    "Error",
    "Critical",
    "Stack",
    "Fatal",
    "Panic",
}
var CapShortSeverityStrings = [...]string{
    "None",
    "Trac",
    "Debg",
    "Info",
    "Warn",
    "Eror",
    "Crit",
    "Stak",
    "Fatl",
    "Panc",
}
var LcSeverityStrings = [...]string{
    "none",
    "trace",
    "debug",
    "info",
    "warn",
    "error",
    "critical",
    "stack",
    "fatal",
    "panic",
}
var LcShortSeverityStrings = [...]string{
    "none",
    "trac",
    "debg",
    "info",
    "warn",
    "eror",
    "crit",
    "stak",
    "fatl",
    "panc",
}
var LcShortestSeverityStrings = [...]string{
    "n",
    "t",
    "d",
    "i",
    "w",
    "e",
    "c",
    "s",
    "f",
    "p",
}
var UcSeverityStrings = [...]string{
    "NONE",
    "TRACE",
    "DEBUG",
    "INFO",
    "WARN",
    "ERROR",
    "CRITICAL",
    "STACK",
    "FATAL",
    "PANIC",
}
var UcShortSeverityStrings = [...]string{
    "NONE",
    "TRAC",
    "DEBG",
    "INFO",
    "WARN",
    "EROR",
    "CRIT",
    "STAK",
    "FATL",
    "PANC",
}
var UcShortestSeverityStrings = [...]string{
    "",
    "T",
    "D",
    "I",
    "W",
    "E",
    "C",
    "S",
    "F",
    "P",
}

func Critical Uses

func Critical(v ...interface{})

func Criticalf Uses

func Criticalf(format string, v ...interface{})

func Criticalln Uses

func Criticalln(v ...interface{})

func Debug Uses

func Debug(v ...interface{})

func Debugf Uses

func Debugf(format string, v ...interface{})

func Debugln Uses

func Debugln(v ...interface{})

func Error Uses

func Error(v ...interface{})

func Errorf Uses

func Errorf(format string, v ...interface{})

func Errorln Uses

func Errorln(v ...interface{})

func Fatal Uses

func Fatal(v ...interface{})

func Fatalf Uses

func Fatalf(format string, v ...interface{})

func Fatalln Uses

func Fatalln(v ...interface{})

func GetStack Uses

func GetStack(calldepth int) []byte

func I64toa Uses

func I64toa(buf *[]byte, i int, d int64) int

I64toa is the same as itoa but for 64bit integers

func Info Uses

func Info(v ...interface{})

func Infof Uses

func Infof(format string, v ...interface{})

func Infoln Uses

func Infoln(v ...interface{})

func IsV Uses

func IsV(level Level) bool

func Itoa Uses

func Itoa(buf *[]byte, i, d int) int

itoa converts an integer d to its ascii representation i is the deintation index in buf algorithm from https://www.facebook.com/notes/facebook-engineering/three-optimization-tips-for-c/10151361643253920

func Log Uses

func Log(sev Severity, v ...interface{})

func NDigits Uses

func NDigits(buf *[]byte, n, i, d int)

nDigits converts an integer d to its ascii representation n is how many digits to use i is the destination index in buf

func Panic Uses

func Panic(v ...interface{})

func Panicf Uses

func Panicf(format string, v ...interface{})

func Panicln Uses

func Panicln(v ...interface{})

func Print Uses

func Print(v ...interface{})

func Printf Uses

func Printf(format string, v ...interface{})

func Println Uses

func Println(v ...interface{})

func SetFormatter Uses

func SetFormatter(f Formatter)

SetFormatter sets the formatter for the standard logger.

func SetMinMaxSeverity Uses

func SetMinMaxSeverity(min Severity, max Severity)

func SetOutput Uses

func SetOutput(w io.Writer)

SetOutput sets the output destination for the standard logger.

func SetSeverities Uses

func SetSeverities(sev Severity)

func SetVerbosity Uses

func SetVerbosity(level Level)

func SeverityToIndex Uses

func SeverityToIndex(sev Severity) int

We use this function to convert a severity to an index that we can then use to index variables like UcSeverityStrings. Why don't we use maps? This is almost 3x faster.

func Stack Uses

func Stack(v ...interface{})

func Stackf Uses

func Stackf(format string, v ...interface{})

func Stackln Uses

func Stackln(v ...interface{})

func Trace Uses

func Trace(v ...interface{})

func Tracef Uses

func Tracef(format string, v ...interface{})

func Traceln Uses

func Traceln(v ...interface{})

func TwoDigits Uses

func TwoDigits(buf *[]byte, i, d int)

twoDigits converts an integer d to its ascii representation i is the destination index in buf

func Ui64toa Uses

func Ui64toa(buf *[]byte, i int, d uint64) int

Ui64toa is the same as itoa but for 64bit unsigned integers

func Warn Uses

func Warn(v ...interface{})

func Warnf Uses

func Warnf(format string, v ...interface{})

func Warnln Uses

func Warnln(v ...interface{})

type FactorLog Uses

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

FactorLog is a logging object that outputs data to an io.Writer. Each write is threadsafe.

func New Uses

func New(out io.Writer, formatter Formatter) *FactorLog

New creates a FactorLog with the given output and format.

func (*FactorLog) Critical Uses

func (l *FactorLog) Critical(v ...interface{})

Critical is equivalent to Print with severity CRITICAL.

func (*FactorLog) Criticalf Uses

func (l *FactorLog) Criticalf(format string, v ...interface{})

Criticalf is equivalent to Printf with severity CRITICAL.

func (*FactorLog) Criticalln Uses

func (l *FactorLog) Criticalln(v ...interface{})

Criticalln is equivalent to Println with severity CRITICAL.

func (*FactorLog) Debug Uses

func (l *FactorLog) Debug(v ...interface{})

Debug is equivalent to Print with severity DEBUG.

func (*FactorLog) Debugf Uses

func (l *FactorLog) Debugf(format string, v ...interface{})

Debugf is equivalent to Printf with severity DEBUG.

func (*FactorLog) Debugln Uses

func (l *FactorLog) Debugln(v ...interface{})

Debugln is equivalent to Println with severity DEBUG.

func (*FactorLog) Error Uses

func (l *FactorLog) Error(v ...interface{})

Error is equivalent to Print with severity ERROR.

func (*FactorLog) Errorf Uses

func (l *FactorLog) Errorf(format string, v ...interface{})

Errorf is equivalent to Printf with severity ERROR.

func (*FactorLog) Errorln Uses

func (l *FactorLog) Errorln(v ...interface{})

Errorln is equivalent to Println with severity ERROR.

func (*FactorLog) Fatal Uses

func (l *FactorLog) Fatal(v ...interface{})

Fatal is equivalent to Print() followed by a call to os.Exit(1).

func (*FactorLog) Fatalf Uses

func (l *FactorLog) Fatalf(format string, v ...interface{})

Fatalf is equivalent to Printf() followed by a call to os.Exit(1).

func (*FactorLog) Fatalln Uses

func (l *FactorLog) Fatalln(v ...interface{})

Fatalln is equivalent to Println() followed by a call to os.Exit(1).

func (*FactorLog) Info Uses

func (l *FactorLog) Info(v ...interface{})

Info is equivalent to Print with severity INFO.

func (*FactorLog) Infof Uses

func (l *FactorLog) Infof(format string, v ...interface{})

Infof is equivalent to Printf with severity INFO.

func (*FactorLog) Infoln Uses

func (l *FactorLog) Infoln(v ...interface{})

Infoln is equivalent to Println with severity INFO.

func (*FactorLog) IsV Uses

func (l *FactorLog) IsV(level Level) bool

IsV tests whether the verbosity is of a certain level. Returns a bool. Example:

if log.IsV(2) {
  log.Info("some info")
}

func (*FactorLog) Log Uses

func (l *FactorLog) Log(sev Severity, v ...interface{})

Log calls l.output to print to the logger. Uses fmt.Sprint.

func (*FactorLog) Output Uses

func (l *FactorLog) Output(sev Severity, calldepth int, v ...interface{}) error

Output will write to the writer with the given severity, calldepth, and string. calldepth is only used if the format requires a call to runtime.Caller.

func (*FactorLog) Panic Uses

func (l *FactorLog) Panic(v ...interface{})

Panic is equivalent to Print() followed by a call to panic().

func (*FactorLog) Panicf Uses

func (l *FactorLog) Panicf(format string, v ...interface{})

Panicf is equivalent to Printf() followed by a call to panic().

func (*FactorLog) Panicln Uses

func (l *FactorLog) Panicln(v ...interface{})

Panicf is equivalent to Printf() followed by a call to panic().

func (*FactorLog) Print Uses

func (l *FactorLog) Print(v ...interface{})

Print calls l.output to print to the logger. Uses fmt.Sprint.

func (*FactorLog) Printf Uses

func (l *FactorLog) Printf(format string, v ...interface{})

Print calls l.output to print to the logger. Uses fmt.Sprintf.

func (*FactorLog) Println Uses

func (l *FactorLog) Println(v ...interface{})

Println calls l.output to print to the logger. Uses fmt.Sprint. This is more of a convenience function. If you really want to output an extra newline at the end, just append \n.

func (*FactorLog) SetFormatter Uses

func (l *FactorLog) SetFormatter(f Formatter)

SetFormatter sets the formatter for this logger.

func (*FactorLog) SetMinMaxSeverity Uses

func (l *FactorLog) SetMinMaxSeverity(min Severity, max Severity)

SetMinMaxSeverity sets the minimum and maximum severities this log will output for. Example:

l.SetMinMaxSeverity(INFO, ERROR)

func (*FactorLog) SetOutput Uses

func (l *FactorLog) SetOutput(w io.Writer)

SetOutput sets the output destination for this logger.

func (*FactorLog) SetSeverities Uses

func (l *FactorLog) SetSeverities(sev Severity)

SetSeverities sets which severities this log will output for. Example:

l.SetSeverities(INFO|DEBUG)

func (*FactorLog) SetVerbosity Uses

func (l *FactorLog) SetVerbosity(level Level)

Sets the verbosity level of this log. Use IsV() or V() to utilize verbosity.

func (*FactorLog) Stack Uses

func (l *FactorLog) Stack(v ...interface{})

Stack is equivalent to Print() followed by printing a stack trace to the configured writer.

func (*FactorLog) Stackf Uses

func (l *FactorLog) Stackf(format string, v ...interface{})

Stackf is equivalent to Printf() followed by printing a stack trace to the configured writer.

func (*FactorLog) Stackln Uses

func (l *FactorLog) Stackln(v ...interface{})

Stackln is equivalent to Println() followed by printing a stack trace to the configured writer.

func (*FactorLog) Trace Uses

func (l *FactorLog) Trace(v ...interface{})

Trace is equivalent to Print with severity TRACE.

func (*FactorLog) Tracef Uses

func (l *FactorLog) Tracef(format string, v ...interface{})

Tracef is equivalent to Printf with severity TRACE.

func (*FactorLog) Traceln Uses

func (l *FactorLog) Traceln(v ...interface{})

Traceln is equivalent to Println with severity TRACE.

func (*FactorLog) V Uses

func (l *FactorLog) V(level Level) Verbose

V tests whether the verbosity is of a certain level, and returns a Verbose object that allows you to chain calls. This is a convenience function and should be avoided if you care about raw performance (use IsV() instead). Example:

log.V(2).Info("some info")

func (*FactorLog) Warn Uses

func (l *FactorLog) Warn(v ...interface{})

Warn is equivalent to Print with severity WARN.

func (*FactorLog) Warnf Uses

func (l *FactorLog) Warnf(format string, v ...interface{})

Warnf is equivalent to Printf with severity WARN.

func (*FactorLog) Warnln Uses

func (l *FactorLog) Warnln(v ...interface{})

Warnln is equivalent to Println with severity WARN.

type Formatter Uses

type Formatter interface {
    // Formats LogRecord and returns the []byte that will
    // be written by the log. This is not inherently thread
    // safe but FactorLog uses a mutex before calling this.
    Format(context LogContext) []byte

    // Returns true if we should call runtime.Caller because
    // we have a format that requires it. We do this because
    // it is expensive.
    ShouldRuntimeCaller() bool
}

Interface to format anything

type Level Uses

type Level int32

Level represents the level of verbosity.

type LogContext Uses

type LogContext struct {
    Time     time.Time
    Severity Severity
    File     string
    Line     int
    Function string
    Pid      int
    Format   *string
    Args     []interface{}
}

Structure used to hold the data used for formatting

type Logger Uses

type Logger interface {
    Output(sev Severity, calldepth int, v ...interface{}) error
    Trace(v ...interface{})
    Tracef(format string, v ...interface{})
    Traceln(v ...interface{})
    Debug(v ...interface{})
    Debugf(format string, v ...interface{})
    Debugln(v ...interface{})
    Info(v ...interface{})
    Infof(format string, v ...interface{})
    Infoln(v ...interface{})
    Warn(v ...interface{})
    Warnf(format string, v ...interface{})
    Warnln(v ...interface{})
    Error(v ...interface{})
    Errorf(format string, v ...interface{})
    Errorln(v ...interface{})
    Critical(v ...interface{})
    Criticalf(format string, v ...interface{})
    Criticalln(v ...interface{})
    Stack(v ...interface{})
    Stackf(format string, v ...interface{})
    Stackln(v ...interface{})
    Log(sev Severity, v ...interface{})

    //Log verbosity
    V(level Level) Verbose
    SetVerbosity(level Level)
    IsV(level Level) bool

    // golang's log interface
    Print(v ...interface{})
    Printf(format string, v ...interface{})
    Println(v ...interface{})
    Fatal(v ...interface{})
    Fatalf(format string, v ...interface{})
    Fatalln(v ...interface{})
    Panic(v ...interface{})
    Panicf(format string, v ...interface{})
    Panicln(v ...interface{})
}

type NullLogger Uses

type NullLogger struct{}

Creates a logger that outputs to nothing

func (NullLogger) Critical Uses

func (NullLogger) Critical(v ...interface{})

func (NullLogger) Criticalf Uses

func (NullLogger) Criticalf(format string, v ...interface{})

func (NullLogger) Criticalln Uses

func (NullLogger) Criticalln(v ...interface{})

func (NullLogger) Debug Uses

func (NullLogger) Debug(v ...interface{})

func (NullLogger) Debugf Uses

func (NullLogger) Debugf(format string, v ...interface{})

func (NullLogger) Debugln Uses

func (NullLogger) Debugln(v ...interface{})

func (NullLogger) Error Uses

func (NullLogger) Error(v ...interface{})

func (NullLogger) Errorf Uses

func (NullLogger) Errorf(format string, v ...interface{})

func (NullLogger) Errorln Uses

func (NullLogger) Errorln(v ...interface{})

func (NullLogger) Fatal Uses

func (NullLogger) Fatal(v ...interface{})

func (NullLogger) Fatalf Uses

func (NullLogger) Fatalf(format string, v ...interface{})

func (NullLogger) Fatalln Uses

func (NullLogger) Fatalln(v ...interface{})

func (NullLogger) Info Uses

func (NullLogger) Info(v ...interface{})

func (NullLogger) Infof Uses

func (NullLogger) Infof(format string, v ...interface{})

func (NullLogger) Infoln Uses

func (NullLogger) Infoln(v ...interface{})

func (NullLogger) IsV Uses

func (NullLogger) IsV(level Level) bool

func (NullLogger) Log Uses

func (NullLogger) Log(sev Severity, v ...interface{})

func (NullLogger) Output Uses

func (NullLogger) Output(sev Severity, calldepth int, v ...interface{}) error

func (NullLogger) Panic Uses

func (NullLogger) Panic(v ...interface{})

func (NullLogger) Panicf Uses

func (NullLogger) Panicf(format string, v ...interface{})

func (NullLogger) Panicln Uses

func (NullLogger) Panicln(v ...interface{})

func (NullLogger) Print Uses

func (NullLogger) Print(v ...interface{})

func (NullLogger) Printf Uses

func (NullLogger) Printf(format string, v ...interface{})

func (NullLogger) Println Uses

func (NullLogger) Println(v ...interface{})

func (NullLogger) SetVerbosity Uses

func (NullLogger) SetVerbosity(level Level)

func (NullLogger) Stack Uses

func (NullLogger) Stack(v ...interface{})

func (NullLogger) Stackf Uses

func (NullLogger) Stackf(format string, v ...interface{})

func (NullLogger) Stackln Uses

func (NullLogger) Stackln(v ...interface{})

func (NullLogger) Trace Uses

func (NullLogger) Trace(v ...interface{})

func (NullLogger) Tracef Uses

func (NullLogger) Tracef(format string, v ...interface{})

func (NullLogger) Traceln Uses

func (NullLogger) Traceln(v ...interface{})

func (NullLogger) V Uses

func (NullLogger) V(level Level) Verbose

func (NullLogger) Warn Uses

func (NullLogger) Warn(v ...interface{})

func (NullLogger) Warnf Uses

func (NullLogger) Warnf(format string, v ...interface{})

func (NullLogger) Warnln Uses

func (NullLogger) Warnln(v ...interface{})

type Severity Uses

type Severity int32

Severity represents the severity of the log.

const (
    NONE Severity = 1 << iota
    TRACE
    DEBUG
    INFO
    WARN
    ERROR
    CRITICAL
    STACK
    FATAL
    PANIC
)

func StringToSeverity Uses

func StringToSeverity(s string) Severity

Convert an uppercase string to a severity.

type StdFormatter Uses

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

func NewStdFormatter Uses

func NewStdFormatter(frmt string) *StdFormatter

Available verbs:

%{SEVERITY} - TRACE, DEBUG, INFO, WARN, ERROR, CRITICAL, STACK, FATAL, PANIC
%{Severity} - Trace, Debug, Info, Warn, Error, Critical, Stack, Fatal, Panic
%{severity} - trace, debug, info, warn, error, critical, stack, fatal, panic
%{SEV} - TRAC, DEBG, INFO, WARN, EROR, CRIT, STAK, FATL, PANC
%{Sev} - Trac, Debg, Info, Warn, Eror, Crit, Stak, Fatl, Panc
%{sev} - trac, debg, info, warn, eror, crit, stak, fatl, panc
%{S} - T, D, I, W, E, C, S, F, P
%{s} - t, d, i, w, e, c, s, f, p
%{Date} - Shorthand for 2006-01-02
%{Time} - Shorthand for 15:04:05
%{Time "<fmt>"} - Specify a format (read time.Format for details).
                  Optimized formats: 2006/01/02, 15:04:05.000, 15:04:05.000000, 15:04:05.000000000
%{Unix} - Returns the number of seconds elapsed since January 1, 1970 UTC.
%{UnixNano} - Returns the number of nanoseconds elapsed since January 1, 1970 UTC.
%{FullFile} - Full source file path (e.g. /dev/project/file.go).
%{File} - The source file name (e.g. file.go).
%{ShortFile} - The short source file name (file without .go).
%{Line} - The source line number.
%{FullFunction} - The full source function including path. (e.g. /dev/project.(*Type).Function)
%{PkgFunction} - The source package and function (e.g. project.(*Type).Function)
%{Function} - The source function name (e.g. (*Type).Function)
%{Color "<fmt>"} - Specify a color (uses https://github.com/mgutz/ansi)
%{Color "<fmt>" "<severity>"} - Specify a color for a given severity (e.g. %{Color "red" "ERROR"})
%{Message} - The message.
%{SafeMessage} - Safe message. It will escape any character below ASCII 32. This helps prevent
                 attacks like using 0x08 to backspace log entries.

func (*StdFormatter) Format Uses

func (f *StdFormatter) Format(context LogContext) []byte

func (*StdFormatter) ShouldRuntimeCaller Uses

func (f *StdFormatter) ShouldRuntimeCaller() bool

type Verbose Uses

type Verbose struct {
    True bool
    // contains filtered or unexported fields
}

Verbose is a structure that enables syntatic sugar when testing for verbosity and calling a log function. See FactorLog.V().

func V Uses

func V(level Level) Verbose

func (Verbose) Critical Uses

func (b Verbose) Critical(v ...interface{})

func (Verbose) Criticalf Uses

func (b Verbose) Criticalf(format string, v ...interface{})

func (Verbose) Criticalln Uses

func (b Verbose) Criticalln(v ...interface{})

func (Verbose) Debug Uses

func (b Verbose) Debug(v ...interface{})

func (Verbose) Debugf Uses

func (b Verbose) Debugf(format string, v ...interface{})

func (Verbose) Debugln Uses

func (b Verbose) Debugln(v ...interface{})

func (Verbose) Error Uses

func (b Verbose) Error(v ...interface{})

func (Verbose) Errorf Uses

func (b Verbose) Errorf(format string, v ...interface{})

func (Verbose) Errorln Uses

func (b Verbose) Errorln(v ...interface{})

func (Verbose) Fatal Uses

func (b Verbose) Fatal(v ...interface{})

func (Verbose) Fatalf Uses

func (b Verbose) Fatalf(format string, v ...interface{})

func (Verbose) Fatalln Uses

func (b Verbose) Fatalln(v ...interface{})

func (Verbose) Info Uses

func (b Verbose) Info(v ...interface{})

func (Verbose) Infof Uses

func (b Verbose) Infof(format string, v ...interface{})

func (Verbose) Infoln Uses

func (b Verbose) Infoln(v ...interface{})

func (Verbose) IsV Uses

func (b Verbose) IsV(level Level) bool

func (Verbose) Log Uses

func (b Verbose) Log(sev Severity, v ...interface{})

func (Verbose) Output Uses

func (b Verbose) Output(sev Severity, calldepth int, v ...interface{}) error

func (Verbose) Panic Uses

func (b Verbose) Panic(v ...interface{})

func (Verbose) Panicf Uses

func (b Verbose) Panicf(format string, v ...interface{})

func (Verbose) Panicln Uses

func (b Verbose) Panicln(v ...interface{})

func (Verbose) Print Uses

func (b Verbose) Print(v ...interface{})

func (Verbose) Printf Uses

func (b Verbose) Printf(format string, v ...interface{})

func (Verbose) Println Uses

func (b Verbose) Println(v ...interface{})

func (Verbose) SetVerbosity Uses

func (b Verbose) SetVerbosity(level Level)

func (Verbose) Stack Uses

func (b Verbose) Stack(v ...interface{})

func (Verbose) Stackf Uses

func (b Verbose) Stackf(format string, v ...interface{})

func (Verbose) Stackln Uses

func (b Verbose) Stackln(v ...interface{})

func (Verbose) Trace Uses

func (b Verbose) Trace(v ...interface{})

func (Verbose) Tracef Uses

func (b Verbose) Tracef(format string, v ...interface{})

func (Verbose) Traceln Uses

func (b Verbose) Traceln(v ...interface{})

func (Verbose) V Uses

func (b Verbose) V(level Level) Verbose

func (Verbose) Warn Uses

func (b Verbose) Warn(v ...interface{})

func (Verbose) Warnf Uses

func (b Verbose) Warnf(format string, v ...interface{})

func (Verbose) Warnln Uses

func (b Verbose) Warnln(v ...interface{})

Package factorlog imports 11 packages (graph) and is imported by 63 packages. Updated 2016-07-15. Refresh now. Tools for package owners.