README

Structured Logging Made Easy

go.dev goreport build coverage stability-stable

Features

  • Dependency Free
  • Simple and Clean Interface
  • Consistent Writer
    • IOWriter, io.Writer wrapper
    • FileWriter, rotating & effective
    • ConsoleWriter, colorful & formatting
    • MultiWriter, multiple level dispatch
    • SyslogWriter, syslog server logging
    • JournalWriter, linux systemd logging
    • EventlogWriter, windows system event
    • AsyncWriter, asynchronously writing
  • Third-party Logger Interceptor
    • Logger.Std, (std)log
    • Logger.Grpc, grpclog.LoggerV2
    • Logger.Logr, logr.Logger
  • Useful utility function
    • Goid(), the goroutine id matches stack trace
    • NewXID(), create a tracing id
    • Fastrandn(n uint32), fast pseudorandom uint32 in [0,n)
    • IsTerminal(fd uintptr), isatty for golang
    • Printf(fmt string, a ...interface{}), printf logging
  • High Performance

Interfaces

Logger
// DefaultLogger is the global logger.
var DefaultLogger = Logger{
	Level:      DebugLevel,
	Caller:     0,
	TimeField:  "",
	TimeFormat: "",
	Writer:     &IOWriter{os.Stderr},
}

// A Logger represents an active logging object that generates lines of JSON output to an io.Writer.
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 RFC3339 with millisecond 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
}
FileWriter & ConsoleWriter
// FileWriter is an Writer that writes to the specified filename.
type FileWriter struct {
	// Filename is the file to write logs to.  Backup log files will be retained
	// in the same directory.
	Filename string

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

	// 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

	// TimeFormat specifies the time format of filename, uses `2006-01-02T15-04-05` as default format.
	// If set with `TimeFormatUnix`, `TimeFormatUnixMs`, times are formated as UNIX timestamp.
	TimeFormat string

	// 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

	// EnsureFolder ensures the file directory creation before writing.
	EnsureFolder bool

	// Cleaner specifies an optional cleanup function of log backups after rotation,
	// if not set, the default behavior is to delete more than MaxBackups log files.
	Cleaner func(filename string, maxBackups int, matches []os.FileInfo)
}

// ConsoleWriter parses the JSON input and writes it in a colorized, human-friendly format to Writer.
// IMPORTANT: Don't use ConsoleWriter on critical path of a high concurrency and low latency application.
//
// Default output format:
//     {Time} {Level} {Goid} {Caller} > {Message} {Key}={Value} {Key}={Value}
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 of line.
	EndWithMessage bool

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

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

Note: FileWriter implements log.Writer and io.Writer interfaces both, it is a drop-in replacement of lumberjack.

Getting Started

Simple Logging Example

An out of box example. playground

package main

import (
	"github.com/phuslu/log"
)

func main() {
	log.Info().Str("foo", "bar").Int("number", 42).Msg("hi, phuslog")
	log.Info().Msgf("foo=%s number=%d error=%+v", "bar", 42, "an error")
}

// Output:
//   {"time":"2020-03-22T09:58:41.828Z","level":"info","foo":"bar","number":42,"message":"hi, phuslog"}
//   {"time":"2020-03-22T09:58:41.828Z","level":"info","message":"foo=bar number=42 error=an error"}

Note: By default log writes to os.Stderr

Customize the configuration and formatting:

To customize logger filed name and format. playground

package main

import (
	"github.com/phuslu/log"
)

func main() {
	log.DefaultLogger = log.Logger{
		Level:      log.InfoLevel,
		Caller:     1,
		TimeField:  "date",
		TimeFormat: "2006-01-02",
		Writer:     &log.IOWriter{os.Stdout},
	}

	log.Info().Str("foo", "bar").Msgf("hello %s", "world")
}

// Output: {"date":"2019-07-04","level":"info","caller":"prog.go:16","foo":"bar","message":"hello world"}
Rotating File Writer

To log to a daily-rotating file, use FileWriter. playground

package main

import (
	"os"
	"path/filepath"
	"time"

	"github.com/phuslu/log"
	"github.com/robfig/cron/v3"
)

func main() {
	logger := log.Logger{
		Level: log.ParseLevel("info"),
		Writer: &log.FileWriter{
			Filename:     "logs/main.log",
			FileMode:     0600,
			MaxSize:      100 * 1024 * 1024,
			MaxBackups:   7,
			EnsureFolder: true,
			LocalTime:    true,
		},
	}

	runner := cron.New(cron.WithLocation(time.Local))
	runner.AddFunc("0 0 * * *", func() { logger.Writer.(*log.FileWriter).Rotate() })
	go runner.Run()

	for {
		time.Sleep(time.Second)
		logger.Info().Msg("hello world")
	}
}
Rotating File Writer within a total size

To rotating log file hourly and keep in a total size, use FileWriter.Cleaner.

package main

import (
	"os"
	"path/filepath"
	"time"

	"github.com/phuslu/log"
	"github.com/robfig/cron/v3"
)

func main() {
	logger := log.Logger{
		Level: log.ParseLevel("info"),
		Writer: &log.FileWriter{
			Filename: "main.log",
			MaxSize:  500 * 1024 * 1024,
			Cleaner:  func(filename string, maxBackups int, matches []os.FileInfo) {
				var dir = filepath.Dir(filename)
				var total int64
				for i := len(matches) - 1; i >= 0; i-- {
					total += matches[i].Size()
					if total > 5*1024*1024*1024 {
						os.Remove(filepath.Join(dir, matches[i].Name()))
					}
				}
			},
		},
	}

	runner := cron.New(cron.WithLocation(time.UTC))
	runner.AddFunc("0 * * * *", func() { logger.Writer.(*log.FileWriter).Rotate() })
	go runner.Run()

	for {
		time.Sleep(time.Second)
		logger.Info().Msg("hello world")
	}
}
Pretty Console Writer

To log a human-friendly, colorized output, use ConsoleWriter. playground

if log.IsTerminal(os.Stderr.Fd()) {
	log.DefaultLogger = log.Logger{
		TimeFormat: "15:04:05",
		Caller:     1,
		Writer: &log.ConsoleWriter{
			ColorOutput:    true,
			QuoteString:    true,
			EndWithMessage: true,
		},
	}
}

log.Debug().Int("everything", 42).Str("foo", "bar").Msg("hello world")
log.Info().Int("everything", 42).Str("foo", "bar").Msg("hello world")
log.Warn().Int("everything", 42).Str("foo", "bar").Msg("hello world")
log.Error().Err(errors.New("an error")).Msg("hello world")

Pretty logging

Note: pretty logging also works on windows console

Formatting Console Writer

To log with user-defined format(e.g. glog), using ConsoleWriter.Formatter. playground

log.DefaultLogger = log.Logger{
	Level:      log.InfoLevel,
	Caller:     1,
	TimeFormat: "0102 15:04:05.999999",
	Writer: &log.ConsoleWriter{
		Formatter: func (w io.Writer, a *log.FormatterArgs) (int, error) {
			return fmt.Fprintf(w, "%c%s %s %s] %s\n%s", strings.ToUpper(a.Level)[0],
				a.Time, a.Goid, a.Caller, a.Message, a.Stack)
		},
	},
}

log.Info().Msgf("hello glog %s", "Info")
log.Warn().Msgf("hello glog %s", "Warn")
log.Error().Msgf("hello glog %s", "Error")

// Output:
// I0725 09:59:57.503246 19 console_test.go:183] hello glog Info
// W0725 09:59:57.504247 19 console_test.go:184] hello glog Warn
// E0725 09:59:57.504247 19 console_test.go:185] hello glog Error
Multiple Dispatching Writer

To log to different writers by different levels, use MultiWriter.

log.DefaultLogger.Writer = &log.MultiWriter{
	InfoWriter:    &log.FileWriter{Filename: "main.INFO", MaxSize: 100<<20},
	WarnWriter:    &log.FileWriter{Filename: "main.WARNING", MaxSize: 100<<20},
	ErrorWriter:   &log.FileWriter{Filename: "main.ERROR", MaxSize: 100<<20},
	ConsoleWriter: &log.ConsoleWriter{ColorOutput: true},
	ConsoleLevel:  log.ErrorLevel,
}

log.Info().Int("number", 42).Str("foo", "bar").Msg("a info log")
log.Warn().Int("number", 42).Str("foo", "bar").Msg("a warn log")
log.Error().Int("number", 42).Str("foo", "bar").Msg("a error log")
Multiple Combined Logger:

To logging to different logger as you want, use below idiom. playground

package main

import (
	"github.com/phuslu/log"
)

var logger = struct {
	Console log.Logger
	Access  log.Logger
	Data    log.Logger
}{
	Console: log.Logger{
		TimeFormat: "15:04:05",
		Caller:     1,
		Writer: &log.ConsoleWriter{
			ColorOutput:    true,
			EndWithMessage: true,
		},
	},
	Access: log.Logger{
		Level: log.InfoLevel,
		Writer: &log.FileWriter{
			Filename:   "access.log",
			MaxSize:    50 * 1024 * 1024,
			MaxBackups: 7,
			LocalTime:  false,
		},
	},
	Data: log.Logger{
		Level: log.InfoLevel,
		Writer: &log.FileWriter{
			Filename:   "data.log",
			MaxSize:    50 * 1024 * 1024,
			MaxBackups: 7,
			LocalTime:  false,
		},
	},
}

func main() {
	logger.Console.Info().Msgf("hello world")
	logger.Access.Log().Msgf("handle request")
	logger.Data.Log().Msgf("some data")
}
SyslogWriter & JournalWriter & EventlogWriter

To log to a syslog server, using SyslogWriter.

log.DefaultLogger.Writer = &log.SyslogWriter{
	// Network : "unixgram",
	// Address : "/run/systemd/journal/syslog",
	Network : "tcp",
	Address : "192.168.0.2:601",
	Tag     : "",
	Marker  : "@cee:",
	Dial    : net.Dial,
}

log.Info().Msg("hi")

// Output: <6>Oct 5 16:25:38 [237]: @cee:{"time":"2020-10-05T16:25:38.026Z","level":"info","message":"hi"}

To log to linux systemd journald, using JournalWriter.

log.DefaultLogger.Writer = &log.JournalWriter{}

log.Info().Int("number", 42).Str("foo", "bar").Msg("hello world")

To log to windows system event, using EventlogWriter.

log.DefaultLogger.Writer = &log.EventlogWriter{
	Source: ".NET Runtime",
	ID:     1000,
}

log.Info().Int("number", 42).Str("foo", "bar").Msg("hello world")
AsyncWriter

To logging asynchronously for performance stability, use AsyncWriter.

logger := log.Logger{
	Level:  log.InfoLevel,
	Writer: &log.AsyncWriter{
		ChannelSize: 100,
		Writer:      &log.FileWriter{
			Filename:   "main.log",
			FileMode:   0600,
			MaxSize:    50*1024*1024,
			MaxBackups: 7,
			LocalTime:  false,
		},
	},
}

logger.Info().Int("number", 42).Str("foo", "bar").Msg("a async info log")
logger.Warn().Int("number", 42).Str("foo", "bar").Msg("a async warn log")
logger.Writer.(io.Closer).Close()

Note: To flush data and quit safely, call AsyncWriter.Close() explicitly.

StdLog & Logr & Grpc Interceptor

Using wrapped loggers for stdlog/grpc/logr. playground

package main

import (
	stdLog "log"
	"github.com/go-logr/logr"
	"github.com/phuslu/log"
	"google.golang.org/grpc/grpclog"
)

func main() {
	ctx := log.NewContext(nil).Str("tag", "hi log").Value()

	var stdlog *stdLog.Logger = log.DefaultLogger.Std(log.InfoLevel, ctx, "prefix ", stdLog.LstdFlags)
	stdlog.Print("hello from stdlog Print")
	stdlog.Println("hello from stdlog Println")
	stdlog.Printf("hello from stdlog %s", "Printf")

	var grpclog grpclog.LoggerV2 = log.DefaultLogger.Grpc(ctx)
	grpclog.Infof("hello %s", "grpclog Infof message")
	grpclog.Errorf("hello %s", "grpclog Errorf message")

	var logrLog logr.Logger = log.DefaultLogger.Logr(ctx)
	logrLog = logrLog.WithName("a_named_logger").WithValues("a_key", "a_value")
	logrLog.Info("hello", "foo", "bar", "number", 42)
	logrLog.Error(errors.New("this is a error"), "hello", "foo", "bar", "number", 42)
}
User-defined Data Structure

To log with user-defined struct effectively, implements MarshalObject. playground

package main

import (
	"github.com/phuslu/log"
)

type User struct {
	ID   int
	Name string
	Pass string
}

func (u *User) MarshalObject(e *log.Entry) {
	e.Int("id", u.ID).Str("name", u.Name).Str("password", "***")
}

func main() {
	log.Info().Object("user", &User{1, "neo", "123456"}).Msg("")
	log.Info().EmbedObject(&User{2, "john", "abc"}).Msg("")
}

// Output:
//   {"time":"2020-07-12T05:03:43.949Z","level":"info","user":{"id":1,"name":"neo","password":"***"}}
//   {"time":"2020-07-12T05:03:43.949Z","level":"info","id":2,"name":"john","password":"***"}
Contextual Fields

To add preserved key:value pairs to each entry, use NewContext. playground

ctx := log.NewContext(nil).Str("ctx_str", "a ctx str").Value()

logger := log.Logger{Level: log.InfoLevel}
logger.Debug().Context(ctx).Int("no0", 0).Msg("zero")
logger.Info().Context(ctx).Int("no1", 1).Msg("first")
logger.Info().Context(ctx).Int("no2", 2).Msg("second")

// Output:
//   {"time":"2020-07-12T05:03:43.949Z","level":"info","ctx_str":"a ctx str","no1":1,"message":"first"}
//   {"time":"2020-07-12T05:03:43.949Z","level":"info","ctx_str":"a ctx str","no2":2,"message":"second"}
High Performance

The most common benchmarks(disable/normal/interface/printf/caller) with zap/zerolog, which runs on github actions:

// go test -v -cpu=4 -run=none -bench=. -benchtime=10s -benchmem log_test.go
package main

import (
	"io/ioutil"
	"testing"

	"github.com/phuslu/log"
	"github.com/rs/zerolog"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

var msg = "The quick brown fox jumps over the lazy dog"
var obj = struct {Rate string; Low int; High float32}{"15", 16, 123.2}

func BenchmarkDisableZap(b *testing.B) {
	logger := zap.New(zapcore.NewCore(
		zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
		zapcore.AddSync(ioutil.Discard),
		zapcore.InfoLevel,
	))
	for i := 0; i < b.N; i++ {
		logger.Debug(msg, zap.String("rate", "15"), zap.Int("low", 16), zap.Float32("high", 123.2))
	}
}

func BenchmarkNormalZap(b *testing.B) {
	logger := zap.New(zapcore.NewCore(
		zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
		zapcore.AddSync(ioutil.Discard),
		zapcore.InfoLevel,
	))
	for i := 0; i < b.N; i++ {
		logger.Info(msg, zap.String("rate", "15"), zap.Int("low", 16), zap.Float32("high", 123.2))
	}
}

func BenchmarkInterfaceZap(b *testing.B) {
	logger := zap.New(zapcore.NewCore(
		zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
		zapcore.AddSync(ioutil.Discard),
		zapcore.InfoLevel,
	)).Sugar()
	for i := 0; i < b.N; i++ {
		logger.Infow(msg, "object", &obj)
	}
}

func BenchmarkPrintfZap(b *testing.B) {
	logger := zap.New(zapcore.NewCore(
		zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
		zapcore.AddSync(ioutil.Discard),
		zapcore.InfoLevel,
	)).Sugar()
	for i := 0; i < b.N; i++ {
		logger.Infof("rate=%s low=%d high=%f msg=%s", "15", 16, 123.2, msg)
	}
}

func BenchmarkCallerZap(b *testing.B) {
	logger := zap.New(zapcore.NewCore(
		zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
		zapcore.AddSync(ioutil.Discard),
		zapcore.InfoLevel),
		zap.AddCaller(),
	)
	for i := 0; i < b.N; i++ {
		logger.Info(msg, zap.String("rate", "15"), zap.Int("low", 16), zap.Float32("high", 123.2))
	}
}

func BenchmarkDisableZeroLog(b *testing.B) {
	zerolog.SetGlobalLevel(zerolog.InfoLevel)
	logger := zerolog.New(ioutil.Discard).With().Timestamp().Logger()
	for i := 0; i < b.N; i++ {
		logger.Debug().Str("rate", "15").Int("low", 16).Float32("high", 123.2).Msg(msg)
	}
}

func BenchmarkNormalZeroLog(b *testing.B) {
	logger := zerolog.New(ioutil.Discard).With().Timestamp().Logger()
	for i := 0; i < b.N; i++ {
		logger.Info().Str("rate", "15").Int("low", 16).Float32("high", 123.2).Msg(msg)
	}
}

func BenchmarkInterfaceZeroLog(b *testing.B) {
	logger := zerolog.New(ioutil.Discard).With().Timestamp().Logger()
	for i := 0; i < b.N; i++ {
		logger.Info().Interface("object", &obj).Msg(msg)
	}
}

func BenchmarkPrintfZeroLog(b *testing.B) {
	logger := zerolog.New(ioutil.Discard).With().Timestamp().Logger()
	for i := 0; i < b.N; i++ {
		logger.Info().Msgf("rate=%s low=%d high=%f msg=%s", "15", 16, 123.2, msg)
	}
}

func BenchmarkCallerZeroLog(b *testing.B) {
	logger := zerolog.New(ioutil.Discard).With().Caller().Timestamp().Logger()
	for i := 0; i < b.N; i++ {
		logger.Info().Str("rate", "15").Int("low", 16).Float32("high", 123.2).Msg(msg)
	}
}

func BenchmarkDisablePhusLog(b *testing.B) {
	logger := log.Logger{Level: log.InfoLevel, Writer: log.IOWriter{ioutil.Discard}}
	for i := 0; i < b.N; i++ {
		logger.Debug().Str("rate", "15").Int("low", 16).Float32("high", 123.2).Msg(msg)
	}
}

func BenchmarkNormalPhusLog(b *testing.B) {
	logger := log.Logger{Writer: log.IOWriter{ioutil.Discard}}
	for i := 0; i < b.N; i++ {
		logger.Info().Str("rate", "15").Int("low", 16).Float32("high", 123.2).Msg(msg)
	}
}

func BenchmarkInterfacePhusLog(b *testing.B) {
	logger := log.Logger{Writer: log.IOWriter{ioutil.Discard}}
	for i := 0; i < b.N; i++ {
		logger.Info().Interface("object", &obj).Msg(msg)
	}
}

func BenchmarkPrintfPhusLog(b *testing.B) {
	logger := log.Logger{Writer: log.IOWriter{ioutil.Discard}}
	for i := 0; i < b.N; i++ {
		logger.Info().Msgf("rate=%s low=%d high=%f msg=%s", "15", 16, 123.2, msg)
	}
}

func BenchmarkCallerPhusLog(b *testing.B) {
	logger := log.Logger{Caller: 1, Writer: log.IOWriter{ioutil.Discard}}
	for i := 0; i < b.N; i++ {
		logger.Info().Str("rate", "15").Int("low", 16).Float32("high", 123.2).Msg(msg)
	}
}

A Performance result as below, for daily benchmark results see github actions

BenchmarkDisableZap-4         	84149790	       138 ns/op	     192 B/op	       1 allocs/op
BenchmarkNormalZap-4          	 8281590	      1459 ns/op	     192 B/op	       1 allocs/op
BenchmarkInterfaceZap-4       	 6159080	      1924 ns/op	     208 B/op	       2 allocs/op
BenchmarkPrintfZap-4          	 6664330	      1846 ns/op	      96 B/op	       2 allocs/op
BenchmarkCallerZap-4          	 3661080	      3280 ns/op	     440 B/op	       4 allocs/op

BenchmarkDisableZeroLog-4     	788723734	        14.7 ns/op	       0 B/op	       0 allocs/op
BenchmarkNormalZeroLog-4      	15282351	       768 ns/op	       0 B/op	       0 allocs/op
BenchmarkInterfaceZeroLog-4   	10396608	      1163 ns/op	      48 B/op	       1 allocs/op
BenchmarkPrintfZeroLog-4      	 8954383	      1360 ns/op	      96 B/op	       2 allocs/op
BenchmarkCallerZeroLog-4      	 3586092	      3563 ns/op	     264 B/op	       3 allocs/op

BenchmarkDisablePhusLog-4     	932239788	        13.1 ns/op	       0 B/op	       0 allocs/op
BenchmarkNormalPhusLog-4      	25032302	       449 ns/op	       0 B/op	       0 allocs/op
BenchmarkInterfacePhusLog-4   	14000850	       837 ns/op	       0 B/op	       0 allocs/op
BenchmarkPrintfPhusLog-4      	13794639	       851 ns/op	      16 B/op	       1 allocs/op
BenchmarkCallerPhusLog-4      	 8207911	      1434 ns/op	     216 B/op	       2 allocs/op

This library uses the following special techniques to achieve better performance,

  1. handwriting time formatting
  2. manual inlining
  3. unrolled functions

A Real World Example

The example starts a geoip http server which supports change log level dynamically

package main

import (
	"encoding/json"
	"fmt"
	"net"
	"net/http"
	"os"

	"github.com/phuslu/iploc"
	"github.com/phuslu/log"
)

type Config struct {
	Listen struct {
		Tcp string
	}
	Log struct {
		Level   string
		Maxsize int64
		Backups int
	}
}

type Handler struct {
	Config       *Config
	AccessLogger log.Logger
}

func (h *Handler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
	reqID := log.NewXID()
	remoteIP, _, _ := net.SplitHostPort(req.RemoteAddr)
	geo := iploc.Country(net.ParseIP(remoteIP))

	h.AccessLogger.Log().
		Xid("req_id", reqID).
		Str("host", req.Host).
		Bytes("geo", geo).
		Str("remote_ip", remoteIP).
		Str("request_uri", req.RequestURI).
		Str("user_agent", req.UserAgent()).
		Str("referer", req.Referer()).
		Msg("access log")

	switch req.RequestURI {
	case "/debug", "/info", "/warn", "/error":
		log.DefaultLogger.SetLevel(log.ParseLevel(req.RequestURI[1:]))
	default:
		fmt.Fprintf(rw, `{"req_id":"%s","ip":"%s","geo":"%s"}`, reqID, remoteIP, geo)
	}
}

func main() {
	config := new(Config)
	err := json.Unmarshal([]byte(`{
		"listen": {
			"tcp": ":8080"
		},
		"log": {
			"level": "debug",
			"maxsize": 1073741824,
			"backups": 5
		}
	}`), config)
	if err != nil {
		log.Fatal().Msgf("json.Unmarshal error: %+v", err)
	}

	handler := &Handler{
		Config: config,
		AccessLogger: log.Logger{
			Writer: &log.FileWriter{
				Filename:   "access.log",
				MaxSize:    config.Log.Maxsize,
				MaxBackups: config.Log.Backups,
				LocalTime:  true,
			},
		},
	}

	if log.IsTerminal(os.Stderr.Fd()) {
		log.DefaultLogger = log.Logger{
			Level:      log.ParseLevel(config.Log.Level),
			Caller:     1,
			TimeFormat: "15:04:05",
			Writer: &log.ConsoleWriter{
				ColorOutput:    true,
				EndWithMessage: true,
			},
		}
		handler.AccessLogger = log.DefaultLogger
	} else {
		log.DefaultLogger = log.Logger{
			Level: log.ParseLevel(config.Log.Level),
			Writer: &log.FileWriter{
				Filename:   "main.log",
				MaxSize:    config.Log.Maxsize,
				MaxBackups: config.Log.Backups,
				LocalTime:  true,
			},
		}
	}

	server := &http.Server{
		Addr:     config.Listen.Tcp,
		ErrorLog: log.DefaultLogger.Std(log.ErrorLevel, nil, "", 0),
		Handler:  handler,
	}

	log.Fatal().Err(server.ListenAndServe()).Msg("listen failed")
}
Acknowledgment

This log is heavily inspired by zerolog, glog, gjson and lumberjack.

Expand ▾ Collapse ▴

Documentation

Index

Constants

View Source
const ErrInvalidXID = xidError("xid: invalid XID")

    ErrInvalidXID is returned when trying to parse an invalid XID

    View Source
    const TimeFormatUnix = "\x01"

      TimeFormatUnix defines a time format that makes time fields to be serialized as Unix timestamp integers.

      View Source
      const TimeFormatUnixMs = "\x02"

        TimeFormatUnixMs defines a time format that makes time fields to be serialized as Unix timestamp integers in milliseconds.

        Variables

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

          DefaultLogger is the global logger.

          Functions

          func Fastrandn

          func Fastrandn(x uint32) uint32

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

            func Goid

            func Goid() int64

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

              func IsTerminal

              func IsTerminal(fd uintptr) bool

                IsTerminal returns whether the given file descriptor is a terminal.

                func Printf

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

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

                  Types

                  type AsyncWriter

                  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

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

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

                      func (*AsyncWriter) WriteEntry

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

                        WriteEntry implements Writer.

                        type ConsoleWriter

                        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 a colorized, human-friendly format to Writer. IMPORTANT: Don't use ConsoleWriter on critical path of a high concurrency and low latency application.

                          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

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

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

                            func (*ConsoleWriter) WriteEntry

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

                              WriteEntry implements Writer.

                              type Context

                              type Context []byte

                                Context represents contextual fields.

                                type Entry

                                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

                                  func Debug() (e *Entry)

                                    Debug starts a new message with debug level.

                                    func Error

                                    func Error() (e *Entry)

                                      Error starts a new message with error level.

                                      func Fatal

                                      func Fatal() (e *Entry)

                                        Fatal starts a new message with fatal level.

                                        func Info

                                        func Info() (e *Entry)

                                          Info starts a new message with info level.

                                          func NewContext

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

                                            NewContext starts a new contextual entry.

                                            func Panic

                                            func Panic() (e *Entry)

                                              Panic starts a new message with panic level.

                                              func Trace

                                              func Trace() (e *Entry)

                                                Trace starts a new message with trace level.

                                                func Warn

                                                func Warn() (e *Entry)

                                                  Warn starts a new message with warning level.

                                                  func (*Entry) AnErr

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

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

                                                    func (*Entry) Bool

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

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

                                                      func (*Entry) Bools

                                                      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

                                                        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

                                                          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

                                                            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

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

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

                                                                func (*Entry) Context

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

                                                                  Context sends the contextual fields to entry.

                                                                  func (*Entry) Dict

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

                                                                    Dict sends the contextual fields with key to entry.

                                                                    func (*Entry) Discard

                                                                    func (e *Entry) Discard() *Entry

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

                                                                      func (*Entry) Dur

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

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

                                                                        func (*Entry) Durs

                                                                        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) EmbedObject

                                                                          func (e *Entry) EmbedObject(obj ObjectMarshaler) *Entry

                                                                            EmbedObject marshals and Embeds an object that implement the ObjectMarshaler interface.

                                                                            func (*Entry) Enabled

                                                                            func (e *Entry) Enabled() bool

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

                                                                              func (*Entry) Err

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

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

                                                                                func (*Entry) Errs

                                                                                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

                                                                                  func (e *Entry) Fields(fields Fields) *Entry

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

                                                                                    func (*Entry) Float32

                                                                                    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

                                                                                      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

                                                                                        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

                                                                                          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

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

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

                                                                                              func (*Entry) Hex

                                                                                              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

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

                                                                                                  IPAddr adds IPv4 or IPv6 Address to the entry.

                                                                                                  func (*Entry) IPPrefix

                                                                                                  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

                                                                                                    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

                                                                                                      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

                                                                                                        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

                                                                                                          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

                                                                                                            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

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

                                                                                                                Interface adds the field key with i marshaled using reflection.

                                                                                                                func (*Entry) Ints

                                                                                                                func (e *Entry) Ints(key string, a []int) *Entry

                                                                                                                  Ints adds the field key with i as a []int to the entry.

                                                                                                                  func (*Entry) Ints16

                                                                                                                  func (e *Entry) Ints16(key string, a []int16) *Entry

                                                                                                                    Ints16 adds the field key with i as a []int16 to the entry.

                                                                                                                    func (*Entry) Ints32

                                                                                                                    func (e *Entry) Ints32(key string, a []int32) *Entry

                                                                                                                      Ints32 adds the field key with i as a []int32 to the entry.

                                                                                                                      func (*Entry) Ints64

                                                                                                                      func (e *Entry) Ints64(key string, a []int64) *Entry

                                                                                                                        Ints64 adds the field key with i as a []int64 to the entry.

                                                                                                                        func (*Entry) Ints8

                                                                                                                        func (e *Entry) Ints8(key string, a []int8) *Entry

                                                                                                                          Ints8 adds the field key with i as a []int8 to the entry.

                                                                                                                          func (*Entry) KeysAndValues

                                                                                                                          func (e *Entry) KeysAndValues(keysAndValues ...interface{}) *Entry

                                                                                                                            KeysAndValues sends keysAndValues to Entry

                                                                                                                            func (*Entry) MACAddr

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

                                                                                                                              MACAddr adds MAC address to the entry.

                                                                                                                              func (*Entry) Msg

                                                                                                                              func (e *Entry) Msg(msg string)

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

                                                                                                                                func (*Entry) Msgf

                                                                                                                                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) Msgs

                                                                                                                                  func (e *Entry) Msgs(args ...interface{})

                                                                                                                                    Msgs sends the entry with msgs added as the message field if not empty.

                                                                                                                                    func (*Entry) Object

                                                                                                                                    func (e *Entry) Object(key string, obj ObjectMarshaler) *Entry

                                                                                                                                      Object marshals an object that implement the ObjectMarshaler interface.

                                                                                                                                      func (*Entry) RawJSON

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

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

                                                                                                                                        func (*Entry) RawJSONStr

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

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

                                                                                                                                          func (*Entry) Stack

                                                                                                                                          func (e *Entry) Stack() *Entry

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

                                                                                                                                            func (*Entry) Str

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

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

                                                                                                                                              func (*Entry) StrInt

                                                                                                                                              func (e *Entry) StrInt(key string, val int64) *Entry

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

                                                                                                                                                func (*Entry) Stringer

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

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

                                                                                                                                                  func (*Entry) Strs

                                                                                                                                                  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

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

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

                                                                                                                                                      func (*Entry) TimeDiff

                                                                                                                                                      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

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

                                                                                                                                                          TimeFormat append append t formated as string using timefmt.

                                                                                                                                                          func (*Entry) Times

                                                                                                                                                          func (e *Entry) Times(key string, a []time.Time) *Entry

                                                                                                                                                            Times append append a formated as string array using time.RFC3339Nano.

                                                                                                                                                            func (*Entry) TimesFormat

                                                                                                                                                            func (e *Entry) TimesFormat(key string, timefmt string, a []time.Time) *Entry

                                                                                                                                                              TimesFormat append append a formated as string array using timefmt.

                                                                                                                                                              func (*Entry) Uint

                                                                                                                                                              func (e *Entry) Uint(key string, i uint) *Entry

                                                                                                                                                                Uint adds the field key with i as a uint to the entry.

                                                                                                                                                                func (*Entry) Uint16

                                                                                                                                                                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

                                                                                                                                                                  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

                                                                                                                                                                    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

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

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

                                                                                                                                                                        func (*Entry) Uints

                                                                                                                                                                        func (e *Entry) Uints(key string, a []uint) *Entry

                                                                                                                                                                          Uints adds the field key with i as a []uint to the entry.

                                                                                                                                                                          func (*Entry) Uints16

                                                                                                                                                                          func (e *Entry) Uints16(key string, a []uint16) *Entry

                                                                                                                                                                            Uints16 adds the field key with i as a []uint16 to the entry.

                                                                                                                                                                            func (*Entry) Uints32

                                                                                                                                                                            func (e *Entry) Uints32(key string, a []uint32) *Entry

                                                                                                                                                                              Uints32 adds the field key with i as a []uint32 to the entry.

                                                                                                                                                                              func (*Entry) Uints64

                                                                                                                                                                              func (e *Entry) Uints64(key string, a []uint64) *Entry

                                                                                                                                                                                Uints64 adds the field key with i as a []uint64 to the entry.

                                                                                                                                                                                func (*Entry) Uints8

                                                                                                                                                                                func (e *Entry) Uints8(key string, a []uint8) *Entry

                                                                                                                                                                                  Uints8 adds the field key with i as a []uint8 to the entry.

                                                                                                                                                                                  func (*Entry) Value

                                                                                                                                                                                  func (e *Entry) Value() Context

                                                                                                                                                                                    Value builds the contextual fields.

                                                                                                                                                                                    func (*Entry) Xid

                                                                                                                                                                                    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 Fields

                                                                                                                                                                                      type Fields map[string]interface{}

                                                                                                                                                                                        Fields type, used to pass to `Fields`.

                                                                                                                                                                                        type FileWriter

                                                                                                                                                                                        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
                                                                                                                                                                                        
                                                                                                                                                                                        	// TimeFormat specifies the time format of filename, uses `2006-01-02T15-04-05` as default format.
                                                                                                                                                                                        	// If set with `TimeFormatUnix`, `TimeFormatUnixMs`, times are formated as UNIX timestamp.
                                                                                                                                                                                        	TimeFormat string
                                                                                                                                                                                        
                                                                                                                                                                                        	// 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
                                                                                                                                                                                        
                                                                                                                                                                                        	// EnsureFolder ensures the file directory creation before writing.
                                                                                                                                                                                        	EnsureFolder bool
                                                                                                                                                                                        
                                                                                                                                                                                        	// Cleaner specifies an optional cleanup function of log backups after rotation,
                                                                                                                                                                                        	// if not set, the default behavior is to delete more than MaxBackups log files.
                                                                                                                                                                                        	Cleaner func(filename string, maxBackups int, matches []os.FileInfo)
                                                                                                                                                                                        	// 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 filesystem modified time 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

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

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

                                                                                                                                                                                          func (*FileWriter) Rotate

                                                                                                                                                                                          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

                                                                                                                                                                                            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, rotate to include a timestamp of the current time, and update symlink with log name file to the new file.

                                                                                                                                                                                              func (*FileWriter) WriteEntry

                                                                                                                                                                                              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, rotate to include a timestamp of the current time, and update symlink with log name file to the new file.

                                                                                                                                                                                                type FormatterArgs

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

                                                                                                                                                                                                  FormatterArgs is a parsed sturct from json input

                                                                                                                                                                                                  func (*FormatterArgs) Get

                                                                                                                                                                                                  func (args *FormatterArgs) Get(key string) (value string)

                                                                                                                                                                                                    Get gets the value associated with the given key.

                                                                                                                                                                                                    type GrpcLogger

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

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

                                                                                                                                                                                                      func (*GrpcLogger) Error

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

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

                                                                                                                                                                                                        func (*GrpcLogger) Errorf

                                                                                                                                                                                                        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

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

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

                                                                                                                                                                                                            func (*GrpcLogger) Fatal

                                                                                                                                                                                                            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

                                                                                                                                                                                                              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

                                                                                                                                                                                                                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

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

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

                                                                                                                                                                                                                    func (*GrpcLogger) Infof

                                                                                                                                                                                                                    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

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

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

                                                                                                                                                                                                                        func (*GrpcLogger) V

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

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

                                                                                                                                                                                                                          func (*GrpcLogger) Warning

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

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

                                                                                                                                                                                                                            func (*GrpcLogger) Warningf

                                                                                                                                                                                                                            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

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

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

                                                                                                                                                                                                                                type IOWriter

                                                                                                                                                                                                                                type IOWriter struct {
                                                                                                                                                                                                                                	io.Writer
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  IOWriter wraps an io.Writer to Writer.

                                                                                                                                                                                                                                  func (IOWriter) WriteEntry

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

                                                                                                                                                                                                                                    WriteEntry implements Writer.

                                                                                                                                                                                                                                    type JournalWriter

                                                                                                                                                                                                                                    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

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

                                                                                                                                                                                                                                        Close implements io.Closer.

                                                                                                                                                                                                                                        func (*JournalWriter) WriteEntry

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

                                                                                                                                                                                                                                          WriteEntry implements Writer.

                                                                                                                                                                                                                                          type Level

                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                            func ParseLevel(s string) (level Level)

                                                                                                                                                                                                                                              ParseLevel converts a level string into a log Level value.

                                                                                                                                                                                                                                              func (Level) String

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

                                                                                                                                                                                                                                                String return lowe case string of Level

                                                                                                                                                                                                                                                type Logger

                                                                                                                                                                                                                                                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

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

                                                                                                                                                                                                                                                    Debug starts a new message with debug level.

                                                                                                                                                                                                                                                    func (*Logger) Err

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

                                                                                                                                                                                                                                                      Err starts a new message with error level with err as a field if not nil or with info level if err is nil.

                                                                                                                                                                                                                                                      func (*Logger) Error

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

                                                                                                                                                                                                                                                        Error starts a new message with error level.

                                                                                                                                                                                                                                                        func (*Logger) Fatal

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

                                                                                                                                                                                                                                                          Fatal starts a new message with fatal level.

                                                                                                                                                                                                                                                          func (*Logger) Grpc

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

                                                                                                                                                                                                                                                            Grpc wraps the Logger to provide a LoggerV2 logger

                                                                                                                                                                                                                                                            func (*Logger) Info

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

                                                                                                                                                                                                                                                              Info starts a new message with info level.

                                                                                                                                                                                                                                                              func (*Logger) Log

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

                                                                                                                                                                                                                                                                Log starts a new message with no level.

                                                                                                                                                                                                                                                                func (*Logger) Logr

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

                                                                                                                                                                                                                                                                  Logr wraps the Logger to provide a logr logger

                                                                                                                                                                                                                                                                  func (*Logger) Panic

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

                                                                                                                                                                                                                                                                    Panic starts a new message with panic level.

                                                                                                                                                                                                                                                                    func (*Logger) Printf

                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                      func (l *Logger) SetLevel(level Level)

                                                                                                                                                                                                                                                                        SetLevel changes logger default level.

                                                                                                                                                                                                                                                                        func (*Logger) Std

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

                                                                                                                                                                                                                                                                          Std wraps the Logger to provide *stdLog.Logger

                                                                                                                                                                                                                                                                          func (*Logger) Trace

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

                                                                                                                                                                                                                                                                            Trace starts a new message with trace level.

                                                                                                                                                                                                                                                                            func (*Logger) Warn

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

                                                                                                                                                                                                                                                                              Warn starts a new message with warning level.

                                                                                                                                                                                                                                                                              func (*Logger) WithLevel

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

                                                                                                                                                                                                                                                                                WithLevel starts a new message with level.

                                                                                                                                                                                                                                                                                type LogrLogger

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

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

                                                                                                                                                                                                                                                                                  func (*LogrLogger) Enabled

                                                                                                                                                                                                                                                                                  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

                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                      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

                                                                                                                                                                                                                                                                                        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

                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                              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

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

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

                                                                                                                                                                                                                                                                                                  func (*MultiWriter) WriteEntry

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

                                                                                                                                                                                                                                                                                                    WriteEntry implements entryWriter.

                                                                                                                                                                                                                                                                                                    type ObjectMarshaler

                                                                                                                                                                                                                                                                                                    type ObjectMarshaler interface {
                                                                                                                                                                                                                                                                                                    	MarshalObject(e *Entry)
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      ObjectMarshaler provides a strongly-typed and encoding-agnostic interface to be implemented by types used with Entry's Object methods.

                                                                                                                                                                                                                                                                                                      type SyslogWriter

                                                                                                                                                                                                                                                                                                      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

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

                                                                                                                                                                                                                                                                                                          Close closes a connection to the syslog server.

                                                                                                                                                                                                                                                                                                          func (*SyslogWriter) WriteEntry

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

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

                                                                                                                                                                                                                                                                                                            type TSVEntry

                                                                                                                                                                                                                                                                                                            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

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

                                                                                                                                                                                                                                                                                                                Bool append the b as a bool to the entry.

                                                                                                                                                                                                                                                                                                                func (*TSVEntry) Byte

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

                                                                                                                                                                                                                                                                                                                  Byte append the b as a byte to the entry.

                                                                                                                                                                                                                                                                                                                  func (*TSVEntry) Bytes

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

                                                                                                                                                                                                                                                                                                                    Bytes adds a bytes as string to the entry.

                                                                                                                                                                                                                                                                                                                    func (*TSVEntry) Caller

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

                                                                                                                                                                                                                                                                                                                      Caller adds the file:line of to the entry.

                                                                                                                                                                                                                                                                                                                      func (*TSVEntry) Float32

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

                                                                                                                                                                                                                                                                                                                        Float32 adds a float32 to the entry.

                                                                                                                                                                                                                                                                                                                        func (*TSVEntry) Float64

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

                                                                                                                                                                                                                                                                                                                          Float64 adds a float64 to the entry.

                                                                                                                                                                                                                                                                                                                          func (*TSVEntry) IPAddr

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

                                                                                                                                                                                                                                                                                                                            IPAddr adds IPv4 or IPv6 Address to the entry.

                                                                                                                                                                                                                                                                                                                            func (*TSVEntry) Int

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

                                                                                                                                                                                                                                                                                                                              Int adds a int to the entry.

                                                                                                                                                                                                                                                                                                                              func (*TSVEntry) Int16

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

                                                                                                                                                                                                                                                                                                                                Int16 adds a int16 to the entry.

                                                                                                                                                                                                                                                                                                                                func (*TSVEntry) Int32

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

                                                                                                                                                                                                                                                                                                                                  Int32 adds a int32 to the entry.

                                                                                                                                                                                                                                                                                                                                  func (*TSVEntry) Int64

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

                                                                                                                                                                                                                                                                                                                                    Int64 adds a int64 to the entry.

                                                                                                                                                                                                                                                                                                                                    func (*TSVEntry) Int8

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

                                                                                                                                                                                                                                                                                                                                      Int8 adds a int8 to the entry.

                                                                                                                                                                                                                                                                                                                                      func (*TSVEntry) Msg

                                                                                                                                                                                                                                                                                                                                      func (e *TSVEntry) Msg()

                                                                                                                                                                                                                                                                                                                                        Msg sends the entry.

                                                                                                                                                                                                                                                                                                                                        func (*TSVEntry) Str

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

                                                                                                                                                                                                                                                                                                                                          Str adds a string to the entry.

                                                                                                                                                                                                                                                                                                                                          func (*TSVEntry) Timestamp

                                                                                                                                                                                                                                                                                                                                          func (e *TSVEntry) Timestamp() *TSVEntry

                                                                                                                                                                                                                                                                                                                                            Timestamp adds the current time as UNIX timestamp

                                                                                                                                                                                                                                                                                                                                            func (*TSVEntry) TimestampMS

                                                                                                                                                                                                                                                                                                                                            func (e *TSVEntry) TimestampMS() *TSVEntry

                                                                                                                                                                                                                                                                                                                                              TimestampMS adds the current time with milliseconds as UNIX timestamp

                                                                                                                                                                                                                                                                                                                                              func (*TSVEntry) Uint

                                                                                                                                                                                                                                                                                                                                              func (e *TSVEntry) Uint(i uint) *TSVEntry

                                                                                                                                                                                                                                                                                                                                                Uint adds a uint to the entry.

                                                                                                                                                                                                                                                                                                                                                func (*TSVEntry) Uint16

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

                                                                                                                                                                                                                                                                                                                                                  Uint16 adds a uint16 to the entry.

                                                                                                                                                                                                                                                                                                                                                  func (*TSVEntry) Uint32

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

                                                                                                                                                                                                                                                                                                                                                    Uint32 adds a uint32 to the entry.

                                                                                                                                                                                                                                                                                                                                                    func (*TSVEntry) Uint64

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

                                                                                                                                                                                                                                                                                                                                                      Uint64 adds a uint64 to the entry.

                                                                                                                                                                                                                                                                                                                                                      func (*TSVEntry) Uint8

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

                                                                                                                                                                                                                                                                                                                                                        Uint8 adds a uint8 to the entry.

                                                                                                                                                                                                                                                                                                                                                        type TSVLogger

                                                                                                                                                                                                                                                                                                                                                        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

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

                                                                                                                                                                                                                                                                                                                                                            New starts a new tsv message.

                                                                                                                                                                                                                                                                                                                                                            type Writer

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

                                                                                                                                                                                                                                                                                                                                                              Writer defines an entry writer interface.

                                                                                                                                                                                                                                                                                                                                                              type XID

                                                                                                                                                                                                                                                                                                                                                              type XID [12]byte

                                                                                                                                                                                                                                                                                                                                                                XID represents a unique request id

                                                                                                                                                                                                                                                                                                                                                                func NewXID

                                                                                                                                                                                                                                                                                                                                                                func NewXID() XID

                                                                                                                                                                                                                                                                                                                                                                  NewXID generates a globally unique XID

                                                                                                                                                                                                                                                                                                                                                                  func NewXIDWithTime

                                                                                                                                                                                                                                                                                                                                                                  func NewXIDWithTime(timestamp int64) (x XID)

                                                                                                                                                                                                                                                                                                                                                                    NewXIDWithTime generates a globally unique XID with unix timestamp

                                                                                                                                                                                                                                                                                                                                                                    func ParseXID

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

                                                                                                                                                                                                                                                                                                                                                                      ParseXID parses an XID from its string representation

                                                                                                                                                                                                                                                                                                                                                                      func (XID) Counter

                                                                                                                                                                                                                                                                                                                                                                      func (x XID) Counter() uint32

                                                                                                                                                                                                                                                                                                                                                                        Counter returns the incrementing value part of the id.

                                                                                                                                                                                                                                                                                                                                                                        func (XID) Machine

                                                                                                                                                                                                                                                                                                                                                                        func (x XID) Machine() []byte

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

                                                                                                                                                                                                                                                                                                                                                                          func (XID) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                            MarshalJSON implements encoding/json Marshaler interface

                                                                                                                                                                                                                                                                                                                                                                            func (XID) MarshalText

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

                                                                                                                                                                                                                                                                                                                                                                              MarshalText implements encoding/text TextMarshaler interface

                                                                                                                                                                                                                                                                                                                                                                              func (XID) Pid

                                                                                                                                                                                                                                                                                                                                                                              func (x XID) Pid() uint16

                                                                                                                                                                                                                                                                                                                                                                                Pid returns the process id part of the id.

                                                                                                                                                                                                                                                                                                                                                                                func (XID) String

                                                                                                                                                                                                                                                                                                                                                                                func (x XID) String() string

                                                                                                                                                                                                                                                                                                                                                                                  String returns a base32 hex lowercased representation of the id.

                                                                                                                                                                                                                                                                                                                                                                                  func (XID) Time

                                                                                                                                                                                                                                                                                                                                                                                  func (x XID) Time() time.Time

                                                                                                                                                                                                                                                                                                                                                                                    Time returns the timestamp part of the id.

                                                                                                                                                                                                                                                                                                                                                                                    func (*XID) UnmarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                                      UnmarshalJSON implements encoding/json Unmarshaler interface

                                                                                                                                                                                                                                                                                                                                                                                      func (*XID) UnmarshalText

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

                                                                                                                                                                                                                                                                                                                                                                                        UnmarshalText implements encoding/text TextUnmarshaler interface