logging

Documentation

Overview

Package logging package contains functionality for viam-server logging.

Index

• Variables
• func CreateNewGRPCClient(ctx context.Context, cloudCfg *CloudConfig) (rpc.ClientConn, error)
• func NewZapLoggerConfig() zap.Config
• func ReplaceGlobal(logger Logger)
• type Appender
• type AtomicLevel
  • func NewAtomicLevelAt(initLevel Level) AtomicLevel
  • func (level AtomicLevel) Get() Level
  • func (level AtomicLevel) Set(newLevel Level)
• type CloudConfig
• type ConsoleAppender
  • func NewStdoutAppender() ConsoleAppender
  • func NewStdoutTestAppender() ConsoleAppender
  • func NewWriterAppender(writer io.Writer) ConsoleAppender
  • func (appender ConsoleAppender) Sync() error
  • func (appender ConsoleAppender) Write(entry zapcore.Entry, fields []zapcore.Field) error
• type Level
  • func LevelFromString(inp string) (Level, error)
  • func (level Level) AsZap() zapcore.Level
  • func (level Level) MarshalJSON() ([]byte, error)
  • func (level Level) String() string
  • func (level *Level) UnmarshalJSON(data []byte) (err error)
• type LogEntry
• type Logger
  • func FromZapCompatible(logger ZapCompatibleLogger) Logger
  • func Global() Logger
  • func NewBlankLogger(name string) Logger
  • func NewDebugLogger(name string) Logger
  • func NewLogger(name string) Logger
  • func NewObservedTestLogger(tb testing.TB) (Logger, *observer.ObservedLogs)
  • func NewTestLogger(tb testing.TB) Logger
• type NetAppender
  • func NewNetAppender(config *CloudConfig) (*NetAppender, error)
  • func (nl *NetAppender) Check(entry zapcore.Entry, checkedEntry *zapcore.CheckedEntry) *zapcore.CheckedEntry
  • func (nl *NetAppender) Close()
  • func (nl *NetAppender) Enabled(level zapcore.Level) bool
  • func (nl *NetAppender) Sync() error
  • func (nl *NetAppender) With(f []zapcore.Field) zapcore.Core
  • func (nl *NetAppender) Write(e zapcore.Entry, f []zapcore.Field) error
• type ZapCompatibleLogger

Variables

var (

	// GlobalLogLevel should be used whenever a zap logger is created that wants to obey the debug
	// flag from the CLI or robot config.
	GlobalLogLevel = zap.NewAtomicLevelAt(zap.InfoLevel)
)

Functions

func CreateNewGRPCClient

func CreateNewGRPCClient(ctx context.Context, cloudCfg *CloudConfig) (rpc.ClientConn, error)

CreateNewGRPCClient creates a new grpc cloud configured to communicate with the robot service based on the cloud config given.

func NewZapLoggerConfig

func NewZapLoggerConfig() zap.Config

NewZapLoggerConfig returns a new default logger config.

func ReplaceGlobal

func ReplaceGlobal(logger Logger)

ReplaceGlobal replaces the global loggers.

Types

type Appender

type Appender interface {
	// Write submits a structured log entry to the appender for logging.
	Write(zapcore.Entry, []zapcore.Field) error
	// Sync is for signaling that any buffered logs to `Write` should be flushed. E.g: at shutdown.
	Sync() error
}

Appender is an output for log entries. This is a subset of the `zapcore.Core` interface.

type AtomicLevel

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

AtomicLevel is a level that can be concurrently accessed.

func NewAtomicLevelAt

func NewAtomicLevelAt(initLevel Level) AtomicLevel

NewAtomicLevelAt creates a new AtomicLevel at the input `initLevel`.

func (AtomicLevel) Get

func (level AtomicLevel) Get() Level

Get returns the level.

func (AtomicLevel) Set

func (level AtomicLevel) Set(newLevel Level)

Set changes the level.

type CloudConfig

type CloudConfig struct {
	AppAddress string
	ID         string
	Secret     string
}

CloudConfig contains the necessary inputs to send logs to the app backend over grpc.

type ConsoleAppender

type ConsoleAppender struct {
	io.Writer
	// contains filtered or unexported fields
}

ConsoleAppender will create human readable lines from log events and write them to the desired output sync. E.g: stdout or a file.

func NewStdoutAppender

func NewStdoutAppender() ConsoleAppender

NewStdoutAppender creates a new appender that prints to stdout.

func NewStdoutTestAppender

func NewStdoutTestAppender() ConsoleAppender

NewStdoutTestAppender creates a new appender that prints to stdout with a whitespace prefix.

func NewWriterAppender

func NewWriterAppender(writer io.Writer) ConsoleAppender

NewWriterAppender creates a new appender that prints to the input writer.

func (ConsoleAppender) Sync

func (appender ConsoleAppender) Sync() error

Sync is a no-op.

func (ConsoleAppender) Write

func (appender ConsoleAppender) Write(entry zapcore.Entry, fields []zapcore.Field) error

Write outputs the log entry to the underlying stream.

type Level

type Level int

Level is an enum of log levels. Its value can be `DEBUG`, `INFO`, `WARN` or `ERROR`.

const (

	// DEBUG log level.
	DEBUG Level = iota - 1
	// INFO log level.
	INFO
	// WARN log level.
	WARN
	// ERROR log level.
	ERROR
)

func LevelFromString

func LevelFromString(inp string) (Level, error)

LevelFromString parses an input string to a log level. The string must be one of `debug`, `info`, `warn` or `error`. The parsing is case-insensitive. An error is returned if the input does not match one of labeled cases.

func (Level) AsZap

func (level Level) AsZap() zapcore.Level

AsZap converts the Level to a `zapcore.Level`.

func (Level) MarshalJSON

func (level Level) MarshalJSON() ([]byte, error)

MarshalJSON converts a log level to a json string.

func (Level) String

func (level Level) String() string

func (*Level) UnmarshalJSON

func (level *Level) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON converts a json string to a log level.

type LogEntry

type LogEntry struct {
	zapcore.Entry
	// contains filtered or unexported fields
}

LogEntry embeds a zapcore Entry and slice of Fields.

type Logger

type Logger interface {
	ZapCompatibleLogger

	SetLevel(level Level)
	Sublogger(subname string) Logger
	AddAppender(appender Appender)
	AsZap() *zap.SugaredLogger
}

Logger interface for logging to.

func FromZapCompatible

func FromZapCompatible(logger ZapCompatibleLogger) Logger

FromZapCompatible upconverts a ZapCompatibleLogger to a logging.Logger. If the argument already satisfies logging.Logger, no changes will be made. A nil input returns a nil logger. An input of unknown type will create a new logger that's not associated with the input.

func Global

func Global() Logger

Global returns the global logger.

func NewBlankLogger

func NewBlankLogger(name string) Logger

NewBlankLogger returns a new logger that outputs Debug+ logs in UTC, but without any pre-existing appenders/outputs.

func NewDebugLogger

func NewDebugLogger(name string) Logger

NewDebugLogger returns a new logger that outputs Debug+ logs to stdout in UTC.

func NewLogger

func NewLogger(name string) Logger

NewLogger returns a new logger that outputs Info+ logs to stdout in UTC.

func NewObservedTestLogger

func NewObservedTestLogger(tb testing.TB) (Logger, *observer.ObservedLogs)

NewObservedTestLogger is like NewTestLogger but also saves logs to an in memory observer.

func NewTestLogger

func NewTestLogger(tb testing.TB) Logger

NewTestLogger returns a new logger that outputs Debug+ logs to stdout in local time.

type NetAppender

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

NetAppender can send log events to the app backend.

func NewNetAppender

func NewNetAppender(config *CloudConfig) (*NetAppender, error)

NewNetAppender creates a NetAppender to send log events to the app backend. NetAppenders ought to be `Close`d prior to shutdown to flush remaining logs.

func (*NetAppender) Check

func (nl *NetAppender) Check(entry zapcore.Entry, checkedEntry *zapcore.CheckedEntry) *zapcore.CheckedEntry

Check checks if the entry should be logged. If so, add it to the CheckedEntry list of cores.

func (*NetAppender) Close

func (nl *NetAppender) Close()

Close the NetAppender. This makes a best effort at sending all logs before returning.

func (*NetAppender) Enabled

func (nl *NetAppender) Enabled(level zapcore.Level) bool

Enabled returns if the NetAppender serving as a `zapcore.Core` should log.

func (*NetAppender) Sync

func (nl *NetAppender) Sync() error

Sync will flush the internal buffer of logs.

func (*NetAppender) With

func (nl *NetAppender) With(f []zapcore.Field) zapcore.Core

With creates a zapcore.Core that will log like a `NetAppender` but with extra fields attached.

func (*NetAppender) Write

func (nl *NetAppender) Write(e zapcore.Entry, f []zapcore.Field) error

type ZapCompatibleLogger

type ZapCompatibleLogger interface {
	Desugar() *zap.Logger
	Level() zapcore.Level
	Named(name string) *zap.SugaredLogger
	Sync() error
	With(args ...interface{}) *zap.SugaredLogger
	WithOptions(opts ...zap.Option) *zap.SugaredLogger

	Debug(args ...interface{})
	Debugf(template string, args ...interface{})
	Debugw(msg string, keysAndValues ...interface{})

	Info(args ...interface{})
	Infof(template string, args ...interface{})
	Infow(msg string, keysAndValues ...interface{})

	Warn(args ...interface{})
	Warnf(template string, args ...interface{})
	Warnw(msg string, keysAndValues ...interface{})

	Error(args ...interface{})
	Errorf(template string, args ...interface{})
	Errorw(msg string, keysAndValues ...interface{})

	Fatal(args ...interface{})
	Fatalf(template string, args ...interface{})
	Fatalw(msg string, keysAndValues ...interface{})
}

ZapCompatibleLogger is a backwards compatibility layer for existing usages of the RDK as a library for Go application code or modules. Public (to the library) methods that take a logger as input should accept this type and upconvert to a Logger via a call to `FromZapCompatible`.