honeybadger

package
v0.0.0-...-2b7dcb4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 17, 2024 License: BSD-2-Clause, MIT Imports: 18 Imported by: 0

README

Honeybadger for Go

Build Status

Go (golang) support for the ⚡ Honeybadger error notifier. Receive instant notification of panics and errors in your Go applications.

Getting Started

1. Install the library

To install, grab the package from GitHub:

go get github.com/honeybadger-io/honeybadger-go

Then add an import to your application code:

import "github.com/honeybadger-io/honeybadger-go"
2. Set your API key

Finally, configure your API key:

honeybadger.Configure(honeybadger.Configuration{APIKey: "your api key"})

You can also configure Honeybadger via environment variables. See Configuration for more information.

3. Enable automatic panic reporting
Panics during HTTP requests

To automatically report panics which happen during an HTTP request, wrap your http.Handler function with honeybadger.Handler:

log.Fatal(http.ListenAndServe(":8080", honeybadger.Handler(handler)))

Request data such as cookies and params will automatically be reported with errors which happen inside honeybadger.Handler. Make sure you recover from panics after honeybadger's Handler has been executed to ensure all panics are reported.

Unhandled Panics

To report all unhandled panics which happen in your application the following can be added to main():

func main() {
  defer honeybadger.Monitor()
  // application code...
}
Manually Reporting Errors

To report an error manually, use honeybadger.Notify:

if err != nil {
  honeybadger.Notify(err)
}

Sample Application

If you'd like to see the library in action before you integrate it with your apps, check out our sample application.

You can deploy the sample app to your Heroku account by clicking this button:

Deploy

Don't forget to destroy the Heroku app after you're done so that you aren't charged for usage.

The code for the sample app is available on Github, in case you'd like to read through it, or run it locally.

Configuration

To set configuration options, use the honeybadger.Configuration method, like so:

honeybadger.Configure(honeybadger.Configuration{
  APIKey: "your api key", 
  Env: "staging"
})

The following options are available to you:

Name Type Default Example Environment variable
APIKey string "" "badger01" HONEYBADGER_API_KEY
Root string The current working directory "/path/to/project" HONEYBADGER_ROOT
Env string "" "production" HONEYBADGER_ENV
Hostname string The hostname of the current server. "badger01" HONEYBADGER_HOSTNAME
Endpoint string "https://api.honeybadger.io" "https://honeybadger.example.com/" HONEYBADGER_ENDPOINT
Timeout time.Duration 3 seconds 10 * time.Second HONEYBADGER_TIMEOUT (nanoseconds)
Logger honeybadger.Logger Logs to stderr CustomLogger{} n/a
Backend honeybadger.Backend HTTP backend CustomBackend{} n/a

Public Interface

honeybadger.Notify(): Send an error to Honeybadger.

If you've handled a panic in your code, but would still like to report the error to Honeybadger, this is the method for you.

Examples:
if err != nil {
  honeybadger.Notify(err)
}

You can also add local context using an optional second argument when calling honeybadger.Notify:

honeybadger.Notify(err, honeybadger.Context{"user_id": 2})

Honeybadger uses the error's class name to group similar errors together. If your error classes are often generic (such as errors.errorString), you can improve grouping by overriding the default with something more unique:

honeybadger.Notify(err, honeybadger.ErrorClass{"CustomClassName"})

To override grouping entirely, you can send a custom fingerprint. All errors with the same fingerprint will be grouped together:

honeybadger.Notify(err, honeybadger.Fingerprint{"A unique string"})
honeybadger.SetContext(): Set metadata to be sent if an error occurs

This method lets you set context data that will be sent if an error should occur.

For example, it's often useful to record the current user's ID when an error occurs in a web app. To do that, just use SetContext to set the user id on each request. If an error occurs, the id will be reported with it.

Examples:
honeybadger.SetContext(honeybadger.Context{
  "user_id": 1,
})
defer honeybadger.Monitor(): Automatically report panics from your functions

To automatically report panics in your functions or methods, add defer honeybadger.Monitor() to the beginning of the function or method you wish to monitor.

Examples:
func risky() {
  defer honeybadger.Monitor()
  // risky business logic...
}

Important: honeybadger.Monitor() will re-panic after it reports the error, so make sure that it is only called once before recovering from the panic (or allowing the process to crash).

honeybadger.BeforeNotify(): Add a callback to skip or modify error notification.

Sometimes you may want to modify the data sent to Honeybadger right before an error notification is sent, or skip the notification entirely. To do so, add a callback using honeybadger.BeforeNotify().

Examples:
honeybadger.BeforeNotify(
  func(notice *honeybadger.Notice) error {
    if notice.ErrorClass == "SkippedError" {
      return fmt.Errorf("Skipping this notification")
    }
    // Return nil to send notification for all other classes.
    return nil
  }
)

To modify information:

honeybadger.BeforeNotify(
  func(notice *honeybadger.Notice) error {
    // Errors in Honeybadger will always have the class name "GenericError".
    notice.ErrorClass = "GenericError"
    return nil
  }
)
honeybadger.NewNullBackend(): Disable data reporting.

NewNullBackend creates a backend which swallows all errors and does not send them to Honeybadger. This is useful for development and testing to disable sending unnecessary errors.

Examples:
honeybadger.Configure(honeybadger.Configuration{Backend: honeybadger.NewNullBackend()})

Creating a new client

In the same way that the log library provides a predefined "standard" logger, honeybadger defines a standard client which may be accessed directly via honeybadger. A new client may also be created by calling honeybadger.New:

hb := honeybadger.New(honeybadger.Configuration{APIKey: "some other api key"})
hb.Notify("This error was reported by an alternate client.")

Grouping

Honeybadger groups by the error class and the first line of the backtrace by default. In some cases it may be desirable to provide your own grouping algorithm. One use case for this is errors.errorString. Because that type is used for many different types of errors in Go, Honeybadger will appear to group unrelated errors together. Here's an example of providing a custom fingerprint which will group errors.errorString by message instead:

honeybadger.BeforeNotify(
  func(notice *honeybadger.Notice) error {
    if notice.ErrorClass == "errors.errorString" {
      notice.Fingerprint = notice.Message
    }
    return nil
  }
)

Note that in this example, the backtrace is ignored. If you want to group by message and backtrace, you could append data from notice.Backtrace to the fingerprint string.

An alternate approach would be to override notice.ErrorClass with a more specific class name that may be inferred from the message.

Versioning

We use Semantic Versioning to version releases of honeybadger-go. Because there is no official method to specify version dependencies in Go, we will do our best never to introduce a breaking change on the master branch of this repo after reaching version 1. Until we reach version 1 there is a small chance that we may introduce a breaking change (changing the signature of a function or method, for example), but we'll always tag a new minor release and broadcast that we made the change.

If you're concerned about versioning, there are two options:

Vendor your dependencies

If you're really concerned about changes to this library, then copy it into your source control management system so that you can perform upgrades on your own time.

Use gopkg.in

Rather than importing directly from GitHub, gopkg.in allows you to use their special URL format to transparently import a branch or tag from GitHub. Because we tag each release, using gopkg.in can enable you to depend explicitly on a certain version of this library. Importing from gopkg.in instead of directly from GitHub is as easy as:

import "gopkg.in/honeybadger-io/honeybadger-go.v0"

Check out the gopkg.in homepage for more information on how to request versions.

Changelog

See https://github.com/honeybadger-io/honeybadger-go/blob/master/CHANGELOG.md

Contributing

If you're adding a new feature, please submit an issue as a preliminary step; that way you can be (moderately) sure that your pull request will be accepted.

To contribute your code:
  1. Fork it.
  2. Create a topic branch git checkout -b my_branch
  3. Commit your changes git commit -am "Boom"
  4. Push to your branch git push origin my_branch
  5. Send a pull request
License

This library is MIT licensed. See the LICENSE file in this repository for details.

Documentation

Index

Constants

View Source 
const VERSION = "0.2.0"

VERSION defines the version of the honeybadger package.

Variables

View Source 
var (
	// client is a pre-defined "global" client.
	DefaultClient = New(Configuration{})

	// Config is a pointer to the global client's Config.
	Config = DefaultClient.Config

	// Notices is the feature for sending error reports.
	Notices = Feature{"notices"}

	// Metrics is deprecated.
	Metrics = Feature{"metrics"}
)
View Source 
var (
	ErrRateExceeded    = errors.New("Rate exceeded: slow down!")
	ErrPaymentRequired = errors.New("Payment required: expired trial or credit card?")
	ErrUnauthorized    = errors.New("Unauthorized: bad API key?")
)

Errors returned by the backend when unable to successfully handle payload.

Functions

func BeforeNotify 

func BeforeNotify(handler func(notice *Notice) error)

BeforeNotify adds a callback function which is run before a notice is reported to Honeybadger. If any function returns an error the notification will be skipped, otherwise it will be sent.

func Configure 

func Configure(c Configuration)

Configure updates configuration of the global client.

func Flush 

func Flush()

Flush blocks until all data (normally sent in the background) has been sent to the Honeybadger service.

func Handler 

func Handler(h http.Handler) http.Handler

Handler returns an http.Handler function which automatically reports panics to Honeybadger and then re-panics.

func Increment 

func Increment(metric string, value int)

Increment is deprecated.

func MetricsHandler 

func MetricsHandler(h http.Handler) http.Handler

MetricsHandler is deprecated.

func Monitor 

func Monitor()

Monitor is used to automatically notify Honeybadger service of panics which happen inside the current function. In order to monitor for panics, defer a call to Monitor. For example: 

func main {
	defer honeybadger.Monitor()
	// Do risky stuff...
}

The Monitor function re-panics after the notification has been sent, so it's still up to the user to recover from panics if desired.

func Notify 

func Notify(err interface{}, extra ...interface{}) (string, error)

Notify reports the error err to the Honeybadger service.

The first argument err may be an error, a string, or any other type in which case its formatted value will be used.

It returns a string UUID which can be used to reference the error from the Honeybadger service, and an error as a second argument.

func SetContext 

func SetContext(c Context)

SetContext merges c Context into the Context of the global client.

func Timing 

func Timing(metric string, value time.Duration)

Timing is deprecated.

Types

type Backend 

type Backend interface {
	Notify(feature Feature, payload Payload) error
}

The Backend interface is implemented by the server type by default, but a custom implementation may be configured by the user.

func NewNullBackend 

func NewNullBackend() Backend

NewNullBackend creates a backend which swallows all errors and does not send them to Honeybadger. This is useful for development and testing to disable sending unnecessary errors.

type CGIData 

type CGIData hash

CGIData stores variables from the server/request environment indexed by key. Header keys should be converted to upercase, all non-alphanumeric characters replaced with underscores, and prefixed with HTTP_. For example, the header "Content-Type" would become "HTTP_CONTENT_TYPE".

type Client 

type Client struct {
	Config *Configuration
	// contains filtered or unexported fields
}

Client is the manager for interacting with the Honeybadger service. It holds the configuration and implements the public API.

func New 

func New(c Configuration) *Client

New returns a new instance of Client.

func (*Client) BeforeNotify 

func (client *Client) BeforeNotify(handler func(notice *Notice) error)

BeforeNotify adds a callback function which is run before a notice is reported to Honeybadger. If any function returns an error the notification will be skipped, otherwise it will be sent.

func (*Client) Configure 

func (client *Client) Configure(config Configuration)

Configure updates the client configuration with the supplied config.

func (*Client) Flush 

func (client *Client) Flush()

Flush blocks until the worker has processed its queue.

func (*Client) Handler 

func (client *Client) Handler(h http.Handler) http.Handler

Handler returns an http.Handler function which automatically reports panics to Honeybadger and then re-panics.

func (*Client) Increment 

func (client *Client) Increment(metric string, value int)

Increment is deprecated.

func (*Client) MetricsHandler 

func (client *Client) MetricsHandler(h http.Handler) http.Handler

MetricsHandler is deprecated.

func (*Client) Monitor 

func (client *Client) Monitor()

Monitor automatically reports panics which occur in the function it's called from. Must be deferred.

func (*Client) Notify 

func (client *Client) Notify(err interface{}, extra ...interface{}) (string, error)

Notify reports the error err to the Honeybadger service.

func (*Client) SetContext 

func (client *Client) SetContext(context Context)

SetContext updates the client context with supplied context.

func (*Client) Timing 

func (client *Client) Timing(metric string, value time.Duration)

Timing is deprecated.

type Configuration 

type Configuration struct {
	APIKey          string
	Root            string
	Env             string
	Hostname        string
	Endpoint        string
	Timeout         time.Duration
	Logger          Logger
	Backend         Backend
	MetricsInterval time.Duration
}

Configuration manages the configuration for the client.

type Context 

type Context hash

Context is used to send extra data to Honeybadger.

func (Context) Update 

func (context Context) Update(other Context)

Update applies the values in other Context to context.

type Error 

type Error struct {
	Message string
	Class   string
	Stack   []*Frame
	// contains filtered or unexported fields
}

Error provides more structured information about a Go error.

func NewError 

func NewError(msg interface{}) Error

func (Error) Error 

func (e Error) Error() string

type ErrorClass 

type ErrorClass struct {
	Name string
}

ErrorClass represents the class name of the error which is sent to Honeybadger.

type Feature 

type Feature struct {
	Endpoint string
}

Feature references a resource provided by the API service. Its Endpoint maps to the collection endpoint of the /v1 API.

type Fingerprint 

type Fingerprint struct {
	Content string
}

Fingerprint represents the fingerprint of the error, which controls grouping in Honeybadger.

func (*Fingerprint) String 

func (f *Fingerprint) String() string

type Frame 

type Frame struct {
	Number string `json:"number"`
	File   string `json:"file"`
	Method string `json:"method"`
}

Frame represent a stack frame inside of a Honeybadger backtrace.

type Logger 

type Logger interface {
	Printf(format string, v ...interface{})
}

The Logger interface is implemented by the standard log package and requires a limited subset of the interface implemented by log.Logger.

type Notice 

type Notice struct {
	APIKey       string
	Error        Error
	Token        string
	ErrorMessage string
	ErrorClass   string
	Hostname     string
	Env          string
	Backtrace    []*Frame
	ProjectRoot  string
	Context      Context
	Params       Params
	CGIData      CGIData
	URL          string
	Fingerprint  string
}

Notice is a representation of the error which is sent to Honeybadger, and implements the Payload interface.

type Params 

type Params url.Values

Params stores the form or url values from an HTTP request.

type Payload 

type Payload interface {
	// contains filtered or unexported methods
}

The Payload interface is implemented by any type which can be handled by the Backend interface.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.