Esempio n. 1
0
func TestHealthD(t *testing.T) {
	// Make two sinks:
	sink := health.NewJsonPollingSink(time.Minute, time.Minute*5)
	sink.StartServer(":6050")
	sink.EmitEvent("foo", "bar", nil)
	sink.EmitTiming("foo", "baz", 1234, nil)
	sink.EmitComplete("foo", health.Success, 5678, nil)

	sink2 := health.NewJsonPollingSink(time.Minute, time.Minute*5)
	sink2.StartServer(":6051")
	sink2.EmitEvent("foo", "bar", nil)
	sink2.EmitTiming("foo", "baz", 4321, nil)
	sink2.EmitComplete("foo", health.ValidationError, 8765, nil)

	hd := StartNewHealthD([]string{":6050", ":6051"}, ":6060", health.NewStream())

	defer func() {
		hd.Stop()
		time.Sleep(time.Millisecond)
	}()

	time.Sleep(time.Millisecond * 15)

	testAggregations(t, hd)
	testAggregationsOverall(t, hd)
	testJobs(t, hd)
	testHosts(t, hd)

}
Esempio n. 2
0
func TestPoll(t *testing.T) {
	setNowMock("2011-09-09T23:36:13Z")
	defer resetNowMock()

	intAgg := health.NewIntervalAggregation(now())
	data := &health.HealthAggregationsResponse{
		InstanceId:           "web22.12345",
		IntervalDuration:     time.Minute,
		IntervalAggregations: []*health.IntervalAggregation{intAgg},
	}
	stop := serveJson(":5050", data)
	defer func() {
		stop()
	}()

	responses := make(chan *pollResponse, 2)
	poll(health.NewStream(), ":5050", responses)
	response := <-responses

	assert.NotNil(t, response)
	assert.Equal(t, response.HostPort, ":5050")
	assert.Equal(t, response.Timestamp, now())
	assert.Nil(t, response.Err)
	assert.Equal(t, response.Code, 200)
	assert.True(t, response.Nanos > 0 && response.Nanos < int64(time.Second))
	assert.Equal(t, response.InstanceId, "web22.12345")
	// we'll just "trust" that the other stuff gets unmarshalled correctly. We didn't really put anything in there anyway in this test.
}
Esempio n. 3
0
// nice to have's
// - handle the case when time goes backwards.
// - we need some way to not return all data from clients on every request. Necessary?
func main() {
	// Get inputs. Read from env variables for now (command line options?)
	monitoredHostPorts := getMonitoredHostPorts()
	serverHostPort := getServerHostPort()
	healthHostPort := getHealthHostPort()

	// Monitor ourselves. This will make our own instrumentation show up in the healthd output
	// I'm not totally sure we want to do this, but (shrug) seems reasonable right now.
	monitoredHostPorts = append(monitoredHostPorts, healthHostPort)

	// Setup our health stream.
	// Log to stdout and a setup an polling sink
	stream := health.NewStream()
	stream.AddSink(&health.WriterSink{os.Stdout})
	jsonPollingSink := health.NewJsonPollingSink(time.Minute, time.Minute*5)
	jsonPollingSink.StartServer(healthHostPort)
	stream.AddSink(jsonPollingSink)

	// Say we're starting!
	stream.EventKv("starting", health.Kvs{
		"monitored_host_ports": strings.Join(monitoredHostPorts, ","),
		"server_host_port":     serverHostPort,
		"health_host_port":     healthHostPort,
	})

	// Start the healthd aggregators in a goroutine(s)
	healthd.StartNewHealthD(monitoredHostPorts, serverHostPort, stream)

	// Block
	select {}
}
package main

import (
	"fmt"
	"net/http"
	"os"
	"runtime/debug"
	"strconv"
	"time"

	"github.com/gocraft/health"
)

var applicationGCStats = debug.GCStats{}
var instrument = health.NewStream()

// SetupInstrumentation handles all the intialisation of the instrumentation handler
func SetupInstrumentation(enabled bool) {
	thisInstr := os.Getenv("TYK_INSTRUMENTATION")

	if thisInstr == "1" {
		enabled = true
	}

	if !enabled {
		return
	}

	if config.StatsdConnectionString == "" {
		log.Error("Instrumentation is enabled, but no connectionstring set for statsd")
		return
Esempio n. 5
0
	"github.com/gocraft/health"
	"github.com/gocraft/web"
	"github.com/nu7hatch/gouuid"
	"io"
	"net/http"
	"runtime"
	"strconv"
)

type Context struct {
	Job   *health.Job
	Panic bool
}

var (
	stream = health.NewStream()
	router = web.New(Context{})
)

func init() {
	router.Middleware((*Context).Log)
	router.Middleware((*Context).CatchPanics)
	router.Middleware((*Context).SetContentType)
	router.Middleware((*Context).Cors)
	router.NotFound((*Context).NotFound)
}

func ListenAndServe(addr string, sink io.Writer) {
	if sink != nil {
		stream.AddSink(&health.WriterSink{sink})
	}