logging

Documentation

Overview

Package logging ... Handles logging within the SDK

Index

• Constants
• func Level(level string) int
• func ObfuscateAPIKey(apikey string) string
• func ObfuscateHTTPHeader(headers http.Header) string
• type ExtendedLevelFilteredLoggerWrapper
  • func (l *ExtendedLevelFilteredLoggerWrapper) DebugFn(format string, params ParamsFn)
  • func (l *ExtendedLevelFilteredLoggerWrapper) ErrorFn(format string, params ParamsFn)
  • func (l *ExtendedLevelFilteredLoggerWrapper) InfoFn(format string, params ParamsFn)
  • func (l *ExtendedLevelFilteredLoggerWrapper) VerboseFn(format string, params ParamsFn)
  • func (l *ExtendedLevelFilteredLoggerWrapper) WarningFn(format string, params ParamsFn)
• type ExtendedLoggerInterface
  • func NewExtendedLogger(options *LoggerOptions) ExtendedLoggerInterface
• type FileRotate
  • func NewFileRotate(opt *FileRotateOptions) (*FileRotate, error)
  • func (f *FileRotate) Write(p []byte) (n int, err error)
• type FileRotateOptions
• type LevelFilteredLoggerWrapper
  • func (l *LevelFilteredLoggerWrapper) Debug(is ...interface{})
  • func (l *LevelFilteredLoggerWrapper) Error(is ...interface{})
  • func (l *LevelFilteredLoggerWrapper) Info(is ...interface{})
  • func (l *LevelFilteredLoggerWrapper) Verbose(is ...interface{})
  • func (l *LevelFilteredLoggerWrapper) Warning(is ...interface{})
• type Logger
  • func (l *Logger) Debug(msg ...interface{})
  • func (l *Logger) Error(msg ...interface{})
  • func (l *Logger) Info(msg ...interface{})
  • func (l *Logger) Verbose(msg ...interface{})
  • func (l *Logger) Warning(msg ...interface{})
• type LoggerInterface
  • func NewLogger(options *LoggerOptions) LoggerInterface
• type LoggerOptions
• type ParamsFn

Constants

const (

	// LevelError log level
	LevelError

	// LevelWarning log level
	LevelWarning

	// LevelInfo log level
	LevelInfo

	// LevelDebug log level
	LevelDebug

	// LevelVerbose log level
	LevelVerbose
)

Standard values

const (
	// LevelNone implies that NOTHING will be logged, not even errors
	LevelNone = math.MinInt32

	// LevelAll implies that All logging levels will be recorded
	LevelAll = math.MaxInt32
)

Special values

Functions

func Level

func Level(level string) int

Level gets current level

func ObfuscateAPIKey

func ObfuscateAPIKey(apikey string) string

ObfuscateAPIKey obfucate part of api key

func ObfuscateHTTPHeader

func ObfuscateHTTPHeader(headers http.Header) string

ObfuscateHTTPHeader obfuscates sensitive data into headers

Types

type ExtendedLevelFilteredLoggerWrapper

type ExtendedLevelFilteredLoggerWrapper struct {
	*LevelFilteredLoggerWrapper
}

ExtendedLevelFilteredLoggerWrapper leveled logger improving message format performance

func (*ExtendedLevelFilteredLoggerWrapper) DebugFn

func (l *ExtendedLevelFilteredLoggerWrapper) DebugFn(format string, params ParamsFn)

DebugFn forwards debug logging messages getting parameters from a function to improve performance

func (*ExtendedLevelFilteredLoggerWrapper) ErrorFn

func (l *ExtendedLevelFilteredLoggerWrapper) ErrorFn(format string, params ParamsFn)

ErrorFn forwards error logging messages getting parameters from a function to improve performance

func (*ExtendedLevelFilteredLoggerWrapper) InfoFn

func (l *ExtendedLevelFilteredLoggerWrapper) InfoFn(format string, params ParamsFn)

InfoFn forwards info logging messages getting parameters from a function to improve performance

func (*ExtendedLevelFilteredLoggerWrapper) VerboseFn

func (l *ExtendedLevelFilteredLoggerWrapper) VerboseFn(format string, params ParamsFn)

VerboseFn forwards verbose logging messages getting parameters from a function to improve performance

func (*ExtendedLevelFilteredLoggerWrapper) WarningFn

func (l *ExtendedLevelFilteredLoggerWrapper) WarningFn(format string, params ParamsFn)

WarningFn forwards warning logging messages getting parameters from a function to improve performance

type ExtendedLoggerInterface

type ExtendedLoggerInterface interface {
	LoggerInterface
	ErrorFn(format string, params ParamsFn)
	WarningFn(format string, params ParamsFn)
	InfoFn(format string, params ParamsFn)
	DebugFn(format string, params ParamsFn)
	VerboseFn(format string, params ParamsFn)
}

ExtendedLoggerInterface ... If a custom logger object is to be used, it should comply with the following interface. (Standard go-lang library log.Logger.Println method signature)

func NewExtendedLogger

func NewExtendedLogger(options *LoggerOptions) ExtendedLoggerInterface

NewExtendedLogger instantiates a new Logger instance. Requires a pointer to a LoggerOptions struct to be passed.

type FileRotate

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

FileRotate rotates a log file at MaxBytes

func NewFileRotate

func NewFileRotate(opt *FileRotateOptions) (*FileRotate, error)

NewFileRotate returns a pointer to a FileRotate instance

func (*FileRotate) Write

func (f *FileRotate) Write(p []byte) (n int, err error)

Write writes async the log message

type FileRotateOptions

type FileRotateOptions struct {
	MaxBytes    int64
	BackupCount int
	Path        string
}

FileRotateOptions struct to configure FileRotate

type LevelFilteredLoggerWrapper

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

LevelFilteredLoggerWrapper forwards log message to delegate if level is set higher than incoming message

func (*LevelFilteredLoggerWrapper) Debug

func (l *LevelFilteredLoggerWrapper) Debug(is ...interface{})

Debug forwards debug logging messages

func (*LevelFilteredLoggerWrapper) Error

func (l *LevelFilteredLoggerWrapper) Error(is ...interface{})

Error forwards error logging messages

func (*LevelFilteredLoggerWrapper) Info

func (l *LevelFilteredLoggerWrapper) Info(is ...interface{})

Info forwards info logging messages

func (*LevelFilteredLoggerWrapper) Verbose

func (l *LevelFilteredLoggerWrapper) Verbose(is ...interface{})

Verbose forwards verbose logging messages

func (*LevelFilteredLoggerWrapper) Warning

func (l *LevelFilteredLoggerWrapper) Warning(is ...interface{})

Warning forwards warning logging messages

type Logger

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

Logger struct. Encapsulates four different loggers, each for a different "level", and provides Error, Debug, Warning and Info functions, that will forward a message to the appropriate logger.

func (*Logger) Debug

func (l *Logger) Debug(msg ...interface{})

Debug logs a message with Debug level

func (*Logger) Error

func (l *Logger) Error(msg ...interface{})

Error logs a message with Error level

func (*Logger) Info

func (l *Logger) Info(msg ...interface{})

Info logs a message with Info level

func (*Logger) Verbose

func (l *Logger) Verbose(msg ...interface{})

Verbose logs a message with Debug level

func (*Logger) Warning

func (l *Logger) Warning(msg ...interface{})

Warning logs a message with Warning level

type LoggerInterface

type LoggerInterface interface {
	Error(msg ...interface{})
	Warning(msg ...interface{})
	Info(msg ...interface{})
	Debug(msg ...interface{})
	Verbose(msg ...interface{})
}

LoggerInterface ... If a custom logger object is to be used, it should comply with the following interface. (Standard go-lang library log.Logger.Println method signature)

func NewLogger

func NewLogger(options *LoggerOptions) LoggerInterface

NewLogger instantiates a new Logger instance. Requires a pointer to a LoggerOptions struct to be passed.

type LoggerOptions

type LoggerOptions struct {
	LogLevel            int
	ErrorWriter         io.Writer
	WarningWriter       io.Writer
	InfoWriter          io.Writer
	DebugWriter         io.Writer
	VerboseWriter       io.Writer
	StandardLoggerFlags int
	Prefix              string
	ExtraFramesToSkip   int
}

LoggerOptions ... Struct that must be passed to the NewLogger constructor to setup a logger CommonWriter and ErrorWriter can be <nil>. In that case they'll default to os.Stdout

type ParamsFn

type ParamsFn = func() []interface{}

ParamsFn is a function that returns a slice of interface{}