Go: cmd/vendor/github.com/google/pprof/internal/plugin Index | Files

package plugin

import "cmd/vendor/github.com/google/pprof/internal/plugin"

Package plugin defines the plugin implementations that the main pprof driver requires.


Package Files


type Fetcher Uses

type Fetcher interface {
    Fetch(src string, duration, timeout time.Duration) (*profile.Profile, string, error)

A Fetcher reads and returns the profile named by src. src can be a local file path or a URL. duration and timeout are units specified by the end user, or 0 by default. duration refers to the length of the profile collection, if applicable, and timeout is the amount of time to wait for a profile before returning an error. Returns the fetched profile, the URL of the actual source of the profile, or an error.

type FlagSet Uses

type FlagSet interface {
    // Bool, Int, Float64, and String define new flags,
    // like the functions of the same name in package flag.
    Bool(name string, def bool, usage string) *bool
    Int(name string, def int, usage string) *int
    Float64(name string, def float64, usage string) *float64
    String(name string, def string, usage string) *string

    // StringList is similar to String but allows multiple values for a
    // single flag
    StringList(name string, def string, usage string) *[]*string

    // ExtraUsage returns any additional text that should be printed after the
    // standard usage message. The extra usage message returned includes all text
    // added with AddExtraUsage().
    // The typical use of ExtraUsage is to show any custom flags defined by the
    // specific pprof plugins being used.
    ExtraUsage() string

    // AddExtraUsage appends additional text to the end of the extra usage message.
    AddExtraUsage(eu string)

    // Parse initializes the flags with their values for this run
    // and returns the non-flag command line arguments.
    // If an unknown flag is encountered or there are no arguments,
    // Parse should call usage and return nil.
    Parse(usage func()) []string

A FlagSet creates and parses command-line flags. It is similar to the standard flag.FlagSet.

type Frame Uses

type Frame struct {
    Func string // name of function
    File string // source file name
    Line int    // line in file

A Frame describes a single line in a source file.

type HTTPServerArgs Uses

type HTTPServerArgs struct {
    // Hostport contains the http server address (derived from flags).
    Hostport string

    Host string // Host portion of Hostport
    Port int    // Port portion of Hostport

    // Handlers maps from URL paths to the handler to invoke to
    // serve that path.
    Handlers map[string]http.Handler

HTTPServerArgs contains arguments needed by an HTTP server that is exporting a pprof web interface.

type Inst Uses

type Inst struct {
    Addr     uint64 // virtual address of instruction
    Text     string // instruction text
    Function string // function name
    File     string // source file
    Line     int    // source line

An Inst is a single instruction in an assembly listing.

type MappingSources Uses

type MappingSources map[string][]struct {
    Source string // URL of the source the mapping was collected from
    Start  uint64 // delta applied to addresses from this source (to represent Merge adjustments)

MappingSources map each profile.Mapping to the source of the profile. The key is either Mapping.File or Mapping.BuildId.

type ObjFile Uses

type ObjFile interface {
    // Name returns the underlyinf file name, if available
    Name() string

    // Base returns the base address to use when looking up symbols in the file.
    Base() uint64

    // BuildID returns the GNU build ID of the file, or an empty string.
    BuildID() string

    // SourceLine reports the source line information for a given
    // address in the file. Due to inlining, the source line information
    // is in general a list of positions representing a call stack,
    // with the leaf function first.
    SourceLine(addr uint64) ([]Frame, error)

    // Symbols returns a list of symbols in the object file.
    // If r is not nil, Symbols restricts the list to symbols
    // with names matching the regular expression.
    // If addr is not zero, Symbols restricts the list to symbols
    // containing that address.
    Symbols(r *regexp.Regexp, addr uint64) ([]*Sym, error)

    // Close closes the file, releasing associated resources.
    Close() error

An ObjFile is a single object file: a shared library or executable.

type ObjTool Uses

type ObjTool interface {
    // Open opens the named object file. If the object is a shared
    // library, start/limit/offset are the addresses where it is mapped
    // into memory in the address space being inspected.
    Open(file string, start, limit, offset uint64) (ObjFile, error)

    // Disasm disassembles the named object file, starting at
    // the start address and stopping at (before) the end address.
    Disasm(file string, start, end uint64) ([]Inst, error)

An ObjTool inspects shared libraries and executable files.

type Options Uses

type Options struct {
    Writer  Writer
    Flagset FlagSet
    Fetch   Fetcher
    Sym     Symbolizer
    Obj     ObjTool
    UI      UI

    // HTTPServer is a function that should block serving http requests,
    // including the handlers specified in args.  If non-nil, pprof will
    // invoke this function if necessary to provide a web interface.
    // If HTTPServer is nil, pprof will use its own internal HTTP server.
    // A common use for a custom HTTPServer is to provide custom
    // authentication checks.
    HTTPServer    func(args *HTTPServerArgs) error
    HTTPTransport http.RoundTripper

Options groups all the optional plugins into pprof.

type Sym Uses

type Sym struct {
    Name  []string // names of symbol (many if symbol was dedup'ed)
    File  string   // object file containing symbol
    Start uint64   // start virtual address
    End   uint64   // virtual address of last byte in sym (Start+size-1)

A Sym describes a single symbol in an object file.

type Symbolizer Uses

type Symbolizer interface {
    Symbolize(mode string, srcs MappingSources, prof *profile.Profile) error

A Symbolizer introduces symbol information into a profile.

type UI Uses

type UI interface {
    // Read returns a line of text (a command) read from the user.
    // prompt is printed before reading the command.
    ReadLine(prompt string) (string, error)

    // Print shows a message to the user.
    // It formats the text as fmt.Print would and adds a final \n if not already present.
    // For line-based UI, Print writes to standard error.
    // (Standard output is reserved for report data.)

    // PrintErr shows an error message to the user.
    // It formats the text as fmt.Print would and adds a final \n if not already present.
    // For line-based UI, PrintErr writes to standard error.

    // IsTerminal returns whether the UI is known to be tied to an
    // interactive terminal (as opposed to being redirected to a file).
    IsTerminal() bool

    // WantBrowser indicates whether a browser should be opened with the -http option.
    WantBrowser() bool

    // SetAutoComplete instructs the UI to call complete(cmd) to obtain
    // the auto-completion of cmd, if the UI supports auto-completion at all.
    SetAutoComplete(complete func(string) string)

A UI manages user interactions.

type Writer Uses

type Writer interface {
    Open(name string) (io.WriteCloser, error)

Writer provides a mechanism to write data under a certain name, typically a filename.

Package plugin imports 5 packages (graph). Updated 2021-01-21. Refresh now. Tools for package owners.