log

log

Log is a simple, highly configurable, Structured Logging library

Why another logging library?

There's a lot of great stuff out there, but this library contains a number of unique features noted below using *.

Features

• Logger is simple, only logic to create the log entry and send it off to the handlers, they take it from there.
• Handlers are simple to write + easy to register + easy to remove
• *Ability to specify which log levels get sent to each handler
• *Handlers & Log Levels are configurable at runtime.
• *WithError automatically extracts and adds file, line and package in error output.
• *Convenient context helpers GetContext & SetContext
• *Works with go-playground/errors extracting wrapped errors, types and tags when used with the WithError interface. This is the default but configurable to support more or other error libraries using SetWithErrorFn.
• *Default logger for quick prototyping and cli applications. It is automatically removed when you register one of your own.

Installation

Use go get

go get github.com/go-playground/log/v8@latest

Usage

import the log package.

package main

import (
	"io"

	"github.com/go-playground/errors/v5"
	"github.com/go-playground/log/v8"
)

func main() {
	// Trace
	defer log.WithTrace().Info("time to run")

	log.Debug("debug")
	log.Info("info")
	log.Notice("notice")
	log.Warn("warn")
	log.Error("error")
	// log.Panic("panic") // this will panic
	log.Alert("alert")
	// log.Fatal("fatal") // this will call os.Exit(1)

	err := errors.New("this is the inner error").AddTags(errors.T("inner", "tag"))
	err = errors.Wrap(err, "this is the wrapping error").AddTags(errors.T("outer", "tag"))

	// logging with fields can be used with any of the above
	log.WithError(err).WithFields(log.F("key", "value")).Info("test info")

	// log unwrapped error
	log.WithError(io.EOF).Error("unwrapped error")

	// predefined global fields
	log.WithDefaultFields(log.Fields{
		{"program", "test"},
		{"version", "0.1.3"},
	}...)

	log.WithField("key", "value").Info("testing default fields")

	// or request scoped default fields
	logger := log.WithFields(
		log.F("request", "req"),
		log.F("scoped", "sco"),
	)

	logger.WithField("key", "value").Info("test")
}

Adding your own Handler

package main

import (
	"bytes"
	"fmt"

	"github.com/go-playground/log/v8"
)

// CustomHandler is your custom handler
type CustomHandler struct {
	// whatever properties you need
}

// Log accepts log entries to be processed
func (c *CustomHandler) Log(e log.Entry) {

	// below prints to os.Stderr but could marshal to JSON
	// and send to central logging server
	//																						       ---------
	// 				                                                                 |----------> | console |
	//                                                                               |             ---------
	// i.e. -----------------               -----------------     Unmarshal    -------------       --------
	//     | app log handler | -- json --> | central log app | --    to    -> | log handler | --> | syslog |
	//      -----------------               -----------------       Entry      -------------       --------
	//      																         |             ---------
	//                                  									         |----------> | DataDog |
	//          																	        	   ---------
	b := new(bytes.Buffer)
	b.Reset()
	b.WriteString(e.Message)

	for _, f := range e.Fields {
		_, _ = fmt.Fprintf(b, " %s=%v", f.Key, f.Value)
	}
	fmt.Println(b.String())
}

func main() {

	cLog := new(CustomHandler)
	log.AddHandler(cLog, log.AllLevels...)

	// Trace
	defer log.WithTrace().Info("took this long")

	log.Debug("debug")
	log.Info("info")
	log.Notice("notice")
	log.Warn("warn")
	log.Error("error")
	// log.Panic("panic") // this will panic
	log.Alert("alert")
	// log.Fatal("fatal") // this will call os.Exit(1)

	// logging with fields can be used with any of the above
	log.WithField("key", "value").Info("test info")
}

Log Level Definitions

Handlers

Pull requests for new handlers are welcome when they don't pull in dependencies, it is preferred to have a dedicated package in this case.

Handler	Description	Docs
json	Allows for log messages to be sent to any wrtier in json format.

Package Versioning

This package strictly adheres to semantic versioning guidelines.

Benchmarks

NOTE: only putting benchmarks at others request, by no means does the number of allocations make one log library better than another!

go test --bench=. -benchmem=true
goos: darwin
goarch: arm64
pkg: github.com/go-playground/log/v8/benchmarks
BenchmarkLogConsoleTenFieldsParallel-8           2392591               503.3 ns/op           648 B/op         12 allocs/op
BenchmarkLogConsoleSimpleParallel-8              4595101               269.9 ns/op            56 B/op          2 allocs/op