Golang: implements http server health checking. gocraft/health

I want to check the health of my service,having the metrics of each endPoint.
My service calls some other services and recieves a Json code, I make templates with it, and then I send it to a http.ResponseWriter.

I searched and I found this package "gocraft/health" but I didn't really understand how it works.

Is there any other way or package to generate metrics or should I just use "gocraft/health.

Thank you in advance

Finally, I choose "gocraft/health", a great library.

Example of usage:

package main

import (
	"log"
	"net/http"
	"os"
	"time"

	"github.com/gocraft/health"
)

//should be global Var
var stream = health.NewStream()

func main() {
	// Log to stdout!
	stream.AddSink(&health.WriterSink{os.Stdout})
	// Make sink and add it to stream
	sink := health.NewJsonPollingSink(time.Minute*5, time.Minute*20)
	stream.AddSink(sink)
	// Start the HTTP server! This will expose metrics via a JSON API.
	adr := "127.0.0.1:5001"
	sink.StartServer(adr)

	http.HandleFunc("/api/getVastPlayer", vastPlayer)
	log.Println("Listening...")
	panic(http.ListenAndServe(":2001", nil))
}

Per the initialization options above, your metrics are aggregated in 5-minute chunks. We'll keep 20 minutes worth of data in memory. Nothing is ever persisted to disk.

You can create as many jobs as you want

func vastPlayer(w http.ResponseWriter, r *http.Request) {
  job_1 := stream.NewJob("/api/getVastPlayer")
  
  ...
  ...

  if bol {
    job_1.Complete(health.Success)
  } else {
    job_1.Complete(health.Error)
  }
}

Once you start your app, this will expose metrics via a JSON API. You can browse the /health endpoint (eg, 127.0.0.1:5001/health) to see the metrics. You will get something like that:

{
  "instance_id": "sd-69536.29342",
  "interval_duration": 86400000000000,
  "aggregations": [
    {
      "interval_start": "2015-06-11T02:00:00+02:00",
      "serial_number": 1340,
      "jobs": {
        "/api/getVastPlayer": {
          "timers": {},
          "events": {},
          "event_errs": {},
          "count": 1328,
          "nanos_sum": 140160794784,
          "nanos_sum_squares": 9.033775178022173E+19,
          "nanos_min": 34507863,
          "nanos_max": 2736850494,
          "count_success": 62,
          "count_validation_error": 1266,
          "count_panic": 0,
          "count_error": 0,
          "count_junk": 0
        },
        "timers": {},
        "events": {},
        "event_errs": {}
      }
    }
  ]
}

For more information and functionality check this link:

https://github.com/gocraft/health

In case you came across this question because you were looking for exposing a /health endpoint, there is an upcoming RFC for health checks: https://github.com/inadarei/rfc-healthcheck

And there's a Go library health-go for exposing health endpoints compliant with that RFC: https://github.com/nelkinda/health-go

Example:

package main

import (
	"github.com/nelkinda/health-go"
	"net/http"
)

func main() {
	// 1. Create the health Handler.
	h := health.New(health.Health{Version: "1", ReleaseID: "1.0.0-SNAPSHOT"}) 

	// 2. Add the handler to your mux/server.
	http.HandleFunc("/health", h.Handler)
	
	// 3. Start your server.
	http.ListenAndServe(":80", nil)
}

It is extensible and supports a number of built-in checks such as uptime and sysinfo.

Disclaimer: I'm the author of health-go.