logging

README

go-log

A la pythonic logging.

Based on the standard log module.

Tested using github.com/stretchr/testify.

The Fatals were turned into panics in all the tests.

coverage: 100% of statements using

#!/bin/bash
profile=cover.out                                   # use this coverage profile
html=c.html                                         # make this HTML file
set -e                                              # stop on any error
rm -f "${profile}" "${html}"                        # clear files
go test -coverprofile "${profile}"                  # generate profile
sed -e 's,^_.*/\([^/]\+\)$,./\1,' -i "${profile}"   # make it usable
go tool cover -html="${profile}" -o "${html}"       # generate HTML
rm -f "${profile}"                                  # remove patched profile
ls -l "${html}"                                     # notify on completion
# EOF #

EOF

Documentation

Index

• Constants
• Variables
• func CanBeLogLevel(level int) bool
• func LogLevelName(level LogLevel) string
• func ValidLogLevel(level LogLevel) bool
• func ValidLogLevelName(level string) bool
• type LogLevel
  • func LogLevelByName(level string) LogLevel
  • func (level LogLevel) Color() aurora.Color
  • func (level LogLevel) Colored(s string, au aurora.Aurora) string
  • func (level LogLevel) Name() string
  • func (self LogLevel) String() string
• type Logger
  • func NewAutoColorLogger(level LogLevel) *Logger
  • func NewColorLogger(level LogLevel) *Logger
  • func NewLogger(level LogLevel) *Logger
  • func (self *Logger) Debug(message string, args ...interface{})
  • func (self *Logger) Error(message string, args ...interface{})
  • func (self *Logger) Fatal(message string, args ...interface{})
  • func (self *Logger) Flags() int
  • func (self *Logger) Info(message string, args ...interface{})
  • func (self *Logger) Log(level LogLevel, message string, args ...interface{})
  • func (self *Logger) Prefix() string
  • func (self *Logger) Say(message string, args ...interface{})
  • func (self *Logger) SetFlags(flags int) *Logger
  • func (self *Logger) SetLevel(level LogLevel)
  • func (self *Logger) SetOutput(writer io.Writer) *Logger
  • func (self *Logger) SetPrefix(prefix string) *Logger
  • func (self *Logger) UseColor(color aurora.Aurora)
  • func (self *Logger) UsePanic(use bool)
  • func (self *Logger) Warn(message string, args ...interface{})
  • func (self *Logger) Warning(message string, args ...interface{})

Constants

const (
	FATAL = LogLevel(0) + iota
	ERROR
	WARNING
	INFO
	DEBUG

	WARN     = WARNING
	CRITICAL = FATAL
	CRYTICAL = FATAL
	INVALID  = LogLevel(-1)
	NOTE     = LogLevel(-2)
)

Variables

var LogLevelColors = map[LogLevel]aurora.Color{
	FATAL:   aurora.WhiteFg | aurora.BrightFg | aurora.RedBg,
	ERROR:   aurora.RedFg | aurora.BrightFg,
	WARNING: aurora.YellowFg | aurora.BrightFg,
	INFO:    aurora.CyanFg | aurora.BrightFg,
	DEBUG:   aurora.GreenFg,
	NOTE:    aurora.BrownFg,
}

var LogLevelNames = map[LogLevel]string{
	FATAL:   "FATAL",
	ERROR:   "ERROR",
	WARNING: "WARNING",
	INFO:    "INFO",
	DEBUG:   "DEBUG",
}

var LogLevelValues = map[string]LogLevel{
	"FATAL":   FATAL,
	"ERROR":   ERROR,
	"WARNING": WARNING,
	"INFO":    INFO,
	"DEBUG":   DEBUG,

	"WARN":     WARNING,
	"CRITICAL": FATAL,
	"CRIT":     FATAL,
	"CRYTICAL": FATAL,
	"CRYT":     FATAL,
}

var Root = NewAutoColorLogger(INFO)

Functions

func CanBeLogLevel

func CanBeLogLevel(level int) bool

func LogLevelName

func LogLevelName(level LogLevel) string

func ValidLogLevel

func ValidLogLevel(level LogLevel) bool

func ValidLogLevelName

func ValidLogLevelName(level string) bool

Types

type LogLevel

type LogLevel int

func LogLevelByName

func LogLevelByName(level string) LogLevel

func (LogLevel) Color

func (level LogLevel) Color() aurora.Color

func (LogLevel) Colored

func (level LogLevel) Colored(s string, au aurora.Aurora) string

func (LogLevel) Name

func (level LogLevel) Name() string

func (LogLevel) String

func (self LogLevel) String() string

type Logger

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

func NewAutoColorLogger

func NewAutoColorLogger(level LogLevel) *Logger

func NewColorLogger

func NewColorLogger(level LogLevel) *Logger

func NewLogger

func NewLogger(level LogLevel) *Logger

func (*Logger) Debug

func (self *Logger) Debug(message string, args ...interface{})

func (*Logger) Error

func (self *Logger) Error(message string, args ...interface{})

func (*Logger) Fatal

func (self *Logger) Fatal(message string, args ...interface{})

func (*Logger) Flags

func (self *Logger) Flags() int

func (*Logger) Info

func (self *Logger) Info(message string, args ...interface{})

func (*Logger) Log

func (self *Logger) Log(level LogLevel, message string, args ...interface{})

func (*Logger) Prefix

func (self *Logger) Prefix() string

func (*Logger) Say

func (self *Logger) Say(message string, args ...interface{})

unconditionally write to Logger with "NOTE:" prefix

func (*Logger) SetFlags

func (self *Logger) SetFlags(flags int) *Logger

func (*Logger) SetLevel

func (self *Logger) SetLevel(level LogLevel)

func (*Logger) SetOutput

func (self *Logger) SetOutput(writer io.Writer) *Logger

func (*Logger) SetPrefix

func (self *Logger) SetPrefix(prefix string) *Logger

func (*Logger) UseColor

func (self *Logger) UseColor(color aurora.Aurora)

func (*Logger) UsePanic

func (self *Logger) UsePanic(use bool)

func (*Logger) Warn

func (self *Logger) Warn(message string, args ...interface{})

func (*Logger) Warning

func (self *Logger) Warning(message string, args ...interface{})