-
Notifications
You must be signed in to change notification settings - Fork 13
/
json.go
94 lines (79 loc) · 2 KB
/
json.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package json
import (
"encoding/json"
"fmt"
"math"
"time"
"github.com/circonus-labs/circonus-unified-agent/cua"
)
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 cua.Metric) ([]byte, error) {
m := s.createObject(metric)
serialized, err := json.Marshal(m)
if err != nil {
return []byte{}, fmt.Errorf("json marshal: %w", err)
}
serialized = append(serialized, '\n')
return serialized, nil
}
func (s *Serializer) SerializeBatch(metrics []cua.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{}, fmt.Errorf("json marshal: %w", err)
}
return serialized, nil
}
func (s *Serializer) createObject(metric cua.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) { //nolint:staticcheck
continue
}
default:
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 *= 10
}
}