term - ActiveState ActiveGo 1.8
...

Package term

import "github.com/go-kit/kit/log/term"
Overview
Index
Examples

Overview ▾

Package term provides tools for logging to a terminal.

Constants

ANSI colors. 

const (
    Default = Color(iota)

    Black
    DarkRed
    DarkGreen
    Brown
    DarkBlue
    DarkMagenta
    DarkCyan
    Gray

    DarkGray
    Red
    Green
    Yellow
    Blue
    Magenta
    Cyan
    White
)

func IsTerminal 

func IsTerminal(w io.Writer) bool

IsTerminal returns true if w writes to a terminal.

func NewColorLogger 

func NewColorLogger(w io.Writer, newLogger func(io.Writer) log.Logger, color func(keyvals ...interface{}) FgBgColor) log.Logger

NewColorLogger returns a Logger which writes colored logs to w. ANSI color codes for the colors returned by color are added to the formatted output from the Logger returned by newLogger and the combined result written to w.

func NewColorWriter 

func NewColorWriter(w io.Writer) io.Writer

NewColorWriter returns an io.Writer that writes to w and provides cross platform support for ANSI color codes. If w is not a terminal it is returned unmodified.

func NewLogger 

func NewLogger(w io.Writer, newLogger func(io.Writer) log.Logger, color func(keyvals ...interface{}) FgBgColor) log.Logger

NewLogger returns a Logger that takes advantage of terminal features if possible. Log events are formatted by the Logger returned by newLogger. If w is a terminal each log event is colored according to the color function.

▾ Example (LevelColors)

Code:

// Color by level value
colorFn := func(keyvals ...interface{}) term.FgBgColor {
    for i := 0; i < len(keyvals)-1; i += 2 {
        if keyvals[i] != "level" {
            continue
        }
        switch keyvals[i+1] {
        case "debug":
            return term.FgBgColor{Fg: term.DarkGray}
        case "info":
            return term.FgBgColor{Fg: term.Gray}
        case "warn":
            return term.FgBgColor{Fg: term.Yellow}
        case "error":
            return term.FgBgColor{Fg: term.Red}
        case "crit":
            return term.FgBgColor{Fg: term.Gray, Bg: term.DarkRed}
        default:
            return term.FgBgColor{}
        }
    }
    return term.FgBgColor{}
}

logger := term.NewLogger(os.Stdout, log.NewJSONLogger, colorFn)

logger.Log("level", "warn", "msg", "yellow")
logger.Log("level", "debug", "msg", "dark gray")

▾ Example (RedErrors)

Code:

// Color errors red
colorFn := func(keyvals ...interface{}) term.FgBgColor {
    for i := 1; i < len(keyvals); i += 2 {
        if _, ok := keyvals[i].(error); ok {
            return term.FgBgColor{Fg: term.White, Bg: term.Red}
        }
    }
    return term.FgBgColor{}
}

logger := term.NewLogger(os.Stdout, log.NewLogfmtLogger, colorFn)

logger.Log("msg", "default color", "err", nil)
logger.Log("msg", "colored because of error", "err", errors.New("coloring error"))

type Color

Color represents an ANSI color. The zero value is Default. 

type Color uint8

type FgBgColor

FgBgColor represents a foreground and background color. 

type FgBgColor struct {
    Fg, Bg Color
}