-
Notifications
You must be signed in to change notification settings - Fork 183
/
monitors.go
155 lines (136 loc) · 4.04 KB
/
monitors.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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
package selfdescribe
import (
"go/doc"
"os"
"path/filepath"
"reflect"
"sort"
"strings"
log "github.com/sirupsen/logrus"
"github.com/signalfx/signalfx-agent/internal/monitors"
)
type metricMetadata struct {
Name string `json:"name"`
Type string `json:"type"`
Description string `json:"description"`
}
type propMetadata struct {
Name string `json:"name"`
Dimension string `json:"dimension"`
Description string `json:"description"`
}
type monitorMetadata struct {
structMetadata
MonitorType string `json:"monitorType"`
AcceptsEndpoints bool `json:"acceptsEndpoints"`
SingleInstance bool `json:"singleInstance"`
Dimensions []dimMetadata `json:"dimensions"`
Metrics []metricMetadata `json:"metrics"`
Properties []propMetadata `json:"properties"`
}
func monitorsStructMetadata() []monitorMetadata {
sms := []monitorMetadata{}
// Set to track undocumented monitors
monTypesSeen := make(map[string]bool)
filepath.Walk("internal/monitors", func(path string, info os.FileInfo, err error) error {
if !info.IsDir() || err != nil {
return err
}
pkgDoc := packageDoc(path)
if pkgDoc == nil {
return nil
}
for monType, monDoc := range monitorDocsInPackage(pkgDoc) {
if _, ok := monitors.ConfigTemplates[monType]; !ok {
log.Errorf("Found MONITOR doc for monitor type %s but it doesn't appear to be registered", monType)
continue
}
t := reflect.TypeOf(monitors.ConfigTemplates[monType]).Elem()
monTypesSeen[monType] = true
allDocs := nestedPackageDocs(path)
mc, _ := t.FieldByName("MonitorConfig")
mmd := monitorMetadata{
structMetadata: getStructMetadata(t),
MonitorType: monType,
AcceptsEndpoints: mc.Tag.Get("acceptsEndpoints") == "true",
SingleInstance: mc.Tag.Get("singleInstance") == "true",
Dimensions: dimensionsFromNotes(allDocs),
Metrics: metricsFromNotes(allDocs),
Properties: propertiesFromNotes(allDocs),
}
mmd.Doc = monDoc
mmd.Package = path
sms = append(sms, mmd)
}
return nil
})
sort.Slice(sms, func(i, j int) bool {
return sms[i].MonitorType < sms[j].MonitorType
})
for k := range monitors.ConfigTemplates {
if !monTypesSeen[k] {
log.Warnf("Monitor Type %s is registered but does not appear to have documentation", k)
}
}
return sms
}
func monitorDocsInPackage(pkgDoc *doc.Package) map[string]string {
out := make(map[string]string)
for _, note := range pkgDoc.Notes["MONITOR"] {
out[note.UID] = note.Body
}
return out
}
func dimensionsFromNotes(allDocs []*doc.Package) []dimMetadata {
var dm []dimMetadata
for _, note := range notesFromDocs(allDocs, "DIMENSION") {
dm = append(dm, dimMetadata{
Name: note.UID,
Description: commentTextToParagraphs(note.Body),
})
}
sort.Slice(dm, func(i, j int) bool {
return dm[i].Name < dm[j].Name
})
return dm
}
func metricsFromNotes(allDocs []*doc.Package) []metricMetadata {
var mm []metricMetadata
for noteMarker, metaType := range map[string]string{
"GAUGE": "gauge",
"TIMESTAMP": "timestamp",
"COUNTER": "counter",
"CUMULATIVE": "cumulative",
} {
for _, note := range notesFromDocs(allDocs, noteMarker) {
mm = append(mm, metricMetadata{
Type: metaType,
Name: note.UID,
Description: commentTextToParagraphs(note.Body),
})
}
}
sort.Slice(mm, func(i, j int) bool {
return mm[i].Name < mm[j].Name
})
return mm
}
func propertiesFromNotes(allDocs []*doc.Package) []propMetadata {
var pm []propMetadata
for _, note := range notesFromDocs(allDocs, "PROPERTY") {
parts := strings.Split(note.UID, ":")
if len(parts) != 2 {
log.Errorf("Property comment 'PROPERTY(%s): %s' in package %s should have form "+
"'PROPERTY(dimension_name:prop_name): desc'", note.UID, note.Body, allDocs[0].Name)
}
pm = append(pm, propMetadata{
Name: parts[1],
Dimension: parts[0],
Description: commentTextToParagraphs(note.Body),
})
}
sort.Slice(pm, func(i, j int) bool {
return pm[i].Name < pm[j].Name
})
return pm
}