tools: golang.org/x/tools/internal/stack Index | Files | Directories

package stack

import "golang.org/x/tools/internal/stack"

Package stack provides support for parsing standard goroutine stack traces.

Index

Package Files

parse.go process.go stack.go

func Process Uses

func Process(out io.Writer, in io.Reader) error

Process and input stream to an output stream, summarizing any stacks that are detected in place.

type Call Uses

type Call struct {
    Stack  Stack   // the shared callstack information
    Groups []Group // the sets of goroutines with the same state
}

Call is set of goroutines that all share the same callstack. They will be grouped by state.

func (Call) Format Uses

func (c Call) Format(w fmt.State, r rune)

type Delta Uses

type Delta struct {
    Before Dump // The goroutines that were only in the before set.
    Shared Dump // The goroutines that were in both sets.
    After  Dump // The goroutines that were only in the after set.
}

Delta represents the difference between two stack dumps.

func Diff Uses

func Diff(before, after Dump) Delta

Diff calculates the delta between two dumps.

type Dump Uses

type Dump []Goroutine

Dump is a raw set of goroutines and their stacks.

func Capture Uses

func Capture() Dump

Capture get the current stack traces from the runtime.

func Parse Uses

func Parse(scanner *Scanner) (Dump, error)

Parse the current contiguous block of goroutine stack traces until the scanned content no longer matches.

type Frame Uses

type Frame struct {
    Function Function
    Position Position
}

Frame is a point in a call stack.

func (Frame) Format Uses

func (f Frame) Format(w fmt.State, c rune)

type Function Uses

type Function struct {
    Package string // package name of function if known
    Type    string // if set function is a method of this type
    Name    string // function name of the frame
}

Function is the function called at a frame.

func (Function) Format Uses

func (f Function) Format(w fmt.State, c rune)

type Goroutine Uses

type Goroutine struct {
    State string // state that the goroutine is in.
    ID    int    // id of the goroutine.
    Stack Stack  // call frames that make up the stack
}

Goroutine is a single parsed goroutine dump.

type Group Uses

type Group struct {
    State      string      // the shared state of the goroutines
    Goroutines []Goroutine // the set of goroutines in this group
}

Group is a set of goroutines with the same stack that are in the same state.

func (Group) Format Uses

func (g Group) Format(w fmt.State, r rune)

type Position Uses

type Position struct {
    Filename string // source filename
    Line     int    // line number within file
}

Position is the file position for a frame.

func (Position) Format Uses

func (p Position) Format(w fmt.State, c rune)

type Scanner Uses

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

Scanner splits an input stream into lines in a way that is consumable by the parser.

func NewScanner Uses

func NewScanner(r io.Reader) *Scanner

NewScanner creates a scanner on top of a reader.

func (*Scanner) Done Uses

func (s *Scanner) Done() bool

Done returns true if the scanner has reached the end of the underlying stream.

func (*Scanner) Err Uses

func (s *Scanner) Err() error

Err returns true if the scanner has reached the end of the underlying stream.

func (*Scanner) Match Uses

func (s *Scanner) Match(re *regexp.Regexp) []string

Match returns the submatchs of the regular expression against the next line. If it matched the line is also consumed.

func (*Scanner) Next Uses

func (s *Scanner) Next() string

Next consumes and returns the next line.

func (*Scanner) Peek Uses

func (s *Scanner) Peek() string

Peek returns the next line without consuming it.

func (*Scanner) Skip Uses

func (s *Scanner) Skip()

Skip consumes the next line without looking at it. Normally used after it has already been looked at using Peek.

func (*Scanner) SkipBlank Uses

func (s *Scanner) SkipBlank()

SkipBlank skips any number of pure whitespace lines.

type Stack Uses

type Stack []Frame

Stack is a set of frames in a callstack.

type Summary Uses

type Summary struct {
    Total int    // the total count of goroutines in the summary
    Calls []Call // the collated stack traces
}

Summary is a set of stacks processed and collated into Calls.

func Summarize Uses

func Summarize(dump Dump) Summary

Summarize a dump for easier consumption. This collates goroutines with equivalent stacks.

func (Summary) Format Uses

func (s Summary) Format(w fmt.State, r rune)

Directories

PathSynopsis
gostacksThe gostacks command processes stdin looking for things that look like stack traces and simplifying them to make the log more readable.
stacktest

Package stack imports 10 packages (graph) and is imported by 2 packages. Updated 2020-08-05. Refresh now. Tools for package owners.