Documentation

Overview

    Package stack provides support for parsing standard goroutine stack traces.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    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)

                                                    Directories

                                                    Path Synopsis
                                                    The gostacks command processes stdin looking for things that look like stack traces and simplifying them to make the log more readable.
                                                    The gostacks command processes stdin looking for things that look like stack traces and simplifying them to make the log more readable.