logger

Documentation

Overview

Package logger provides tiny structured logging abstraction or facade for various logging libraries, allowing the end user to plug in the desired logging library in main.go.

Index

• type Adapter
• type Entry
• type Field
• type Global
  • func (g *Global) Debug(ctx context.Context, msg string)
  • func (g *Global) Error(ctx context.Context, msg string)
  • func (g *Global) Info(ctx context.Context, msg string)
  • func (g *Global) SetAdapter(adapter Adapter)
  • func (g *Global) Warn(ctx context.Context, msg string)
  • func (g *Global) With(key string, value interface{}) *Global
  • func (g *Global) WithError(err error) *Global
  • func (g *Global) WithSkippedCallerFrame() *Global
• type Level
  • func (l Level) MoreSevereThan(other Level) bool
  • func (l Level) String() string
• type Logger
  • func WithAdapter(adapter Adapter) Logger
  • func (l Logger) Debug(ctx context.Context, msg string)
  • func (l Logger) Error(ctx context.Context, msg string)
  • func (l Logger) Info(ctx context.Context, msg string)
  • func (l Logger) Warn(ctx context.Context, msg string)
  • func (l Logger) With(key string, value interface{}) Logger
  • func (l Logger) WithError(err error) Logger
  • func (l Logger) WithSkippedCallerFrame() Logger

Types

type Adapter

type Adapter interface {
	Log(context.Context, Entry)
}

Adapter is an interface to be implemented by logger adapters.

type Entry

type Entry struct {
	Level   Level
	Message string

	// Fields contains all accumulated fields, in the order they were appended.
	//
	// Please do not update fields in the slice as other go-routines may still read them. To add a new field
	// please use append built-in function. To remove a field, please create a new slice and copy remaining fields.
	// To update field first remove it and then add a new one.
	//
	// Fields can be nil.
	Fields []Field

	Error error // Error can be nil
	// SkippedCallerFrames can be used by logger.Adapter to extract caller information (file and line number)
	SkippedCallerFrames int
}

Entry is a logging entry created by logger and passed to adapter.

type Field

type Field struct {
	Key   string
	Value interface{}
}

Field contains key-value pair.

type Global

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

Global is a logger shared globally. You can use it to define global logger for your package:

package yourpackage
import "github.com/elgopher/yala/logger"
var log logger.Global // define global logger, no need to initialize (by default nothing is logged)

func SetLoggerAdapter(adapter logger.Adapter) {
	log.SetAdapter(adapter)
}

It is safe to use it concurrently.

func (*Global) Debug

func (g *Global) Debug(ctx context.Context, msg string)

Debug logs a message at DebugLevel.

func (*Global) Error

func (g *Global) Error(ctx context.Context, msg string)

Error logs a message at ErrorLevel.

func (*Global) Info

func (g *Global) Info(ctx context.Context, msg string)

Info logs a message at InfoLevel.

func (*Global) SetAdapter

func (g *Global) SetAdapter(adapter Adapter)

SetAdapter updates adapter implementation. By default, nothing is logged.

It can be run anytime. Please note though that this method is meant to be used by end user, configuring logging from the central place (such as main.go or any other package setting up the entire application).

If this method is called on an instance created using With* methods, then all parent and child loggers are updated too.

func (*Global) Warn

func (g *Global) Warn(ctx context.Context, msg string)

Warn logs a message at WarnLevel.

func (*Global) With

func (g *Global) With(key string, value interface{}) *Global

With creates a new child logger with field.

func (*Global) WithError

func (g *Global) WithError(err error) *Global

WithError creates a new child logger with error.

func (*Global) WithSkippedCallerFrame

func (g *Global) WithSkippedCallerFrame() *Global

WithSkippedCallerFrame creates a new child logger with one more skipped caller frame. This function is handy when you want to write your own logging helpers.

type Level

type Level int8

Level is a severity level of message. Use Level.MoreSevereThan to compare two levels.

const (
	// DebugLevel level is usually enabled only when debugging (disabled in production). Very verbose logging.
	DebugLevel Level = iota - 1
	// InfoLevel is used for informational messages, for confirmation that the program is working as expected.
	InfoLevel
	// WarnLevel is used for non-critical entries that deserve eyes.
	WarnLevel
	// ErrorLevel is used for errors that should definitely be noted. If an application is running smoothly,
	// it shouldn't generate any error-level logs.
	ErrorLevel
)

func (Level) MoreSevereThan

func (l Level) MoreSevereThan(other Level) bool

MoreSevereThan returns true if level is more severe than the argument.

func (Level) String

func (l Level) String() string

String converts the Level to a string. For example InfoLevel becomes "INFO".

type Logger

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

Logger is an immutable logger to log messages or create new loggers with fields or error.

You can't update the adapter once created.

It is safe to use it concurrently.

func WithAdapter

func WithAdapter(adapter Adapter) Logger

WithAdapter creates a new Logger.

func (Logger) Debug

func (l Logger) Debug(ctx context.Context, msg string)

Debug logs a message at DebugLevel.

func (Logger) Error

func (l Logger) Error(ctx context.Context, msg string)

Error logs a message at ErrorLevel.

func (Logger) Info

func (l Logger) Info(ctx context.Context, msg string)

Info logs a message at InfoLevel.

func (Logger) Warn

func (l Logger) Warn(ctx context.Context, msg string)

Warn logs a message at WarnLevel.

func (Logger) With

func (l Logger) With(key string, value interface{}) Logger

With creates a new logger with field.

func (Logger) WithError

func (l Logger) WithError(err error) Logger

WithError creates a new logger with error.

func (Logger) WithSkippedCallerFrame

func (l Logger) WithSkippedCallerFrame() Logger

WithSkippedCallerFrame creates a new logger with one more skipped caller frame. This function is handy when you want to write your own logging helpers.