log: github.com/phuslu/log Index | Files

package log

import "github.com/phuslu/log"

Index

Package Files

async.go console.go console_unix.go file.go goid.go grpc.go journal.go json.go level.go logger.go logr.go multi.go stdlog.go sugar.go syslog.go time_linux.go tsv.go xid.go

Constants

const (
    // TimeFormatRFC3339Milli is RFC3339 with millisecond precision.
    TimeFormatRFC3339Milli = ""

    // TimeFormatUnix defines a time format that makes time fields to be
    // serialized as Unix timestamp integers.
    TimeFormatUnix = "\x01"

    // TimeFormatUnixMs defines a time format that makes time fields to be
    // serialized as Unix timestamp integers in milliseconds.
    TimeFormatUnixMs = "\x02"
)

Variables

var DefaultLogger = Logger{
    Level:      DebugLevel,
    Caller:     0,
    TimeField:  "",
    TimeFormat: "",
    Writer:     IOWriter{os.Stderr},
}

DefaultLogger is the global logger.

var ErrInvalidXID = errors.New("xid: invalid XID")

ErrInvalidXID is returned when trying to parse an invalid XID

func Fastrandn Uses

func Fastrandn(x uint32) uint32

Fastrandn returns a pseudorandom uint32 in [0,n).

go:noescape go:linkname Fastrandn runtime.fastrandn

func Goid Uses

func Goid() int64

Goid returns the current goroutine id. It exactly matches goroutine id of the stack trace.

func IsTerminal Uses

func IsTerminal(fd uintptr) bool

IsTerminal returns whether the given file descriptor is a terminal.

func Printf Uses

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

Printf sends a log entry without extra field. Arguments are handled in the manner of fmt.Printf.

type AsyncWriter Uses

type AsyncWriter struct {
    // ChannelSize is the size of the data channel, the default size is 1.
    ChannelSize uint

    // Writer specifies the writer of output.
    Writer Writer
    // contains filtered or unexported fields
}

AsyncWriter is an Writer that writes asynchronously.

func (*AsyncWriter) Close Uses

func (w *AsyncWriter) Close() (err error)

Close implements io.Closer, and closes the underlying Writer.

func (*AsyncWriter) WriteEntry Uses

func (w *AsyncWriter) WriteEntry(e *Entry) (int, error)

WriteEntry implements Writer.

type ConsoleWriter Uses

type ConsoleWriter struct {
    // ColorOutput determines if used colorized output.
    ColorOutput bool

    // QuoteString determines if quoting string values.
    QuoteString bool

    // EndWithMessage determines if output message in the end.
    EndWithMessage bool

    // Formatter specifies an optional text formatter for creating a customized output,
    // If it is set, ColorOutput, QuoteString and EndWithMessage will be ignore.
    Formatter func(w io.Writer, args *FormatterArgs) (n int, err error)

    // Writer is the output destination. using os.Stderr if empty.
    Writer io.Writer
}

ConsoleWriter parses the JSON input and writes it in an (optionally) colorized, human-friendly format to Writer.

Default output format:

{Time} {Level} {Goid} {Caller} > {Message} {Key}={Value} {Key}={Value}

Note: The performance of ConsoleWriter is not good enough, because it will parses JSON input into structured records, then output in a specific order. Roughly 2x faster than logrus.TextFormatter, 0.8x fast as zap.ConsoleEncoder, and 5x faster than zerolog.ConsoleWriter.

func (*ConsoleWriter) Close Uses

func (w *ConsoleWriter) Close() (err error)

Close implements io.Closer, will closes the underlying Writer if not empty.

func (*ConsoleWriter) Write Uses

func (w *ConsoleWriter) Write(p []byte) (int, error)

Write implements io.Writer

func (*ConsoleWriter) WriteEntry Uses

func (w *ConsoleWriter) WriteEntry(e *Entry) (int, error)

WriteEntry implements Writer.

type Context Uses

type Context []byte

Context represents contextual fields.

type Entry Uses

type Entry struct {
    Level Level
    // contains filtered or unexported fields
}

Entry represents a log entry. It is instanced by one of the level method of Logger and finalized by the Msg or Msgf method.

func Debug Uses

func Debug() (e *Entry)

Debug starts a new message with debug level.

func Error Uses

func Error() (e *Entry)

Error starts a new message with error level.

func Fatal Uses

func Fatal() (e *Entry)

Fatal starts a new message with fatal level.

func Info Uses

func Info() (e *Entry)

Info starts a new message with info level.

func NewContext Uses

func NewContext(dst []byte) (e *Entry)

NewContext starts a new contextual entry.

func Panic Uses

func Panic() (e *Entry)

Panic starts a new message with panic level.

func Trace Uses

func Trace() (e *Entry)

Trace starts a new message with trace level.

func Warn Uses

func Warn() (e *Entry)

Warn starts a new message with warning level.

func (*Entry) AnErr Uses

func (e *Entry) AnErr(key string, err error) *Entry

AnErr adds the field key with serialized err to the logger context.

func (*Entry) Bool Uses

func (e *Entry) Bool(key string, b bool) *Entry

Bool append append the val as a bool to the entry.

func (*Entry) Bools Uses

func (e *Entry) Bools(key string, b []bool) *Entry

Bools adds the field key with val as a []bool to the entry.

func (*Entry) Byte Uses

func (e *Entry) Byte(key string, val byte) *Entry

Byte adds the field key with val as a byte to the entry.

func (*Entry) Bytes Uses

func (e *Entry) Bytes(key string, val []byte) *Entry

Bytes adds the field key with val as a string to the entry.

func (*Entry) BytesOrNil Uses

func (e *Entry) BytesOrNil(key string, val []byte) *Entry

BytesOrNil adds the field key with val as a string or nil to the entry.

func (*Entry) Caller Uses

func (e *Entry) Caller(depth int) *Entry

Caller adds the file:line of the "caller" key.

func (*Entry) Context Uses

func (e *Entry) Context(ctx Context) *Entry

Context sends the contextual fields to entry.

func (*Entry) Dict Uses

func (e *Entry) Dict(key string, ctx Context) *Entry

Dict sends the contextual fields with key to entry.

func (*Entry) Discard Uses

func (e *Entry) Discard() *Entry

Discard disables the entry so Msg(f) won't print it.

func (*Entry) Dur Uses

func (e *Entry) Dur(key string, d time.Duration) *Entry

Dur adds the field key with duration d to the entry.

func (*Entry) Durs Uses

func (e *Entry) Durs(key string, d []time.Duration) *Entry

Durs adds the field key with val as a []time.Duration to the entry.

func (*Entry) Enabled Uses

func (e *Entry) Enabled() bool

Enabled return false if the entry is going to be filtered out by log level.

func (*Entry) Err Uses

func (e *Entry) Err(err error) *Entry

Err adds the field "error" with serialized err to the entry.

func (*Entry) Errs Uses

func (e *Entry) Errs(key string, errs []error) *Entry

Errs adds the field key with errs as an array of serialized errors to the entry.

func (*Entry) Fields Uses

func (e *Entry) Fields(fields map[string]interface{}) *Entry

Fields is a helper function to use a map to set fields using type assertion.

func (*Entry) Float32 Uses

func (e *Entry) Float32(key string, f float32) *Entry

Float32 adds the field key with f as a float32 to the entry.

func (*Entry) Float64 Uses

func (e *Entry) Float64(key string, f float64) *Entry

Float64 adds the field key with f as a float64 to the entry.

func (*Entry) Floats32 Uses

func (e *Entry) Floats32(key string, f []float32) *Entry

Floats32 adds the field key with f as a []float32 to the entry.

func (*Entry) Floats64 Uses

func (e *Entry) Floats64(key string, f []float64) *Entry

Floats64 adds the field key with f as a []float64 to the entry.

func (*Entry) GoStringer Uses

func (e *Entry) GoStringer(key string, val fmt.GoStringer) *Entry

GoStringer adds the field key with val.GoStringer() to the entry.

func (*Entry) Hex Uses

func (e *Entry) Hex(key string, val []byte) *Entry

Hex adds the field key with val as a hex string to the entry.

func (*Entry) IPAddr Uses

func (e *Entry) IPAddr(key string, ip net.IP) *Entry

IPAddr adds IPv4 or IPv6 Address to the entry.

func (*Entry) IPPrefix Uses

func (e *Entry) IPPrefix(key string, pfx net.IPNet) *Entry

IPPrefix adds IPv4 or IPv6 Prefix (address and mask) to the entry.

func (*Entry) Int Uses

func (e *Entry) Int(key string, i int) *Entry

Int adds the field key with i as a int to the entry.

func (*Entry) Int16 Uses

func (e *Entry) Int16(key string, i int16) *Entry

Int16 adds the field key with i as a int16 to the entry.

func (*Entry) Int32 Uses

func (e *Entry) Int32(key string, i int32) *Entry

Int32 adds the field key with i as a int32 to the entry.

func (*Entry) Int64 Uses

func (e *Entry) Int64(key string, i int64) *Entry

Int64 adds the field key with i as a int64 to the entry.

func (*Entry) Int8 Uses

func (e *Entry) Int8(key string, i int8) *Entry

Int8 adds the field key with i as a int8 to the entry.

func (*Entry) Interface Uses

func (e *Entry) Interface(key string, i interface{}) *Entry

Interface adds the field key with i marshaled using reflection.

func (*Entry) MACAddr Uses

func (e *Entry) MACAddr(key string, ha net.HardwareAddr) *Entry

MACAddr adds MAC address to the entry.

func (*Entry) Msg Uses

func (e *Entry) Msg(msg string)

Msg sends the entry with msg added as the message field if not empty.

func (*Entry) Msgf Uses

func (e *Entry) Msgf(format string, v ...interface{})

Msgf sends the entry with formatted msg added as the message field if not empty.

func (*Entry) RawJSON Uses

func (e *Entry) RawJSON(key string, b []byte) *Entry

RawJSON adds already encoded JSON to the log line under key.

func (*Entry) RawJSONStr Uses

func (e *Entry) RawJSONStr(key string, s string) *Entry

RawJSONStr adds already encoded JSON String to the log line under key.

func (*Entry) Stack Uses

func (e *Entry) Stack() *Entry

Stack enables stack trace printing for the error passed to Err().

func (*Entry) Str Uses

func (e *Entry) Str(key string, val string) *Entry

Str adds the field key with val as a string to the entry.

func (*Entry) Stringer Uses

func (e *Entry) Stringer(key string, val fmt.Stringer) *Entry

Stringer adds the field key with val.String() to the entry.

func (*Entry) Strs Uses

func (e *Entry) Strs(key string, vals []string) *Entry

Strs adds the field key with vals as a []string to the entry.

func (*Entry) Time Uses

func (e *Entry) Time(key string, t time.Time) *Entry

Time append append t formated as string using time.RFC3339Nano.

func (*Entry) TimeDiff Uses

func (e *Entry) TimeDiff(key string, t time.Time, start time.Time) *Entry

TimeDiff adds the field key with positive duration between time t and start. If time t is not greater than start, duration will be 0. Duration format follows the same principle as Dur().

func (*Entry) TimeFormat Uses

func (e *Entry) TimeFormat(key string, timefmt string, t time.Time) *Entry

TimeFormat append append t formated as string using timefmt.

func (*Entry) Uint16 Uses

func (e *Entry) Uint16(key string, i uint16) *Entry

Uint16 adds the field key with i as a uint16 to the entry.

func (*Entry) Uint32 Uses

func (e *Entry) Uint32(key string, i uint32) *Entry

Uint32 adds the field key with i as a uint32 to the entry.

func (*Entry) Uint64 Uses

func (e *Entry) Uint64(key string, i uint64) *Entry

Uint64 adds the field key with i as a uint64 to the entry.

func (*Entry) Uint8 Uses

func (e *Entry) Uint8(key string, i uint8) *Entry

Uint8 adds the field key with i as a uint8 to the entry.

func (*Entry) Value Uses

func (e *Entry) Value() Context

Value builds the contextual fields.

func (*Entry) Xid Uses

func (e *Entry) Xid(key string, xid [12]byte) *Entry

Xid adds the field key with xid.ID as a base32 string to the entry.

type Event Uses

type Event = Entry

Event is an alias for Entry

Deprecated: Use Entry instead.

type FileWriter Uses

type FileWriter struct {
    // Filename is the file to write logs to.  Backup log files will be retained
    // in the same directory.
    Filename string

    // MaxSize is the maximum size in bytes of the log file before it gets rotated.
    MaxSize int64

    // MaxBackups is the maximum number of old log files to retain.  The default
    // is to retain all old log files
    MaxBackups int

    // FileMode represents the file's mode and permission bits.  The default
    // mode is 0644
    FileMode os.FileMode

    // LocalTime determines if the time used for formatting the timestamps in
    // log files is the computer's local time.  The default is to use UTC time.
    LocalTime bool

    // HostName determines if the hostname used for formatting in log files.
    HostName bool

    // ProcessID determines if the pid used for formatting in log files.
    ProcessID bool
    // contains filtered or unexported fields
}

FileWriter is an Writer that writes to the specified filename.

Backups use the log file name given to FileWriter, in the form `name.timestamp.ext` where name is the filename without the extension, timestamp is the time at which the log was rotated formatted with the time.Time format of `2006-01-02T15-04-05` and the extension is the original extension. For example, if your FileWriter.Filename is `/var/log/foo/server.log`, a backup created at 6:30pm on Nov 11 2016 would use the filename `/var/log/foo/server.2016-11-04T18-30-00.log`

Cleaning Up Old Log Files

Whenever a new logfile gets created, old log files may be deleted. The most recent files according to the encoded timestamp will be retained, up to a number equal to MaxBackups (or all of them if MaxBackups is 0). Any files with an encoded timestamp older than MaxAge days are deleted, regardless of MaxBackups. Note that the time encoded in the timestamp is the rotation time, which may differ from the last time that file was written to.

func (*FileWriter) Close Uses

func (w *FileWriter) Close() (err error)

Close implements io.Closer, and closes the current logfile.

func (*FileWriter) Rotate Uses

func (w *FileWriter) Rotate() (err error)

Rotate causes Logger to close the existing log file and immediately create a new one. This is a helper function for applications that want to initiate rotations outside of the normal rotation rules, such as in response to SIGHUP. After rotating, this initiates compression and removal of old log files according to the configuration.

func (*FileWriter) Write Uses

func (w *FileWriter) Write(p []byte) (n int, err error)

Write implements io.Writer. If a write would cause the log file to be larger than MaxSize, the file is closed, renamed to include a timestamp of the current time, and a new log file is created using the original log file name. If the length of the write is greater than MaxSize, an error is returned.

func (*FileWriter) WriteEntry Uses

func (w *FileWriter) WriteEntry(e *Entry) (n int, err error)

WriteEntry implements Writer. If a write would cause the log file to be larger than MaxSize, the file is closed, renamed to include a timestamp of the current time, and a new log file is created using the original log file name. If the length of the write is greater than MaxSize, an error is returned.

type FormatterArgs Uses

type FormatterArgs struct {
    Time      string // "2019-07-10T05:35:54.277Z"
    Level     string // "info"
    Caller    string // "prog.go:42"
    Goid      string // "123"
    Message   string // "a structure message"
    Stack     string // "<stack string>"
    KeyValues []struct {
        Key   string // "foo"
        Value string // "bar"
    }
}

FormatterArgs is a parsed sturct from json input

type GrpcLogger Uses

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

GrpcLogger implements methods to satisfy interface google.golang.org/grpc/grpclog.LoggerV2.

func (*GrpcLogger) Error Uses

func (g *GrpcLogger) Error(args ...interface{})

Error logs to ERROR log. Arguments are handled in the manner of fmt.Print.

func (*GrpcLogger) Errorf Uses

func (g *GrpcLogger) Errorf(format string, args ...interface{})

Errorf logs to ERROR log. Arguments are handled in the manner of fmt.Printf.

func (*GrpcLogger) Errorln Uses

func (g *GrpcLogger) Errorln(args ...interface{})

Errorln logs to ERROR log. Arguments are handled in the manner of fmt.Println.

func (*GrpcLogger) Fatal Uses

func (g *GrpcLogger) Fatal(args ...interface{})

Fatal logs to ERROR log. Arguments are handled in the manner of fmt.Print. gRPC ensures that all Fatal logs will exit with os.Exit(1). Implementations may also call os.Exit() with a non-zero exit code.

func (*GrpcLogger) Fatalf Uses

func (g *GrpcLogger) Fatalf(format string, args ...interface{})

Fatalf logs to ERROR log. Arguments are handled in the manner of fmt.Printf. gRPC ensures that all Fatal logs will exit with os.Exit(1). Implementations may also call os.Exit() with a non-zero exit code.

func (*GrpcLogger) Fatalln Uses

func (g *GrpcLogger) Fatalln(args ...interface{})

Fatalln logs to ERROR log. Arguments are handled in the manner of fmt.Println. gRPC ensures that all Fatal logs will exit with os.Exit(1). Implementations may also call os.Exit() with a non-zero exit code.

func (*GrpcLogger) Info Uses

func (g *GrpcLogger) Info(args ...interface{})

Info logs to INFO log. Arguments are handled in the manner of fmt.Print.

func (*GrpcLogger) Infof Uses

func (g *GrpcLogger) Infof(format string, args ...interface{})

Infof logs to INFO log. Arguments are handled in the manner of fmt.Printf.

func (*GrpcLogger) Infoln Uses

func (g *GrpcLogger) Infoln(args ...interface{})

Infoln logs to INFO log. Arguments are handled in the manner of fmt.Println.

func (*GrpcLogger) V Uses

func (g *GrpcLogger) V(level int) bool

V reports whether verbosity level l is at least the requested verbose leveg.

func (*GrpcLogger) Warning Uses

func (g *GrpcLogger) Warning(args ...interface{})

Warning logs to WARNING log. Arguments are handled in the manner of fmt.Print.

func (*GrpcLogger) Warningf Uses

func (g *GrpcLogger) Warningf(format string, args ...interface{})

Warningf logs to WARNING log. Arguments are handled in the manner of fmt.Printf.

func (*GrpcLogger) Warningln Uses

func (g *GrpcLogger) Warningln(args ...interface{})

Warningln logs to WARNING log. Arguments are handled in the manner of fmt.Println.

type IOWriter Uses

type IOWriter struct {
    io.Writer
}

IOWriter wraps an io.Writer to Writer.

func (IOWriter) WriteEntry Uses

func (w IOWriter) WriteEntry(e *Entry) (n int, err error)

WriteEntry implements Writer.

type JournalWriter Uses

type JournalWriter struct {
    // JournalSocket specifies socket name, using `/run/systemd/journal/socket` if empty.
    JournalSocket string
    // contains filtered or unexported fields
}

JournalWriter is an Writer that writes logs to journald.

func (*JournalWriter) Close Uses

func (w *JournalWriter) Close() (err error)

Close implements io.Closer.

func (*JournalWriter) WriteEntry Uses

func (w *JournalWriter) WriteEntry(e *Entry) (n int, err error)

WriteEntry implements Writer.

type Level Uses

type Level uint32

Level defines log levels.

const (
    // TraceLevel defines trace log level.
    TraceLevel Level = 1
    // DebugLevel defines debug log level.
    DebugLevel Level = 2
    // InfoLevel defines info log level.
    InfoLevel Level = 3
    // WarnLevel defines warn log level.
    WarnLevel Level = 4
    // ErrorLevel defines error log level.
    ErrorLevel Level = 5
    // FatalLevel defines fatal log level.
    FatalLevel Level = 6
    // PanicLevel defines panic log level.
    PanicLevel Level = 7
)

func ParseLevel Uses

func ParseLevel(s string) (level Level)

ParseLevel converts a level string into a log Level value.

func (Level) String Uses

func (l Level) String() (s string)

String return lowe case string of Level

type Logger Uses

type Logger struct {
    // Level defines log levels.
    Level Level

    // Caller determines if adds the file:line of the "caller" key.
    Caller int

    // TimeField defines the time filed name in output.  It uses "time" in if empty.
    TimeField string

    // TimeFormat specifies the time format in output. It uses time.RFC3339 with milliseconds if empty.
    // If set with `TimeFormatUnix`, `TimeFormatUnixMs`, times are formated as UNIX timestamp.
    TimeFormat string

    // Writer specifies the writer of output. It uses a wrapped os.Stderr Writer in if empty.
    Writer Writer
}

A Logger represents an active logging object that generates lines of JSON output to an io.Writer.

func (*Logger) Debug Uses

func (l *Logger) Debug() (e *Entry)

Debug starts a new message with debug level.

func (*Logger) Error Uses

func (l *Logger) Error() (e *Entry)

Error starts a new message with error level.

func (*Logger) Fatal Uses

func (l *Logger) Fatal() (e *Entry)

Fatal starts a new message with fatal level.

func (*Logger) Grpc Uses

func (l *Logger) Grpc(context Context) (g *GrpcLogger)

Grpc wraps the Logger to provide a LoggerV2 logger

func (*Logger) Info Uses

func (l *Logger) Info() (e *Entry)

Info starts a new message with info level.

func (*Logger) Log Uses

func (l *Logger) Log() (e *Entry)

Log starts a new message with no level.

func (*Logger) Logr Uses

func (l *Logger) Logr(context Context) *LogrLogger

Logr wraps the Logger to provide a logr logger

func (*Logger) Panic Uses

func (l *Logger) Panic() (e *Entry)

Panic starts a new message with panic level.

func (*Logger) Printf Uses

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

Printf sends a log entry without extra field. Arguments are handled in the manner of fmt.Printf.

func (*Logger) SetLevel Uses

func (l *Logger) SetLevel(level Level)

SetLevel changes logger default level.

func (*Logger) Std Uses

func (l *Logger) Std(level Level, context Context, prefix string, flag int) *stdLog.Logger

Std wraps the Logger to provide *stdLog.Logger

func (*Logger) Sugar Uses

func (l *Logger) Sugar(context Context) (s *SugaredLogger)

Sugar wraps the Logger to provide a more ergonomic, but a little bit slower, API. Sugaring a Logger is quite inexpensive, so it's reasonable for a single application to use both Loggers and SugaredLoggers, converting between them on the boundaries of performance-sensitive code.

func (*Logger) Trace Uses

func (l *Logger) Trace() (e *Entry)

Trace starts a new message with trace level.

func (*Logger) Warn Uses

func (l *Logger) Warn() (e *Entry)

Warn starts a new message with warning level.

func (*Logger) WithLevel Uses

func (l *Logger) WithLevel(level Level) (e *Entry)

WithLevel starts a new message with level.

type LogrLogger Uses

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

LogrLogger implements methods to satisfy interface github.com/go-logr/logr.Logger.

func (*LogrLogger) Enabled Uses

func (l *LogrLogger) Enabled() bool

Enabled tests whether this Logger is enabled. For example, commandline flags might be used to set the logging verbosity and disable some info logs.

func (*LogrLogger) Error Uses

func (l *LogrLogger) Error(err error, msg string, keysAndValues ...interface{})

Error logs an error, with the given message and key/value pairs as context. It functions similarly to calling Info with the "error" named value, but may have unique behavior, and should be preferred for logging errors (see the package documentations for more information).

The msg field should be used to add context to any underlying error, while the err field should be used to attach the actual error that triggered this log line, if present.

func (*LogrLogger) Info Uses

func (l *LogrLogger) Info(msg string, keysAndValues ...interface{})

Info logs a non-error message with the given key/value pairs as context.

The msg argument should be used to add some constant description to the log line. The key/value pairs can then be used to add additional variable information. The key/value pairs should alternate string keys and arbitrary values.

func (*LogrLogger) V Uses

func (l *LogrLogger) V(level int) *LogrLogger

V returns an Logger value for a specific verbosity level, relative to this Logger. In other words, V values are additive. V higher verbosity level means a log message is less important. It's illegal to pass a log level less than zero.

func (*LogrLogger) WithName Uses

func (l *LogrLogger) WithName(name string) *LogrLogger

WithName adds a new element to the logger's name. Successive calls with WithName continue to append suffixes to the logger's name. It's strongly recommended that name segments contain only letters, digits, and hyphens (see the package documentation for more information).

func (*LogrLogger) WithValues Uses

func (l *LogrLogger) WithValues(keysAndValues ...interface{}) *LogrLogger

WithValues adds some key-value pairs of context to a logger. See Info for documentation on how key/value pairs work.

type MultiWriter Uses

type MultiWriter struct {
    // InfoWriter specifies all the level logs writes to
    InfoWriter Writer

    // WarnWriter specifies the level greater than or equal to WarnLevel writes to
    WarnWriter Writer

    // WarnWriter specifies the level greater than or equal to ErrorLevel writes to
    ErrorWriter Writer

    // ConsoleWriter specifies the console writer
    ConsoleWriter Writer

    // ConsoleLevel specifies the level greater than or equal to it also writes to
    ConsoleLevel Level
}

MultiWriter is an Writer that log to different writers by different levels

func (*MultiWriter) Close Uses

func (w *MultiWriter) Close() (err error)

Close implements io.Closer, and closes the underlying LeveledWriter.

func (*MultiWriter) WriteEntry Uses

func (w *MultiWriter) WriteEntry(e *Entry) (n int, err error)

WriteEntry implements entryWriter.

type SugaredLogger Uses

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

A SugaredLogger wraps the base Logger functionality in a slower, but less verbose, API. Any Logger can be converted to a SugaredLogger with its Sugar method.

Unlike the Logger, the SugaredLogger doesn't insist on structured logging. For each log level, it exposes three methods: one for loosely-typed structured logging, one for println-style formatting, and one for printf-style formatting.

func (*SugaredLogger) Debug Uses

func (s *SugaredLogger) Debug(args ...interface{})

Debug uses fmt.Sprint to construct and log a message.

func (*SugaredLogger) Debugf Uses

func (s *SugaredLogger) Debugf(template string, args ...interface{})

Debugf uses fmt.Sprintf to log a templated message.

func (*SugaredLogger) Debugw Uses

func (s *SugaredLogger) Debugw(msg string, keysAndValues ...interface{})

Debugw logs a message with some additional context.

func (*SugaredLogger) Error Uses

func (s *SugaredLogger) Error(args ...interface{})

Error uses fmt.Sprint to construct and log a message.

func (*SugaredLogger) Errorf Uses

func (s *SugaredLogger) Errorf(template string, args ...interface{})

Errorf uses fmt.Sprintf to log a templated message.

func (*SugaredLogger) Errorw Uses

func (s *SugaredLogger) Errorw(msg string, keysAndValues ...interface{})

Errorw logs a message with some additional context.

func (*SugaredLogger) Fatal Uses

func (s *SugaredLogger) Fatal(args ...interface{})

Fatal uses fmt.Sprint to construct and log a message.

func (*SugaredLogger) Fatalf Uses

func (s *SugaredLogger) Fatalf(template string, args ...interface{})

Fatalf uses fmt.Sprintf to log a templated message.

func (*SugaredLogger) Fatalw Uses

func (s *SugaredLogger) Fatalw(msg string, keysAndValues ...interface{})

Fatalw logs a message with some additional context.

func (*SugaredLogger) Info Uses

func (s *SugaredLogger) Info(args ...interface{})

Info uses fmt.Sprint to construct and log a message.

func (*SugaredLogger) Infof Uses

func (s *SugaredLogger) Infof(template string, args ...interface{})

Infof uses fmt.Sprintf to log a templated message.

func (*SugaredLogger) Infow Uses

func (s *SugaredLogger) Infow(msg string, keysAndValues ...interface{})

Infow logs a message with some additional context.

func (*SugaredLogger) Level Uses

func (s *SugaredLogger) Level(level Level) *SugaredLogger

Level creates a child logger with the minimum accepted level set to level.

func (*SugaredLogger) Log Uses

func (s *SugaredLogger) Log(keysAndValues ...interface{}) error

Log sends a log entry with extra fields.

func (*SugaredLogger) Panic Uses

func (s *SugaredLogger) Panic(args ...interface{})

Panic uses fmt.Sprint to construct and log a message.

func (*SugaredLogger) Panicf Uses

func (s *SugaredLogger) Panicf(template string, args ...interface{})

Panicf uses fmt.Sprintf to log a templated message.

func (*SugaredLogger) Panicw Uses

func (s *SugaredLogger) Panicw(msg string, keysAndValues ...interface{})

Panicw logs a message with some additional context.

func (*SugaredLogger) Print Uses

func (s *SugaredLogger) Print(args ...interface{})

Print sends a log entry without extra field. Arguments are handled in the manner of fmt.Print.

func (*SugaredLogger) Printf Uses

func (s *SugaredLogger) Printf(format string, args ...interface{})

Printf sends a log entry without extra field. Arguments are handled in the manner of fmt.Printf.

func (*SugaredLogger) Println Uses

func (s *SugaredLogger) Println(args ...interface{})

Println sends a log entry without extra field. Arguments are handled in the manner of fmt.Print.

func (*SugaredLogger) Warn Uses

func (s *SugaredLogger) Warn(args ...interface{})

Warn uses fmt.Sprint to construct and log a message.

func (*SugaredLogger) Warnf Uses

func (s *SugaredLogger) Warnf(template string, args ...interface{})

Warnf uses fmt.Sprintf to log a templated message.

func (*SugaredLogger) Warnw Uses

func (s *SugaredLogger) Warnw(msg string, keysAndValues ...interface{})

Warnw logs a message with some additional context.

type SyslogWriter Uses

type SyslogWriter struct {
    // Network specifies network of the syslog server
    Network string

    // Address specifies address of the syslog server
    Address string

    // Hostname specifies hostname of the syslog message
    Hostname string

    // Tag specifies tag of the syslog message
    Tag string

    // Marker specifies prefix of the syslog message, e.g. `@cee:`
    Marker string

    // Dial specifies the dial function for creating TCP/TLS connections.
    Dial func(network, addr string) (net.Conn, error)
    // contains filtered or unexported fields
}

SyslogWriter is an Writer that writes logs to a syslog server..

func (*SyslogWriter) Close Uses

func (w *SyslogWriter) Close() (err error)

Close closes a connection to the syslog server.

func (*SyslogWriter) WriteEntry Uses

func (w *SyslogWriter) WriteEntry(e *Entry) (n int, err error)

WriteEntry implements Writer, sends logs with priority to the syslog server.

type TSVEntry Uses

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

TSVEntry represents a tsv log entry. It is instanced by one of TSVLogger and finalized by the Msg method.

func (*TSVEntry) Bool Uses

func (e *TSVEntry) Bool(b bool) *TSVEntry

Bool append the b as a bool to the entry.

func (*TSVEntry) Byte Uses

func (e *TSVEntry) Byte(b byte) *TSVEntry

Byte append the b as a byte to the entry.

func (*TSVEntry) Bytes Uses

func (e *TSVEntry) Bytes(val []byte) *TSVEntry

Bytes adds a bytes as string to the entry.

func (*TSVEntry) Float32 Uses

func (e *TSVEntry) Float32(f float32) *TSVEntry

Float32 adds a float32 to the entry.

func (*TSVEntry) Float64 Uses

func (e *TSVEntry) Float64(f float64) *TSVEntry

Float64 adds a float64 to the entry.

func (*TSVEntry) IPAddr Uses

func (e *TSVEntry) IPAddr(ip net.IP) *TSVEntry

IPAddr adds IPv4 or IPv6 Address to the entry.

func (*TSVEntry) Int Uses

func (e *TSVEntry) Int(i int) *TSVEntry

Int adds a int to the entry.

func (*TSVEntry) Int16 Uses

func (e *TSVEntry) Int16(i int16) *TSVEntry

Int16 adds a int16 to the entry.

func (*TSVEntry) Int32 Uses

func (e *TSVEntry) Int32(i int32) *TSVEntry

Int32 adds a int32 to the entry.

func (*TSVEntry) Int64 Uses

func (e *TSVEntry) Int64(i int64) *TSVEntry

Int64 adds a int64 to the entry.

func (*TSVEntry) Int8 Uses

func (e *TSVEntry) Int8(i int8) *TSVEntry

Int8 adds a int8 to the entry.

func (*TSVEntry) Msg Uses

func (e *TSVEntry) Msg()

Msg sends the entry.

func (*TSVEntry) Str Uses

func (e *TSVEntry) Str(val string) *TSVEntry

Str adds a string to the entry.

func (*TSVEntry) Timestamp Uses

func (e *TSVEntry) Timestamp() *TSVEntry

Timestamp adds the current time as UNIX timestamp

func (*TSVEntry) TimestampMS Uses

func (e *TSVEntry) TimestampMS() *TSVEntry

TimestampMS adds the current time with milliseconds as UNIX timestamp

func (*TSVEntry) Uint16 Uses

func (e *TSVEntry) Uint16(i uint16) *TSVEntry

Uint16 adds a uint16 to the entry.

func (*TSVEntry) Uint32 Uses

func (e *TSVEntry) Uint32(i uint32) *TSVEntry

Uint32 adds a uint32 to the entry.

func (*TSVEntry) Uint64 Uses

func (e *TSVEntry) Uint64(i uint64) *TSVEntry

Uint64 adds a uint64 to the entry.

func (*TSVEntry) Uint8 Uses

func (e *TSVEntry) Uint8(i uint8) *TSVEntry

Uint8 adds a uint8 to the entry.

type TSVLogger Uses

type TSVLogger struct {
    Separator byte
    Writer    io.Writer
}

TSVLogger represents an active logging object that generates lines of TSV output to an io.Writer.

func (*TSVLogger) New Uses

func (l *TSVLogger) New() (e *TSVEntry)

New starts a new tsv message.

type Writer Uses

type Writer interface {
    WriteEntry(*Entry) (int, error)
}

Writer defines an entry writer interface.

type XID Uses

type XID [12]byte

XID represents a unique request id

func NewXID Uses

func NewXID() XID

NewXID generates a globally unique XID

func NewXIDWithTime Uses

func NewXIDWithTime(unix int64) (x XID)

NewXIDWithTime generates a globally unique XID with unix timestamp

func ParseXID Uses

func ParseXID(s string) (x XID, err error)

ParseXID parses an XID from its string representation

func (XID) Counter Uses

func (x XID) Counter() uint32

Counter returns the incrementing value part of the id.

func (XID) Machine Uses

func (x XID) Machine() []byte

Machine returns the 3-byte machine id part of the id.

func (XID) MarshalJSON Uses

func (x XID) MarshalJSON() (dst []byte, err error)

MarshalJSON implements encoding/json Marshaler interface

func (XID) MarshalText Uses

func (x XID) MarshalText() (dst []byte, err error)

MarshalText implements encoding/text TextMarshaler interface

func (XID) Pid Uses

func (x XID) Pid() uint16

Pid returns the process id part of the id.

func (XID) String Uses

func (x XID) String() string

String returns a base32 hex lowercased representation of the id.

func (XID) Time Uses

func (x XID) Time() time.Time

Time returns the timestamp part of the id.

func (*XID) UnmarshalJSON Uses

func (x *XID) UnmarshalJSON(b []byte) (err error)

UnmarshalJSON implements encoding/json Unmarshaler interface

func (*XID) UnmarshalText Uses

func (x *XID) UnmarshalText(text []byte) (err error)

UnmarshalText implements encoding/text TextUnmarshaler interface

Package log imports 23 packages (graph). Updated 2020-10-24. Refresh now. Tools for package owners.