package stack

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

Package stack provides support for parsing standard goroutine stack traces.

Index ¶

• func Process(out io.Writer, in io.Reader) error
• type Call
• func (c Call) Format(w fmt.State, r rune)
• type Delta
• func Diff(before, after Dump) Delta
• type Dump
• func Capture() Dump
• func Parse(scanner *Scanner) (Dump, error)
• type Frame
• func (f Frame) Format(w fmt.State, c rune)
• type Function
• func (f Function) Format(w fmt.State, c rune)
• type Goroutine
• type Group
• func (g Group) Format(w fmt.State, r rune)
• type Position
• func (p Position) Format(w fmt.State, c rune)
• type Scanner
• func NewScanner(r io.Reader) *Scanner
• func (s *Scanner) Done() bool
• func (s *Scanner) Err() error
• func (s *Scanner) Match(re *regexp.Regexp) []string
• func (s *Scanner) Next() string
• func (s *Scanner) Peek() string
• func (s *Scanner) Skip()
• func (s *Scanner) SkipBlank()
• type Stack
• type Summary
• func Summarize(dump Dump) Summary
• func (s Summary) Format(w fmt.State, r rune)

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 ¶