observance

Documentation

Index

• Variables
• type Config
• type Fields
• type Logger
  • func NewLogrus(logLevel string, appName string, sentryURL string, version string) (Logger, error)
• type LogrusLogger
  • func (l *LogrusLogger) Debug(msg interface{})
  • func (l *LogrusLogger) Error(msg interface{})
  • func (l *LogrusLogger) Info(msg interface{})
  • func (l *LogrusLogger) Level() string
  • func (l *LogrusLogger) SetOutput(w io.Writer)
  • func (l *LogrusLogger) Trace(msg interface{})
  • func (l *LogrusLogger) Warn(msg interface{})
  • func (l *LogrusLogger) WithError(err error) Logger
  • func (l *LogrusLogger) WithField(key string, value interface{}) Logger
  • func (l *LogrusLogger) WithFields(fields Fields) Logger
• type LogrusTestLogger
  • func (l *LogrusTestLogger) Entries() []TestLogEntry
  • func (l *LogrusTestLogger) LastEntry() TestLogEntry
  • func (l *LogrusTestLogger) Reset()
• type Measurer
• type Obs
  • func NewObs(config Config) (*Obs, error)
  • func (o *Obs) CopyWithRequest(r *http.Request) *Obs
  • func (o *Obs) PanicRecover()
• type PrometheusMetrics
  • func NewPrometheusMetrics(url, appName string, flushInterval time.Duration, logger Logger) *PrometheusMetrics
  • func (m *PrometheusMetrics) DurationSince(name string, start time.Time)
  • func (m *PrometheusMetrics) Increment(name string)
  • func (m *PrometheusMetrics) SetGauge(name string, value float64)
  • func (m *PrometheusMetrics) SetGaugeInt64(name string, value int64)
• type TestLogEntry
• type TestLogger
  • func NewTestLogger() TestLogger

Examples

• NewTestLogger

Variables

var (
	RequestIDHeader = "Fastbill-Outer-RequestId"
	AccountIDHeader = "Fastbill-AccountId"
)

These variables define which headers are checked for finding the request and account id.

Types

type Config

type Config struct {
	AppName              string
	LogLevel             string
	SentryURL            string
	Version              string
	MetricsURL           string
	MetricsFlushInterval time.Duration
}

Config contains all config variables for setting up observability (logging, metrics).

type Fields

type Fields = map[string]interface{}

Fields is a type alias to ease reading.

type Logger

type Logger interface {
	Level() string
	Trace(msg interface{})
	Debug(msg interface{})
	Info(msg interface{})
	Warn(msg interface{})
	Error(msg interface{})
	WithField(key string, value interface{}) Logger
	WithFields(fields Fields) Logger
	WithError(err error) Logger
	SetOutput(w io.Writer)
}

Logger is a general interface to be implemented for multiple loggers.

func NewLogrus

func NewLogrus(logLevel string, appName string, sentryURL string, version string) (Logger, error)

NewLogrus creates a Logrus logger that fulfils the Logger interface with Sentry integration. All log messages will contain app name, pid and hostname/containerID.

type LogrusLogger

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

LogrusLogger wraps Logrus to provide an implementation of the Logger interface.

func (*LogrusLogger) Debug

func (l *LogrusLogger) Debug(msg interface{})

Debug writes a log entry with level "debug".

func (*LogrusLogger) Error

func (l *LogrusLogger) Error(msg interface{})

Error writes a log entry with level "error".

func (*LogrusLogger) Info

func (l *LogrusLogger) Info(msg interface{})

Info writes a log entry with level "info".

func (*LogrusLogger) Level

func (l *LogrusLogger) Level() string

Level returns the log level that was set for the logger. Only entries with that level or above with be logged.

func (*LogrusLogger) SetOutput

func (l *LogrusLogger) SetOutput(w io.Writer)

SetOutput changes where the logs are written to. The default is Stdout.

func (*LogrusLogger) Trace

func (l *LogrusLogger) Trace(msg interface{})

Trace writes a log entry with level "trace".

func (*LogrusLogger) Warn

func (l *LogrusLogger) Warn(msg interface{})

Warn writes a log entry with level "warning".

func (*LogrusLogger) WithError

func (l *LogrusLogger) WithError(err error) Logger

WithError adds an error for logging.

func (*LogrusLogger) WithField

func (l *LogrusLogger) WithField(key string, value interface{}) Logger

WithField adds an additional field for logging.

func (*LogrusLogger) WithFields

func (l *LogrusLogger) WithFields(fields Fields) Logger

WithFields allows to add multiple additional fields to the logging. The argument needs to be of type Fields (map[string]interface{}).

type LogrusTestLogger

type LogrusTestLogger struct {
	LogrusLogger
	// contains filtered or unexported fields
}

LogrusTestLogger implements TestLogger.

func (*LogrusTestLogger) Entries

func (l *LogrusTestLogger) Entries() []TestLogEntry

Entries returns all recorded log entries.

func (*LogrusTestLogger) LastEntry

func (l *LogrusTestLogger) LastEntry() TestLogEntry

LastEntry returns the last recorded log entry.

func (*LogrusTestLogger) Reset

func (l *LogrusTestLogger) Reset()

Reset clears the recorded logs to start fresh.

type Measurer

type Measurer interface {
	Increment(name string)
	SetGauge(name string, value float64)
	SetGaugeInt64(name string, value int64)
	DurationSince(name string, start time.Time)
}

Measurer defines the generic interface capturing metrics.

type Obs

type Obs struct {
	Logger  Logger
	Metrics Measurer
}

Obs is a wrapper for all things that helps to observe the operation of the service: logging, monitoring, tracing

func NewObs

func NewObs(config Config) (*Obs, error)

NewObs creates a new observance instance for logging. Optional: If a Sentry URL was provided logs with level error will be sent to Sentry. Optional: If a metrics URL was provided a Prometheus Pushgateway metrics can be captured.

func (*Obs) CopyWithRequest

func (o *Obs) CopyWithRequest(r *http.Request) *Obs

CopyWithRequest creates a new observance and adds request-specific fields to the logger (and maybe at some point to the other parts of observance, too) Logs url, method, requestId and accountId (if present)

func (*Obs) PanicRecover

func (o *Obs) PanicRecover()

PanicRecover can be used to recover panics in the main thread and log the messages.

type PrometheusMetrics

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

PrometheusMetrics is an implementation of Measurer.

func NewPrometheusMetrics

func NewPrometheusMetrics(url, appName string, flushInterval time.Duration, logger Logger) *PrometheusMetrics

NewPrometheusMetrics creates a new metrics instance to collect metrics.

func (*PrometheusMetrics) DurationSince

func (m *PrometheusMetrics) DurationSince(name string, start time.Time)

DurationSince is a utility method that accepts a metrics name and start time. It then calculates the duration between the start time and now. The result is converted to milliseconds and then tracked using SetGauge.

func (*PrometheusMetrics) Increment

func (m *PrometheusMetrics) Increment(name string)

Increment is used to count occurances. It can only be used for values that never decrease.

func (*PrometheusMetrics) SetGauge

func (m *PrometheusMetrics) SetGauge(name string, value float64)

SetGauge is used to track a float64 value over time.

func (*PrometheusMetrics) SetGaugeInt64

func (m *PrometheusMetrics) SetGaugeInt64(name string, value int64)

SetGaugeInt64 is used to track an int64 value over time. The integer value will be converted to a float to fit the prometheus API.

type TestLogEntry

type TestLogEntry struct {
	Level   string
	Message string
	Data    map[string]interface{}
}

TestLogEntry represents one recorded log entry in the test logger.

type TestLogger

type TestLogger interface {
	Logger
	LastEntry() TestLogEntry
	Entries() []TestLogEntry
	Reset()
}

TestLogger is an extended Logger interface for testing. It allows to check the logs that were recorded.

func NewTestLogger

func NewTestLogger() TestLogger

NewTestLogger creates a new TestLogger that can be used to create a test observance instance.

Example

logger := NewTestLogger()
obs := &Obs{Logger: logger}
obs.Logger.WithField("testField", "testValue").Error("testMessage1")
fmt.Println(logger.LastEntry().Level, logger.LastEntry().Message, logger.LastEntry().Data)

obs.Logger.Info("testMessage2")
fmt.Printf("%+v", logger.Entries())

Output:

error testMessage1 map[testField:testValue]
[{Level:error Message:testMessage1 Data:map[testField:testValue]} {Level:info Message:testMessage2 Data:map[]}]