kubernetes/vendor/golang.org/x/net/trace/trace.go

var DebugUseAfterFinish

const debugRequestsPath

const debugEventsPath

var AuthRequest

func init() {}

// NewContext returns a copy of the parent context
// and associates it with a Trace.
func NewContext(ctx context.Context, tr Trace) context.Context {}

// FromContext returns the Trace bound to the context, if any.
func FromContext(ctx context.Context) (tr Trace, ok bool) {}

// 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) {}

// 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) {}

// 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) {}

func parseArgs(req *http.Request) (fam string, b int, ok bool) {}

func lookupBucket(fam string, b int) *traceBucket {}

type contextKeyT

var contextKey

type Trace

type lazySprintf

func (l *lazySprintf) String() string {}

// New returns a new Trace with the specified family and title.
func New(family, title string) Trace {}

func (tr *trace) Finish() {}

const bucketsPerFamily

const tracesPerBucket

const maxActiveTraces

const maxEventsPerTrace

const numHistogramBuckets

var activeMu

var activeTraces

var completedMu

var completedTraces

type traceSet

func (ts *traceSet) Len() int {}

func (ts *traceSet) Add(tr *trace) {}

func (ts *traceSet) Remove(tr *trace) {}

// FirstN returns the first n traces ordered by time.
func (ts *traceSet) FirstN(n int) traceList {}

func getActiveTraces(fam string) traceList {}

func getFamily(fam string, allocNew bool) *family {}

func allocFamily(fam string) *family {}

type family

func newFamily() *family {}

type traceBucket

func (b *traceBucket) Add(tr *trace) {}

// 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 {}

func (b *traceBucket) Empty() bool {}

type cond

type minCond

func (m minCond) match(t *trace) bool {}

func (m minCond) String() string      {}

type errorCond

func (e errorCond) match(t *trace) bool {}

func (e errorCond) String() string      {}

type traceList

// Free calls unref on each element of the list.
func (trl traceList) Free() {}

// traceList may be sorted in reverse chronological order.
func (trl traceList) Len() int           {}

func (trl traceList) Less(i, j int) bool {}

func (trl traceList) Swap(i, j int)      {}

type event

// 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 {}

type discarded

func (d *discarded) String() string {}

type trace

func (tr *trace) reset() {}

// 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) {}

func (tr *trace) addEvent(x interface{}

func (tr *trace) LazyLog(x fmt.Stringer, sensitive bool) {}

func (tr *trace) LazyPrintf(format string, a ...interface{}

func (tr *trace) SetError() {}

func (tr *trace) SetRecycler(f func(interface{}

func (tr *trace) SetTraceInfo(traceID, spanID uint64) {}

func (tr *trace) SetMaxEvents(m int) {}

func (tr *trace) ref() {}

func (tr *trace) unref() {}

func (tr *trace) When() string {}

func (tr *trace) ElapsedTime() string {}

func (tr *trace) Events() []event {}

var traceFreeList

// newTrace returns a trace ready to use.
func newTrace() *trace {}

// freeTrace adds tr to traceFreeList if there's room.
// This is non-blocking.
func freeTrace(tr *trace) {}

func elapsed(d time.Duration) string {}

var pageTmplCache

var pageTmplOnce

func pageTmpl() *template.Template {}

const pageHTML