Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
14 contributors

Users who have contributed to this file

@dsymonds @bradfitz @RaduBerinde @tormoder @tonistiigi @tamird @Sajmani @SamWhited @nicday @ebfe @rakyll @okdave @dhowden @jadekler
1131 lines (981 sloc) 28.1 KB
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
/*
Package trace implements tracing of requests and long-lived objects.
It exports HTTP interfaces on /debug/requests and /debug/events.
A trace.Trace provides tracing for short-lived objects, usually requests.
A request handler might be implemented like this:
func fooHandler(w http.ResponseWriter, req *http.Request) {
tr := trace.New("mypkg.Foo", req.URL.Path)
defer tr.Finish()
...
tr.LazyPrintf("some event %q happened", str)
...
if err := somethingImportant(); err != nil {
tr.LazyPrintf("somethingImportant failed: %v", err)
tr.SetError()
}
}
The /debug/requests HTTP endpoint organizes the traces by family,
errors, and duration. It also provides histogram of request duration
for each family.
A trace.EventLog provides tracing for long-lived objects, such as RPC
connections.
// A Fetcher fetches URL paths for a single domain.
type Fetcher struct {
domain string
events trace.EventLog
}
func NewFetcher(domain string) *Fetcher {
return &Fetcher{
domain,
trace.NewEventLog("mypkg.Fetcher", domain),
}
}
func (f *Fetcher) Fetch(path string) (string, error) {
resp, err := http.Get("http://" + f.domain + "/" + path)
if err != nil {
f.events.Errorf("Get(%q) = %v", path, err)
return "", err
}
f.events.Printf("Get(%q) = %s", path, resp.Status)
...
}
func (f *Fetcher) Close() error {
f.events.Finish()
return nil
}
The /debug/events HTTP endpoint organizes the event logs by family and
by time since the last error. The expanded view displays recent log
entries and the log's call stack.
*/
package trace // import "golang.org/x/net/trace"
import (
"bytes"
"context"
"fmt"
"html/template"
"io"
"log"
"net"
"net/http"
"net/url"
"runtime"
"sort"
"strconv"
"sync"
"sync/atomic"
"time"
"golang.org/x/net/internal/timeseries"
)
// DebugUseAfterFinish controls whether to debug uses of Trace values after finishing.
// FOR DEBUGGING ONLY. This will slow down the program.
var DebugUseAfterFinish = false
// HTTP ServeMux paths.
const (
debugRequestsPath = "/debug/requests"
debugEventsPath = "/debug/events"
)
// AuthRequest determines whether a specific request is permitted to load the
// /debug/requests or /debug/events pages.
//
// It returns two bools; the first indicates whether the page may be viewed at all,
// and the second indicates whether sensitive events will be shown.
//
// AuthRequest may be replaced by a program to customize its authorization requirements.
//
// The default AuthRequest function returns (true, true) if and only if the request
// comes from localhost/127.0.0.1/[::1].
var AuthRequest = func(req *http.Request) (any, sensitive bool) {
// RemoteAddr is commonly in the form "IP" or "IP:port".
// If it is in the form "IP:port", split off the port.
host, _, err := net.SplitHostPort(req.RemoteAddr)
if err != nil {
host = req.RemoteAddr
}
switch host {
case "localhost", "127.0.0.1", "::1":
return true, true
default:
return false, false
}
}
func init() {
_, pat := http.DefaultServeMux.Handler(&http.Request{URL: &url.URL{Path: debugRequestsPath}})
if pat == debugRequestsPath {
panic("/debug/requests is already registered. You may have two independent copies of " +
"golang.org/x/net/trace in your binary, trying to maintain separate state. This may " +
"involve a vendored copy of golang.org/x/net/trace.")
}
// TODO(jbd): Serve Traces from /debug/traces in the future?
// There is no requirement for a request to be present to have traces.
http.HandleFunc(debugRequestsPath, Traces)
http.HandleFunc(debugEventsPath, Events)
}
// NewContext returns a copy of the parent context
// and associates it with a Trace.
func NewContext(ctx context.Context, tr Trace) context.Context {
return context.WithValue(ctx, contextKey, tr)
}
// FromContext returns the Trace bound to the context, if any.
func FromContext(ctx context.Context) (tr Trace, ok bool) {
tr, ok = ctx.Value(contextKey).(Trace)
return
}
// Traces responds with traces from the program.
// The package initialization registers it in http.DefaultServeMux
// at /debug/requests.
//
// It performs authorization by running AuthRequest.
func Traces(w http.ResponseWriter, req *http.Request) {
any, sensitive := AuthRequest(req)
if !any {
http.Error(w, "not allowed", http.StatusUnauthorized)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
Render(w, req, sensitive)
}
// Events responds with a page of events collected by EventLogs.
// The package initialization registers it in http.DefaultServeMux
// at /debug/events.
//
// It performs authorization by running AuthRequest.
func Events(w http.ResponseWriter, req *http.Request) {
any, sensitive := AuthRequest(req)
if !any {
http.Error(w, "not allowed", http.StatusUnauthorized)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
RenderEvents(w, req, sensitive)
}
// Render renders the HTML page typically served at /debug/requests.
// It does not do any auth checking. The request may be nil.
//
// Most users will use the Traces handler.
func Render(w io.Writer, req *http.Request, sensitive bool) {
data := &struct {
Families []string
ActiveTraceCount map[string]int
CompletedTraces map[string]*family
// Set when a bucket has been selected.
Traces traceList
Family string
Bucket int
Expanded bool
Traced bool
Active bool
ShowSensitive bool // whether to show sensitive events
Histogram template.HTML
HistogramWindow string // e.g. "last minute", "last hour", "all time"
// If non-zero, the set of traces is a partial set,
// and this is the total number.
Total int
}{
CompletedTraces: completedTraces,
}
data.ShowSensitive = sensitive
if req != nil {
// Allow show_sensitive=0 to force hiding of sensitive data for testing.
// This only goes one way; you can't use show_sensitive=1 to see things.
if req.FormValue("show_sensitive") == "0" {
data.ShowSensitive = false
}
if exp, err := strconv.ParseBool(req.FormValue("exp")); err == nil {
data.Expanded = exp
}
if exp, err := strconv.ParseBool(req.FormValue("rtraced")); err == nil {
data.Traced = exp
}
}
completedMu.RLock()
data.Families = make([]string, 0, len(completedTraces))
for fam := range completedTraces {
data.Families = append(data.Families, fam)
}
completedMu.RUnlock()
sort.Strings(data.Families)
// We are careful here to minimize the time spent locking activeMu,
// since that lock is required every time an RPC starts and finishes.
data.ActiveTraceCount = make(map[string]int, len(data.Families))
activeMu.RLock()
for fam, s := range activeTraces {
data.ActiveTraceCount[fam] = s.Len()
}
activeMu.RUnlock()
var ok bool
data.Family, data.Bucket, ok = parseArgs(req)
switch {
case !ok:
// No-op
case data.Bucket == -1:
data.Active = true
n := data.ActiveTraceCount[data.Family]
data.Traces = getActiveTraces(data.Family)
if len(data.Traces) < n {
data.Total = n
}
case data.Bucket < bucketsPerFamily:
if b := lookupBucket(data.Family, data.Bucket); b != nil {
data.Traces = b.Copy(data.Traced)
}
default:
if f := getFamily(data.Family, false); f != nil {
var obs timeseries.Observable
f.LatencyMu.RLock()
switch o := data.Bucket - bucketsPerFamily; o {
case 0:
obs = f.Latency.Minute()
data.HistogramWindow = "last minute"
case 1:
obs = f.Latency.Hour()
data.HistogramWindow = "last hour"
case 2:
obs = f.Latency.Total()
data.HistogramWindow = "all time"
}
f.LatencyMu.RUnlock()
if obs != nil {
data.Histogram = obs.(*histogram).html()
}
}
}
if data.Traces != nil {
defer data.Traces.Free()
sort.Sort(data.Traces)
}
completedMu.RLock()
defer completedMu.RUnlock()
if err := pageTmpl().ExecuteTemplate(w, "Page", data); err != nil {
log.Printf("net/trace: Failed executing template: %v", err)
}
}
func parseArgs(req *http.Request) (fam string, b int, ok bool) {
if req == nil {
return "", 0, false
}
fam, bStr := req.FormValue("fam"), req.FormValue("b")
if fam == "" || bStr == "" {
return "", 0, false
}
b, err := strconv.Atoi(bStr)
if err != nil || b < -1 {
return "", 0, false
}
return fam, b, true
}
func lookupBucket(fam string, b int) *traceBucket {
f := getFamily(fam, false)
if f == nil || b < 0 || b >= len(f.Buckets) {
return nil
}
return f.Buckets[b]
}
type contextKeyT string
var contextKey = contextKeyT("golang.org/x/net/trace.Trace")
// Trace represents an active request.
type Trace interface {
// LazyLog adds x to the event log. It will be evaluated each time the
// /debug/requests page is rendered. Any memory referenced by x will be
// pinned until the trace is finished and later discarded.
LazyLog(x fmt.Stringer, sensitive bool)
// LazyPrintf evaluates its arguments with fmt.Sprintf each time the
// /debug/requests page is rendered. Any memory referenced by a will be
// pinned until the trace is finished and later discarded.
LazyPrintf(format string, a ...interface{})
// SetError declares that this trace resulted in an error.
SetError()
// SetRecycler sets a recycler for the trace.
// f will be called for each event passed to LazyLog at a time when
// it is no longer required, whether while the trace is still active
// and the event is discarded, or when a completed trace is discarded.
SetRecycler(f func(interface{}))
// SetTraceInfo sets the trace info for the trace.
// This is currently unused.
SetTraceInfo(traceID, spanID uint64)
// SetMaxEvents sets the maximum number of events that will be stored
// in the trace. This has no effect if any events have already been
// added to the trace.
SetMaxEvents(m int)
// Finish declares that this trace is complete.
// The trace should not be used after calling this method.
Finish()
}
type lazySprintf struct {
format string
a []interface{}
}
func (l *lazySprintf) String() string {
return fmt.Sprintf(l.format, l.a...)
}
// New returns a new Trace with the specified family and title.
func New(family, title string) Trace {
tr := newTrace()
tr.ref()
tr.Family, tr.Title = family, title
tr.Start = time.Now()
tr.maxEvents = maxEventsPerTrace
tr.events = tr.eventsBuf[:0]
activeMu.RLock()
s := activeTraces[tr.Family]
activeMu.RUnlock()
if s == nil {
activeMu.Lock()
s = activeTraces[tr.Family] // check again
if s == nil {
s = new(traceSet)
activeTraces[tr.Family] = s
}
activeMu.Unlock()
}
s.Add(tr)
// Trigger allocation of the completed trace structure for this family.
// This will cause the family to be present in the request page during
// the first trace of this family. We don't care about the return value,
// nor is there any need for this to run inline, so we execute it in its
// own goroutine, but only if the family isn't allocated yet.
completedMu.RLock()
if _, ok := completedTraces[tr.Family]; !ok {
go allocFamily(tr.Family)
}
completedMu.RUnlock()
return tr
}
func (tr *trace) Finish() {
elapsed := time.Now().Sub(tr.Start)
tr.mu.Lock()
tr.Elapsed = elapsed
tr.mu.Unlock()
if DebugUseAfterFinish {
buf := make([]byte, 4<<10) // 4 KB should be enough
n := runtime.Stack(buf, false)
tr.finishStack = buf[:n]
}
activeMu.RLock()
m := activeTraces[tr.Family]
activeMu.RUnlock()
m.Remove(tr)
f := getFamily(tr.Family, true)
tr.mu.RLock() // protects tr fields in Cond.match calls
for _, b := range f.Buckets {
if b.Cond.match(tr) {
b.Add(tr)
}
}
tr.mu.RUnlock()
// Add a sample of elapsed time as microseconds to the family's timeseries
h := new(histogram)
h.addMeasurement(elapsed.Nanoseconds() / 1e3)
f.LatencyMu.Lock()
f.Latency.Add(h)
f.LatencyMu.Unlock()
tr.unref() // matches ref in New
}
const (
bucketsPerFamily = 9
tracesPerBucket = 10
maxActiveTraces = 20 // Maximum number of active traces to show.
maxEventsPerTrace = 10
numHistogramBuckets = 38
)
var (
// The active traces.
activeMu sync.RWMutex
activeTraces = make(map[string]*traceSet) // family -> traces
// Families of completed traces.
completedMu sync.RWMutex
completedTraces = make(map[string]*family) // family -> traces
)
type traceSet struct {
mu sync.RWMutex
m map[*trace]bool
// We could avoid the entire map scan in FirstN by having a slice of all the traces
// ordered by start time, and an index into that from the trace struct, with a periodic
// repack of the slice after enough traces finish; we could also use a skip list or similar.
// However, that would shift some of the expense from /debug/requests time to RPC time,
// which is probably the wrong trade-off.
}
func (ts *traceSet) Len() int {
ts.mu.RLock()
defer ts.mu.RUnlock()
return len(ts.m)
}
func (ts *traceSet) Add(tr *trace) {
ts.mu.Lock()
if ts.m == nil {
ts.m = make(map[*trace]bool)
}
ts.m[tr] = true
ts.mu.Unlock()
}
func (ts *traceSet) Remove(tr *trace) {
ts.mu.Lock()
delete(ts.m, tr)
ts.mu.Unlock()
}
// FirstN returns the first n traces ordered by time.
func (ts *traceSet) FirstN(n int) traceList {
ts.mu.RLock()
defer ts.mu.RUnlock()
if n > len(ts.m) {
n = len(ts.m)
}
trl := make(traceList, 0, n)
// Fast path for when no selectivity is needed.
if n == len(ts.m) {
for tr := range ts.m {
tr.ref()
trl = append(trl, tr)
}
sort.Sort(trl)
return trl
}
// Pick the oldest n traces.
// This is inefficient. See the comment in the traceSet struct.
for tr := range ts.m {
// Put the first n traces into trl in the order they occur.
// When we have n, sort trl, and thereafter maintain its order.
if len(trl) < n {
tr.ref()
trl = append(trl, tr)
if len(trl) == n {
// This is guaranteed to happen exactly once during this loop.
sort.Sort(trl)
}
continue
}
if tr.Start.After(trl[n-1].Start) {
continue
}
// Find where to insert this one.
tr.ref()
i := sort.Search(n, func(i int) bool { return trl[i].Start.After(tr.Start) })
trl[n-1].unref()
copy(trl[i+1:], trl[i:])
trl[i] = tr
}
return trl
}
func getActiveTraces(fam string) traceList {
activeMu.RLock()
s := activeTraces[fam]
activeMu.RUnlock()
if s == nil {
return nil
}
return s.FirstN(maxActiveTraces)
}
func getFamily(fam string, allocNew bool) *family {
completedMu.RLock()
f := completedTraces[fam]
completedMu.RUnlock()
if f == nil && allocNew {
f = allocFamily(fam)
}
return f
}
func allocFamily(fam string) *family {
completedMu.Lock()
defer completedMu.Unlock()
f := completedTraces[fam]
if f == nil {
f = newFamily()
completedTraces[fam] = f
}
return f
}
// family represents a set of trace buckets and associated latency information.
type family struct {
// traces may occur in multiple buckets.
Buckets [bucketsPerFamily]*traceBucket
// latency time series
LatencyMu sync.RWMutex
Latency *timeseries.MinuteHourSeries
}
func newFamily() *family {
return &family{
Buckets: [bucketsPerFamily]*traceBucket{
{Cond: minCond(0)},
{Cond: minCond(50 * time.Millisecond)},
{Cond: minCond(100 * time.Millisecond)},
{Cond: minCond(200 * time.Millisecond)},
{Cond: minCond(500 * time.Millisecond)},
{Cond: minCond(1 * time.Second)},
{Cond: minCond(10 * time.Second)},
{Cond: minCond(100 * time.Second)},
{Cond: errorCond{}},
},
Latency: timeseries.NewMinuteHourSeries(func() timeseries.Observable { return new(histogram) }),
}
}
// traceBucket represents a size-capped bucket of historic traces,
// along with a condition for a trace to belong to the bucket.
type traceBucket struct {
Cond cond
// Ring buffer implementation of a fixed-size FIFO queue.
mu sync.RWMutex
buf [tracesPerBucket]*trace
start int // < tracesPerBucket
length int // <= tracesPerBucket
}
func (b *traceBucket) Add(tr *trace) {
b.mu.Lock()
defer b.mu.Unlock()
i := b.start + b.length
if i >= tracesPerBucket {
i -= tracesPerBucket
}
if b.length == tracesPerBucket {
// "Remove" an element from the bucket.
b.buf[i].unref()
b.start++
if b.start == tracesPerBucket {
b.start = 0
}
}
b.buf[i] = tr
if b.length < tracesPerBucket {
b.length++
}
tr.ref()
}
// Copy returns a copy of the traces in the bucket.
// If tracedOnly is true, only the traces with trace information will be returned.
// The logs will be ref'd before returning; the caller should call
// the Free method when it is done with them.
// TODO(dsymonds): keep track of traced requests in separate buckets.
func (b *traceBucket) Copy(tracedOnly bool) traceList {
b.mu.RLock()
defer b.mu.RUnlock()
trl := make(traceList, 0, b.length)
for i, x := 0, b.start; i < b.length; i++ {
tr := b.buf[x]
if !tracedOnly || tr.spanID != 0 {
tr.ref()
trl = append(trl, tr)
}
x++
if x == b.length {
x = 0
}
}
return trl
}
func (b *traceBucket) Empty() bool {
b.mu.RLock()
defer b.mu.RUnlock()
return b.length == 0
}
// cond represents a condition on a trace.
type cond interface {
match(t *trace) bool
String() string
}
type minCond time.Duration
func (m minCond) match(t *trace) bool { return t.Elapsed >= time.Duration(m) }
func (m minCond) String() string { return fmt.Sprintf("%gs", time.Duration(m).Seconds()) }
type errorCond struct{}
func (e errorCond) match(t *trace) bool { return t.IsError }
func (e errorCond) String() string { return "errors" }
type traceList []*trace
// Free calls unref on each element of the list.
func (trl traceList) Free() {
for _, t := range trl {
t.unref()
}
}
// traceList may be sorted in reverse chronological order.
func (trl traceList) Len() int { return len(trl) }
func (trl traceList) Less(i, j int) bool { return trl[i].Start.After(trl[j].Start) }
func (trl traceList) Swap(i, j int) { trl[i], trl[j] = trl[j], trl[i] }
// An event is a timestamped log entry in a trace.
type event struct {
When time.Time
Elapsed time.Duration // since previous event in trace
NewDay bool // whether this event is on a different day to the previous event
Recyclable bool // whether this event was passed via LazyLog
Sensitive bool // whether this event contains sensitive information
What interface{} // string or fmt.Stringer
}
// WhenString returns a string representation of the elapsed time of the event.
// It will include the date if midnight was crossed.
func (e event) WhenString() string {
if e.NewDay {
return e.When.Format("2006/01/02 15:04:05.000000")
}
return e.When.Format("15:04:05.000000")
}
// discarded represents a number of discarded events.
// It is stored as *discarded to make it easier to update in-place.
type discarded int
func (d *discarded) String() string {
return fmt.Sprintf("(%d events discarded)", int(*d))
}
// trace represents an active or complete request,
// either sent or received by this program.
type trace struct {
// Family is the top-level grouping of traces to which this belongs.
Family string
// Title is the title of this trace.
Title string
// Start time of the this trace.
Start time.Time
mu sync.RWMutex
events []event // Append-only sequence of events (modulo discards).
maxEvents int
recycler func(interface{})
IsError bool // Whether this trace resulted in an error.
Elapsed time.Duration // Elapsed time for this trace, zero while active.
traceID uint64 // Trace information if non-zero.
spanID uint64
refs int32 // how many buckets this is in
disc discarded // scratch space to avoid allocation
finishStack []byte // where finish was called, if DebugUseAfterFinish is set
eventsBuf [4]event // preallocated buffer in case we only log a few events
}
func (tr *trace) reset() {
// Clear all but the mutex. Mutexes may not be copied, even when unlocked.
tr.Family = ""
tr.Title = ""
tr.Start = time.Time{}
tr.mu.Lock()
tr.Elapsed = 0
tr.traceID = 0
tr.spanID = 0
tr.IsError = false
tr.maxEvents = 0
tr.events = nil
tr.recycler = nil
tr.mu.Unlock()
tr.refs = 0
tr.disc = 0
tr.finishStack = nil
for i := range tr.eventsBuf {
tr.eventsBuf[i] = event{}
}
}
// delta returns the elapsed time since the last event or the trace start,
// and whether it spans midnight.
// L >= tr.mu
func (tr *trace) delta(t time.Time) (time.Duration, bool) {
if len(tr.events) == 0 {
return t.Sub(tr.Start), false
}
prev := tr.events[len(tr.events)-1].When
return t.Sub(prev), prev.Day() != t.Day()
}
func (tr *trace) addEvent(x interface{}, recyclable, sensitive bool) {
if DebugUseAfterFinish && tr.finishStack != nil {
buf := make([]byte, 4<<10) // 4 KB should be enough
n := runtime.Stack(buf, false)
log.Printf("net/trace: trace used after finish:\nFinished at:\n%s\nUsed at:\n%s", tr.finishStack, buf[:n])
}
/*
NOTE TO DEBUGGERS
If you are here because your program panicked in this code,
it is almost definitely the fault of code using this package,
and very unlikely to be the fault of this code.
The most likely scenario is that some code elsewhere is using
a trace.Trace after its Finish method is called.
You can temporarily set the DebugUseAfterFinish var
to help discover where that is; do not leave that var set,
since it makes this package much less efficient.
*/
e := event{When: time.Now(), What: x, Recyclable: recyclable, Sensitive: sensitive}
tr.mu.Lock()
e.Elapsed, e.NewDay = tr.delta(e.When)
if len(tr.events) < tr.maxEvents {
tr.events = append(tr.events, e)
} else {
// Discard the middle events.
di := int((tr.maxEvents - 1) / 2)
if d, ok := tr.events[di].What.(*discarded); ok {
(*d)++
} else {
// disc starts at two to count for the event it is replacing,
// plus the next one that we are about to drop.
tr.disc = 2
if tr.recycler != nil && tr.events[di].Recyclable {
go tr.recycler(tr.events[di].What)
}
tr.events[di].What = &tr.disc
}
// The timestamp of the discarded meta-event should be
// the time of the last event it is representing.
tr.events[di].When = tr.events[di+1].When
if tr.recycler != nil && tr.events[di+1].Recyclable {
go tr.recycler(tr.events[di+1].What)
}
copy(tr.events[di+1:], tr.events[di+2:])
tr.events[tr.maxEvents-1] = e
}
tr.mu.Unlock()
}
func (tr *trace) LazyLog(x fmt.Stringer, sensitive bool) {
tr.addEvent(x, true, sensitive)
}
func (tr *trace) LazyPrintf(format string, a ...interface{}) {
tr.addEvent(&lazySprintf{format, a}, false, false)
}
func (tr *trace) SetError() {
tr.mu.Lock()
tr.IsError = true
tr.mu.Unlock()
}
func (tr *trace) SetRecycler(f func(interface{})) {
tr.mu.Lock()
tr.recycler = f
tr.mu.Unlock()
}
func (tr *trace) SetTraceInfo(traceID, spanID uint64) {
tr.mu.Lock()
tr.traceID, tr.spanID = traceID, spanID
tr.mu.Unlock()
}
func (tr *trace) SetMaxEvents(m int) {
tr.mu.Lock()
// Always keep at least three events: first, discarded count, last.
if len(tr.events) == 0 && m > 3 {
tr.maxEvents = m
}
tr.mu.Unlock()
}
func (tr *trace) ref() {
atomic.AddInt32(&tr.refs, 1)
}
func (tr *trace) unref() {
if atomic.AddInt32(&tr.refs, -1) == 0 {
tr.mu.RLock()
if tr.recycler != nil {
// freeTrace clears tr, so we hold tr.recycler and tr.events here.
go func(f func(interface{}), es []event) {
for _, e := range es {
if e.Recyclable {
f(e.What)
}
}
}(tr.recycler, tr.events)
}
tr.mu.RUnlock()
freeTrace(tr)
}
}
func (tr *trace) When() string {
return tr.Start.Format("2006/01/02 15:04:05.000000")
}
func (tr *trace) ElapsedTime() string {
tr.mu.RLock()
t := tr.Elapsed
tr.mu.RUnlock()
if t == 0 {
// Active trace.
t = time.Since(tr.Start)
}
return fmt.Sprintf("%.6f", t.Seconds())
}
func (tr *trace) Events() []event {
tr.mu.RLock()
defer tr.mu.RUnlock()
return tr.events
}
var traceFreeList = make(chan *trace, 1000) // TODO(dsymonds): Use sync.Pool?
// newTrace returns a trace ready to use.
func newTrace() *trace {
select {
case tr := <-traceFreeList:
return tr
default:
return new(trace)
}
}
// freeTrace adds tr to traceFreeList if there's room.
// This is non-blocking.
func freeTrace(tr *trace) {
if DebugUseAfterFinish {
return // never reuse
}
tr.reset()
select {
case traceFreeList <- tr:
default:
}
}
func elapsed(d time.Duration) string {
b := []byte(fmt.Sprintf("%.6f", d.Seconds()))
// For subsecond durations, blank all zeros before decimal point,
// and all zeros between the decimal point and the first non-zero digit.
if d < time.Second {
dot := bytes.IndexByte(b, '.')
for i := 0; i < dot; i++ {
b[i] = ' '
}
for i := dot + 1; i < len(b); i++ {
if b[i] == '0' {
b[i] = ' '
} else {
break
}
}
}
return string(b)
}
var pageTmplCache *template.Template
var pageTmplOnce sync.Once
func pageTmpl() *template.Template {
pageTmplOnce.Do(func() {
pageTmplCache = template.Must(template.New("Page").Funcs(template.FuncMap{
"elapsed": elapsed,
"add": func(a, b int) int { return a + b },
}).Parse(pageHTML))
})
return pageTmplCache
}
const pageHTML = `
{{template "Prolog" .}}
{{template "StatusTable" .}}
{{template "Epilog" .}}
{{define "Prolog"}}
<html>
<head>
<title>/debug/requests</title>
<style type="text/css">
body {
font-family: sans-serif;
}
table#tr-status td.family {
padding-right: 2em;
}
table#tr-status td.active {
padding-right: 1em;
}
table#tr-status td.latency-first {
padding-left: 1em;
}
table#tr-status td.empty {
color: #aaa;
}
table#reqs {
margin-top: 1em;
}
table#reqs tr.first {
{{if $.Expanded}}font-weight: bold;{{end}}
}
table#reqs td {
font-family: monospace;
}
table#reqs td.when {
text-align: right;
white-space: nowrap;
}
table#reqs td.elapsed {
padding: 0 0.5em;
text-align: right;
white-space: pre;
width: 10em;
}
address {
font-size: smaller;
margin-top: 5em;
}
</style>
</head>
<body>
<h1>/debug/requests</h1>
{{end}} {{/* end of Prolog */}}
{{define "StatusTable"}}
<table id="tr-status">
{{range $fam := .Families}}
<tr>
<td class="family">{{$fam}}</td>
{{$n := index $.ActiveTraceCount $fam}}
<td class="active {{if not $n}}empty{{end}}">
{{if $n}}<a href="?fam={{$fam}}&b=-1{{if $.Expanded}}&exp=1{{end}}">{{end}}
[{{$n}} active]
{{if $n}}</a>{{end}}
</td>
{{$f := index $.CompletedTraces $fam}}
{{range $i, $b := $f.Buckets}}
{{$empty := $b.Empty}}
<td {{if $empty}}class="empty"{{end}}>
{{if not $empty}}<a href="?fam={{$fam}}&b={{$i}}{{if $.Expanded}}&exp=1{{end}}">{{end}}
[{{.Cond}}]
{{if not $empty}}</a>{{end}}
</td>
{{end}}
{{$nb := len $f.Buckets}}
<td class="latency-first">
<a href="?fam={{$fam}}&b={{$nb}}">[minute]</a>
</td>
<td>
<a href="?fam={{$fam}}&b={{add $nb 1}}">[hour]</a>
</td>
<td>
<a href="?fam={{$fam}}&b={{add $nb 2}}">[total]</a>
</td>
</tr>
{{end}}
</table>
{{end}} {{/* end of StatusTable */}}
{{define "Epilog"}}
{{if $.Traces}}
<hr />
<h3>Family: {{$.Family}}</h3>
{{if or $.Expanded $.Traced}}
<a href="?fam={{$.Family}}&b={{$.Bucket}}">[Normal/Summary]</a>
{{else}}
[Normal/Summary]
{{end}}
{{if or (not $.Expanded) $.Traced}}
<a href="?fam={{$.Family}}&b={{$.Bucket}}&exp=1">[Normal/Expanded]</a>
{{else}}
[Normal/Expanded]
{{end}}
{{if not $.Active}}
{{if or $.Expanded (not $.Traced)}}
<a href="?fam={{$.Family}}&b={{$.Bucket}}&rtraced=1">[Traced/Summary]</a>
{{else}}
[Traced/Summary]
{{end}}
{{if or (not $.Expanded) (not $.Traced)}}
<a href="?fam={{$.Family}}&b={{$.Bucket}}&exp=1&rtraced=1">[Traced/Expanded]</a>
{{else}}
[Traced/Expanded]
{{end}}
{{end}}
{{if $.Total}}
<p><em>Showing <b>{{len $.Traces}}</b> of <b>{{$.Total}}</b> traces.</em></p>
{{end}}
<table id="reqs">
<caption>
{{if $.Active}}Active{{else}}Completed{{end}} Requests
</caption>
<tr><th>When</th><th>Elapsed&nbsp;(s)</th></tr>
{{range $tr := $.Traces}}
<tr class="first">
<td class="when">{{$tr.When}}</td>
<td class="elapsed">{{$tr.ElapsedTime}}</td>
<td>{{$tr.Title}}</td>
{{/* TODO: include traceID/spanID */}}
</tr>
{{if $.Expanded}}
{{range $tr.Events}}
<tr>
<td class="when">{{.WhenString}}</td>
<td class="elapsed">{{elapsed .Elapsed}}</td>
<td>{{if or $.ShowSensitive (not .Sensitive)}}... {{.What}}{{else}}<em>[redacted]</em>{{end}}</td>
</tr>
{{end}}
{{end}}
{{end}}
</table>
{{end}} {{/* if $.Traces */}}
{{if $.Histogram}}
<h4>Latency (&micro;s) of {{$.Family}} over {{$.HistogramWindow}}</h4>
{{$.Histogram}}
{{end}} {{/* if $.Histogram */}}
</body>
</html>
{{end}} {{/* end of Epilog */}}
`
You can’t perform that action at this time.