fabric: github.com/hyperledger/fabric/common/flogging Index | Files | Directories

package flogging

import "github.com/hyperledger/fabric/common/flogging"

Index

Package Files

core.go global.go legacy.go levels.go loggerlevels.go logging.go zap.go

Constants

const (
    CONSOLE = iota
    JSON
    LOGFMT
)
const (
    // DisabledLevel represents a disabled log level. Logs at this level should
    // never be emitted.
    DisabledLevel = zapcore.Level(math.MinInt8)

    // PayloadLevel is used to log the extremely detailed message level debug
    // information.
    PayloadLevel = zapcore.Level(zapcore.DebugLevel - 1)
)

func ActivateSpec Uses

func ActivateSpec(spec string)

ActivateSpec is used to activate a logging specification.

func DefaultLevel Uses

func DefaultLevel() string

DefaultLevel returns the fallback value for loggers to use if parsing fails.

func GetLoggerLevel Uses

func GetLoggerLevel(loggerName string) string

GetLoggerLevel gets the current logging level for the logger with the provided name.

func Init Uses

func Init(config Config)

Init initializes logging with the provided config.

func InitBackend Uses

func InitBackend(formatter logging.Formatter, output io.Writer)

InitBackend sets up the logging backend based on the provided logging formatter and I/O writer.

func InitFromSpec Uses

func InitFromSpec(spec string) string

InitFromSpec initializes the logging based on the supplied spec. It is exposed externally so that consumers of the flogging package may parse their own logging specification. The logging specification has the following form:

[<logger>[,<logger>...]=]<level>[:[<logger>[,<logger>...]=]<logger>...]

func IsValidLevel Uses

func IsValidLevel(level string) bool

func NameToLevel Uses

func NameToLevel(level string) zapcore.Level

NameToLevel converts a level name to a zapcore.Level. If the level name is unknown, zapcore.InfoLevel is returned.

func NewGRPCLogger Uses

func NewGRPCLogger(l *zap.Logger) *zapgrpc.Logger

NewGRPCLogger creates a grpc.Logger that delegates to a zap.Logger.

func NewZapLogger Uses

func NewZapLogger(core zapcore.Core, options ...zap.Option) *zap.Logger

NewZapLogger creates a zap logger around a new zap.Core. The core will use the provided encoder and sinks and a level enabler that is associated with the provided logger name. The logger that is returned will be named the same as the logger.

func Reset Uses

func Reset()

Reset sets logging to the defaults defined in this package.

Used in tests and in the package init

func SetFormat Uses

func SetFormat(formatSpec string) logging.Formatter

SetFormat sets the logging format.

type Config Uses

type Config struct {
    // Format is the log record format specifier for the Logging instance. If the
    // spec is the string "json", log records will be formatted as JSON. Any
    // other string will be provided to the FormatEncoder. Please see
    // fabenc.ParseFormat for details on the supported verbs.
    //
    // If Format is not provided, a default format that provides basic information will
    // be used.
    Format string

    // LogSpec determines the log levels that are enabled for the logging system. The
    // spec must be in a format that can be processed by ActivateSpec.
    //
    // If LogSpec is not provided, loggers will be enabled at the INFO level.
    LogSpec string

    // Writer is the sink for encoded and formatted log records.
    //
    // If a Writer is not provided, os.Stderr will be used as the log sink.
    Writer io.Writer
}

Config is used to provide dependencies to a Logging instance.

type Core Uses

type Core struct {
    zapcore.LevelEnabler
    Levels   *LoggerLevels
    Encoders map[Encoding]zapcore.Encoder
    Selector EncodingSelector
    Output   zapcore.WriteSyncer
    Observer Observer
}

Core is a custom implementation of a zapcore.Core. It's a terrible hack that only exists to work around the intersection of state associated with encoders, implementation hiding in zapcore, and implicit, ad-hoc logger initialization within fabric.

In addition to encoding log entries and fields to a buffer, zap Encoder implementations also need to maintain field state. When zapcore.Core.With is used, the associated encoder is cloned and the fields are added to the encoder. This means that encoder instances cannot be shared across cores.

In terms of implementation hiding, it's difficult for our FormatEncoder to cleanly wrap the JSON and console implementations from zap as all methods from the zapcore.ObjectEncoder would need to be implemented to delegate to the correct backend.

This implementation works by associating multiple encoders with a core. When fields are added to the core, the fields are added to all of the encoder implementations. The core also references the logging configuration to determine the proper encoding to use, the writer to delegate to, and the enabled levels.

func (*Core) Check Uses

func (c *Core) Check(e zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry

func (*Core) Sync Uses

func (c *Core) Sync() error

func (*Core) With Uses

func (c *Core) With(fields []zapcore.Field) zapcore.Core

func (*Core) Write Uses

func (c *Core) Write(e zapcore.Entry, fields []zapcore.Field) error

type Encoding Uses

type Encoding int8

type EncodingSelector Uses

type EncodingSelector interface {
    Encoding() Encoding
}

EncodingSelector is used to determine whether log records are encoded as JSON or in human readable CONSOLE or LOGFMT formats.

type FabricLogger Uses

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

A FabricLogger is an adapter around a zap.SugaredLogger that provides structured logging capabilities while preserving much of the legacy logging behavior.

The most significant difference between the FabricLogger and the zap.SugaredLogger is that methods without a formatting suffix (f or w) build the log entry message with fmt.Sprintln instead of fmt.Sprint. Without this change, arguments are not separated by spaces.

func MustGetLogger Uses

func MustGetLogger(loggerName string) *FabricLogger

MustGetLogger creates a logger with the specified name. If an invalid name is provided, the operation will panic.

func NewFabricLogger Uses

func NewFabricLogger(l *zap.Logger, options ...zap.Option) *FabricLogger

NewFabricLogger creates a logger that delegates to the zap.SugaredLogger.

func (*FabricLogger) Critical Uses

func (f *FabricLogger) Critical(args ...interface{})

for backwards compatibility

func (*FabricLogger) Criticalf Uses

func (f *FabricLogger) Criticalf(template string, args ...interface{})

func (*FabricLogger) DPanic Uses

func (f *FabricLogger) DPanic(args ...interface{})

func (*FabricLogger) DPanicf Uses

func (f *FabricLogger) DPanicf(template string, args ...interface{})

func (*FabricLogger) DPanicw Uses

func (f *FabricLogger) DPanicw(msg string, kvPairs ...interface{})

func (*FabricLogger) Debug Uses

func (f *FabricLogger) Debug(args ...interface{})

func (*FabricLogger) Debugf Uses

func (f *FabricLogger) Debugf(template string, args ...interface{})

func (*FabricLogger) Debugw Uses

func (f *FabricLogger) Debugw(msg string, kvPairs ...interface{})

func (*FabricLogger) Error Uses

func (f *FabricLogger) Error(args ...interface{})

func (*FabricLogger) Errorf Uses

func (f *FabricLogger) Errorf(template string, args ...interface{})

func (*FabricLogger) Errorw Uses

func (f *FabricLogger) Errorw(msg string, kvPairs ...interface{})

func (*FabricLogger) Fatal Uses

func (f *FabricLogger) Fatal(args ...interface{})

func (*FabricLogger) Fatalf Uses

func (f *FabricLogger) Fatalf(template string, args ...interface{})

func (*FabricLogger) Fatalw Uses

func (f *FabricLogger) Fatalw(msg string, kvPairs ...interface{})

func (*FabricLogger) Info Uses

func (f *FabricLogger) Info(args ...interface{})

func (*FabricLogger) Infof Uses

func (f *FabricLogger) Infof(template string, args ...interface{})

func (*FabricLogger) Infow Uses

func (f *FabricLogger) Infow(msg string, kvPairs ...interface{})

func (*FabricLogger) IsEnabledFor Uses

func (f *FabricLogger) IsEnabledFor(level zapcore.Level) bool

func (*FabricLogger) Named Uses

func (f *FabricLogger) Named(name string) *FabricLogger

func (*FabricLogger) Notice Uses

func (f *FabricLogger) Notice(args ...interface{})

func (*FabricLogger) Noticef Uses

func (f *FabricLogger) Noticef(template string, args ...interface{})

func (*FabricLogger) Panic Uses

func (f *FabricLogger) Panic(args ...interface{})

func (*FabricLogger) Panicf Uses

func (f *FabricLogger) Panicf(template string, args ...interface{})

func (*FabricLogger) Panicw Uses

func (f *FabricLogger) Panicw(msg string, kvPairs ...interface{})

func (*FabricLogger) Sync Uses

func (f *FabricLogger) Sync() error

func (*FabricLogger) Warn Uses

func (f *FabricLogger) Warn(args ...interface{})

func (*FabricLogger) Warnf Uses

func (f *FabricLogger) Warnf(template string, args ...interface{})

func (*FabricLogger) Warning Uses

func (f *FabricLogger) Warning(args ...interface{})

func (*FabricLogger) Warningf Uses

func (f *FabricLogger) Warningf(template string, args ...interface{})

func (*FabricLogger) Warnw Uses

func (f *FabricLogger) Warnw(msg string, kvPairs ...interface{})

func (*FabricLogger) With Uses

func (f *FabricLogger) With(args ...interface{}) *FabricLogger

func (*FabricLogger) WithOptions Uses

func (f *FabricLogger) WithOptions(opts ...zap.Option) *FabricLogger

func (*FabricLogger) Zap Uses

func (f *FabricLogger) Zap() *zap.Logger

type LoggerLevels Uses

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

LoggerLevels tracks the logging level of named loggers.

func (*LoggerLevels) ActivateSpec Uses

func (l *LoggerLevels) ActivateSpec(spec string) error

ActivateSpec is used to modify logging levels.

The logging specification has the following form:

[<logger>[,<logger>...]=]<level>[:[<logger>[,<logger>...]=]<level>...]

func (*LoggerLevels) DefaultLevel Uses

func (l *LoggerLevels) DefaultLevel() zapcore.Level

DefaultLevel returns the default logging level for loggers that do not have an explicit level set.

func (*LoggerLevels) Enabled Uses

func (l *LoggerLevels) Enabled(lvl zapcore.Level) bool

Enabled function is an enabled check that evaluates the minimum active logging level. It serves as a fast check before the (relatively) expensive Check call in the core.

func (*LoggerLevels) Level Uses

func (l *LoggerLevels) Level(loggerName string) zapcore.Level

Level returns the effective logging level for a logger. If a level has not been explicitly set for the logger, the default logging level will be returned.

func (*LoggerLevels) Spec Uses

func (l *LoggerLevels) Spec() string

Spec returns a normalized version of the active logging spec.

type Logging Uses

type Logging struct {
    *LoggerLevels
    // contains filtered or unexported fields
}

Logging maintains the state associated with the fabric logging system. It is intended to bridge between the legacy logging infrastructure built around go-logging and the structured, level logging provided by zap.

var Global *Logging

func New Uses

func New(c Config) (*Logging, error)

New creates a new logging system and initializes it with the provided configuration.

func (*Logging) Apply Uses

func (s *Logging) Apply(c Config) error

Apply applies the provided configuration to the logging system.

func (*Logging) Check Uses

func (s *Logging) Check(e zapcore.Entry, ce *zapcore.CheckedEntry)

func (*Logging) Encoding Uses

func (s *Logging) Encoding() Encoding

Encoding satisfies the Encoding interface. It determines whether the JSON or CONSOLE encoder should be used by the Core when log records are written.

func (*Logging) Logger Uses

func (s *Logging) Logger(name string) *FabricLogger

Logger instantiates a new FabricLogger with the specified name. The name is used to determine which log levels are enabled.

func (*Logging) SetFormat Uses

func (s *Logging) SetFormat(format string) error

SetFormat updates how log records are formatted and encoded. Log entries created after this method has completed will use the new format.

An error is returned if the log format specification cannot be parsed.

func (*Logging) SetObserver Uses

func (s *Logging) SetObserver(observer Observer)

SetObserver is used to provide a log observer that will be called as log levels are checked or written.. Only a single observer is supported.

func (*Logging) SetWriter Uses

func (s *Logging) SetWriter(w io.Writer)

SetWriter controls which writer formatted log records are written to. Writers, with the exception of an *os.File, need to be safe for concurrent use by multiple go routines.

func (*Logging) Sync Uses

func (s *Logging) Sync() error

Sync satisfies the zapcore.WriteSyncer interface. It is used by the Core to flush log records before terminating the process.

func (*Logging) Write Uses

func (s *Logging) Write(b []byte) (int, error)

Write satisfies the io.Write contract. It delegates to the writer argument of SetWriter or the Writer field of Config. The Core uses this when encoding log records.

func (*Logging) WriteEntry Uses

func (s *Logging) WriteEntry(e zapcore.Entry, fields []zapcore.Field)

func (*Logging) ZapLogger Uses

func (s *Logging) ZapLogger(name string) *zap.Logger

ZapLogger instantiates a new zap.Logger with the specified name. The name is used to determine which log levels are enabled.

type Observer Uses

type Observer interface {
    Check(e zapcore.Entry, ce *zapcore.CheckedEntry)
    WriteEntry(e zapcore.Entry, fields []zapcore.Field)
}

Directories

PathSynopsis
fabenc
floggingtest
httpadmin
httpadmin/fakesCode generated by counterfeiter.
metrics
mockCode generated by counterfeiter.

Package flogging imports 16 packages (graph) and is imported by 433 packages. Updated 2019-06-25. Refresh now. Tools for package owners.