import "github.com/phuslu/log"
buffer.go console.go console_posix.go file.go goid.go grpc.go journal.go level.go logger.go logr.go std.go sugar.go time_linux.go tsv.go
const (
// 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"
)const ColorTemplate = "" /* 552 byte string literal not displayed */
ColorTemplate provides a pre-defined text/template for console color output
type . 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>"
KeyValue []struct {
Key string // "foo"
Value interface{} // "bar"
}
}
A quick example is
log.DefaultLogger.Writer = &log.ConsoleWriter{
Template: template.Must(template.New("").Funcs(log.ColorFuncMap).Parse(log.ColorTemplate)),
Writer: os.Stderr,
}
Note: use [sprig](https://github.com/Masterminds/sprig) to provides more template functions.
var ColorFuncMap = template.FuncMap{ "black": func(s string) string { return "\x1b[30m" + s + "\x1b[0m" }, "red": func(s string) string { return "\x1b[31m" + s + "\x1b[0m" }, "green": func(s string) string { return "\x1b[32m" + s + "\x1b[0m" }, "yellow": func(s string) string { return "\x1b[33m" + s + "\x1b[0m" }, "blue": func(s string) string { return "\x1b[34m" + s + "\x1b[0m" }, "magenta": func(s string) string { return "\x1b[35m" + s + "\x1b[0m" }, "cyan": func(s string) string { return "\x1b[36m" + s + "\x1b[0m" }, "white": func(s string) string { return "\x1b[37m" + s + "\x1b[0m" }, "gray": func(s string) string { return "\x1b[90m" + s + "\x1b[0m" }, "contains": strings.Contains, "endsswith": strings.HasSuffix, "low": strings.ToLower, "match": path.Match, "quote": strconv.Quote, "statswith": strings.HasPrefix, "title": strings.ToTitle, "upper": strings.ToUpper, }
ColorFuncMap provides a pre-defined template functions for color string
var DefaultLogger = Logger{ Level: DebugLevel, Caller: 0, TimeField: "", TimeFormat: "", Writer: os.Stderr, }
DefaultLogger is the global logger.
Fastrandn returns a pseudorandom uint32 in [0,n).
go:noescape go:linkname Fastrandn runtime.fastrandn
Flush writes any buffered data to the underlying io.Writer.
Goid returns the current goroutine id. It exactly matches goroutine id of the stack trace.
IsTerminal returns whether the given file descriptor is a terminal.
Printf sends a log event without extra field. Arguments are handled in the manner of fmt.Printf.
type BufferWriter struct {
// BufferSize is the size in bytes of the buffer before it gets flushed.
BufferSize int
// FlushDuration is the period of the writer flush duration
FlushDuration time.Duration
// Writer specifies the writer of output.
Writer io.Writer
// contains filtered or unexported fields
}BufferWriter is an io.WriteCloser that writes with fixed size buffer.
func (w *BufferWriter) Close() (err error)
Close implements io.Closer, and closes the underlaying Writer.
func (w *BufferWriter) Flush() (err error)
Flush flushes all pending log I/O.
func (w *BufferWriter) Write(p []byte) (n int, err error)
Write implements io.Writer. If a write would cause the log buffer to be larger than Size, the buffer is written to the underlaying Writer and cleared.
type ConsoleWriter struct {
// ColorOutput determines if used colorized output.
ColorOutput bool
// Deprecated: Use ColorOutput instead.
ANSIColor bool
// QuoteString determines if quoting string values.
QuoteString bool
// EndWithMessage determines if output message in the end.
EndWithMessage bool
// TimeField specifies the field name for time in output.
TimeField string
// Template determines console output template if not empty.
// see https://github.com/phuslu/log/blob/master/console.go#L328
// for available Template Arguments.
Template *template.Template
// 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.
func (w *ConsoleWriter) Write(p []byte) (int, error)
Context represents contextual fields.
type Event struct {
// contains filtered or unexported fields
}Event represents a log event. It is instanced by one of the level method of Logger and finalized by the Msg or Msgf method.
Debug starts a new message with debug level.
Error starts a new message with error level.
Fatal starts a new message with fatal level.
Info starts a new message with info level.
NewContext starts a new contextual event.
Panic starts a new message with panic level.
Trace starts a new message with trace level.
Warn starts a new message with warning level.
AnErr adds the field key with serialized err to the logger context.
Bool append append the val as a bool to the event.
Bools adds the field key with val as a []bool to the event.
Byte adds the field key with val as a byte to the event.
Bytes adds the field key with val as a string to the event.
BytesOrNil adds the field key with val as a string or nil to the event.
Caller adds the file:line of the "caller" key.
Context sends the contextual fields to event.
Dict sends the contextual fields with key to event.
Discard disables the event so Msg(f) won't print it.
Dur adds the field key with duration d to the event.
Durs adds the field key with val as a []time.Duration to the event.
Enabled return false if the event is going to be filtered out by log level.
Err adds the field "error" with serialized err to the event.
Errs adds the field key with errs as an array of serialized errors to the event.
Float32 adds the field key with f as a float32 to the event.
Float64 adds the field key with f as a float64 to the event.
Floats32 adds the field key with f as a []float32 to the event.
Floats64 adds the field key with f as a []float64 to the event.
GoStringer adds the field key with val.GoStringer() to the event.
Hex adds the field key with val as a hex string to the event.
IPAddr adds IPv4 or IPv6 Address to the event
IPPrefix adds IPv4 or IPv6 Prefix (address and mask) to the event
Int adds the field key with i as a int to the event.
Int16 adds the field key with i as a int16 to the event.
Int32 adds the field key with i as a int32 to the event.
Int64 adds the field key with i as a int64 to the event.
Int8 adds the field key with i as a int8 to the event.
Interface adds the field key with i marshaled using reflection.
MACAddr adds MAC address to the event
Msg sends the event with msg added as the message field if not empty.
Msgf sends the event with formatted msg added as the message field if not empty.
RawJSON adds already encoded JSON to the log line under key.
RawJSONStr adds already encoded JSON String to the log line under key.
Stack enables stack trace printing for the error passed to Err().
Str adds the field key with val as a string to the event.
Stringer adds the field key with val.String() to the event.
Strs adds the field key with vals as a []string to the event.
Time append append t formated as string using time.RFC3339Nano.
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().
TimeFormat append append t formated as string using timefmt.
Uint16 adds the field key with i as a uint16 to the event.
Uint32 adds the field key with i as a uint32 to the event.
Uint64 adds the field key with i as a uint64 to the event.
Uint8 adds the field key with i as a uint8 to the event.
Value builds the contextual fields.
Xid adds the field key with xid.ID as a base32 string to the event.
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 io.WriteCloser 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`
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 (w *FileWriter) Close() (err error)
Close implements io.Closer, and closes the current logfile.
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 (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.
The Flusher interface is implemented by BufferWriters that allow an Logger to flush buffered data to the output.
type GrpcLogger struct {
// contains filtered or unexported fields
}GrpcLogger implements methods to satisfy interface google.golang.org/grpc/grpclog.LoggerV2.
func (g *GrpcLogger) Error(args ...interface{})
Error logs to ERROR log. Arguments are handled in the manner of fmt.Print.
func (g *GrpcLogger) Errorf(format string, args ...interface{})
Errorf logs to ERROR log. Arguments are handled in the manner of fmt.Printf.
func (g *GrpcLogger) Errorln(args ...interface{})
Errorln logs to ERROR log. Arguments are handled in the manner of fmt.Println.
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 (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 (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 (g *GrpcLogger) Info(args ...interface{})
Info logs to INFO log. Arguments are handled in the manner of fmt.Print.
func (g *GrpcLogger) Infof(format string, args ...interface{})
Infof logs to INFO log. Arguments are handled in the manner of fmt.Printf.
func (g *GrpcLogger) Infoln(args ...interface{})
Infoln logs to INFO log. Arguments are handled in the manner of fmt.Println.
func (g *GrpcLogger) V(level int) bool
V reports whether verbosity level l is at least the requested verbose leveg.
func (g *GrpcLogger) Warning(args ...interface{})
Warning logs to WARNING log. Arguments are handled in the manner of fmt.Print.
func (g *GrpcLogger) Warningf(format string, args ...interface{})
Warningf logs to WARNING log. Arguments are handled in the manner of fmt.Printf.
func (g *GrpcLogger) Warningln(args ...interface{})
Warningln logs to WARNING log. Arguments are handled in the manner of fmt.Println.
type JournalWriter struct {
// journal socket, using `/run/systemd/journal/socket` if empty.
JournalSocket string
// TimeField specifies the field name for time in output.
TimeField string
// contains filtered or unexported fields
}JournalWriter is an io.WriteCloser that writes logs to journald.
func (w *JournalWriter) Close() (err error)
Write implements io.Closer.
func (w *JournalWriter) Write(p []byte) (n int, err error)
Write implements io.Writer.
Level defines log levels.
const (
// TraceLevel defines trace log level.
TraceLevel Level = -1
// DebugLevel defines debug log level.
DebugLevel Level = 0
// InfoLevel defines info log level.
InfoLevel Level = 1
// WarnLevel defines warn log level.
WarnLevel Level = 2
// ErrorLevel defines error log level.
ErrorLevel Level = 3
// FatalLevel defines fatal log level.
FatalLevel Level = 4
// PanicLevel defines panic log level.
PanicLevel Level = 5
)ParseLevel converts a level string into a log Level value. returns an error if the input string does not match known values.
First return first upper letter of Level
Lower return lowe case string of Level
Three return three letters of Level
Title return title case string of Level
Upper return upper case string of Level
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.RFC3389 in if empty.
// If set with `TimeFormatUnix`, `TimeFormatUnixMs`, times are formated as UNIX timestamp.
TimeFormat string
// Writer specifies the writer of output. It uses os.Stderr in if empty.
Writer io.Writer
}A Logger represents an active logging object that generates lines of JSON output to an io.Writer.
Debug starts a new message with debug level.
Error starts a new message with error level.
Fatal starts a new message with fatal level.
func (l *Logger) Grpc(context Context) (g *GrpcLogger)
Grpc wraps the Logger to provide a LoggerV2 logger
Info starts a new message with info level.
func (l *Logger) Logr(context Context) *LogrLogger
Logr wraps the Logger to provide a logr logger
Panic starts a new message with panic level.
Printf sends a log event without extra field. Arguments are handled in the manner of fmt.Printf.
SetLevel changes logger default level.
Std wraps the Logger to provide *stdLog.Logger
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.
Trace starts a new message with trace level.
Warn starts a new message with warning level.
WithLevel starts a new message with level.
type LogrLogger struct {
// contains filtered or unexported fields
}LogrLogger implements methods to satisfy interface github.com/go-logr/logr.Logger.
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 (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 (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 (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 (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 (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 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 (s *SugaredLogger) Debug(args ...interface{})
Debug uses fmt.Sprint to construct and log a message.
func (s *SugaredLogger) Debugf(template string, args ...interface{})
Debugf uses fmt.Sprintf to log a templated message.
func (s *SugaredLogger) Debugw(msg string, keysAndValues ...interface{})
Debugw logs a message with some additional context.
func (s *SugaredLogger) Error(args ...interface{})
Error uses fmt.Sprint to construct and log a message.
func (s *SugaredLogger) Errorf(template string, args ...interface{})
Errorf uses fmt.Sprintf to log a templated message.
func (s *SugaredLogger) Errorw(msg string, keysAndValues ...interface{})
Errorw logs a message with some additional context.
func (s *SugaredLogger) Fatal(args ...interface{})
Fatal uses fmt.Sprint to construct and log a message.
func (s *SugaredLogger) Fatalf(template string, args ...interface{})
Fatalf uses fmt.Sprintf to log a templated message.
func (s *SugaredLogger) Fatalw(msg string, keysAndValues ...interface{})
Fatalw logs a message with some additional context.
func (s *SugaredLogger) Info(args ...interface{})
Info uses fmt.Sprint to construct and log a message.
func (s *SugaredLogger) Infof(template string, args ...interface{})
Infof uses fmt.Sprintf to log a templated message.
func (s *SugaredLogger) Infow(msg string, keysAndValues ...interface{})
Infow logs a message with some additional context.
func (s *SugaredLogger) Level(level Level) *SugaredLogger
Level creates a child logger with the minimum accepted level set to level.
func (s *SugaredLogger) Log(keysAndValues ...interface{}) error
Log sends a log event with extra fields.
func (s *SugaredLogger) Panic(args ...interface{})
Panic uses fmt.Sprint to construct and log a message.
func (s *SugaredLogger) Panicf(template string, args ...interface{})
Panicf uses fmt.Sprintf to log a templated message.
func (s *SugaredLogger) Panicw(msg string, keysAndValues ...interface{})
Panicw logs a message with some additional context.
func (s *SugaredLogger) Print(args ...interface{})
Print sends a log event without extra field. Arguments are handled in the manner of fmt.Print.
func (s *SugaredLogger) Printf(format string, args ...interface{})
Printf sends a log event without extra field. Arguments are handled in the manner of fmt.Printf.
func (s *SugaredLogger) Println(args ...interface{})
Println sends a log event without extra field. Arguments are handled in the manner of fmt.Print.
func (s *SugaredLogger) Warn(args ...interface{})
Warn uses fmt.Sprint to construct and log a message.
func (s *SugaredLogger) Warnf(template string, args ...interface{})
Warnf uses fmt.Sprintf to log a templated message.
func (s *SugaredLogger) Warnw(msg string, keysAndValues ...interface{})
Warnw logs a message with some additional context.
type TSVEvent struct {
// contains filtered or unexported fields
}TSVEvent represents a tsv log event. It is instanced by one of TSVLogger and finalized by the Msg method.
Bool append the b as a bool to the event.
Byte append the b as a byte to the event.
Bytes adds a bytes as string to the event.
Float32 adds a float32 to the event.
Float64 adds a float64 to the event.
IPAddr adds IPv4 or IPv6 Address to the event
Int adds a int to the event.
Int16 adds a int16 to the event.
Int32 adds a int32 to the event.
Int64 adds a int64 to the event.
Int8 adds a int8 to the event.
Msg sends the event.
Str adds a string to the event.
Timestamp adds the current time as UNIX timestamp
TimestampMS adds the current time with milliseconds as UNIX timestamp
Uint16 adds a uint16 to the event.
Uint32 adds a uint32 to the event.
Uint64 adds a uint64 to the event.
Uint8 adds a uint8 to the event.
TSVLogger represents an active logging object that generates lines of TSV output to an io.Writer.
New starts a new tsv message.
type Writer = FileWriter
Writer is an alias for FileWriter
Deprecated: Use FileWriter instead.
Package log imports 22 packages (graph). Updated 2020-08-08. Refresh now. Tools for package owners.