log

Documentation

Overview

Package log is a generated GoMock package.

Index

• func BuildZapLogger(cfg Config) *zap.Logger
• func CapturePanic(logger Logger, retError *error)
• func NewCLILogger() *zapLogger
• func NewLazyLogger(logger Logger, tagFn func() []tag.Tag) *lazyLogger
• func NewNoopLogger() *noopLogger
• func NewReplayLogger(logger Logger, ctx workflow.Context, enableLogInReplay bool) *replayLogger
• func NewTestLogger() *zapLogger
• func NewThrottledLogger(logger Logger, rps quotas.RateFn) *throttledLogger
• func NewZapLogger(zl *zap.Logger) *zapLogger
• type Config
• type Logger
  • func With(logger Logger, tags ...tag.Tag) Logger
• type MockLogger
  • func NewMockLogger(ctrl *gomock.Controller) *MockLogger
  • func (m *MockLogger) Debug(msg string, tags ...tag.Tag)
  • func (m *MockLogger) EXPECT() *MockLoggerMockRecorder
  • func (m *MockLogger) Error(msg string, tags ...tag.Tag)
  • func (m *MockLogger) Fatal(msg string, tags ...tag.Tag)
  • func (m *MockLogger) Info(msg string, tags ...tag.Tag)
  • func (m *MockLogger) Warn(msg string, tags ...tag.Tag)
• type MockLoggerMockRecorder
  • func (mr *MockLoggerMockRecorder) Debug(msg interface{}, tags ...interface{}) *gomock.Call
  • func (mr *MockLoggerMockRecorder) Error(msg interface{}, tags ...interface{}) *gomock.Call
  • func (mr *MockLoggerMockRecorder) Fatal(msg interface{}, tags ...interface{}) *gomock.Call
  • func (mr *MockLoggerMockRecorder) Info(msg interface{}, tags ...interface{}) *gomock.Call
  • func (mr *MockLoggerMockRecorder) Warn(msg interface{}, tags ...interface{}) *gomock.Call
• type MockSkipLogger
  • func NewMockSkipLogger(ctrl *gomock.Controller) *MockSkipLogger
  • func (m *MockSkipLogger) EXPECT() *MockSkipLoggerMockRecorder
  • func (m *MockSkipLogger) Skip(extraSkip int) Logger
• type MockSkipLoggerMockRecorder
  • func (mr *MockSkipLoggerMockRecorder) Skip(extraSkip interface{}) *gomock.Call
• type MockWithLogger
  • func NewMockWithLogger(ctrl *gomock.Controller) *MockWithLogger
  • func (m *MockWithLogger) EXPECT() *MockWithLoggerMockRecorder
  • func (m *MockWithLogger) With(tags ...tag.Tag) Logger
• type MockWithLoggerMockRecorder
  • func (mr *MockWithLoggerMockRecorder) With(tags ...interface{}) *gomock.Call
• type SdkLogger
  • func NewSdkLogger(logger Logger) *SdkLogger
  • func (l *SdkLogger) Debug(msg string, keyvals ...interface{})
  • func (l *SdkLogger) Error(msg string, keyvals ...interface{})
  • func (l *SdkLogger) Info(msg string, keyvals ...interface{})
  • func (l *SdkLogger) Warn(msg string, keyvals ...interface{})
  • func (l *SdkLogger) With(keyvals ...interface{}) log.Logger
• type SkipLogger
• type WithLogger

Functions

func BuildZapLogger

func BuildZapLogger(cfg Config) *zap.Logger

BuildZapLogger builds and returns a new zap.Logger for this logging configuration

func CapturePanic

func CapturePanic(logger Logger, retError *error)

CapturePanic is used to capture panic, it will log the panic and also return the error through pointer. If the panic value is not error then a default error is returned We have to use pointer is because in golang: "recover return nil if was not called directly by a deferred function." And we have to set the returned error otherwise our handler will return nil as error which is incorrect

func NewCLILogger

func NewCLILogger() *zapLogger

NewCLILogger returns a logger at debug level and log into STDERR for logging from within CLI tools

func NewLazyLogger

func NewLazyLogger(logger Logger, tagFn func() []tag.Tag) *lazyLogger

func NewNoopLogger

func NewNoopLogger() *noopLogger

NewNoopLogger return a noopLogger

func NewReplayLogger

func NewReplayLogger(logger Logger, ctx workflow.Context, enableLogInReplay bool) *replayLogger

NewReplayLogger creates a logger which is aware of Temporal replay mode

func NewTestLogger

func NewTestLogger() *zapLogger

NewTestLogger returns a logger at debug level and log into STDERR

func NewThrottledLogger

func NewThrottledLogger(logger Logger, rps quotas.RateFn) *throttledLogger

NewThrottledLogger returns an implementation of logger that throttles the log messages being emitted. The underlying implementation uses a token bucket rate limiter and stops emitting logs once the bucket runs out of tokens

Fatal/Panic logs are always emitted without any throttling

func NewZapLogger

func NewZapLogger(zl *zap.Logger) *zapLogger

NewZapLogger returns a new zap based logger from zap.Logger

Types

type Config

type Config struct {
	// Stdout is true if the output needs to goto standard out
	Stdout bool `yaml:"stdout"`
	// Level is the desired log level
	Level string `yaml:"level"`
	// OutputFile is the path to the log output file
	OutputFile string `yaml:"outputFile"`
}

Config contains the config items for logger

type Logger

type Logger interface {
	Debug(msg string, tags ...tag.Tag)
	Info(msg string, tags ...tag.Tag)
	Warn(msg string, tags ...tag.Tag)
	Error(msg string, tags ...tag.Tag)
	Fatal(msg string, tags ...tag.Tag)
}

Logger is the logging interface. Usage example:

 logger.Info("hello world",
         tag.WorkflowNextEventID(123),
         tag.WorkflowActionWorkflowStarted,
         tag.WorkflowNamespaceID("test-namespace-id")),
	 )
 Note: msg should be static, do not use fmt.Sprintf() for msg. Anything dynamic should be tagged.

func With

func With(logger Logger, tags ...tag.Tag) Logger

With returns Logger instance that prepend every log entry with tags. If logger implements WithLogger it is used, otherwise every log call will be intercepted.

type MockLogger

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

MockLogger is a mock of Logger interface.

func NewMockLogger

func NewMockLogger(ctrl *gomock.Controller) *MockLogger

NewMockLogger creates a new mock instance.

func (*MockLogger) Debug

func (m *MockLogger) Debug(msg string, tags ...tag.Tag)

Debug mocks base method.

func (*MockLogger) EXPECT

func (m *MockLogger) EXPECT() *MockLoggerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockLogger) Error

func (m *MockLogger) Error(msg string, tags ...tag.Tag)

Error mocks base method.

func (*MockLogger) Fatal

func (m *MockLogger) Fatal(msg string, tags ...tag.Tag)

Fatal mocks base method.

func (*MockLogger) Info

func (m *MockLogger) Info(msg string, tags ...tag.Tag)

Info mocks base method.

func (*MockLogger) Warn

func (m *MockLogger) Warn(msg string, tags ...tag.Tag)

Warn mocks base method.

type MockLoggerMockRecorder

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

MockLoggerMockRecorder is the mock recorder for MockLogger.

func (*MockLoggerMockRecorder) Debug

func (mr *MockLoggerMockRecorder) Debug(msg interface{}, tags ...interface{}) *gomock.Call

Debug indicates an expected call of Debug.

func (*MockLoggerMockRecorder) Error

func (mr *MockLoggerMockRecorder) Error(msg interface{}, tags ...interface{}) *gomock.Call

Error indicates an expected call of Error.

func (*MockLoggerMockRecorder) Fatal

func (mr *MockLoggerMockRecorder) Fatal(msg interface{}, tags ...interface{}) *gomock.Call

Fatal indicates an expected call of Fatal.

func (*MockLoggerMockRecorder) Info

func (mr *MockLoggerMockRecorder) Info(msg interface{}, tags ...interface{}) *gomock.Call

Info indicates an expected call of Info.

func (*MockLoggerMockRecorder) Warn

func (mr *MockLoggerMockRecorder) Warn(msg interface{}, tags ...interface{}) *gomock.Call

Warn indicates an expected call of Warn.

type MockSkipLogger

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

MockSkipLogger is a mock of SkipLogger interface.

func NewMockSkipLogger

func NewMockSkipLogger(ctrl *gomock.Controller) *MockSkipLogger

NewMockSkipLogger creates a new mock instance.

func (*MockSkipLogger) EXPECT

func (m *MockSkipLogger) EXPECT() *MockSkipLoggerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockSkipLogger) Skip

func (m *MockSkipLogger) Skip(extraSkip int) Logger

Skip mocks base method.

type MockSkipLoggerMockRecorder

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

MockSkipLoggerMockRecorder is the mock recorder for MockSkipLogger.

func (*MockSkipLoggerMockRecorder) Skip

func (mr *MockSkipLoggerMockRecorder) Skip(extraSkip interface{}) *gomock.Call

Skip indicates an expected call of Skip.

type MockWithLogger

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

MockWithLogger is a mock of WithLogger interface.

func NewMockWithLogger

func NewMockWithLogger(ctrl *gomock.Controller) *MockWithLogger

NewMockWithLogger creates a new mock instance.

func (*MockWithLogger) EXPECT

func (m *MockWithLogger) EXPECT() *MockWithLoggerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockWithLogger) With

func (m *MockWithLogger) With(tags ...tag.Tag) Logger

With mocks base method.

type MockWithLoggerMockRecorder

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

MockWithLoggerMockRecorder is the mock recorder for MockWithLogger.

func (*MockWithLoggerMockRecorder) With

func (mr *MockWithLoggerMockRecorder) With(tags ...interface{}) *gomock.Call

With indicates an expected call of With.

type SdkLogger

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

func NewSdkLogger

func NewSdkLogger(logger Logger) *SdkLogger

func (*SdkLogger) Debug

func (l *SdkLogger) Debug(msg string, keyvals ...interface{})

func (*SdkLogger) Error

func (l *SdkLogger) Error(msg string, keyvals ...interface{})

func (*SdkLogger) Info

func (l *SdkLogger) Info(msg string, keyvals ...interface{})

func (*SdkLogger) Warn

func (l *SdkLogger) Warn(msg string, keyvals ...interface{})

func (*SdkLogger) With

func (l *SdkLogger) With(keyvals ...interface{}) log.Logger

type SkipLogger

type SkipLogger interface {
	Skip(extraSkip int) Logger
}

If logger implements SkipLogger then Skip method will be called and extraSkip parameter will have number of extra stack trace frames to skip (useful to log caller func file/line).

type WithLogger

type WithLogger interface {
	With(tags ...tag.Tag) Logger
}

Implement WithLogger interface with With method which should return new instance of logger with prepended tags. If WithLogger is not implemented on logger, internal (not very efficient) preppender is used. Create prepended logger example:

logger = log.With(
        logger,
        tag.WorkflowNextEventID(123),
        tag.WorkflowActionWorkflowStarted,
        tag.WorkflowNamespaceID("test-namespace-id"))
...
logger.Info("hello world")