health

README

go-health

A library that enables async dependency health checking for services running on an orchastrated container platform such as kubernetes or mesos.

Why is this important?

Container orchestration platforms require that the underlying service(s) expose a "healthcheck" which is used by the platform to determine whether the container is in a good or bad state.

While this can be achieved by simply exposing a /status endpoint that perfoms synchronous checks against its dependencies (followed by returning a 200 or non-200 status code), it is not optimal for a number of reasons:

• It does not scale
  • The more dependencies you add, the longer your healthcheck will take to complete (and potentially cause your service to be killed off by the orchestration platform).
  • Depending on the complexity of a given dependency, your check may be fairly involved where it is okay for it to take 30s+ to complete.
• It adds unnecessary load on yours deps or at worst, becomes a DoS target
  • Non-malicious scenario
    • Thundering herd problem -- in the event of a deployment (or restart, etc.), all of your service containers are likely to have their /status endpoints checked by the orchestration platform as soon as they come up. Depending on the complexity of the checks, running that many simultaneous checks against your dependencies could cause at worst the dependencies to experience problems and at minimum add unnecessary load.
    • Security scanners -- if your organization runs periodic security scans, they may hit your /status endpoint and trigger unnecessary dep checks.
  • Malicious scenario
    • Loading up any basic HTTP benchmarking tool and pointing it at your /status endpoint could choke your dependencies (and potentially your service).

With that said, not everyone needs asynchronous checks. If your service has one dependency (and that is unlikely to change), it is trivial to write a basic, synchronous check and it will probably suffice.

However, if you anticipate that your service will have several dependencies, with varying degrees of complexity for determing their health state - you should probably think about introducing asynchronous health checks.

How does this library help?

Writing an async healthchecking framework for your service is not a trivial task, especially if Go is not your primary language.

This library:

• Allows you to define how to check your dependencies.
• Allows you to define warning and fatal thresholds.
• Will run your dependency checks on a given interval, in the background.
• Exposes a way for you to gather the check results in a fast and thread-safe manner to help determine the final status of your /status endpoint.
• Comes bundled w/ a number of checkers for well-known dependencies such as MySQL, PostgreSQL, Redis, HTTP, Mongo.
• Makes it simple to implement and provide your own checkers (by adhering to the checker interface).
• Is test-friendly
  • Provides an easy way to disable dependency health checking.
  • Uses an interface for its dependencies, allowing you to insert fakes/mocks at test time.

Example

For full examples, look through the examples dir

1. Create an instance of health and configure a checker (or two)

import (
	health "github.com/InVisionApp/go-health"
	"github.com/InVisionApp/go-health/checkers"
	"github.com/InVisionApp/go-health/handlers"
)

// Create a new health instance
h := health.New()

// Create a checker
myURL, _ := url.Parse("https://google.com")
myCheck, _ := checkers.NewHTTP(&checkers.HTTPConfig{
    URL: myURL,
})

1. Register your check with your health instance

h.AddChecks([]*health.Config{
    {
        Name:     "my-check",
        Checker:  myCheck,
        Interval: time.Duration(2) * time.Second,
        Fatal:    true,
    },
)

1. Start the healthcheck

h.Start()

From here on, you can either configure an endpoint such as /healthcheck to use a built-in handler such as handlers.NewJSONHandlerFunc() or get the current health state of all your deps by traversing the data returned by h.State().

Additional Documentation

• Examples
• Checkers
• Logging

Contributing

All PR's are welcome, as long as they are well tested. Follow the typical fork->branch->pr flow.

Documentation

Index

• Variables
• type Config
• type Health
  • func New() *Health
  • func (h *Health) AddCheck(cfg *Config) error
  • func (h *Health) AddChecks(cfgs []*Config) error
  • func (h *Health) DisableLogging()
  • func (h *Health) Failed() bool
  • func (h *Health) Start() error
  • func (h *Health) State() (map[string]State, bool, error)
  • func (h *Health) Stop() error
• type ICheckable
• type IHealth
• type State

Variables

var (
	// ErrNoAddCfgWhenActive is returned when you attempt to add check(s) to an already active healthcheck instance
	ErrNoAddCfgWhenActive = errors.New("Unable to add new check configuration(s) while healthcheck is active")

	// ErrAlreadyRunning is returned when you attempt to `h.Start()` an already running healthcheck
	ErrAlreadyRunning = errors.New("Healthcheck is already running - nothing to start")

	// ErrAlreadyStopped is returned when you attempt to `h.Stop()` a non-running healthcheck instance
	ErrAlreadyStopped = errors.New("Healthcheck is not running - nothing to stop")

	// ErrEmptyConfigs is returned when you attempt to add an empty slice of configs via `h.AddChecks()`
	ErrEmptyConfigs = errors.New("Configs appears to be empty - nothing to add")
)

Types

type Config

type Config struct {
	Name     string
	Checker  ICheckable
	Interval time.Duration
	Fatal    bool
}

The Config struct is used for defining and configuring checks.

type Health

type Health struct {
	Logger loggers.ILogger
	// contains filtered or unexported fields
}

Health contains internal go-health internal structures

func New

func New() *Health

New returns a new instance of the Health struct.

func (*Health) AddCheck

func (h *Health) AddCheck(cfg *Config) error

AddCheck is used for adding a single check definition to the current health instance.

func (*Health) AddChecks

func (h *Health) AddChecks(cfgs []*Config) error

AddChecks is used for adding multiple check definitions at once (as opposed to adding them sequentially via `AddCheck()`).

func (*Health) DisableLogging

func (h *Health) DisableLogging()

DisableLogging will disable all logging by inserting the noop logger

func (*Health) Failed

func (h *Health) Failed() bool

Failed will return the basic state of overall health. This should be used when details about the failure are not needed

func (*Health) Start

func (h *Health) Start() error

Start will start all of the defined health checks. Each of the checks run in their own goroutines (as `time.Ticker`).

func (*Health) State

func (h *Health) State() (map[string]State, bool, error)

State will return a map of all current healthcheck states (thread-safe), a bool indicating whether the healthcheck has fully failed and a potential error.

The returned structs can be used for figuring out additional analytics or used for building your own status handler (as opposed to using the built-in `hc.HandlerBasic` or `hc.HandlerJSON`).

The map key is the name of the check.

func (*Health) Stop

func (h *Health) Stop() error

Stop will cause all of the running health checks to be stopped. Additionally, all existing check states will be reset.

type ICheckable

type ICheckable interface {
	// Status allows you to return additional data as an `interface{}` and `error`
	// to signify that the check has failed. If `interface{}` is non-nil, it will
	// be exposed under `State.Details` for that particular check.
	Status() (interface{}, error)
}

The ICheckable interface is implemented by a number of bundled checkers such as `MySQLChecker`, `RedisChecker` and `HTTPChecker`. By implementing the interface, you can feed your own custom checkers into the health library.

type IHealth

type IHealth interface {
	AddChecks(cfgs []*Config) error
	AddCheck(cfg *Config) error
	Start() error
	Stop() error
	State() (map[string]State, bool, error)
	Failed() bool
}

The IHealth interface can be useful if you plan on replacing the actual health checker with a mock during testing. Otherwise, you can set `hc.Disable = true` after instantiation.

type State

type State struct {
	Name   string `json:"name"`
	Status string `json:"status"`
	Err    string `json:"error,omitempty"`
	// contains JSON message (that can be marshaled)
	Details   interface{} `json:"details,omitempty"`
	CheckTime time.Time   `json:"check_time"`
}

The State struct contains the results of the latest run of a particular check.