logsink

Documentation

Index

• func NewFileWriter(logPath string, maxSizeMB, maxBackups int) (io.WriteCloser, error)
• func NewHTTPHandler(newLogWriteCloser NewLogWriteCloserFunc, abort <-chan struct{}, ...) http.Handler
• type CounterVec
• type GaugeVec
• type LogWriteCloser
• type MetricsCollector
• type NewLogWriteCloserFunc
• type RateLimitConfig

Functions

func NewFileWriter

func NewFileWriter(logPath string, maxSizeMB, maxBackups int) (io.WriteCloser, error)

NewFileWriter returns an io.WriteCloser that will write log messages to disk.

func NewHTTPHandler

func NewHTTPHandler(
	newLogWriteCloser NewLogWriteCloserFunc,
	abort <-chan struct{},
	ratelimit *RateLimitConfig,
	metrics MetricsCollector,
	modelUUID string,
) http.Handler

NewHTTPHandler returns a new http.Handler for receiving log messages over a websocket, using the given NewLogWriteCloserFunc to obtain a writer to which the log messages will be written.

ratelimit defines an optional rate-limit configuration. If nil, no rate- limiting will be applied.

Types

type CounterVec

type CounterVec interface {
	// With returns a Counter for a given labels slice
	With(prometheus.Labels) prometheus.Counter
}

CounterVec is a Collector that bundles a set of Counters that all share the same description.

type GaugeVec

type GaugeVec interface {
	// With returns a Gauge for a given labels slice
	With(prometheus.Labels) prometheus.Gauge
}

GaugeVec is a Collector that bundles a set of Gauges that all share the same description.

type LogWriteCloser

type LogWriteCloser interface {
	io.Closer

	// WriteLog writes out the given log record.
	WriteLog(params.LogRecord) error
}

LogWriteCloser provides an interface for persisting log records. The LogCloser's Close method should be called to release any resources once it is done with.

type MetricsCollector

type MetricsCollector interface {

	// TotalConnections returns a prometheus metric that can be incremented
	// as a counter for the total number connections being served from the api
	// handler.
	TotalConnections() prometheus.Counter

	// Connections returns a prometheus metric that can be incremented and
	// decremented as a gauge, for the number connections being current served
	// from the api handler.
	Connections() prometheus.Gauge

	// PingFailureCount returns a prometheus metric for the number of
	// ping failures per model uuid, that can be incremented as
	// a counter.
	PingFailureCount(modelUUID string) prometheus.Counter

	// LogWriteCount returns a prometheus metric for the number of writes to
	// the log that happened. It's split on the success/failure, so the charts
	// will have to take that into account.
	LogWriteCount(modelUUID, state string) prometheus.Counter

	// LogReadCount returns a prometheus metric for the number of reads to
	// the log that happened. It's split on the success/error/disconnect, so
	// the charts will have to take that into account.
	LogReadCount(modelUUID, state string) prometheus.Counter
}

MetricsCollector represents a way to change the metrics for the logsink api handler.

type NewLogWriteCloserFunc

type NewLogWriteCloserFunc func(*http.Request) (LogWriteCloser, error)

NewLogWriteCloserFunc returns a new LogWriteCloser for the given http.Request.

type RateLimitConfig

type RateLimitConfig struct {
	// Burst is the number of log messages that will be let through before
	// we start rate limiting.
	Burst int64

	// Refill is the rate at which log messages will be let through once
	// the initial burst amount has been depleted.
	Refill time.Duration

	// Clock is the clock used to wait when rate-limiting log receives.
	Clock clock.Clock
}

RateLimitConfig contains the rate-limit configuration for the logsink handler.