logging

package module
v0.0.0-...-22e02bf Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 7, 2013 License: BSD-3-Clause Imports: 12 Imported by: 0

README

Golang logging library

Package logging implements a logging infrastructure for Go. It supports different logging backends like syslog, file and memory. Multiple backends can be utilized with different log levels per backend and logger.

Installing

Using go get

$ go get github.com/op/go-logging

After this command go-logging is ready to use. Its source will be in:

$GOROOT/src/pkg/github.com/op/go-logging

You can use go get -u -a to update all installed packages.

Example

package main

import "github.com/op/go-logging"

var log = logging.MustGetLogger("package.example")

func main() {
	logging.SetLevel(logging.INFO, "package.example")
	log.Debug("hello %s", "golang")
	log.Info("hello %s", "golang")
}

Documentation

Examples are found in examples/. For docs, see http://godoc.org/github.com/op/go-logging or run:

$ go doc github.com/op/go-logging

Documentation

Overview

Package logging implements a logging infrastructure for Go. It supports different logging backends like syslog, file and memory. Multiple backends can be utilized with different log levels per backend and logger.

Index

Constants

This section is empty.

Variables

View Source
var ErrInvalidLogLevel = errors.New("logger: invalid log level")

Functions

func Redact

func Redact(s string) string

Redact returns a string of * having the same length as s.

func SetLevel

func SetLevel(level Level, module string)

SetLevel sets the logging level for the specified module. The module corresponds to the string specified in GetLogger.

Types

type Backend

type Backend interface {
	Log(Level, int, *Record) error
}

Backend is the interface which a log backend need to implement to be able to be used as a logging backend.

type ChannelMemoryBackend

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

ChannelMemoryBackend is very similar to the MemoryBackend, except that it internally utilizes a channel.

func NewChannelMemoryBackend

func NewChannelMemoryBackend(size int) *ChannelMemoryBackend

NewChannelMemoryBackend creates a simple in-memory logging backend which utilizes a go channel for communication.

Start will automatically be called by this function.

func (*ChannelMemoryBackend) Flush

func (b *ChannelMemoryBackend) Flush()

Flush waits until all records in the buffered channel have been processed.

func (*ChannelMemoryBackend) Head

func (b *ChannelMemoryBackend) Head() *node

Head returns the oldest record node kept in memory. It can be used to iterate over records, one by one, up to the last record.

Note: new records can get added while iterating. Hence the number of records iterated over might be larger than the maximum size.

func (*ChannelMemoryBackend) Log

func (b *ChannelMemoryBackend) Log(level Level, calldepth int, rec *Record) error

Log implements the Log method required by Backend.

func (*ChannelMemoryBackend) Start

func (b *ChannelMemoryBackend) Start()

Start launches the internal goroutine which starts processing data from the input channel.

func (*ChannelMemoryBackend) Stop

func (b *ChannelMemoryBackend) Stop()

Stop signals the internal goroutine to exit and waits until it have.

type Level

type Level int

Level defines all available log levels for log messages.

const (
	CRITICAL Level = iota
	ERROR
	WARNING
	NOTICE
	INFO
	DEBUG
)

func GetLevel

func GetLevel(module string) Level

GetLevel returns the logging level for the specified module.

func LogLevel

func LogLevel(level string) (Level, error)

LogLevel returns the log level from a string representation.

func (Level) String

func (p Level) String() string

String returns the string representation of a logging level.

type Leveled

type Leveled interface {
	GetLevel(string) Level
	SetLevel(Level, string)
	IsEnabledFor(Level, string) bool
}

type LeveledBackend

type LeveledBackend interface {
	Backend
	Leveled
}

LeveledBackend is a log backend with additional knobs for setting levels on individual modules to different levels.

func AddModuleLevel

func AddModuleLevel(backend Backend) LeveledBackend

AddModuleLevel wraps a log backend with knobs to have different log levels for different modules.

func MultiLogger

func MultiLogger(backends ...Backend) LeveledBackend

MultiLogger creates a logger which contain multiple loggers.

func SetBackend

func SetBackend(backends ...Backend) LeveledBackend

Set backend replaces the backend currently set with the given new logging backend.

type LogBackend

type LogBackend struct {
	Logger *log.Logger
	Color  bool
}

LogBackend utilizes the standard log module.

func NewLogBackend

func NewLogBackend(out io.Writer, prefix string, flag int) *LogBackend

NewLogBackend creates a new LogBackend.

func (*LogBackend) Log

func (b *LogBackend) Log(level Level, calldepth int, rec *Record) error

type Logger

type Logger struct {
	Module string
}

func GetLogger

func GetLogger(module string) (*Logger, error)

TODO call NewLogger and remove MustGetLogger? GetLogger creates and returns a Logger object based on the module name.

func MustGetLogger

func MustGetLogger(module string) *Logger

MustGetLogger is like GetLogger but panics if the logger can't be created. It simplifies safe initialization of a global logger for eg. a package.

func (*Logger) Critical

func (l *Logger) Critical(format string, args ...interface{})

Critical logs a message using CRITICAL as log level.

func (*Logger) Debug

func (l *Logger) Debug(format string, args ...interface{})

Debug logs a message using DEBUG as log level.

func (*Logger) Error

func (l *Logger) Error(format string, args ...interface{})

Error logs a message using ERROR as log level.

func (*Logger) Fatal

func (l *Logger) Fatal(args ...interface{})

Fatal is equivalent to l.Critical(fmt.Sprint()) followed by a call to os.Exit(1).

func (*Logger) Fatalf

func (l *Logger) Fatalf(format string, args ...interface{})

Fatalf is equivalent to l.Critical followed by a call to os.Exit(1).

func (*Logger) Info

func (l *Logger) Info(format string, args ...interface{})

Info logs a message using INFO as log level.

func (*Logger) IsEnabledFor

func (l *Logger) IsEnabledFor(level Level) bool

IsEnabledFor returns true if the logger is enabled for the given level.

func (*Logger) Notice

func (l *Logger) Notice(format string, args ...interface{})

Notice logs a message using NOTICE as log level.

func (*Logger) Panic

func (l *Logger) Panic(args ...interface{})

Panic is equivalent to l.Critical(fmt.Sprint()) followed by a call to panic().

func (*Logger) Panicf

func (l *Logger) Panicf(format string, args ...interface{})

Panicf is equivalent to l.Critical followed by a call to panic().

func (*Logger) Warning

func (l *Logger) Warning(format string, args ...interface{})

Warning logs a message using WARNING as log level.

type MemoryBackend

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

MemoryBackend is a simple memory based logging backend that will not produce any output but merly keep records, up to the given size, in memory.

func InitForTesting

func InitForTesting(level Level) *MemoryBackend

InitForTesting is a convenient method when using logging in a test.

func NewMemoryBackend

func NewMemoryBackend(size int) *MemoryBackend

NewMemoryBackend creates a simple in-memory logging backend.

func (*MemoryBackend) Head

func (b *MemoryBackend) Head() *node

Head returns the oldest record node kept in memory. It can be used to iterate over records, one by one, up to the last record.

Note: new records can get added while iterating. Hence the number of records iterated over might be larger than the maximum size.

func (*MemoryBackend) Log

func (b *MemoryBackend) Log(level Level, calldepth int, rec *Record) error

Log implements the Log method required by Backend.

type Record

type Record struct {
	Id     uint64
	Time   time.Time
	Module string
	// contains filtered or unexported fields
}

Record represents a log record and contains the timestamp when the record was created, an increasing id, filename and line and finally the actual formatted log line.

func (*Record) Formatted

func (r *Record) Formatted() string

type Redactor

type Redactor interface {
	Redacted() interface{}
}

Redactor is an interface for types that may contain sensitive information (like passwords), which shouldn't be printed to the log. The idea was found in relog as part of the vitness project.

type SyslogBackend

type SyslogBackend struct {
	Writer *syslog.Writer
}

SyslogBackend is a simple logger to syslog backend. It automatically maps the internal log levels to appropriate syslog log levels.

func NewSyslogBackend

func NewSyslogBackend(prefix string) (b *SyslogBackend, err error)

NewSyslogBackend connects to the syslog daemon using UNIX sockets with the given prefix. If prefix is not given, the prefix will be derived from the launched command.

func (*SyslogBackend) Log

func (b *SyslogBackend) Log(level Level, calldepth int, rec *Record) error

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL