README

bchlog

Build Status ISC License GoDoc

Package bchlog defines a logger interface and provides a default implementation of a subsystem-aware leveled logger implementing the same interface.

Installation

$ go get github.com/gcash/bchlog

License

Package btclog is licensed under the copyfree ISC License.

Expand ▾ Collapse ▴

Documentation

Overview

    Package bchlog defines an interface and default implementation for subsystem logging.

    Log level verbosity may be modified at runtime for each individual subsystem logger.

    The default implementation in this package must be created by the Backend type. Backends can write to any io.Writer, including multi-writers created by io.MultiWriter. Multi-writers allow log output to be written to many writers, including standard output and log files.

    Optional logging behavior can be specified by using the LOGFLAGS environment variable and overridden per-Backend by using the WithFlags call option. Multiple LOGFLAGS options can be specified, separated by commas. The following options are recognized:

    longfile: Include the full filepath and line number in all log messages
    
    shortfile: Include the filename and line number in all log messages.
    Overrides longfile.
    

    Index

    Constants

    View Source
    const (
    	// Llongfile modifies the logger output to include full path and line number
    	// of the logging callsite, e.g. /a/b/c/main.go:123.
    	Llongfile uint32 = 1 << iota
    
    	// Lshortfile modifies the logger output to include filename and line number
    	// of the logging callsite, e.g. main.go:123.  Overrides Llongfile.
    	Lshortfile
    )

      Flags to modify Backend's behavior.

      Variables

      This section is empty.

      Functions

      This section is empty.

      Types

      type Backend

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

        Backend is a logging backend. Subsystems created from the backend write to the backend's Writer. Backend provides atomic writes to the Writer from all subsystems.

        func NewBackend

        func NewBackend(w io.Writer, opts ...BackendOption) *Backend

          NewBackend creates a logger backend from a Writer.

          func (*Backend) Logger

          func (b *Backend) Logger(subsystemTag string) Logger

            Logger returns a new logger for a particular subsystem that writes to the Backend b. A tag describes the subsystem and is included in all log messages. The logger uses the info verbosity level by default.

            type BackendOption

            type BackendOption func(b *Backend)

              BackendOption is a function used to modify the behavior of a Backend.

              func WithFlags

              func WithFlags(flags uint32) BackendOption

                WithFlags configures a Backend to use the specified flags rather than using the package's defaults as determined through the LOGFLAGS environment variable.

                type Level

                type Level uint32

                  Level is the level at which a logger is configured. All messages sent to a level which is below the current level are filtered.

                  const (
                  	LevelTrace Level = iota
                  	LevelDebug
                  	LevelInfo
                  	LevelWarn
                  	LevelError
                  	LevelCritical
                  	LevelOff
                  )

                    Level constants.

                    func LevelFromString

                    func LevelFromString(s string) (l Level, ok bool)

                      LevelFromString returns a level based on the input string s. If the input can't be interpreted as a valid log level, the info level and false is returned.

                      func (Level) String

                      func (l Level) String() string

                        String returns the tag of the logger used in log messages, or "OFF" if the level will not produce any log output.

                        type Logger

                        type Logger interface {
                        	// Tracef formats message according to format specifier and writes to
                        	// to log with LevelTrace.
                        	Tracef(format string, params ...interface{})
                        
                        	// Debugf formats message according to format specifier and writes to
                        	// log with LevelDebug.
                        	Debugf(format string, params ...interface{})
                        
                        	// Infof formats message according to format specifier and writes to
                        	// log with LevelInfo.
                        	Infof(format string, params ...interface{})
                        
                        	// Warnf formats message according to format specifier and writes to
                        	// to log with LevelWarn.
                        	Warnf(format string, params ...interface{})
                        
                        	// Errorf formats message according to format specifier and writes to
                        	// to log with LevelError.
                        	Errorf(format string, params ...interface{})
                        
                        	// Criticalf formats message according to format specifier and writes to
                        	// log with LevelCritical.
                        	Criticalf(format string, params ...interface{})
                        
                        	// Trace formats message using the default formats for its operands
                        	// and writes to log with LevelTrace.
                        	Trace(v ...interface{})
                        
                        	// Debug formats message using the default formats for its operands
                        	// and writes to log with LevelDebug.
                        	Debug(v ...interface{})
                        
                        	// Info formats message using the default formats for its operands
                        	// and writes to log with LevelInfo.
                        	Info(v ...interface{})
                        
                        	// Warn formats message using the default formats for its operands
                        	// and writes to log with LevelWarn.
                        	Warn(v ...interface{})
                        
                        	// Error formats message using the default formats for its operands
                        	// and writes to log with LevelError.
                        	Error(v ...interface{})
                        
                        	// Critical formats message using the default formats for its operands
                        	// and writes to log with LevelCritical.
                        	Critical(v ...interface{})
                        
                        	// Level returns the current logging level.
                        	Level() Level
                        
                        	// SetLevel changes the logging level to the passed level.
                        	SetLevel(level Level)
                        }

                          Logger is an interface which describes a level-based logger. A default implementation of Logger is implemented by this package and can be created by calling (*Backend).Logger.

                          var Disabled Logger

                            Disabled is a Logger that will never output anything.