stackimpact

README

StackImpact Go Profiler

Overview

StackImpact is a production-grade performance profiler built for both production and development environments. It gives developers continuous and historical code-level view of application performance that is essential for locating CPU, memory allocation and I/O hot spots as well as latency bottlenecks. Included runtime metrics and error monitoring complement profiles for extensive performance analysis. Learn more at stackimpact.com.

Features

• Continuous hot spot profiling of CPU usage, memory allocation and blocking calls.
• Continuous latency bottleneck tracing.
• Error and panic monitoring.
• Health monitoring including CPU, memory, garbage collection and other runtime metrics.
• Alerts on profile anomalies.
• Team access.

Learn more on the features page (with screenshots).

How it works

The StackImpact profiler agent is imported into a program and used as a normal package. When the program runs, various sampling profilers are started and stopped automatically by the agent and/or programmatically using the agent methods. The agent periodically reports recorded profiles and metrics to the StackImpact Dashboard. The agent can also operate in manual mode, which should be used in development only.

Documentation

See full documentation for reference.

Requirements

Linux, OS X or Windows. Go version 1.5+.

Getting started

Create StackImpact account

Sign up for a free trial account at stackimpact.com (also with GitHub login).

Installing the agent

Install the Go agent by running

go get github.com/stackimpact/stackimpact-go

And import the package github.com/stackimpact/stackimpact-go in your application.

Configuring the agent

Start the agent by specifying the agent key and application name. The agent key can be found in your account's Configuration section.

agent := stackimpact.Start(stackimpact.Options{
	AgentKey: "agent key here",
	AppName: "MyGoApp",
})

All initialization options:

• AgentKey (Required) The access key for communication with the StackImpact servers.
• AppName (Required) A name to identify and group application data. Typically, a single codebase, deployable unit or executable module corresponds to one application. Sometimes also referred as a service.
• AppVersion (Optional) Sets application version, which can be used to associate profiling information with the source code release.
• AppEnvironment (Optional) Used to differentiate applications in different environments.
• HostName (Optional) By default, host name will be the OS hostname.
• ProxyAddress (Optional) Proxy server URL to use when connecting to the Dashboard servers.
• HTTPClient (Optional) An http.Client instance to be used instead of the default client for reporting data to Dashboard servers.
• DisableAutoProfiling (Optional) If set to true, disables the default automatic profiling and reporting. Focused or manual profiling should be used instead. Useful for environments without support for timers or background tasks.
• Debug (Optional) Enables debug logging.
• Logger (Optional) A log.Logger instance to be used instead of default STDOUT logger.

Basic example

package main

import (
	"fmt"
	"net/http"

	"github.com/stackimpact/stackimpact-go"
)

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello world!")
}

func main() {
	agent := stackimpact.Start(stackimpact.Options{
		AgentKey: "agent key here",
		AppName: "Basic Go Server",
		AppVersion: "1.0.0",
		AppEnvironment: "production",
	})

	http.HandleFunc(agent.ProfileHandlerFunc("/", handler)) 
	http.ListenAndServe(":8080", nil)
}

Focused profiling

Focused profiling is suitable for repeating code, such as request or event handlers. By default, the agent starts and stops profiling automatically. In order to make sure the agent profiles the most relevant execution intervals, the following methods can be used. In addition to more precise profiling, timing information will also be reported for the profiled spans.

// Use this method to instruct the agent to start and stop 
// profiling. It does not guarantee that any profiler will be 
// started. The decision is made by the agent based on the 
// overhead constraints. The method returns Span object, on 
// which the Stop() method should be called. 
span := agent.Profile();
defer span.Stop();

// This method is similar to the Profile() method. It additionally
// allows to specify a span name to group span timing measurements.
span := agent.ProfileWithName(name);
defer span.Stop();

// A helper function to profile HTTP handler execution by wrapping 
// http.Handle method parameters.
// Usage example:
//   http.Handle(agent.ProfileHandler("/some-path", someHandler))
pattern, wrappedHandler := agent.ProfileHandler(pattern, handler)

// A helper function to profile HTTP handler function execution 
// by wrapping http.HandleFunc method parameters.
// Usage example:
//   http.HandleFunc(agent.ProfileHandlerFunc("/some-path", someHandlerFunc))
pattern, wrappedHandlerFunc := agent.ProfileHandlerFunc(pattern, handlerFunc)

Error reporting

To monitor exceptions and panics with stack traces, the error recording API can be used.

Recording handled errors:

// Aggregates and reports errors with regular intervals.
agent.RecordError(someError)

Recording panics without recovering:

// Aggregates and reports panics with regular intervals.
defer agent.RecordPanic()

Recording and recovering from panics:

// Aggregates and reports panics with regular intervals. This function also
// recovers from panics.
defer agent.RecordAndRecoverPanic()

Manual profiling

Manual profiling should not be used in production!

By default, the agent starts and stops profiling automatically. Manual profiling allows to start and stop profilers directly. It is suitable for profiling short-lived programs and should not be used for long-running production applications. Automatic profiling should be disabled with DisableAutoProfiling: true.

// Start CPU profiler.
agent.StartCPUProfiler();

// Stop CPU profiler and report the recorded profile to the Dashboard.
// Automatic profiling should be disabled.
agent.StopCPUProfiler();

// Start blocking call profiler.
agent.StartBlockProfiler();

// Stop blocking call profiler and report the recorded profile to the Dashboard.
agent.StopBlockProfiler();

// Report current allocation profile to the Dashboard.
agent.ReportAllocationProfile();

Analyzing performance data in the Dashboard

Once your application is restarted, you can start observing continuously recorded CPU, memory, I/O, and other hot spot profiles, execution bottlenecks as well as process metrics in the Dashboard.

Troubleshooting

To enable debug logging, add Debug: true to startup options. If the debug log doesn't give you any hints on how to fix a problem, please report it to our support team in your account's Support section.

Overhead

The agent overhead is measured to be less than 1% for applications under high load.

Documentation

Index

• Constants
• func WithPprofLabel(key string, val string, req *http.Request, fn func())
• type Agent
  • func NewAgent() *Agent
  • func Start(options Options) *Agent
  • func (a *Agent) Configure(agentKey string, appName string)
  • func (a *Agent) MeasureHandler(pattern string, handler http.Handler) (string, http.Handler)
  • func (a *Agent) MeasureHandlerFunc(pattern string, handlerFunc func(http.ResponseWriter, *http.Request)) (string, func(http.ResponseWriter, *http.Request))
  • func (a *Agent) MeasureSegment(segmentName string) *Segment
  • func (a *Agent) Profile() *Span
  • func (a *Agent) ProfileHandler(pattern string, handler http.Handler) (string, http.Handler)
  • func (a *Agent) ProfileHandlerFunc(pattern string, handlerFunc func(http.ResponseWriter, *http.Request)) (string, func(http.ResponseWriter, *http.Request))
  • func (a *Agent) ProfileWithName(name string) *Span
  • func (a *Agent) RecordAndRecoverPanic()
  • func (a *Agent) RecordError(err interface{})
  • func (a *Agent) RecordPanic()
  • func (a *Agent) Report()
  • func (a *Agent) ReportAllocationProfile()
  • func (a *Agent) ReportWithHTTPClient(client *http.Client)
  • func (a *Agent) Start(options Options)
  • func (a *Agent) StartBlockProfiler()
  • func (a *Agent) StartCPUProfiler()
  • func (a *Agent) StopBlockProfiler()
  • func (a *Agent) StopCPUProfiler()
  • func (a *Agent) UpdateOptions(options Options)
• type Options
• type Segment
  • func (s *Segment) Stop()
• type Span
  • func (s *Span) Stop()

Constants

const ErrorGroupHandledExceptions string = "Handled exceptions"

const ErrorGroupRecoveredPanics string = "Recovered panics"

const ErrorGroupUnrecoveredPanics string = "Unrecovered panics"

Functions

func WithPprofLabel

func WithPprofLabel(key string, val string, req *http.Request, fn func())

Types

type Agent

type Agent struct {

	// compatibility < 1.2.0
	DashboardAddress string
	AgentKey         string
	AppName          string
	HostName         string
	Debug            bool
	// contains filtered or unexported fields
}

func NewAgent

func NewAgent() *Agent

DEPRECATED. Kept for compatibility with <1.4.3.

func Start

func Start(options Options) *Agent

Starts the agent with configuration options. Required options are AgentKey and AppName.

func (*Agent) Configure

func (a *Agent) Configure(agentKey string, appName string)

DEPRECATED. Kept for compatibility with <1.2.0.

func (*Agent) MeasureHandler

func (a *Agent) MeasureHandler(pattern string, handler http.Handler) (string, http.Handler)

DEPRECATED. A helper function to measure HTTP handler execution by wrapping http.Handle method parameters.

func (*Agent) MeasureHandlerFunc

func (a *Agent) MeasureHandlerFunc(pattern string, handlerFunc func(http.ResponseWriter, *http.Request)) (string, func(http.ResponseWriter, *http.Request))

DEPRECATED. A helper function to measure HTTP handler function execution by wrapping http.HandleFunc method parameters.

func (*Agent) MeasureSegment

func (a *Agent) MeasureSegment(segmentName string) *Segment

DEPRECATED. Starts measurement of execution time of a code segment. To stop measurement call Stop on returned Segment object. After calling Stop the segment is recorded, aggregated and reported with regular intervals.

func (*Agent) Profile

func (a *Agent) Profile() *Span

Use this method to instruct the agent to start and stop profiling. It does not guarantee that any profiler will be started. The decision is made by the agent based on the overhead constraints. The method returns Span object, on which the Stop() method should be called.

func (*Agent) ProfileHandler

func (a *Agent) ProfileHandler(pattern string, handler http.Handler) (string, http.Handler)

A helper function to profile HTTP handler execution by wrapping http.Handle method parameters.

func (*Agent) ProfileHandlerFunc

func (a *Agent) ProfileHandlerFunc(pattern string, handlerFunc func(http.ResponseWriter, *http.Request)) (string, func(http.ResponseWriter, *http.Request))

A helper function to profile HTTP handler function execution by wrapping http.HandleFunc method parameters.

func (*Agent) ProfileWithName

func (a *Agent) ProfileWithName(name string) *Span

This method is similar to the Profile() method. It additionally allows to specify a span name to group span timing measurements.

func (*Agent) RecordAndRecoverPanic

func (a *Agent) RecordAndRecoverPanic()

Aggregates and reports panics with regular intervals. This function also recovers from panics

func (*Agent) RecordError

func (a *Agent) RecordError(err interface{})

Aggregates and reports errors with regular intervals.

func (*Agent) RecordPanic

func (a *Agent) RecordPanic()

Aggregates and reports panics with regular intervals.

func (*Agent) Report

func (a *Agent) Report()

DEPRECATED. Kept for compatibility.

func (*Agent) ReportAllocationProfile

func (a *Agent) ReportAllocationProfile()

Report current allocation profile to the Dashboard.

func (*Agent) ReportWithHTTPClient

func (a *Agent) ReportWithHTTPClient(client *http.Client)

DEPRECATED. Kept for compatibility.

func (*Agent) Start

func (a *Agent) Start(options Options)

Starts the agent with configuration options. Required options are AgentKey and AppName.

func (*Agent) StartBlockProfiler

func (a *Agent) StartBlockProfiler()

Start blocking call profiler. Automatic profiling should be disabled.

func (*Agent) StartCPUProfiler

func (a *Agent) StartCPUProfiler()

Start CPU profiler. Automatic profiling should be disabled.

func (*Agent) StopBlockProfiler

func (a *Agent) StopBlockProfiler()

Stop blocking call profiler and report the recorded profile to the Dashboard.

func (*Agent) StopCPUProfiler

func (a *Agent) StopCPUProfiler()

Stop CPU profiler and report the recorded profile to the Dashboard.

func (*Agent) UpdateOptions

func (a *Agent) UpdateOptions(options Options)

Update some options after the agent has already been started. Only ProxyAddress, HTTPClient and Debug options are updatable.

type Options

type Options struct {
	DashboardAddress     string
	ProxyAddress         string
	HTTPClient           *http.Client
	AgentKey             string
	AppName              string
	AppVersion           string
	AppEnvironment       string
	HostName             string
	DisableAutoProfiling bool
	Debug                bool
	Logger               *log.Logger
	ProfileAgent         bool
}

type Segment

type Segment struct {
	Name string

	Duration float64
	// contains filtered or unexported fields
}

func (*Segment) Stop

func (s *Segment) Stop()

Stops the measurement of a code segment execution time.

type Span

type Span struct {
	// contains filtered or unexported fields
}

func (*Span) Stop

func (s *Span) Stop()

Stops profiling.