forked from stackimpact/stackimpact-go
/
segment_reporter.go
93 lines (73 loc) · 2.24 KB
/
segment_reporter.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
package internal
import (
"sync"
)
type SegmentReporter struct {
agent *Agent
reportingStrategy *ReportingStrategy
recordLock *sync.Mutex
segmentGraphs map[string]*BreakdownNode
}
type Segment struct {
path []string
duration int64
}
func newSegmentReporter(agent *Agent) *SegmentReporter {
sr := &SegmentReporter{
agent: agent,
reportingStrategy: nil,
recordLock: &sync.Mutex{},
segmentGraphs: make(map[string]*BreakdownNode),
}
sr.reportingStrategy = newReportingStrategy(agent, 60, 60, nil,
func(trigger string) {
sr.agent.log("Segment report triggered by reporting strategy, trigger=%v", trigger)
sr.report(trigger)
},
)
return sr
}
func (sr *SegmentReporter) start() {
sr.reportingStrategy.start()
}
func (sr *SegmentReporter) recordSegment(path []string, duration int64) {
go sr.recordSegmentSync(path, duration)
}
func (sr *SegmentReporter) recordSegmentSync(path []string, duration int64) {
if len(path) == 0 || len(path) > 5 {
sr.agent.log("Invalid segment path, length=%v", len(path))
return
}
sr.recordLock.Lock()
var currentNode *BreakdownNode = nil
for _, name := range path {
if currentNode == nil {
segmentGraph, exists := sr.segmentGraphs[path[0]]
if !exists {
segmentGraph = newBreakdownNode(path[0])
sr.segmentGraphs[path[0]] = segmentGraph
}
currentNode = segmentGraph
} else {
currentNode = currentNode.findOrAddChild(name)
}
}
currentNode.updateP95(float64(duration))
sr.recordLock.Unlock()
}
func (sr *SegmentReporter) report(trigger string) {
sr.recordLock.Lock()
for _, segmentGraph := range sr.segmentGraphs {
segmentGraph.evaluateP95()
if len(segmentGraph.children) > 0 {
metric := newMetric(sr.agent, TypeTrace, CategorySegmentTrace, segmentGraph.name, UnitMillisecond)
metric.createMeasurement(trigger, segmentGraph.measurement, segmentGraph)
sr.agent.messageQueue.addMessage("metric", metric.toMap())
}
metric := newMetric(sr.agent, TypeState, CategorySegments, segmentGraph.name, UnitMillisecond)
metric.createMeasurement(trigger, segmentGraph.measurement, nil)
sr.agent.messageQueue.addMessage("metric", metric.toMap())
}
sr.segmentGraphs = make(map[string]*BreakdownNode)
sr.recordLock.Unlock()
}