logger

Documentation

Index

• Constants
• Variables
• func Blue(l Logger) *color.Color
• func CtxWithForkedOutput(ctx context.Context, writer io.Writer) context.Context
• func CtxWithLogHandler(ctx context.Context, handler LogHandler) context.Context
• func DefaultEnv(ctx context.Context) []string
• func Green(l Logger) *color.Color
• func NewPrefixedLogger(prefix string, original Logger) *prefixedLogger
• func PrepareEnv(l Logger, env []string) []string
• func Red(l Logger) *color.Color
• func WithLogger(ctx context.Context, logger Logger) context.Context
• func Yellow(l Logger) *color.Color
• type DeferredLogger
  • func NewDeferredLogger(ctx context.Context) *DeferredLogger
  • func (dl *DeferredLogger) CopyBuffered(lvl Level) *bytes.Buffer
  • func (dl *DeferredLogger) Original() Logger
  • func (dl *DeferredLogger) SetOutput(l Logger)
• type Fields
• type FuncLoggerWriter
  • func (fw FuncLoggerWriter) Write(b []byte) (int, error)
• type Level
  • func (l Level) AsSevereAs(log Level) bool
  • func (l Level) ShouldDisplay(log Level) bool
  • func (l Level) ToProtoID() int32
• type LogHandler
• type Logger
  • func Get(ctx context.Context) Logger
  • func NewFuncLogger(supportsColor bool, level Level, ...) Logger
  • func NewLogger(minLevel Level, writer io.Writer) Logger
  • func NewTestLogger(writer io.Writer) Logger
• type MutexWriter
  • func NewMutexWriter(underlying io.Writer) MutexWriter
  • func (w MutexWriter) Write(b []byte) (int, error)

Constants

const FieldNameBuildEvent = "buildEvent"

const FieldNameProgressID = "progressID"

const FieldNameProgressMustPrint = "progressMustPrint"

Most progress lines are optional. For example, if a bunch of little upload updates come in, it's ok to skip some.

progressMustPrint="1" indicates that this line must appear in the output - e.g., a line that communicates that the upload finished.

Variables

var (
	NoneLvl    = Level{/* contains filtered or unexported fields */}
	DebugLvl   = Level{/* contains filtered or unexported fields */}
	VerboseLvl = Level{/* contains filtered or unexported fields */}
	InfoLvl    = Level{/* contains filtered or unexported fields */}
	WarnLvl    = Level{/* contains filtered or unexported fields */}
	ErrorLvl   = Level{/* contains filtered or unexported fields */}
)

var LoggerContextKey = contextKey{}

Functions

func Blue

func Blue(l Logger) *color.Color

func CtxWithForkedOutput

func CtxWithForkedOutput(ctx context.Context, writer io.Writer) context.Context

Returns a context containing a logger that forks all of its output to both the parent context's logger and to the given `io.Writer`

func CtxWithLogHandler

func CtxWithLogHandler(ctx context.Context, handler LogHandler) context.Context

func DefaultEnv

func DefaultEnv(ctx context.Context) []string

DefaultEnv returns a set of strings in the form of "key=value" based on the current process' environment with additional entries to improve subprocess log output.

func Green

func Green(l Logger) *color.Color

func NewPrefixedLogger

func NewPrefixedLogger(prefix string, original Logger) *prefixedLogger

func PrepareEnv

func PrepareEnv(l Logger, env []string) []string

PrepareEnv returns a set of strings in the form of "key=value" based on a provided set of strings in the same format with additional entries to improve subprocess log output.

func Red

func Red(l Logger) *color.Color

func WithLogger

func WithLogger(ctx context.Context, logger Logger) context.Context

func Yellow

func Yellow(l Logger) *color.Color

Types

type DeferredLogger

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

A logger that buffers its log lines until we have an output logger.

func NewDeferredLogger

func NewDeferredLogger(ctx context.Context) *DeferredLogger

func (*DeferredLogger) CopyBuffered

func (dl *DeferredLogger) CopyBuffered(lvl Level) *bytes.Buffer

func (*DeferredLogger) Original

func (dl *DeferredLogger) Original() Logger

The original logger that we're deferring output away from.

func (*DeferredLogger) SetOutput

func (dl *DeferredLogger) SetOutput(l Logger)

Set the output logger, and send all the buffered output to the new logger.

type Fields

type Fields map[string]string

Allow arbitrary fields on a log. Inspired by the logrus.Fields API https://github.com/sirupsen/logrus

type FuncLoggerWriter

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

func (FuncLoggerWriter) Write

func (fw FuncLoggerWriter) Write(b []byte) (int, error)

type Level

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

func (Level) AsSevereAs

func (l Level) AsSevereAs(log Level) bool

func (Level) ShouldDisplay

func (l Level) ShouldDisplay(log Level) bool

If l is the logger level, determine if we should display logs of the given severity.

func (Level) ToProtoID

func (l Level) ToProtoID() int32

type LogHandler

type LogHandler interface {
	Write(level Level, fields Fields, bytes []byte) error
}

type Logger

type Logger interface {
	// log information that is likely to only be of interest to tilt developers
	Debugf(format string, a ...interface{})

	// log information that a tilt user might not want to see on every run, but that they might find
	// useful when debugging their Tiltfile/docker/k8s configs
	Verbosef(format string, a ...interface{})

	// log information that we always want to show
	Infof(format string, a ...interface{})

	// Warnings to show in the alert pane.
	Warnf(format string, a ...interface{})

	// Halting errors to show in the alert pane.
	Errorf(format string, a ...interface{})

	Write(level Level, bytes []byte)

	// gets an io.Writer that filters to the specified level for, e.g., passing to a subprocess
	Writer(level Level) io.Writer

	Level() Level

	SupportsColor() bool

	WithFields(fields Fields) Logger
}

Logger with better controls for levels and colors.

Note that our loggers often serve as both traditional loggers (where each call to PodLog() is a discrete log entry that may be emitted as JSON or with newlines) and as Writers (where each call to Write() may be part of a larger output stream, and each message may not end in a newline).

Logger implementations that bridge these two worlds should have discrete messages (like Infof) append a newline to the string before passing it to Write().

func Get

func Get(ctx context.Context) Logger

func NewFuncLogger

func NewFuncLogger(supportsColor bool, level Level, write func(level Level, fields Fields, b []byte) error) Logger

func NewLogger

func NewLogger(minLevel Level, writer io.Writer) Logger

func NewTestLogger

func NewTestLogger(writer io.Writer) Logger

type MutexWriter

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

func NewMutexWriter

func NewMutexWriter(underlying io.Writer) MutexWriter

func (MutexWriter) Write

func (w MutexWriter) Write(b []byte) (int, error)