health

type AvailabilityStatus string

type Check struct {
	// The Name must be unique among all checks. Name is a required attribute.
	Name string // Required

	// Check is the check function that will be executed to check availability.
	// This function must return an error if the checked service is considered
	// not available. Check is a required attribute.
	Check func(ctx context.Context) error // Required

	// Timeout will override the global timeout value, if it is smaller than
	// the global timeout (see WithTimeout).
	Timeout time.Duration // Optional

	// MaxTimeInError will set a duration for how long a service must be
	// in an error state until it is considered down/unavailable.
	MaxTimeInError time.Duration // Optional

	// MaxContiguousFails will set a maximum number of contiguous
	// check fails until the service is considered down/unavailable.
	MaxContiguousFails uint // Optional

	// StatusListener allows to set a listener that will be called
	// whenever the AvailabilityStatus (e.g. from "up" to "down").
	StatusListener func(ctx context.Context, name string, state CheckState) // Optional

	// Interceptors holds a list of Interceptor instances that will be executed one after another in the
	// order as they appear in the list.
	Interceptors []Interceptor

	// DisablePanicRecovery disables automatic recovery from panics. If left in its default value (false),
	// panics will be automatically converted into errors instead.
	DisablePanicRecovery bool

	// PanicHandler allows to set a panic handler.
	PanicHandler func(ctx context.Context, err error) // Optional
	// contains filtered or unexported fields
}

type CheckResult struct {
	// Status is the availability status of a component.
	Status AvailabilityStatus `json:"status"`
	// Timestamp holds the time when the check was executed.
	Timestamp time.Time `json:"timestamp,omitempty"`
	// Error contains the check error message, if the check failed.
	Error error `json:"error,omitempty"`
}

type CheckState struct {
	// LastCheckedAt holds the time of when the check was last executed.
	LastCheckedAt time.Time
	// LastCheckedAt holds the last time of when the check did not return an error.
	LastSuccessAt time.Time
	// LastFailureAt holds the last time of when the check did return an error.
	LastFailureAt time.Time
	// FirstCheckStartedAt holds the time of when the first check was started.
	FirstCheckStartedAt time.Time
	// ContiguousFails holds the number of how often the check failed in a row.
	ContiguousFails uint
	// Result holds the error of the last check (nil if successful).
	Result error
	// The current availability status of the check.
	Status AvailabilityStatus
}

type Checker interface {
	// Start will start all necessary background workers and prepare
	// the checker for further usage.
	Start()
	// Stop will stop the checker.
	Stop()
	// Check runs all synchronous (i.e., non-periodic) check functions.
	// It returns the aggregated health status (combined from the results
	// of this executions synchronous checks and the previously reported
	// results of asynchronous/periodic checks. This function expects a
	// context, that may contain deadlines to which will be adhered to.
	// The context will be passed to all downstream calls
	// (such as listeners, component check functions, and interceptors).
	Check(ctx context.Context) Result
	// GetRunningPeriodicCheckCount returns the number of currently
	// running periodic checks.
	GetRunningPeriodicCheckCount() int
	// IsStarted returns true, if the Checker was started (see Checker.Start)
	// and is currently still running. Returns false otherwise.
	IsStarted() bool
}

type GRPCHealthClientService interface {
	healthgrpc.HealthClient
}

type GRPCServer struct{}

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

type HandlerOption func(*HandlerConfig)

type Interceptor func(next InterceptorFunc) InterceptorFunc

type InterceptorFunc func(ctx context.Context, checkName string, state CheckState) CheckState

type JSONResultWriter struct{}

type Middleware func(next MiddlewareFunc) MiddlewareFunc

type MiddlewareFunc func(r *http.Request) Result

type Option func(config *checkerConfig)

type Result struct {
	// Info contains additional information about this health result.
	Info map[string]interface{} `json:"info,omitempty"`
	// Status is the aggregated system availability status.
	Status AvailabilityStatus `json:"status"`
	// Details contains health information for all checked components.
	Details map[string]CheckResult `json:"details,omitempty"`
}

type ResultWriter interface {
	// Write writes a Result into a http.ResponseWriter in a format
	// that the ResultWriter supports (such as XML, JSON, etc.).
	// A ResultWriter is expected to write at least the following information into the http.ResponseWriter:
	// (1) A MIME type header (e.g., "Content-Type" : "application/json"),
	// (2) the HTTP status code that is passed in parameter statusCode (this is necessary due to ordering constraints
	// when writing into a http.ResponseWriter, and
	// (3) the response body in the format that the ResultWriter supports.
	Write(result *Result, statusCode int, w http.ResponseWriter, r *http.Request) error
}

type State struct {
	// Status is the aggregated system health status.
	Status AvailabilityStatus
	// CheckState contains the state of all checks.
	CheckState map[string]CheckState
}