package stack

import "golang.org/x/tools/internal/jsonrpc2/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)

Functions ¶

func Process ¶

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.

Types ¶

type Call ¶

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 ¶

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

type Delta ¶

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 ¶

func Diff(before, after Dump) Delta

Diff calculates the delta between two dumps.

type Dump ¶

type Dump []Goroutine

Dump is a raw set of goroutines and their stacks.

func Capture ¶

func Capture() Dump

Capture get the current stack traces from the runtime.

func Parse ¶

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

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

type Frame ¶

type Frame struct {
	Function Function
	Position Position
}

Frame is a point in a call stack.

func (Frame) Format ¶

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

type Function ¶

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 ¶

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

type Goroutine ¶

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 ¶

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 ¶

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

type Position ¶

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

Position is the file position for a frame.

func (Position) Format ¶

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

type Scanner ¶

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 ¶

func NewScanner(r io.Reader) *Scanner

NewScanner creates a scanner on top of a reader.

func (*Scanner) Done ¶

func (s *Scanner) Done() bool

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

func (*Scanner) Err ¶

func (s *Scanner) Err() error

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

func (*Scanner) Match ¶

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 ¶

func (s *Scanner) Next() string

Next consumes and returns the next line.

func (*Scanner) Peek ¶

func (s *Scanner) Peek() string

Peek returns the next line without consuming it.

func (*Scanner) Skip ¶

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 ¶

func (s *Scanner) SkipBlank()

SkipBlank skips any number of pure whitespace lines.

type Stack ¶

type Stack []Frame

Stack is a set of frames in a callstack.

type Summary ¶

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 ¶

func Summarize(dump Dump) Summary

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

func (Summary) Format ¶

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

Source Files ¶

parse.go process.go stack.go

Directories ¶