Code refactoring for bpa operator

[icn.git] / cmd / bpa-operator / vendor / golang.org / x / net / trace / trace.go

// 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 */}}
`