health

Documentation

Index

• func AwaitAlive(ctx context.Context, c Client, freq time.Duration, options ...rpc.Option) (bool, error)
• func AwaitHealthy(ctx context.Context, c Client, freq time.Duration, options ...rpc.Option) (bool, error)
• func AwaitReady(ctx context.Context, c Client, freq time.Duration, options ...rpc.Option) (bool, error)
• func NewGetAndPostHandler(log logging.Logger, reporter Reporter) (http.Handler, error)
• func NewGetHandler(reporter func() (map[string]Result, bool)) http.Handler
• type APIReply
• type Checker
• type CheckerFunc
  • func (f CheckerFunc) HealthCheck(ctx context.Context) (interface{}, error)
• type Client
  • func NewClient(uri string) Client
• type Health
  • func New(log logging.Logger, registerer prometheus.Registerer) (Health, error)
• type Registerer
• type Reporter
• type Result
• type Service
  • func (s *Service) Health(_ *http.Request, _ *struct{}, reply *APIReply) error
  • func (s *Service) Liveness(_ *http.Request, _ *struct{}, reply *APIReply) error
  • func (s *Service) Readiness(_ *http.Request, _ *struct{}, reply *APIReply) error

Functions

func AwaitAlive

func AwaitAlive(ctx context.Context, c Client, freq time.Duration, options ...rpc.Option) (bool, error)

AwaitAlive polls the node every [freq] until the node reports liveness. Only returns an error if [ctx] returns an error.

func AwaitHealthy

func AwaitHealthy(ctx context.Context, c Client, freq time.Duration, options ...rpc.Option) (bool, error)

AwaitHealthy polls the node every [freq] until the node reports healthy. Only returns an error if [ctx] returns an error.

func AwaitReady

func AwaitReady(ctx context.Context, c Client, freq time.Duration, options ...rpc.Option) (bool, error)

AwaitReady polls the node every [freq] until the node reports ready. Only returns an error if [ctx] returns an error.

func NewGetAndPostHandler

func NewGetAndPostHandler(log logging.Logger, reporter Reporter) (http.Handler, error)

NewGetAndPostHandler returns a health handler that supports GET and jsonrpc POST requests.

func NewGetHandler

func NewGetHandler(reporter func() (map[string]Result, bool)) http.Handler

NewGetHandler return a health handler that supports GET requests reporting the result of the provided [reporter].

Types

type APIReply

type APIReply struct {
	Checks  map[string]Result `json:"checks"`
	Healthy bool              `json:"healthy"`
}

APIReply is the response for Readiness, Health, and Liveness.

type Checker

type Checker interface {
	// HealthCheck returns health check results and, if not healthy, a non-nil
	// error
	//
	// It is expected that the results are json marshallable.
	HealthCheck(context.Context) (interface{}, error)
}

Checker can have its health checked

type CheckerFunc

type CheckerFunc func(context.Context) (interface{}, error)

func (CheckerFunc) HealthCheck

func (f CheckerFunc) HealthCheck(ctx context.Context) (interface{}, error)

type Client

type Client interface {
	// Readiness returns if the node has finished initialization
	Readiness(context.Context, ...rpc.Option) (*APIReply, error)
	// Health returns a summation of the health of the node
	Health(context.Context, ...rpc.Option) (*APIReply, error)
	// Liveness returns if the node is in need of a restart
	Liveness(context.Context, ...rpc.Option) (*APIReply, error)
}

Client interface for Avalanche Health API Endpoint For helpers to wait for Readiness, Health, or Liveness, see AwaitReady, AwaitHealthy, and AwaitAlive.

func NewClient

func NewClient(uri string) Client

NewClient returns a client to interact with Health API endpoint

type Health

type Health interface {
	Registerer
	Reporter

	Start(ctx context.Context, freq time.Duration)
	Stop()
}

Health defines the full health service interface for registering, reporting and refreshing health checks.

func New

func New(log logging.Logger, registerer prometheus.Registerer) (Health, error)

type Registerer

type Registerer interface {
	RegisterReadinessCheck(name string, checker Checker) error
	RegisterHealthCheck(name string, checker Checker) error
	RegisterLivenessCheck(name string, checker Checker) error
}

Registerer defines how to register new components to check the health of.

type Reporter

type Reporter interface {
	Readiness() (map[string]Result, bool)
	Health() (map[string]Result, bool)
	Liveness() (map[string]Result, bool)
}

Reporter returns the current health status.

type Result

type Result struct {
	// Details of the HealthCheck.
	Details interface{} `json:"message,omitempty"`

	// Error is the string representation of the error returned by the failing
	// HealthCheck. The value is nil if the check passed.
	Error *string `json:"error,omitempty"`

	// Timestamp of the last HealthCheck.
	Timestamp time.Time `json:"timestamp,omitempty"`

	// Duration is the amount of time this HealthCheck last took to evaluate.
	Duration time.Duration `json:"duration"`

	// ContiguousFailures the HealthCheck has returned.
	ContiguousFailures int64 `json:"contiguousFailures,omitempty"`

	// TimeOfFirstFailure of the HealthCheck,
	TimeOfFirstFailure *time.Time `json:"timeOfFirstFailure,omitempty"`
}

type Service

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

func (*Service) Health

func (s *Service) Health(_ *http.Request, _ *struct{}, reply *APIReply) error

Health returns a summation of the health of the node

func (*Service) Liveness

func (s *Service) Liveness(_ *http.Request, _ *struct{}, reply *APIReply) error

Liveness returns if the node is in need of a restart

func (*Service) Readiness

func (s *Service) Readiness(_ *http.Request, _ *struct{}, reply *APIReply) error

Readiness returns if the node has finished initialization