func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
statsdHost := flag.String("statsd", "", "Statsd host to record load test metrics")
flag.Parse()
stats, err := statsd.NewClient(*statsdHost, "hystrix.loadtest.service")
if err != nil {
log.Fatalf("could not initialize statsd client: %v", err)
}
c, err := plugins.InitializeStatsdCollector(&plugins.StatsdCollectorConfig{
StatsdAddr: *statsdHost,
Prefix: "hystrix.loadtest.circuits",
})
if err != nil {
log.Fatalf("could not initialize statsd client: %v", err)
}
metricCollector.Registry.Register(c.NewStatsdCollector)
hystrix.ConfigureCommand("test", hystrix.CommandConfig{
Timeout: 50,
})
go rotateDelay()
http.HandleFunc("/", timedHandler(handle, stats))
log.Print("starting server")
log.Fatal(http.ListenAndServe(":8888", nil))
}
func main() {
for {
client, err := statsd.NewClient("104.130.20.4:8125", hostname())
if err != nil {
fmt.Println(err.Error())
}
memoryUtil()
defer client.Close()
value, _ := memoryUtil()
fmt.Println(value)
client.Gauge("Apache2", value, 0.4)
fmt.Println(hostname())
time.Sleep(1 * time.Second)
}
}
func main() {
configPath := flag.String("config", "config.yml", "Path to configuration file")
flag.Parse()
configBytes, err := ioutil.ReadFile(*configPath)
cmd.FailOnError(err, fmt.Sprintf("Failed to read configuration file from '%s'", *configPath))
var c config
err = yaml.Unmarshal(configBytes, &c)
cmd.FailOnError(err, fmt.Sprintf("Failed to parse configuration file from '%s'", *configPath))
go cmd.DebugServer(c.DebugAddr)
stats, err := statsd.NewClient(c.StatsdServer, c.StatsdPrefix)
cmd.FailOnError(err, "Failed to create StatsD client")
scope := metrics.NewStatsdScope(stats, "caa-service")
resolver := bdns.NewDNSResolverImpl(
c.DNSTimeout.Duration,
[]string{c.DNSResolver},
scope,
clock.Default(),
5,
)
s, l, err := bgrpc.NewServer(&c.GRPC, scope)
cmd.FailOnError(err, "Failed to setup gRPC server")
ccs := &caaCheckerServer{resolver, scope}
pb.RegisterCAACheckerServer(s, ccs)
err = s.Serve(l)
cmd.FailOnError(err, "gRPC service failed")
}
// NewStatsd returns a new Statsd implementation that sends stats to addr.
func NewStatsd(addr, prefix string) (*Statsd, error) {
c, err := statsd.NewClient(addr, prefix)
if err != nil {
return nil, err
}
return &Statsd{
client: c,
}, nil
}
func sendStats(statsdHost string, prefix string, gauges map[string]int64, counters map[string]int64) {
client, err := statsd.NewClient(statsdHost, prefix)
if err != nil {
color.Red("ERROR: can't connect to statsd")
}
defer client.Close()
sendGauges(client, gauges)
sendCounters(client, counters)
}
// InitializeStatsdCollector creates the connection to the Statsd server
// and should be called before any metrics are recorded.
//
// Users should ensure to call Close() on the client.
func InitializeStatsdCollector(config *StatsdCollectorConfig) (*StatsdCollectorClient, error) {
c, err := statsd.NewClient(config.StatsdAddr, config.Prefix)
if err != nil {
log.Printf("Could not initiale buffered client: %s. Falling back to a Noop Statsd client", err)
c, _ = statsd.NewNoopClient()
}
return &StatsdCollectorClient{
client: c,
}, err
}
func main() {
perLogBufferSize := flag.Int("perLogBufferSize", 25000, "")
perLogDBWorkers := flag.Int("perLogDBWorkers", 5, "")
dbMaxIdleConns := flag.Int("dbMaxIdleConns", 300, "")
flag.Parse()
configFilename := "config.json"
var config cross.Config
contents, err := ioutil.ReadFile(configFilename)
if err != nil {
fmt.Println(err)
return
}
err = json.Unmarshal(contents, &config)
if err != nil {
fmt.Println(err)
return
}
stats, err := statsd.NewClient(config.StatsdURI, "pollinator")
if err != nil {
fmt.Println(err)
return
}
db, err := cross.NewDatabase(config.DatabaseURI, stats, *dbMaxIdleConns)
if err != nil {
fmt.Println(err)
return
}
logs := make([]*cross.Log, len(config.Logs))
for i, kl := range config.Logs {
log, err := cross.NewLog(db, stats, kl, *perLogBufferSize, *perLogDBWorkers)
if err != nil {
fmt.Println(err)
return
}
logs[i] = log
}
p := pollinator{
db: db,
dbWorkers: 250,
stats: stats,
logs: logs,
}
// p.getUpdates()
for _, l := range p.logs {
missing, err := l.CountMissingChains()
fmt.Printf("%s: %d (%s)\n", l.Description, missing, err)
}
}
func main() {
appname := path.Base(os.Args[0])
logrus.SetFormatter(&logrus.JSONFormatter{})
logger = logrus.WithFields(logrus.Fields{
"applicationname": appname,
})
var k8shost, k8sport, k8sproto, prefix string
var statsdhost, statsdport string
if k8shost = os.Getenv("KUBERNETES_SERVICE_HOST"); k8shost == "" {
logger.Panic("Must Supply KUBERNETES_SERVICE_HOST")
}
if k8sport = os.Getenv("KUBERNETES_SERVICE_PORT"); k8sport == "" {
logger.Panic("Must Supply KUBERNETES_SERVICE_PORT")
}
if k8sproto = os.Getenv("KUBERNETES_SERVICE_PROTO"); k8sproto == "" {
logger.Panic("Must Supply KUBERNETES_SERVICE_PROTO (http/https)")
}
if statsdhost = os.Getenv("STATSD_SERVICE_HOST"); statsdhost == "" {
logger.Panic("Must Supply STATSD_SERVICE_HOST")
}
if statsdport = os.Getenv("STATSD_SERVICE_PORT"); statsdport == "" {
logger.Panic("Must Supply STATSD_SERVICE_PORT")
}
if prefix = os.Getenv("STATSD_PREFIX"); prefix == "" {
prefix = "k8smon"
}
k8s := fmt.Sprintf("%s://%s:%s", k8sproto, k8shost, k8sport)
logger.Infof("Connecting to Kubernetes Master: %s", k8s)
config := unversioned.Config{
Host: k8s,
Version: "v1",
}
var err error
k8sclient, err = unversioned.New(&config)
if err != nil {
logger.Panic("Unable to connect to Kubernetes Master", err)
}
sd := fmt.Sprintf("%s:%s", statsdhost, statsdport)
logger.Infof("Connecting to statsd: %s", sd)
statsdclient, err = statsd.NewClient(sd, prefix)
if err != nil {
logger.Panic("Unable to connect to statsd", err)
}
for {
CountInstances()
time.Sleep(time.Second * 5)
}
}
// SendStats will send all stats collected by TubesStats() to statsd
//
// Return error if fail to connect to statsd
func SendStats(stats map[string]map[string]int) error {
client, err := statsd.NewClient(config.StatsdAddr, config.StatsdPrefix)
if err != nil {
return fmt.Errorf("Failed to connect to statsd: %s", err)
}
for tube, sts := range stats {
verbose1("sending stats of tube %s", tube)
for stat, value := range sts {
name := fmt.Sprintf("%s.%s", tube, stat)
client.Gauge(name, int64(value), 1.0)
verbose2("%s.%s: %d", config.StatsdPrefix, name, value)
}
}
return nil
}
func main() {
var prefix string
mysqlDSN := "root:root@tcp(127.0.0.1:3306)/mysql"
statsdURL := "127.0.0.1:8125"
flag.StringVar(&prefix, "prefix", "", "prefix to send to statsd, usually server hostname")
flag.Parse()
if flag.NArg() < 2 {
fmt.Println("Usage: mysql-query-metric-statsd QUERY METRIC_NAME")
fmt.Println("\nOptions:")
flag.PrintDefaults()
os.Exit(0)
}
if os.Getenv("MYSQL_DSN") != "" {
mysqlDSN = os.Getenv("MYSQL_DSN")
}
if os.Getenv("STATSD_URL") != "" {
statsdURL = os.Getenv("STATSD_URL")
}
query := flag.Arg(0)
metricName := flag.Arg(1)
db, err := sql.Open("mysql", mysqlDSN)
if err != nil {
log.Fatal("Error connecting to mysql:", err)
}
log.Println("Executing mysql query:", query)
var value int64
if err := db.QueryRow(query).Scan(&value); err != nil {
log.Fatal("Error executing mysql query:", err)
}
sc, err := statsd.NewClient(statsdURL, prefix)
if err != nil {
log.Fatal("Error creating statsd client:", err)
}
defer sc.Close()
sc.Gauge(metricName, value, 1.0)
log.Printf("Sent metric prefix=%v name=%v value=%v", prefix, metricName, value)
}
func main() {
port := "8125"
if len(os.Args) > 1 {
port = os.Args[1]
}
client, err := statsd.NewClient(fmt.Sprintf("127.0.0.1:%s", port), "testNamespace")
if err != nil {
fmt.Printf("Error connecting to statsd server: %v\n", err.Error())
return
}
defer client.Close()
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
line := scanner.Text()
inputs := strings.Split(line, " ")
if len(inputs) < 3 {
fmt.Printf("Wrong number of inputs, 3 needed at least\n")
continue
}
statsdType := inputs[0]
name := inputs[1]
value, _ := strconv.ParseInt(inputs[2], 10, 0)
var sampleRate float32 = 1.0
if len(inputs) == 4 {
rate, _ := strconv.ParseFloat(inputs[3], 32)
sampleRate = float32(rate)
}
switch statsdType {
case "count":
client.Inc(name, value, sampleRate)
case "gauge":
client.Gauge(name, value, sampleRate)
case "gaugedelta":
client.GaugeDelta(name, value, sampleRate)
case "timing":
client.Timing(name, value, sampleRate)
default:
fmt.Printf("Unsupported operation: %s\n", statsdType)
}
}
}
/*
Connects statsd server and sends the metric
*/
func statsdSender(config *configuration, msg string) {
client, err := statsd.NewClient(statsdURIBuilder(config), "")
if err != nil {
logger.Error(err.Error())
}
defer client.Close()
arr := strings.Split(msg, ":")
key := arr[0]
value, err := strconv.ParseInt(arr[1], 10, 64)
if err != nil {
logger.Error(err.Error())
}
// logger.Info("Statsd data flushed: %s", msg)
err = client.Inc(key, value, 1.0)
if err != nil {
logger.Error(err.Error())
}
}
func SendStatsD(gs string, gt string, gv int64) {
// connect to statsd
var sd string = "127.0.0.1:8125"
var gk string = "nginx"
client, err := statsd.NewClient(sd, gk)
if err != nil {
log.Println(err)
}
defer client.Close()
// send metrics to statsd
var fi float32 = 10.0
var mt string = "status.demo_nginx_com"
client.Inc(mt+"."+gs+"."+gt, gv, fi)
}
// NewStatsdStatsRecorder accepts an address and a namespace as strings and returns a pointer
// to an initialized Stat instance.
func NewStatsdStatsRecorder(address, namespace string) *StatsdStatsRecorder {
client, err := statsd.NewClient(address, namespace)
if err != nil {
return nil
}
stats := &StatsdStatsRecorder{
address: address,
// arbitrary buffer size just to support as much
// non blocking as possible
counter: make(chan *StatsdStat, 100),
timer: make(chan *StatsdStat, 100),
gauge: make(chan *StatsdStat, 100),
client: client,
}
go stats.Start()
return stats
}
// Open allocates resources for the stats writer.
func (s *StatsWriter) Open(host string, port string, prefix string) error {
var err error
if s.isOpen {
return errors.New("Stats Writer is already open")
}
s.isOpen = true
// If necessary, use the no-op client so we don't need to test everywhere.
if host == "" {
s.Client, _ = statsd.NewNoopClient()
err = errors.New("Stats Writer not configured")
} else {
addr := net.JoinHostPort(host, port)
s.Client, err = statsd.NewClient(addr, prefix)
if err != nil {
s.Client, _ = statsd.NewNoopClient()
}
}
// Report memory usage stats every second.
s.quit = make(chan struct{})
if err == nil {
// Don't bother starting the ticker when using the no-op client.
// (We still make the channel, to simplify the close.)
statsTicker := time.NewTicker(time.Second * 1)
go func() {
for _ = range statsTicker.C {
select {
case <-s.quit:
return
default:
s.sendMemoryStats()
}
}
}()
}
return err
}
func SendStatsD(gs string, gt string, gv int64) {
// assign variables for statsd server and metric name prefix
var statsdServer string = "127.0.0.1:8125"
var gk string = "nginx"
// connect to statsd
client, err := statsd.NewClient(statsdServer, gk)
if err != nil {
log.Println(err)
}
defer client.Close()
// assign variables for metric name and interval
var fi float32 = 10.0
var st string = "status"
var sn string = "demo_nginx_com"
// send metrics to statsd
client.Inc(st+"."+sn+"."+gs+"."+gt, gv, fi)
}
func pushStats(statsd_config Statsd, status ServerStatus) error {
prefix := fmt.Sprintf("statsd.mongodb.%s.%s.%s", statsd_config.Env, statsd_config.Cluster, status.Host)
host_port := fmt.Sprintf("%s:%d", statsd_config.Host, statsd_config.Port)
client, err := statsd.NewClient(host_port, prefix)
if err != nil {
return err
}
defer client.Close()
err = pushConnections(client, status.Connections)
if err != nil {
return err
}
err = pushOpcounters(client, status.Opcounters)
if err != nil {
return err
}
err = pushMem(client, status.Mem)
if err != nil {
return err
}
err = pushGlobalLocks(client, status.GlobalLocks)
if err != nil {
return err
}
err = pushExtraInfo(client, status.ExtraInfo)
if err != nil {
return err
}
return nil
}
func main() {
// command line flags
var opts struct {
HostPort string `long:"host" default:"127.0.0.1:8125" description:"host:port of statsd server"`
Prefix string `long:"prefix" default:"test-client" description:"Statsd prefix"`
StatType string `long:"type" default:"count" description:"stat type to send. Can be timing, count, guage"`
StatValue int64 `long:"value" default:"1" description:"Value to send"`
Name string `short:"n" long:"name" default:"counter" description:"stat name"`
Rate float32 `short:"r" long:"rate" default:"1.0" description:"sample rate"`
Volume int `short:"c" long:"count" default:"1000" description:"Number of stats to send. Volume."`
Nil bool `long:"nil" default:"false" description:"Use nil client"`
Buffered bool `long:"buffered" default:"false" description:"Use a buffered client"`
Duration time.Duration `short:"d" long:"duration" default:"10s" description:"How long to spread the volume across. Each second of duration volume/seconds events will be sent."`
}
// parse said flags
_, err := flags.Parse(&opts)
if err != nil {
if e, ok := err.(*flags.Error); ok {
if e.Type == flags.ErrHelp {
os.Exit(0)
}
}
fmt.Printf("Error: %+v\n", err)
os.Exit(1)
}
if opts.Nil && opts.Buffered {
fmt.Printf("Specifying both nil and buffered together is invalid.")
os.Exit(1)
}
var client statsd.Statter
if !opts.Nil {
if !opts.Buffered {
client, err = statsd.NewClient(opts.HostPort, opts.Prefix)
} else {
client, err = statsd.NewBufferedClient(opts.HostPort, opts.Prefix, opts.Duration/time.Duration(4), 0)
}
if err != nil {
log.Fatal(err)
}
defer client.Close()
}
var stat func(stat string, value int64, rate float32) error
switch opts.StatType {
case "count":
stat = func(stat string, value int64, rate float32) error {
return client.Inc(stat, value, rate)
}
case "gauge":
stat = func(stat string, value int64, rate float32) error {
return client.Gauge(stat, value, rate)
}
case "timing":
stat = func(stat string, value int64, rate float32) error {
return client.Timing(stat, value, rate)
}
default:
log.Fatal("Unsupported state type")
}
pertick := opts.Volume / int(opts.Duration.Seconds()) / 10
// add some extra tiem, because the first tick takes a while
ender := time.After(opts.Duration + 100*time.Millisecond)
c := time.Tick(time.Second / 10)
count := 0
for {
select {
case <-c:
for x := 0; x < pertick; x++ {
err := stat(opts.Name, opts.StatValue, opts.Rate)
if err != nil {
log.Printf("Got Error: %+v", err)
break
}
count += 1
}
case <-ender:
log.Printf("%d events called", count)
os.Exit(0)
return
}
}
}
func main() {
configFilename := "config.yml"
content, err := ioutil.ReadFile(configFilename)
if err != nil {
fmt.Println(err)
return
}
var c config
err = yaml.Unmarshal(content, &c)
whoisTimeout, err := time.ParseDuration(c.WHOIS.Timeout)
if err != nil {
fmt.Println(err)
return
}
whoisKeepAlive, err := time.ParseDuration(c.WHOIS.KeepAlive)
if err != nil {
fmt.Println(err)
return
}
asnFinder := asnFinder.New(
c.WHOIS.Host,
c.WHOIS.Port,
whoisTimeout,
whoisKeepAlive,
)
stats, err := statsd.NewClient(net.JoinHostPort(c.StatsD.Host, c.StatsD.Port), "gobservatory")
if err != nil {
fmt.Println(err)
return
}
database, err := db.New(stats)
if err != nil {
fmt.Println(err)
return
}
nssPool, err := core.PoolFromPEM(c.NSSPool)
if err != nil {
fmt.Println(err)
return
}
msPool, err := core.PoolFromPEM(c.MSPool)
if err != nil {
fmt.Println(err)
return
}
transPool, err := core.PoolFromPEM(c.TransPool)
if err != nil {
fmt.Println(err)
return
}
go core.ProfileCmd(stats)
obs := submission.New(
nssPool,
msPool,
transPool,
c.SubmissionAPI.Host,
c.SubmissionAPI.Port,
asnFinder,
database,
stats,
)
wg := new(sync.WaitGroup)
for i := 0; i < c.Workers; i++ {
wg.Add(1)
go obs.ParseSubmissions(wg)
}
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, os.Interrupt)
go func() {
for _ = range sigChan {
fmt.Println("\nInterrupt! Shutting down API server and waiting for remaining submissions to be processed")
err = obs.Shutdown()
if err != nil {
fmt.Printf("Problem shutting down API server: %s\n", err)
return
}
}
}()
err = obs.Serve("", "")
if err != nil {
fmt.Println(err)
return
}
wg.Wait()
}
func main() {
for {
client, err := statsd.NewClient("127.0.0.1:8125", "nginx")
// handle any errors
if err != nil {
log.Fatal(err)
}
var status_json string = "http://demo.nginx.com/status"
// request status json from NGINX Plus
x, err := http.Get(status_json)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
x_dec := json.NewDecoder(x.Body)
// sleep x seconds
time.Sleep(time.Millisecond * 1000)
// re-request json from NGINX Plus
y, err := http.Get(status_json)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
y_dec := json.NewDecoder(y.Body)
// loop through both to get diff
var x_data StatusJSON
if err := x_dec.Decode(&x_data); err == io.EOF {
break
} else if err != nil {
log.Fatal(err)
}
var y_data StatusJSON
if err := y_dec.Decode(&y_data); err == io.EOF {
break
} else if err != nil {
log.Fatal(err)
}
// processes
ngx_proc := (y_data.Processes.Respawned)
fmt.Println("status.demo.processes.respawned", ngx_proc)
client.Inc("status.demo.processes.respawned", ngx_proc, 1.0)
// connections
ngx_ca := (y_data.Connections.Accepted - x_data.Connections.Accepted)
fmt.Println("status.demo.connections.accepted", ngx_ca)
client.Inc("status.demo.connections.accepted", ngx_ca, 1.0)
ngx_cd := (y_data.Connections.Dropped - x_data.Connections.Dropped)
fmt.Println("status.demo.connections.dropped", ngx_cd)
client.Inc("status.demo.connections.dropped", ngx_cd, 1.0)
ngx_can := (y_data.Connections.Active)
fmt.Println("status.demo.connections.active", ngx_can)
client.Inc("status.demo.connections.active", ngx_can, 1.0)
ngx_cai := (y_data.Connections.Idle)
fmt.Println("status.demo.connections.idle", ngx_cai)
client.Inc("status.demo.connections.idle", ngx_cai, 1.0)
// requests
ngx_req := (y_data.Requests.Current)
fmt.Println("status.demo.requests.current", ngx_req)
client.Inc("status.demo.requests.current", ngx_req, 1.0)
ngx_reqt := (y_data.Requests.Total - x_data.Requests.Total)
fmt.Println("status.demo.requests.total", ngx_reqt)
client.Inc("status.demo.requests.total", ngx_reqt, 1.0)
// server zones
ngx_sz_oproc := (y_data.ServerZones.One.Processing)
fmt.Println("status.demo.serverzones.one.processing", ngx_sz_oproc)
client.Inc("status.demo.serverzones.one.processing", ngx_sz_oproc, 1.0)
ngx_sz_orec := (y_data.ServerZones.One.Received - x_data.ServerZones.One.Received)
fmt.Println("status.demo.serverzones.one.received", ngx_sz_orec)
client.Inc("status.demo.serverzones.one.received", ngx_sz_orec, 1.0)
ngx_sz_osent := (y_data.ServerZones.One.Sent - x_data.ServerZones.One.Sent)
fmt.Println("status.demo.serverzones.one.sent", ngx_sz_osent)
client.Inc("status.demo.serverzones.one.sent", ngx_sz_osent, 1.0)
ngx_sz_oreq := (y_data.ServerZones.One.Requests - x_data.ServerZones.One.Requests)
fmt.Println("status.demo.serverzones.one.requests", ngx_sz_oreq)
client.Inc("status.demo.serverzones.one.requests", ngx_sz_oreq, 1.0)
ngx_sz_oresp_t := (y_data.ServerZones.One.Responses.Total - x_data.ServerZones.One.Responses.Total)
fmt.Println("status.demo.serverzones.one.responses.total", ngx_sz_oresp_t)
client.Inc("status.demo.serverzones.one.responses.total", ngx_sz_oresp_t, 1.0)
ngx_sz_oresp_1xx := (y_data.ServerZones.One.Responses.OneXx - x_data.ServerZones.One.Responses.OneXx)
fmt.Println("status.demo.serverzones.one.responses.1xx", ngx_sz_oresp_1xx)
client.Inc("status.demo.serverzones.one.responses.1xx", ngx_sz_oresp_1xx, 1.0)
ngx_sz_oresp_2xx := (y_data.ServerZones.One.Responses.TwoXx - x_data.ServerZones.One.Responses.TwoXx)
fmt.Println("status.demo.serverzones.one.responses.2xx", ngx_sz_oresp_2xx)
client.Inc("status.demo.serverzones.one.responses.2xx", ngx_sz_oresp_2xx, 1.0)
ngx_sz_oresp_3xx := (y_data.ServerZones.One.Responses.ThreeXx - x_data.ServerZones.One.Responses.ThreeXx)
fmt.Println("status.demo.serverzones.one.responses.3xx", ngx_sz_oresp_3xx)
client.Inc("status.demo.serverzones.one.responses.3xx", ngx_sz_oresp_3xx, 1.0)
ngx_sz_oresp_4xx := (y_data.ServerZones.One.Responses.FourXx - x_data.ServerZones.One.Responses.FourXx)
fmt.Println("status.demo.serverzones.one.responses.4xx", ngx_sz_oresp_4xx)
client.Inc("status.demo.serverzones.one.responses.4xx", ngx_sz_oresp_4xx, 1.0)
ngx_sz_oresp_5xx := (y_data.ServerZones.One.Responses.FiveXx - x_data.ServerZones.One.Responses.FiveXx)
fmt.Println("status.demo.serverzones.one.responses.5xx", ngx_sz_oresp_5xx)
client.Inc("status.demo.serverzones.one.responses.5xx", ngx_sz_oresp_5xx, 1.0)
ngx_sz_oresp_err_perc := (ngx_sz_oresp_4xx + ngx_sz_oresp_5xx/ngx_sz_oresp_t)
fmt.Println("status.demo.serverzones.one.responses.error_percentage", ngx_sz_oresp_err_perc)
client.Inc("status.demo.serverzones.one.responses.error_percentage", ngx_sz_oresp_err_perc, 1.0)
// close any open connections before loop restarts
// close any open connections before loop restarts
client.Close()
x.Body.Close()
y.Body.Close()
}
}
func main() {
app := cli.NewApp()
app.Name = "stxy"
app.Version = "0.0.4"
app.Usage = "haproxy stats to statsd"
app.Flags = []cli.Flag{
cli.StringFlag{
Name: "haproxy-url",
Value: "localhost:22002/;csv",
Usage: "host:port of haproxy server",
},
cli.StringFlag{
Name: "statsd-url, s",
Value: "localhost:8125",
Usage: "host:port of statsd server",
},
cli.StringFlag{
Name: "prefix,p",
Usage: "statsd namespace",
Value: "haproxy",
},
cli.StringFlag{
Name: "interval,i",
Usage: "time in milliseconds",
Value: "10000",
},
}
app.Action = func(c *cli.Context) {
interval, _ := strconv.ParseInt(c.String("interval"), 10, 64)
for {
client, err := statsd.NewClient(c.String("s"), c.String("p"))
// handle any errors
if err != nil {
log.Fatal(err)
}
// make sure to clean up
defer client.Close()
initial_stats := get_stats(c.String("haproxy-url"))
previous := map[string]int64{}
for _, v := range initial_stats {
if v[1] == "BACKEND" {
previous[fmt.Sprint("1xx_", v[0])] = get_value(v, "hrsp_1xx", 39)
previous[fmt.Sprint("2xx_", v[0])] = get_value(v, "hrsp_2xx", 40)
previous[fmt.Sprint("3xx_", v[0])] = get_value(v, "hrsp_3xx", 41)
previous[fmt.Sprint("4xx_", v[0])] = get_value(v, "hrsp_4xx", 42)
previous[fmt.Sprint("5xx_", v[0])] = get_value(v, "hrsp_5xx", 43)
}
}
time.Sleep(time.Duration(interval) * time.Millisecond)
records := get_stats(c.String("haproxy-url"))
for _, record := range records {
if record[1] == "BACKEND" {
go send_gauge(client, record, "scur", 4)
go send_gauge(client, record, "smax", 5)
go send_gauge(client, record, "ereq", 12)
go send_gauge(client, record, "econ", 13)
go send_gauge(client, record, "rate", 33)
go send_gauge(client, record, "bin", 8)
go send_gauge(client, record, "bout", 9)
go send_counter(previous[fmt.Sprint("1xx_", record[0])], client, record, "hrsp_1xx", 39)
go send_counter(previous[fmt.Sprint("2xx_", record[0])], client, record, "hrsp_2xx", 40)
go send_counter(previous[fmt.Sprint("3xx_", record[0])], client, record, "hrsp_3xx", 41)
go send_counter(previous[fmt.Sprint("4xx_", record[0])], client, record, "hrsp_4xx", 42)
go send_counter(previous[fmt.Sprint("5xx_", record[0])], client, record, "hrsp_5xx", 43)
go send_gauge(client, record, "qtime", 58)
go send_gauge(client, record, "ctime", 59)
go send_gauge(client, record, "rtime", 60)
go send_gauge(client, record, "ttime", 61)
}
}
color.White("-------------------")
}
}
app.Run(os.Args)
}