24
const maxEventsPerLog = 100
27
MaxErrAge time.Duration
31
var buckets = []bucket{
33
{10 * time.Second, "errs<10s"},
34
{1 * time.Minute, "errs<1m"},
35
{10 * time.Minute, "errs<10m"},
36
{1 * time.Hour, "errs<1h"},
37
{10 * time.Hour, "errs<10h"},
38
{24000 * time.Hour, "errors"},
45
func RenderEvents(w http.ResponseWriter, req *http.Request, sensitive bool) {
61
data.Families = make([]string, 0, len(families))
63
for name := range families {
64
data.Families = append(data.Families, name)
67
sort.Strings(data.Families)
70
data.Counts = make([][]int, len(data.Families))
71
for i, name := range data.Families {
73
f := getEventFamily(name)
74
data.Counts[i] = make([]int, len(data.Buckets))
75
for j, b := range data.Buckets {
76
data.Counts[i][j] = f.Count(now, b.MaxErrAge)
82
data.Family, data.Bucket, ok = parseEventsArgs(req)
86
data.EventLogs = getEventFamily(data.Family).Copy(now, buckets[data.Bucket].MaxErrAge)
88
if data.EventLogs != nil {
89
defer data.EventLogs.Free()
90
sort.Sort(data.EventLogs)
92
if exp, err := strconv.ParseBool(req.FormValue("exp")); err == nil {
99
if err := eventsTmpl().Execute(w, data); err != nil {
100
log.Printf("net/trace: Failed executing template: %v", err)
104
func parseEventsArgs(req *http.Request) (fam string, b int, ok bool) {
105
fam, bStr := req.FormValue("fam"), req.FormValue("b")
106
if fam == "" || bStr == "" {
109
b, err := strconv.Atoi(bStr)
110
if err != nil || b < 0 || b >= len(buckets) {
117
type EventLog interface {
120
Printf(format string, a ...interface{})
123
Errorf(format string, a ...interface{})
132
func NewEventLog(family, title string) EventLog {
135
el.Family, el.Title = family, title
136
el.Start = time.Now()
137
el.events = make([]logEntry, 0, maxEventsPerLog)
138
el.stack = make([]uintptr, 32)
139
n := runtime.Callers(2, el.stack)
140
el.stack = el.stack[:n]
142
getEventFamily(family).add(el)
146
func (el *eventLog) Finish() {
147
getEventFamily(el.Family).remove(el)
153
families = make(map[string]*eventFamily)
156
func getEventFamily(fam string) *eventFamily {
167
type eventFamily struct {
172
func (f *eventFamily) add(el *eventLog) {
174
f.eventLogs = append(f.eventLogs, el)
178
func (f *eventFamily) remove(el *eventLog) {
181
for i, el0 := range f.eventLogs {
183
copy(f.eventLogs[i:], f.eventLogs[i+1:])
184
f.eventLogs = f.eventLogs[:len(f.eventLogs)-1]
190
func (f *eventFamily) Count(now time.Time, maxErrAge time.Duration) (n int) {
193
for _, el := range f.eventLogs {
194
if el.hasRecentError(now, maxErrAge) {
201
func (f *eventFamily) Copy(now time.Time, maxErrAge time.Duration) (els eventLogs) {
204
els = make(eventLogs, 0, len(f.eventLogs))
205
for _, el := range f.eventLogs {
206
if el.hasRecentError(now, maxErrAge) {
208
els = append(els, el)
214
type eventLogs []*eventLog
217
func (els eventLogs) Free() {
218
for _, el := range els {
224
func (els eventLogs) Len() int { return len(els) }
225
func (els eventLogs) Less(i, j int) bool { return els[i].Start.After(els[j].Start) }
226
func (els eventLogs) Swap(i, j int) { els[i], els[j] = els[j], els[i] }
229
type logEntry struct {
231
Elapsed time.Duration
239
func (e logEntry) WhenString() string {
241
return e.When.Format("2006/01/02 15:04:05.000000")
243
return e.When.Format("15:04:05.000000")
247
type eventLog struct {
266
LastErrorTime time.Time
272
func (el *eventLog) reset() {
276
el.Start = time.Time{}
279
el.LastErrorTime = time.Time{}
284
func (el *eventLog) hasRecentError(now time.Time, maxErrAge time.Duration) bool {
289
defer el.mu.RUnlock()
290
return now.Sub(el.LastErrorTime) < maxErrAge
296
func (el *eventLog) delta(t time.Time) (time.Duration, bool) {
297
if len(el.events) == 0 {
298
return t.Sub(el.Start), false
300
prev := el.events[len(el.events)-1].When
301
return t.Sub(prev), prev.Day() != t.Day()
305
func (el *eventLog) Printf(format string, a ...interface{}) {
306
el.printf(false, format, a...)
309
func (el *eventLog) Errorf(format string, a ...interface{}) {
310
el.printf(true, format, a...)
313
func (el *eventLog) printf(isErr bool, format string, a ...interface{}) {
314
e := logEntry{When: time.Now(), IsErr: isErr, What: fmt.Sprintf(format, a...)}
316
e.Elapsed, e.NewDay = el.delta(e.When)
317
if len(el.events) < maxEventsPerLog {
318
el.events = append(el.events, e)
321
if el.discarded == 0 {
331
el.events[0].What = fmt.Sprintf("(%d events discarded)", el.discarded)
334
el.events[0].When = el.events[1].When
335
copy(el.events[1:], el.events[2:])
336
el.events[maxEventsPerLog-1] = e
339
el.LastErrorTime = e.When
344
func (el *eventLog) ref() {
345
atomic.AddInt32(&el.refs, 1)
348
func (el *eventLog) unref() {
349
if atomic.AddInt32(&el.refs, -1) == 0 {
354
func (el *eventLog) When() string {
355
return el.Start.Format("2006/01/02 15:04:05.000000")
358
func (el *eventLog) ElapsedTime() string {
359
elapsed := time.Since(el.Start)
360
return fmt.Sprintf("%.6f", elapsed.Seconds())
363
func (el *eventLog) Stack() string {
364
buf := new(bytes.Buffer)
365
tw := tabwriter.NewWriter(buf, 1, 8, 1, '\t', 0)
366
printStackRecord(tw, el.stack)
374
func printStackRecord(w io.Writer, stk []uintptr) {
375
for _, pc := range stk {
376
f := runtime.FuncForPC(pc)
380
file, line := f.FileLine(pc)
383
if strings.HasPrefix(name, "runtime.") {
386
fmt.Fprintf(w, "# %s\t%s:%d\n", name, file, line)
390
func (el *eventLog) Events() []logEntry {
392
defer el.mu.RUnlock()
397
var freeEventLogs = make(chan *eventLog, 1000)
400
func newEventLog() *eventLog {
402
case el := <-freeEventLogs:
411
func freeEventLog(el *eventLog) {
414
case freeEventLogs <- el:
419
var eventsTmplCache *template.Template
420
var eventsTmplOnce sync.Once
422
func eventsTmpl() *template.Template {
423
eventsTmplOnce.Do(func() {
424
eventsTmplCache = template.Must(template.New("events").Funcs(template.FuncMap{
426
"trimSpace": strings.TrimSpace,
427
}).Parse(eventsHTML))
429
return eventsTmplCache
435
<title>events</title>
437
<style type="text/css">
439
font-family: sans-serif;
441
table#req-status td.family {
444
table#req-status td.active {
447
table#req-status td.empty {
453
table#reqs tr.first {
454
{{if $.Expanded}}font-weight: bold;{{end}}
457
font-family: monospace;
463
table#reqs td.elapsed {
476
<h1>/debug/events</h1>
478
<table id="req-status">
479
{{range $i, $fam := .Families}}
481
<td class="family">{{$fam}}</td>
483
{{range $j, $bucket := $.Buckets}}
484
{{$n := index $.Counts $i $j}}
485
<td class="{{if not $bucket.MaxErrAge}}active{{end}}{{if not $n}}empty{{end}}">
486
{{if $n}}<a href="?fam={{$fam}}&b={{$j}}{{if $.Expanded}}&exp=1{{end}}">{{end}}
487
[{{$n}} {{$bucket.String}}]
497
<h3>Family: {{$.Family}}</h3>
499
{{if $.Expanded}}<a href="?fam={{$.Family}}&b={{$.Bucket}}">{{end}}
500
[Summary]{{if $.Expanded}}</a>{{end}}
502
{{if not $.Expanded}}<a href="?fam={{$.Family}}&b={{$.Bucket}}&exp=1">{{end}}
503
[Expanded]{{if not $.Expanded}}</a>{{end}}
506
<tr><th>When</th><th>Elapsed</th></tr>
507
{{range $el := $.EventLogs}}
509
<td class="when">{{$el.When}}</td>
510
<td class="elapsed">{{$el.ElapsedTime}}</td>
515
<td class="when"></td>
516
<td class="elapsed"></td>
517
<td><pre>{{$el.Stack|trimSpace}}</pre></td>
521
<td class="when">{{.WhenString}}</td>
522
<td class="elapsed">{{elapsed .Elapsed}}</td>
523
<td>.{{if .IsErr}}E{{else}}.{{end}}. {{.What}}</td>