stack

Documentation

Overview

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)