Package coverage contains APIs for writing coverage profile data at runtime from long-running and/or server programs that do not terminate via [os.Exit].

Package debug contains facilities for programs to debug themselves while they are running.

Package metrics provides a stable interface to access implementation-defined metrics exported by the Go runtime.

Package pprof writes runtime profiling data in the format expected by the pprof visualization tool.

Package race implements data race detection logic.

Package trace contains facilities for programs to generate traces for the Go execution tracer.

AddCleanup attaches a cleanup function to ptr.

BlockProfile returns n, the number of records in the current blocking profile.

Breakpoint executes a breakpoint trap.

Caller reports file and line number information about function invocations on the calling goroutine's stack.

Callers fills the slice pc with the return program counters of function invocations on the calling goroutine's stack.

CallersFrames takes a slice of PC values returned by [Callers] and prepares to return function/file/line information.

CPUProfile panics.

FuncForPC returns a *[Func] describing the function that contains the given program counter address, or else nil.

GC runs a garbage collection and blocks the caller until the garbage collection is complete.

Goexit terminates the goroutine that calls it.

GOMAXPROCS sets the maximum number of CPUs that can be executing simultaneously and returns the previous setting.

GOROOT returns the root of the Go tree.

GoroutineProfile returns n, the number of records in the active goroutine stack profile.

Gosched yields the processor, allowing other goroutines to run.

KeepAlive marks its argument as currently reachable.

LockOSThread wires the calling goroutine to its current operating system thread.

MemProfile returns a profile of memory allocated and freed per allocation site.

MutexProfile returns n, the number of records in the current mutex profile.

NumCgoCall returns the number of cgo calls made by the current process.

NumCPU returns the number of logical CPUs usable by the current process.

NumGoroutine returns the number of goroutines that currently exist.

ReadMemStats populates m with memory allocator statistics.

ReadTrace returns the next chunk of binary tracing data, blocking until data is available.

SetBlockProfileRate controls the fraction of goroutine blocking events that are reported in the blocking profile.

SetCgoTraceback records three C functions to use to gather traceback information from C code and to convert that traceback information into symbolic information.

SetCPUProfileRate sets the CPU profiling rate to hz samples per second.

SetFinalizer sets the finalizer associated with obj to the provided finalizer function.

SetMutexProfileFraction controls the fraction of mutex contention events that are reported in the mutex profile.

Stack formats a stack trace of the calling goroutine into buf and returns the number of bytes written to buf.

StartTrace enables tracing for the current process.

StopTrace stops tracing, if it was previously enabled.

ThreadCreateProfile returns n, the number of records in the thread creation profile.

UnlockOSThread undoes an earlier call to LockOSThread.

Version returns the Go tree's version string.

Compiler is the name of the compiler toolchain that built the running binary.

GOARCH is the running program's architecture target: one of 386, amd64, arm, s390x, and so on.

GOOS is the running program's operating system target: one of darwin, freebsd, linux, and so on.

MemProfileRate controls the fraction of memory allocations that are recorded and reported in the memory profile.

BlockProfileRecord describes blocking events originated at a particular call sequence (stack trace).

Cleanup is a handle to a cleanup call for a specific object.

Frame is the information returned by [Frames] for each call frame.

Frames may be used to get function/file/line information for a slice of PC values returned by [Callers].

A Func represents a Go function in the running binary.

A MemProfileRecord describes the live objects allocated by a particular call sequence (stack trace).

A MemStats records statistics about the memory allocator.

A PanicNilError happens when code calls panic(nil).

A Pinner is a set of Go objects each pinned to a fixed location in memory.

A StackRecord describes a single execution stack.

A TypeAssertionError explains a failed type assertion.

The Error interface identifies a run time error.