package runtime/pprof

type CPURecorder struct { ... }

func CPURecorderConfig struct {
    // Period sets the duration between profile samples.
    //
    // If no value is set, the sample period for the duration is implementation-defined.
    // This implementation-defined value is independent of [runtime.SetCPUProfileRate],
    // but the rate set here may be visible to consumers of [StartCPUProfile], so callers
    // are discouraged from using both CPURecorder and StartCPUProfile in the same
    // program.
    Period time.Duration
}

func NewCPURecorder(CPURecorderConfig) (*CPURecorder, error)

// Start applies the recorder's configuration and begins global collection of
// CPU samples.
//
// Returns an error if this recorder had already been started.
func (*CPURecorder) Start(io.Writer) error

// Stop completes collection of the CPU profile.
//
// Returns an error on any failure to write to the io.Writer provided to Start,
// or if the recorder had not been started.
func (*CPURecorder) Stop() error

type AllocRecorder struct { ... }

func AllocRecorderConfig struct {
    // BytesPerSample sets the maximum number of bytes allocated between samples.
    //
    // If no value is set, the sample period for the duration is implementation-defined.
    // This implementation-defined value is independent of [runtime.MemProfileRate],
    // but the rate set here may be visible to consumers of [Profile.WriteTo].
    BytesPerSample int64
}

func NewAllocRecorder(AllocRecorderConfig) *AllocRecorder

// Start applies the recorder's configuration and takes a snapshot of the profile.
//
// Returns an error if this recorder had already been started.
func (*AllocRecorder) Start(io.Writer) error

// Stop takes a second snapshot and computes the difference with the profile
// taken at start. The resulting profile is written to the io.Writer provided
// to Start. It contains all sampled allocations made in the window of time between
// Start and Stop, which is useful for identifying sources of high allocation volume.
//
// Returns an error on any failure to write to the io.Writer provided to Start,
// or if the recorder had not been started.
func (*AllocRecorder) Stop() error

type HeapRecorder struct { ... }

func HeapRecorderConfig struct {
    // None for now.
}

func NewHeapRecorder(HeapRecorderConfig) *HeapRecorder

// Snapshot writes a sampled profile of the live heap to the provided io.Writer.
//
// The sampling rate is controlled by [runtime.MemProfileRate].
func (*HeapRecorder) Snapshot(io.Writer) (int, error)

// Start applies the recorder's configuration and takes a snapshot of the sampled live heap.
//
// Returns an error if this recorder had already been started.
func (*HeapRecorder) Start(io.Writer) error

// Stop takes a second snapshot and computes the difference with the profile
// taken at start. The resulting profile is written to the io.Writer provided
// to Start. This delta is useful for identifying memory leaks, since memory leaks
// will quickly rise out of the noise with a large positive delta over time.
//
// Returns an error on any failure to write to the io.Writer provided to Start,
// or if the recorder had not been started.
func (*HeapRecorder) Stop() error

type BlockRecorder struct { ... }

func BlockRecorderConfig struct {
    // EventsPerSample sets the number of goroutine block events between samples.
    //
    // If no value is set, the sample period for the duration is implementation-defined.
    // This implementation-defined value is independent of [runtime.SetBlockProfileRate],
    // but the rate set here may be visible to consumers of [Profile.WriteTo].
    EventsPerSample int
}

func NewBlockRecorder(BlockRecorderConfig) (*BlockRecorder, error)

// Start applies the recorder's configuration and takes a snapshot of the profile.
//
// Returns an error if this recorder had already been started.
func (*BlockRecorder) Start(io.Writer) error

// Stop takes a second snapshot and computes the difference with the profile
// taken at start. The resulting profile is written to the io.Writer provided
// to Start.
//
// Returns an error on any failure to write to the io.Writer provided to Start,
// or if the recorder had not been started.
func (*BlockRecorder) Stop() error

type MutexRecorder struct { ... }

func MutexRecorderConfig struct {
    // EventsPerSample sets the maximum number of unlock events between samples.
    //
    // If no value is set, the sample period for the duration is implementation-defined.
    // This implementation-defined value is independent of [runtime.SetMutexProfileRate],
    // but the rate set here may be visible to consumers of [Profile.WriteTo].
    EventsPerSample int
}

func NewMutexRecorder(MutexRecorderConfig) (*MutexRecorder, error)

// Start applies the recorder's configuration and takes a snapshot of the profile.
//
// Returns an error if this recorder had already been started.
func (*MutexRecorder) Start(io.Writer) error

// Stop takes a second snapshot and computes the difference with the profile
// taken at start. The resulting profile is written to the io.Writer provided
// to Start.
//
// Returns an error on any failure to write to the io.Writer provided to Start,
// or if the recorder had not been started.
func (*MutexRecorder) Stop() error

type GoroutineRecorder struct { ... }

func GoroutineRecorderConfig struct {
    Format GoroutineProfileFormat
}

// GoroutineProfileFormat is an enumeration of available formats for writing
// out the goroutine profile.
type GoroutineProfileFormat int

const (
    PprofGoroutineProfile GoroutineProfileFormat = iota // Default gzipped protobuf.
    TextGoroutineProfile                                // Legacy text profile.
    TracebackGoroutineProfile                           // Matches default traceback format.
)

func NewGoroutineRecorder(MutexRecorderConfig) (*GoroutineRecorder, error)

// Snapshot snapshots the state of all goroutines, assembles it into a profile,
// and writes the result to the provided io.Writer.
func (*GoroutineRecorder) Snapshot(io.Writer) (int, error)

// ProfileRecorder is a generic profile recorder that works for any profile.
//
// It does not provide as much customizability as the more specific types,
// but works with any Profile, include custom Profiles.
type ProfileRecorder struct { ... }
func ProfileRecorderConfig struct {
    // None for now.
}

func NewProfileRecorder(*Profile, ProfileRecorderConfig) (*ProfileRecorder, error)

// Start applies the recorder's configuration and takes a snapshot of the profile.
//
// Returns an error if this recorder had already been started.
func (*ProfileRecorder) Start(io.Writer) error

// Stop takes a second snapshot and computes the difference with the profile
// taken at start. The resulting profile is written to the io.Writer provided
// to Start.
//
// Returns an error on any failure to write to the io.Writer provided to Start,
// or if the recorder had not been started.
func (*ProfileRecorder) Stop() error

// Snapshot emits all profile data collected since program start until this point.
func (*ProfileRecorder) Snapshot(io.Writer) (int, error)