check

type Check struct {
	// Id should be any unique value for this check.
	Id string

	// Schedule determines when this Check is due to be executed.
	Schedule Schedule

	// Command is the command this check runs against the service or host.
	// Examples are snmp, ping, dns, or http commands
	Command Command

	// Meta is a key/value store of any extra data you want to live with the
	// check.
	Meta map[string]any

	// Incident needs to be the current active incident for this check
	// or else nil.
	Incident *Incident

	// SuppressIncidents set to true means when this Check executes and
	// produces an Incident, it discards it.
	SuppressIncidents bool

	// Handlers is a slice of handlers to execute after the Check's Command runs.
	// A Handler has a Mutate() and Process() method for mutating a Check's data
	// and processing it, respectfully.  Mutate() methods are called first in
	// sequential order as specified in this slice.  Then Process() methods are
	// called asynchronously.
	Handlers []Handler

	// LastCheck is a time.Time of the last time this Check executed. This will
	// be updated automatically by Execute(), but be sure it's set to the
	// correct time when loading a check from an external database.
	LastCheck *time.Time

	// LastResult is a Result from the last time this Check executed (or nil).
	// This will be updated automatically by Execute(), but be sure it's set to
	// the correct Result when loading a check from an external database.
	//
	// LastResult could be used by the Command to determine value deltas.  If
	// you are certain this is not required in your case, then this could always
	// be nil.
	LastResult *Result

	// Executed is true when the Check has had Execute() called on it.  You should
	// set this back to false prior to queueing it again.
	Executed bool
	// contains filtered or unexported fields
}

type Command interface {
	Run(*Check) (*Result, error)
}

type Handler interface {
	// Mutate allows the handler to mutate any data in the Check, Result or
	// Incident prior to Process()ing it.  Mutate() is called sequentially in
	// the order the Handlers are defined on the Check.
	Mutate(check *Check, newResult *Result, newIncident *Incident)

	// Process executes asynchronously and should not mutate data.
	Process(check *Check, newResult *Result, newIncident *Incident) error
}

type Incident struct {
	Id           uuid.UUID
	FromState    ResultState
	ToState      ResultState
	ReasonCode   string
	Time         time.Time
	Resolved     *time.Time
	Acknowledged *time.Time
}

type Option func(*Check)

type PeriodicSchedule struct {
	IntervalSeconds int
}

type Queue interface {
	Enqueue(chk *Check)
	Dequeue() *Check
	Count() uint64
	Flush()
}

type Result struct {
	Id         uuid.UUID
	State      ResultState
	ReasonCode string
	Metrics    []ResultMetric
	Time       time.Time
}

type ResultMetric struct {
	// Label is an identifier for the metric (ex. avg_rtt_ms, temperature_f).
	Label string

	// Value is the metric's numeric value.  It is a string so that it can hold
	// any number, and it is up to the user to convert this into whatever
	// numerical type they need during processing.
	Value string

	// Type is the type of metric Value is.  Can be ResultMetricCounter or
	// ResultMetricGauge.
	Type ResultMetricType
}

type ResultMetricType uint8

type ResultState uint8

type Schedule interface {
	// DueAt returns a time.Time of the exact point in time the Check will
	// be next due.
	DueAt(*Check) time.Time
}