func writeSeries(client *influxdb.Client, buf []*influxdb.Series) {
err := client.WriteSeries(buf)
if err != nil {
Conf.Logger.Printf("influxdb can't write series %+v", err)
}
return
}
func send(r metrics.Registry, client *influxClient.Client) error {
series := []*influxClient.Series{}
r.Each(func(name string, i interface{}) {
now := getCurrentTime()
switch metric := i.(type) {
case metrics.Counter:
series = append(series, &influxClient.Series{
Name: fmt.Sprintf("%s.count", name),
Columns: []string{"time", "count"},
Points: [][]interface{}{
{now, metric.Count()},
},
})
case metrics.Gauge:
series = append(series, &influxClient.Series{
Name: fmt.Sprintf("%s.value", name),
Columns: []string{"time", "value"},
Points: [][]interface{}{
{now, metric.Value()},
},
})
case metrics.GaugeFloat64:
series = append(series, &influxClient.Series{
Name: fmt.Sprintf("%s.value", name),
Columns: []string{"time", "value"},
Points: [][]interface{}{
{now, metric.Value()},
},
})
case metrics.Histogram:
h := metric.Snapshot()
ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
series = append(series, &influxClient.Series{
Name: fmt.Sprintf("%s.histogram", name),
Columns: []string{"time", "count", "min", "max", "mean", "std-dev",
"50-percentile", "75-percentile", "95-percentile",
"99-percentile", "999-percentile"},
Points: [][]interface{}{
{now, h.Count(), h.Min(), h.Max(), h.Mean(), h.StdDev(),
ps[0], ps[1], ps[2], ps[3], ps[4]},
},
})
case metrics.Meter:
m := metric.Snapshot()
series = append(series, &influxClient.Series{
Name: fmt.Sprintf("%s.meter", name),
Columns: []string{"count", "one-minute",
"five-minute", "fifteen-minute", "mean"},
Points: [][]interface{}{
{m.Count(), m.Rate1(), m.Rate5(), m.Rate15(), m.RateMean()},
},
})
case metrics.Timer:
h := metric.Snapshot()
ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
series = append(series, &influxClient.Series{
Name: fmt.Sprintf("%s.timer", name),
Columns: []string{"count", "min", "max", "mean", "std-dev",
"50-percentile", "75-percentile", "95-percentile",
"99-percentile", "999-percentile", "one-minute", "five-minute", "fifteen-minute", "mean-rate"},
Points: [][]interface{}{
{h.Count(), h.Min(), h.Max(), h.Mean(), h.StdDev(),
ps[0], ps[1], ps[2], ps[3], ps[4],
h.Rate1(), h.Rate5(), h.Rate15(), h.RateMean()},
},
})
}
})
if err := client.WriteSeries(series); err != nil {
log.Println(err)
}
return nil
}
func send(client *influxClient.Client, series []*influxClient.Series) error {
return client.WriteSeries(series)
}
// mainLoop initiates all ports and handles the traffic
func mainLoop() {
openPorts()
defer closePorts()
ports := 1
if errPort != nil {
ports++
}
waitCh := make(chan bool)
go func(num int) {
total := 0
for {
select {
case v := <-inCh:
if !v {
log.Println("IN port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
} else {
total++
}
case v := <-errCh:
if !v {
log.Println("ERR port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
} else {
total++
}
}
if total >= num && waitCh != nil {
waitCh <- true
}
}
}(ports)
log.Println("Waiting for port connections to establish... ")
select {
case <-waitCh:
log.Println("Ports connected")
waitCh = nil
case <-time.Tick(30 * time.Second):
log.Println("Timeout: port connections were not established within provided interval")
exitCh <- syscall.SIGTERM
return
}
log.Println("Waiting for options to arrive...")
var (
influxHost, influxUsername, influxPassword, influxDB, tmpStr string
parts, kv []string
ip [][]byte
)
for {
ip, err = optionsPort.RecvMessageBytes(0)
if err != nil {
log.Println("Error receiving IP:", err.Error())
continue
}
if !runtime.IsValidIP(ip) || !runtime.IsPacket(ip) {
continue
}
tmpStr = string(ip[1])
parts = strings.Split(tmpStr, ",")
for _, p := range parts {
kv = strings.Split(p, "=")
if len(kv) != 2 {
continue
}
switch kv[0] {
case "host":
influxHost = kv[1]
case "user":
influxUsername = kv[1]
case "pass":
influxPassword = kv[1]
case "db":
influxDB = kv[1]
}
}
optionsPort.Close()
break
}
var (
config *influxdb.ClientConfig
client *influxdb.Client
)
config = &influxdb.ClientConfig{
Host: influxHost,
Username: influxUsername,
Password: influxPassword,
Database: influxDB,
}
log.Printf("Using ClientConfig = %#v", config)
client, err := influxdb.NewClient(config)
if err != nil {
fmt.Println("Error creating InfluxDB client:", err.Error())
exitCh <- syscall.SIGTERM
return
}
log.Println("Started...")
var series *influxdb.Series
for {
ip, err = inPort.RecvMessageBytes(0)
if err != nil {
log.Println("Error receiving message:", err.Error())
continue
}
if !runtime.IsValidIP(ip) {
continue
}
err = json.Unmarshal(ip[1], &series)
if err != nil {
log.Println("Failed to decode incoming series:", err.Error())
continue
}
if err = client.WriteSeries([]*influxdb.Series{series}); err != nil {
log.Println("Error writing series:", err.Error())
if errPort != nil {
errPort.SendMessage(runtime.NewPacket([]byte(err.Error())))
}
continue
}
}
}