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 4 packages. Updated 2020-10-28. Refresh now. Tools for package owners.