log

README

Log

Simple logger for Go.

Features

• Pretty console handler for terminals
• Adds a level filter handler
• json and logfmt handlers
• Adds a multi-logger

Install

go get github.com/livebud/log

Example

log := log.Multi(
  log.Filter(log.LevelInfo, log.Console(color.Ignore(), os.Stderr)),
  log.Json(os.Stderr),
)
log.Debug("world", "args", 10)
log.Info("hello", "planet", "world", "args", 10)
log.Warn("hello", "planet", "world", "args", 10)
log.Error("hello world", "planet", "world", "args", 10)

Contributors

• Matt Mueller (@mattmueller)

License

MIT

Documentation

Overview

Package log is inspired by apex/log.

Index

• Variables
• type Buffered
  • func Buffer() *Buffered
  • func (b *Buffered) Debug(args ...interface{}) error
  • func (b *Buffered) Debugf(msg string, args ...interface{}) error
  • func (b *Buffered) Error(args ...interface{}) error
  • func (b *Buffered) Errorf(msg string, args ...interface{}) error
  • func (b *Buffered) Field(key string, value interface{}) Log
  • func (b *Buffered) Fields(fields map[string]interface{}) Log
  • func (b *Buffered) Info(args ...interface{}) error
  • func (b *Buffered) Infof(msg string, args ...interface{}) error
  • func (h *Buffered) Log(entry *Entry) error
  • func (b *Buffered) Notice(args ...interface{}) error
  • func (b *Buffered) Noticef(msg string, args ...interface{}) error
  • func (b *Buffered) Warn(args ...interface{}) error
  • func (b *Buffered) Warnf(msg string, args ...interface{}) error
• type Entry
  • func (e *Entry) MarshalJSON() ([]byte, error)
• type Fields
  • func (f Fields) Get(key string) interface{}
  • func (f Fields) Keys() []string
• type Handler
  • func Console(color color.Writer, writer io.Writer) Handler
  • func Filter(level Level, handler Handler) Handler
  • func Json(w io.Writer) Handler
• type Level
  • func ParseLevel(level string) (Level, error)
  • func (level Level) String() string
• type Log
  • func Debugger() Log
  • func Default() Log
  • func Discard() Log
  • func Multi(handlers ...Handler) Log
  • func Parse(filter string) (Log, error)
• type Logger
  • func New(handler Handler) *Logger
  • func (l *Logger) Debug(args ...interface{}) error
  • func (l *Logger) Debugf(msg string, args ...interface{}) error
  • func (l *Logger) Error(args ...interface{}) error
  • func (l *Logger) Errorf(msg string, args ...interface{}) error
  • func (l *Logger) Field(key string, value interface{}) Log
  • func (l *Logger) Fields(fields map[string]interface{}) Log
  • func (l *Logger) Info(args ...interface{}) error
  • func (l *Logger) Infof(msg string, args ...interface{}) error
  • func (l *Logger) Notice(args ...interface{}) error
  • func (l *Logger) Noticef(msg string, args ...interface{}) error
  • func (l *Logger) Warn(args ...interface{}) error
  • func (l *Logger) Warnf(msg string, args ...interface{}) error

Examples

• Console
• Multi

Variables

var (
	// Debug message is written to the console
	Debug = stderr.Debug
	// Debugf message is written to the console
	Debugf = stderr.Debugf
	// Info message is written to the console
	Info = stderr.Info
	// Infof message is written to the console
	Infof = stderr.Infof
	// Notice message is written to the console
	Notice = stderr.Notice
	// Noticef message is written to the console
	Noticef = stderr.Noticef
	// Warn message is written to the console
	Warn = stderr.Warn
	// Warnf message is written to the console
	Warnf = stderr.Warnf
	// Error message is written to the console
	Error = stderr.Error
	// Errorf message is written to the console
	Errorf = stderr.Errorf
)

var Now = time.Now

Now returns the current time.

Types

type Buffered

type Buffered struct {
	Entries []*Entry
	// contains filtered or unexported fields
}

func Buffer

func Buffer() *Buffered

func (*Buffered) Debug

func (b *Buffered) Debug(args ...interface{}) error

func (*Buffered) Debugf

func (b *Buffered) Debugf(msg string, args ...interface{}) error

func (*Buffered) Error

func (b *Buffered) Error(args ...interface{}) error

func (*Buffered) Errorf

func (b *Buffered) Errorf(msg string, args ...interface{}) error

func (*Buffered) Field

func (b *Buffered) Field(key string, value interface{}) Log

func (*Buffered) Fields

func (b *Buffered) Fields(fields map[string]interface{}) Log

func (*Buffered) Info

func (b *Buffered) Info(args ...interface{}) error

func (*Buffered) Infof

func (b *Buffered) Infof(msg string, args ...interface{}) error

func (*Buffered) Log

func (h *Buffered) Log(entry *Entry) error

func (*Buffered) Notice

func (b *Buffered) Notice(args ...interface{}) error

func (*Buffered) Noticef

func (b *Buffered) Noticef(msg string, args ...interface{}) error

func (*Buffered) Warn

func (b *Buffered) Warn(args ...interface{}) error

func (*Buffered) Warnf

func (b *Buffered) Warnf(msg string, args ...interface{}) error

type Entry

type Entry struct {
	Time    time.Time `json:"ts,omitempty"`
	Level   Level     `json:"lvl,omitempty"`
	Message string    `json:"msg,omitempty"`
	Fields  Fields    `json:"fields,omitempty"`
}

func (*Entry) MarshalJSON

func (e *Entry) MarshalJSON() ([]byte, error)

type Fields

type Fields map[string]interface{}

func (Fields) Get

func (f Fields) Get(key string) interface{}

func (Fields) Keys

func (f Fields) Keys() []string

type Handler

type Handler interface {
	Log(log *Entry) error
}

func Console

func Console(color color.Writer, writer io.Writer) Handler

Console handler

Example

package main

import (
	"os"

	"github.com/livebud/color"
	"github.com/livebud/log"
)

func main() {
	log := log.New(log.Console(color.Ignore(), os.Stdout))
	log.Debug("world", "args", 10)
	log.Info("hello", "planet", "world", "args", 10)
	log.Warn("hello", "planet", "world", "args", 10)
	// log.Error("hello world", slog.String("planet", "world"), "args", 10)
	

func Filter

func Filter(level Level, handler Handler) Handler

Filter logs by level

func Json

func Json(w io.Writer) Handler

type Level

type Level uint8

Level of the logger

const (
	LevelDebug Level = iota + 1
	LevelInfo
	LevelNotice
	LevelWarn
	LevelError
)

Log level

func ParseLevel

func ParseLevel(level string) (Level, error)

func (Level) String

func (level Level) String() string

type Log

type Log interface {
	Field(key string, value interface{}) Log
	Fields(fields map[string]interface{}) Log
	Debug(args ...interface{}) error
	Debugf(msg string, args ...interface{}) error
	Info(args ...interface{}) error
	Infof(msg string, args ...interface{}) error
	Notice(args ...interface{}) error
	Noticef(msg string, args ...interface{}) error
	Warn(args ...interface{}) error
	Warnf(msg string, args ...interface{}) error
	Error(args ...interface{}) error
	Errorf(msg string, args ...interface{}) error
}

func Debugger

func Debugger() Log

Debugger log

func Default

func Default() Log

Default log

func Discard

func Discard() Log

Discard logger is a logger that discards all messages.

func Multi

func Multi(handlers ...Handler) Log

Multi logs to multiple places

Example

package main

import (
	"os"

	"github.com/livebud/color"
	"github.com/livebud/log"
)

func main() {
	log := log.Multi(
		log.Filter(log.LevelDebug, log.Console(color.Default(), os.Stderr)),
		log.Json(os.Stderr),
	)
	log.Debug("world", "args", 10)
	log.Field("planet", "world").Field("args", 10).Info("hello")
	log.Warnf("hello %s", "world")
	log.Error("hello world", "planet", "world", "args", 10)
}

func Parse

func Parse(filter string) (Log, error)

Parse the logger with a given filter

type Logger

type Logger struct {
	Handler Handler
}

func New

func New(handler Handler) *Logger

New logger

func (*Logger) Debug

func (l *Logger) Debug(args ...interface{}) error

func (*Logger) Debugf

func (l *Logger) Debugf(msg string, args ...interface{}) error

func (*Logger) Error

func (l *Logger) Error(args ...interface{}) error

func (*Logger) Errorf

func (l *Logger) Errorf(msg string, args ...interface{}) error

func (*Logger) Field

func (l *Logger) Field(key string, value interface{}) Log

func (*Logger) Fields

func (l *Logger) Fields(fields map[string]interface{}) Log

func (*Logger) Info

func (l *Logger) Info(args ...interface{}) error

func (*Logger) Infof

func (l *Logger) Infof(msg string, args ...interface{}) error

func (*Logger) Notice

func (l *Logger) Notice(args ...interface{}) error

func (*Logger) Noticef

func (l *Logger) Noticef(msg string, args ...interface{}) error

func (*Logger) Warn

func (l *Logger) Warn(args ...interface{}) error

func (*Logger) Warnf

func (l *Logger) Warnf(msg string, args ...interface{}) error