93 lines
1.9 KiB
Go
93 lines
1.9 KiB
Go
package json
|
|
|
|
import (
|
|
"encoding/json"
|
|
"math"
|
|
"time"
|
|
|
|
"github.com/influxdata/telegraf"
|
|
)
|
|
|
|
type serializer struct {
|
|
TimestampUnits time.Duration
|
|
}
|
|
|
|
func NewSerializer(timestampUnits time.Duration) (*serializer, error) {
|
|
s := &serializer{
|
|
TimestampUnits: truncateDuration(timestampUnits),
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
func (s *serializer) Serialize(metric telegraf.Metric) ([]byte, error) {
|
|
m := s.createObject(metric)
|
|
serialized, err := json.Marshal(m)
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
serialized = append(serialized, '\n')
|
|
|
|
return serialized, nil
|
|
}
|
|
|
|
func (s *serializer) SerializeBatch(metrics []telegraf.Metric) ([]byte, error) {
|
|
objects := make([]interface{}, 0, len(metrics))
|
|
for _, metric := range metrics {
|
|
m := s.createObject(metric)
|
|
objects = append(objects, m)
|
|
}
|
|
|
|
obj := map[string]interface{}{
|
|
"metrics": objects,
|
|
}
|
|
|
|
serialized, err := json.Marshal(obj)
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
return serialized, nil
|
|
}
|
|
|
|
func (s *serializer) createObject(metric telegraf.Metric) map[string]interface{} {
|
|
m := make(map[string]interface{}, 4)
|
|
|
|
tags := make(map[string]string, len(metric.TagList()))
|
|
for _, tag := range metric.TagList() {
|
|
tags[tag.Key] = tag.Value
|
|
}
|
|
m["tags"] = tags
|
|
|
|
fields := make(map[string]interface{}, len(metric.FieldList()))
|
|
for _, field := range metric.FieldList() {
|
|
switch fv := field.Value.(type) {
|
|
case float64:
|
|
// JSON does not support these special values
|
|
if math.IsNaN(fv) || math.IsInf(fv, 0) {
|
|
continue
|
|
}
|
|
}
|
|
fields[field.Key] = field.Value
|
|
}
|
|
m["fields"] = fields
|
|
|
|
m["name"] = metric.Name()
|
|
m["timestamp"] = metric.Time().UnixNano() / int64(s.TimestampUnits)
|
|
return m
|
|
}
|
|
|
|
func truncateDuration(units time.Duration) time.Duration {
|
|
// Default precision is 1s
|
|
if units <= 0 {
|
|
return time.Second
|
|
}
|
|
|
|
// Search for the power of ten less than the duration
|
|
d := time.Nanosecond
|
|
for {
|
|
if d*10 > units {
|
|
return d
|
|
}
|
|
d = d * 10
|
|
}
|
|
}
|