metrics

Documentation

Index

• Constants
• func NewBBSElectionMetronNotifier(logger lager.Logger, metronClient loggingclient.IngressClient) ifrit.Runner
• func NewDBStatMetronNotifier(logger lager.Logger, clock clock.Clock, dbStats DBStats, ...) ifrit.Runner
• func NewFileDescriptorMetronNotifier(logger lager.Logger, newTicker clock.Ticker, ...) ifrit.Runner
• type BBSElectionMetronNotifier
  • func (notifier BBSElectionMetronNotifier) Run(signals <-chan os.Signal, ready chan<- struct{}) error
• type DBStats
• type FileDescriptorMetronNotifier
  • func (notifier FileDescriptorMetronNotifier) Run(signals <-chan os.Signal, ready chan<- struct{}) error
• type LRPStatMetronNotifier
  • func NewLRPStatMetronNotifier(logger lager.Logger, clock clock.Clock, metronClient logging.IngressClient) LRPStatMetronNotifier
• type RequestStatMetronNotifier
  • func NewRequestStatMetronNotifier(logger lager.Logger, ticker clock.Ticker, ...) *RequestStatMetronNotifier
  • func (notifier *RequestStatMetronNotifier) IncrementRequestCounter(delta int)
  • func (notifier *RequestStatMetronNotifier) ReadAndResetLatency() time.Duration
  • func (notifier *RequestStatMetronNotifier) Run(signals <-chan os.Signal, ready chan<- struct{}) error
  • func (notifier *RequestStatMetronNotifier) UpdateLatency(latency time.Duration)
• type TaskStatMetronNotifier
  • func NewTaskStatMetronNotifier(logger lager.Logger, clock clock.Clock, metronClient logging.IngressClient) TaskStatMetronNotifier

Constants

const (
	OpenFileDescriptorsMetric = "OpenFileDescriptors"
	FileDescriptorUnits       = "descriptors"
)

const (
	DefaultEmitMetricsFrequency = 15 * time.Second

	ConvergenceLRPRunsMetric     = "ConvergenceLRPRuns"
	ConvergenceLRPDurationMetric = "ConvergenceLRPDuration"

	LRPsUnclaimedMetric     = "LRPsUnclaimed"
	LRPsClaimedMetric       = "LRPsClaimed"
	LRPsRunningMetric       = "LRPsRunning"
	CrashedActualLRPsMetric = "CrashedActualLRPs"
	LRPsMissingMetric       = "LRPsMissing"
	LRPsExtraMetric         = "LRPsExtra"

	SuspectRunningLRPsMetric = "SuspectRunningActualLRPs"
	SuspectClaimedLRPsMetric = "SuspectClaimedActualLRPs"

	LRPsDesiredMetric         = "LRPsDesired"
	CrashingDesiredLRPsMetric = "CrashingDesiredLRPs"

	PresentCellsMetric = "PresentCells"
	SuspectCellsMetric = "SuspectCells"
)

const (
	DefaultTaskEmitMetricsFrequency = 15 * time.Second

	ConvergenceTaskRunsMetric     = "ConvergenceTaskRuns"
	ConvergenceTaskDurationMetric = "ConvergenceTaskDuration"

	TasksStartedMetric   = "TasksStarted"
	TasksSucceededMetric = "TasksSucceeded"
	TasksFailedMetric    = "TasksFailed"

	TasksPendingMetric   = "TasksPending"
	TasksRunningMetric   = "TasksRunning"
	TasksCompletedMetric = "TasksCompleted"
	TasksResolvingMetric = "TasksResolving"

	ConvergenceTasksPrunedMetric = "ConvergenceTasksPruned"
	ConvergenceTasksKickedMetric = "ConvergenceTasksKicked"
)

const (
	DefaultEmitFrequency = 60 * time.Second
)

Functions

func NewBBSElectionMetronNotifier

func NewBBSElectionMetronNotifier(logger lager.Logger, metronClient loggingclient.IngressClient) ifrit.Runner

func NewDBStatMetronNotifier

func NewDBStatMetronNotifier(logger lager.Logger, clock clock.Clock, dbStats DBStats, metronClient logging.IngressClient, monitor monitor.Monitor) ifrit.Runner

func NewFileDescriptorMetronNotifier

func NewFileDescriptorMetronNotifier(logger lager.Logger, newTicker clock.Ticker, metronClient loggingclient.IngressClient, procPath string) ifrit.Runner

Types

type BBSElectionMetronNotifier

type BBSElectionMetronNotifier struct {
	Logger lager.Logger
	// contains filtered or unexported fields
}

func (BBSElectionMetronNotifier) Run

func (notifier BBSElectionMetronNotifier) Run(signals <-chan os.Signal, ready chan<- struct{}) error

type DBStats

type DBStats interface {
	OpenConnections() int
	WaitDuration() time.Duration
	WaitCount() int64
}

type FileDescriptorMetronNotifier

type FileDescriptorMetronNotifier struct {
	Logger lager.Logger
	// contains filtered or unexported fields
}

func (FileDescriptorMetronNotifier) Run

func (notifier FileDescriptorMetronNotifier) Run(signals <-chan os.Signal, ready chan<- struct{}) error

type LRPStatMetronNotifier

type LRPStatMetronNotifier interface {
	ifrit.Runner

	RecordFreshDomains(domains []string)
	RecordConvergenceDuration(duration time.Duration)
	RecordLRPCounts(
		unclaimed, claimed, running, crashed, missing, extra,
		suspectRunning, suspectClaimed, desired, crashingDesired int,
	)
	RecordCellCounts(present, suspect int)
}

func NewLRPStatMetronNotifier

func NewLRPStatMetronNotifier(logger lager.Logger, clock clock.Clock, metronClient logging.IngressClient) LRPStatMetronNotifier

type RequestStatMetronNotifier

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

func NewRequestStatMetronNotifier

func NewRequestStatMetronNotifier(logger lager.Logger, ticker clock.Ticker, metronClient loggingclient.IngressClient) *RequestStatMetronNotifier

func (*RequestStatMetronNotifier) IncrementRequestCounter

func (notifier *RequestStatMetronNotifier) IncrementRequestCounter(delta int)

func (*RequestStatMetronNotifier) ReadAndResetLatency

func (notifier *RequestStatMetronNotifier) ReadAndResetLatency() time.Duration

func (*RequestStatMetronNotifier) Run

func (notifier *RequestStatMetronNotifier) Run(signals <-chan os.Signal, ready chan<- struct{}) error

func (*RequestStatMetronNotifier) UpdateLatency

func (notifier *RequestStatMetronNotifier) UpdateLatency(latency time.Duration)

type TaskStatMetronNotifier

type TaskStatMetronNotifier interface {
	ifrit.Runner

	RecordConvergenceDuration(duration time.Duration)
	RecordTaskStarted(cellID string)
	RecordTaskSucceeded(cellID string)
	RecordTaskFailed(cellID string)
	RecordTaskCounts(pending, running, completed, resolved int, pruned, kicked uint64)
}

func NewTaskStatMetronNotifier

func NewTaskStatMetronNotifier(logger lager.Logger, clock clock.Clock, metronClient logging.IngressClient) TaskStatMetronNotifier