pyroscope

Documentation

Index

• Variables
• func TagWrapper(ctx context.Context, labels LabelSet, cb func(context.Context))
• type Config
• type LabelSet
• type Logger
• type ProfileType
• type Profiler
  • func Start(cfg Config) (*Profiler, error)
  • func (p *Profiler) Flush(wait bool)
  • func (p *Profiler) Stop() error
• type Session
  • func NewSession(c SessionConfig) (*Session, error)
  • func (ps *Session) Stop()
• type SessionConfig

Variables

var DefaultProfileTypes = []ProfileType{
	ProfileCPU,
	ProfileAllocObjects,
	ProfileAllocSpace,
	ProfileInuseObjects,
	ProfileInuseSpace,
}

var Labels = pprof.Labels

var StandardLogger = &standardLoggerImpl{}

Functions

func TagWrapper

func TagWrapper(ctx context.Context, labels LabelSet, cb func(context.Context))

Types

type Config

type Config struct {
	ApplicationName        string // e.g backend.purchases
	Tags                   map[string]string
	ServerAddress          string // e.g http://pyroscope.services.internal:4040
	AuthToken              string // specify this token when using pyroscope cloud
	SampleRate             uint32 // todo this one is not used
	Logger                 Logger
	ProfileTypes           []ProfileType
	DisableGCRuns          bool // this will disable automatic runtime.GC runs between getting the heap profiles
	DisableAutomaticResets bool // disable automatic profiler reset every 10 seconds. Reset manually by calling Flush method
	DisableCumulativeMerge bool // disable client side merging of cumulative profiles (alloc_objects, alloc_count, block_count, block_duration, mutex_count, mutex_duration) merging
}

type LabelSet

type LabelSet = pprof.LabelSet

type Logger

type Logger interface {
	Infof(_ string, _ ...interface{})
	Debugf(_ string, _ ...interface{})
	Errorf(_ string, _ ...interface{})
}

Logger is an interface that library users can use It is based on logrus, but much smaller — That's because we don't want library users to have to implement all of the logrus's methods

type ProfileType

type ProfileType string

const (
	ProfileCPU           ProfileType = "cpu"
	ProfileInuseObjects  ProfileType = "inuse_objects"
	ProfileAllocObjects  ProfileType = "alloc_objects"
	ProfileInuseSpace    ProfileType = "inuse_space"
	ProfileAllocSpace    ProfileType = "alloc_space"
	ProfileGoroutines    ProfileType = "goroutines"
	ProfileMutexCount    ProfileType = "mutex_count"
	ProfileMutexDuration ProfileType = "mutex_duration"
	ProfileBlockCount    ProfileType = "block_count"
	ProfileBlockDuration ProfileType = "block_duration"
	DefaultSampleRate                = 100
)

type Profiler

type Profiler struct {
	// contains filtered or unexported fields
}

func Start

func Start(cfg Config) (*Profiler, error)

Start starts continuously profiling go code

func (*Profiler) Flush

func (p *Profiler) Flush(wait bool)

Flush resets current profiling session. if wait is true, also waits for all profiles to be uploaded synchronously

func (*Profiler) Stop

func (p *Profiler) Stop() error

Stop stops continuous profiling session and uploads the remaining profiling data

type Session

type Session struct {
	DisableAutomaticResets bool
	// contains filtered or unexported fields
}

func NewSession

func NewSession(c SessionConfig) (*Session, error)

func (*Session) Stop

func (ps *Session) Stop()

type SessionConfig

type SessionConfig struct {
	Upstream               upstream.Upstream
	Logger                 Logger
	AppName                string
	Tags                   map[string]string
	ProfilingTypes         []ProfileType
	DisableGCRuns          bool
	DisableAutomaticResets bool
	DisableCumulativeMerge bool
	SampleRate             uint32
	UploadRate             time.Duration
}