health

README

health-go

• Exposes an HTTP handler that retrieves health status of the application
• Implements some generic checkers for the following services:
  • RabbitMQ
  • PostgreSQL
  • Redis
  • HTTP
  • MongoDB
  • MySQL
  • gRPC

Usage

The library exports Handler and HandlerFunc functions which are fully compatible with net/http.

Additionally, library exports Measure function that returns summary status for all the registered health checks, so it can be used in non-HTTP environments.

Handler

package main

import (
  "net/http"
  "time"

  "github.com/hellofresh/health-go/v3"
  healthMysql "github.com/hellofresh/health-go/v3/checks/mysql"
)

func main() {
  health.Register(health.Config{
    Name: "rabbitmq",
    Timeout: time.Second*5,
    SkipOnErr: true,
    Check: func() error {
      // rabbitmq health check implementation goes here
    },
  })

  health.Register(health.Config{
    Name: "mongodb",
    Check: func() error {
      // mongo_db health check implementation goes here
    },
  })
  
  health.Register(health.Config{
    Name:      "mysql",
    Timeout:   time.Second * 2,
    SkipOnErr: false,
    Check: healthMysql.New(healthMysql.Config{
      DSN: "test:test@tcp(0.0.0.0:31726)/test?charset=utf8",
    },
  })

  http.Handle("/status", health.Handler())
  http.ListenAndServe(":3000", nil)
}

HandlerFunc

package main

import (
  "net/http"
  "time"

  "github.com/go-chi/chi"
  "github.com/hellofresh/health-go/v3"
  healthMysql "github.com/hellofresh/health-go/v3/checks/mysql"
)

func main() {
  health.Register(health.Config{
    Name: "rabbitmq",
    Timeout: time.Second*5,
    SkipOnErr: true,
    Check: func() error {
      // rabbitmq health check implementation goes here
    }),
  })

  health.Register(health.Config{
    Name: "mongodb",
    Check: func() error {
      // mongo_db health check implementation goes here
    },
  })
  
  health.Register(health.Config{
    Name:      "mysql",
    Timeout:   time.Second * 2,
    SkipOnErr: false,
    Check: healthMysql.New(healthMysql.Config{
      DSN:               "test:test@tcp(0.0.0.0:31726)/test?charset=utf8",
    },
  })

  r := chi.NewRouter()
  r.Get("/status", health.HandlerFunc)
  http.ListenAndServe(":3000", nil)
}

For more examples please check here

API Documentation

GET /status

Get the health of the application.

• Method: GET
• Endpoint: /status
• Request:

curl localhost:3000/status

• Response:

HTTP/1.1 200 OK

{
  "status": "OK",
  "timestamp": "2017-01-01T00:00:00.413567856+033:00",
  "system": {
    "version": "go1.8",
    "goroutines_count": 4,
    "total_alloc_bytes": 21321,
    "heap_objects_count": 21323,
    "alloc_bytes": 234523
  }
}

HTTP/1.1 200 OK

{
  "status": "Partially Available",
  "timestamp": "2017-01-01T00:00:00.413567856+033:00",
  "failures": {
    "rabbitmq": "Failed during rabbitmq health check"
  },
  "system": {
    "version": "go1.8",
    "goroutines_count": 4,
    "total_alloc_bytes": 21321,
    "heap_objects_count": 21323,
    "alloc_bytes": 234523
  }
}

HTTP/1.1 503 Service Unavailable

{
  "status": "Unavailable",
  "timestamp": "2017-01-01T00:00:00.413567856+033:00",
  "failures": {
    "mongodb": "Failed during mongodb health check"
  },
  "system": {
    "version": "go1.8",
    "goroutines_count": 4,
    "total_alloc_bytes": 21321,
    "heap_objects_count": 21323,
    "alloc_bytes": 234523
  }
}

Contributing

• Fork it
• Create your feature branch (git checkout -b my-new-feature)
• Commit your changes (git commit -am 'Add some feature')
• Push to the branch (git push origin my-new-feature)
• Create new Pull Request

---

GitHub @hellofresh  ·  Medium @engineering.hellofresh

Documentation

Index

• func Handler() http.Handler
• func HandlerFunc(w http.ResponseWriter, r *http.Request)
• func Register(c Config) error
• func Reset()
• type Check
  • func Measure() Check
• type CheckFunc
• type Config
• type Status
• type System

Functions

func Handler

func Handler() http.Handler

Handler returns an HTTP handler (http.HandlerFunc).

func HandlerFunc

func HandlerFunc(w http.ResponseWriter, r *http.Request)

HandlerFunc is the HTTP handler function.

func Register

func Register(c Config) error

Register registers a check config to be performed.

func Reset

func Reset()

Reset unregisters all previously set check configs

Types

type Check

type Check struct {
	// Status is the check status.
	Status Status `json:"status"`
	// Timestamp is the time in which the check occurred.
	Timestamp time.Time `json:"timestamp"`
	// Failures holds the failed checks along with their messages.
	Failures map[string]string `json:"failures,omitempty"`
	// System holds information of the go process.
	System `json:"system"`
}

Check represents the health check response.

func Measure

func Measure() Check

Measure runs all the registered health checks and returns summary status

type CheckFunc

type CheckFunc func() error

CheckFunc is the func which executes the check.

type Config

type Config struct {
	// Name is the name of the resource to be checked.
	Name string
	// Timeout is the timeout defined for every check.
	Timeout time.Duration
	// SkipOnErr if set to true, it will retrieve StatusOK providing the error message from the failed resource.
	SkipOnErr bool
	// Check is the func which executes the check.
	Check CheckFunc
}

Config carries the parameters to run the check.

type Status

type Status string

Status type represents health status

const (
	StatusOK                 Status = "OK"
	StatusPartiallyAvailable Status = "Partially Available"
	StatusUnavailable        Status = "Unavailable"
	StatusTimeout            Status = "Timeout during health check"
)

Possible health statuses

type System

type System struct {
	// Version is the go version.
	Version string `json:"version"`
	// GoroutinesCount is the number of the current goroutines.
	GoroutinesCount int `json:"goroutines_count"`
	// TotalAllocBytes is the total bytes allocated.
	TotalAllocBytes int `json:"total_alloc_bytes"`
	// HeapObjectsCount is the number of objects in the go heap.
	HeapObjectsCount int `json:"heap_objects_count"`
	// TotalAllocBytes is the bytes allocated and not yet freed.
	AllocBytes int `json:"alloc_bytes"`
}

System runtime variables about the go process.