sentry-go: github.com/getsentry/sentry-go Index | Examples | Files | Directories

package sentry

import "github.com/getsentry/sentry-go"

Package sentry is the official Sentry SDK for Go.

For more information about Sentry and SDK features please have a look at the documentation site https://docs.sentry.io/platforms/go/.

Basic Usage

The first step is to initialize the SDK, providing at a minimum the DSN of your Sentry project. This step is accomplished through a call to sentry.Init.

func main() {
	err := sentry.Init(...)
	...
}

A more detailed yet simple example is available at https://github.com/getsentry/sentry-go/blob/master/example/basic/main.go.

Integrations

The SDK has support for several Go frameworks, available as subpackages.

Getting Support

For paid Sentry.io accounts, head out to https://sentry.io/support.

For all users, support channels include:

Forum: https://forum.sentry.io
Discord: https://discord.gg/Ww9hbqr (#go channel)

If you found an issue with the SDK, please report through https://github.com/getsentry/sentry-go/issues/new/choose.

For responsibly disclosing a security issue, please follow the steps in https://sentry.io/security/#vulnerability-disclosure.

Initializing the SDK with a custom HTTP transport gives a lot of flexibility to inspect requests and responses. This example adds before and after hooks.

Code:

package main

import (
    "fmt"
    "net/http"
    "net/http/httputil"
    "os"
    "time"

    "github.com/getsentry/sentry-go"
)

// TransportWithHooks is an http.RoundTripper that wraps an existing
// http.RoundTripper adding hooks that run before and after each round trip.
type TransportWithHooks struct {
    http.RoundTripper
    Before func(*http.Request) error
    After  func(*http.Request, *http.Response, error) (*http.Response, error)
}

func (t *TransportWithHooks) RoundTrip(req *http.Request) (*http.Response, error) {
    if err := t.Before(req); err != nil {
        return nil, err
    }
    resp, err := t.RoundTripper.RoundTrip(req)
    return t.After(req, resp, err)
}

// Initializing the SDK with a custom HTTP transport gives a lot of flexibility
// to inspect requests and responses. This example adds before and after hooks.
func main() {
    err := sentry.Init(sentry.ClientOptions{
        // Either set your DSN here or set the SENTRY_DSN environment variable.
        Dsn:   "",
        Debug: true,
        HTTPTransport: &TransportWithHooks{
            RoundTripper: http.DefaultTransport,
            Before: func(req *http.Request) error {
                if b, err := httputil.DumpRequestOut(req, true); err != nil {
                    fmt.Println(err)
                } else {
                    fmt.Printf("%s\n", b)
                }
                return nil
            },
            After: func(req *http.Request, resp *http.Response, err error) (*http.Response, error) {
                if b, err := httputil.DumpResponse(resp, true); err != nil {
                    fmt.Println(err)
                } else {
                    fmt.Printf("%s\n", b)
                }
                return resp, err
            },
        },
    })
    if err != nil {
        fmt.Fprintf(os.Stderr, "sentry.Init: %s\n", err)
        os.Exit(1)
    }
    defer sentry.Flush(2 * time.Second)

    sentry.CaptureMessage("test")

}

Index

Examples

Package Files

client.go doc.go dsn.go hub.go integrations.go interfaces.go scope.go sentry.go sourcereader.go stacktrace.go transport.go util.go

Constants

const (
    // HubContextKey is the key used to store the current Hub.
    HubContextKey = contextKey(1)
    // RequestContextKey is the key used to store the current http.Request.
    RequestContextKey = contextKey(2)
)

Keys used to store values in a Context. Use with Context.Value to access values stored by the SDK.

const Version = "0.7.0"

Version is the version of the SDK.

Variables

var Logger = log.New(ioutil.Discard, "[Sentry] ", log.LstdFlags)

Logger is an instance of log.Logger that is use to provide debug information about running Sentry Client can be enabled by either using Logger.SetOutput directly or with Debug client option.

func AddBreadcrumb Uses

func AddBreadcrumb(breadcrumb *Breadcrumb)

AddBreadcrumb records a new breadcrumb.

The total number of breadcrumbs that can be recorded are limited by the configuration on the client.

func AddGlobalEventProcessor Uses

func AddGlobalEventProcessor(processor EventProcessor)

AddGlobalEventProcessor adds processor to the global list of event processors. Global event processors apply to all events.

Deprecated: Use Scope.AddEventProcessor or Client.AddEventProcessor instead.

func ConfigureScope Uses

func ConfigureScope(f func(scope *Scope))

ConfigureScope is a shorthand for CurrentHub().ConfigureScope.

func Flush Uses

func Flush(timeout time.Duration) bool

Flush waits until the underlying Transport sends any buffered events to the Sentry server, blocking for at most the given timeout. It returns false if the timeout was reached. In that case, some events may not have been sent.

Flush should be called before terminating the program to avoid unintentionally dropping events.

Do not call Flush indiscriminately after every call to CaptureEvent, CaptureException or CaptureMessage. Instead, to have the SDK send events over the network synchronously, configure it to use the HTTPSyncTransport in the call to Init.

func HasHubOnContext Uses

func HasHubOnContext(ctx context.Context) bool

HasHubOnContext checks whether Hub instance is bound to a given Context struct.

func Init Uses

func Init(options ClientOptions) error

Init initializes the SDK with options. The returned error is non-nil if options is invalid, for instance if a malformed DSN is provided.

func PopScope Uses

func PopScope()

PopScope is a shorthand for CurrentHub().PopScope.

func PushScope Uses

func PushScope()

PushScope is a shorthand for CurrentHub().PushPushScope.

func SetHubOnContext Uses

func SetHubOnContext(ctx context.Context, hub *Hub) context.Context

SetHubOnContext stores given Hub instance on the Context struct and returns a new Context.

func WithScope Uses

func WithScope(f func(scope *Scope))

WithScope is a shorthand for CurrentHub().WithScope.

type Breadcrumb struct {
    Category  string                 `json:"category,omitempty"`
    Data      map[string]interface{} `json:"data,omitempty"`
    Level     Level                  `json:"level,omitempty"`
    Message   string                 `json:"message,omitempty"`
    Timestamp time.Time              `json:"timestamp"`
    Type      string                 `json:"type,omitempty"`
}

Breadcrumb specifies an application event that occurred before a Sentry event. An event may contain one or more breadcrumbs.

func (b *Breadcrumb) MarshalJSON() ([]byte, error)

MarshalJSON converts the Breadcrumb struct to JSON.

type BreadcrumbHint map[string]interface{}

BreadcrumbHint contains information that can be associated with a Breadcrumb.

type Client Uses

type Client struct {
    Transport Transport
    // contains filtered or unexported fields
}

Client is the underlying processor that is used by the main API and Hub instances.

func NewClient Uses

func NewClient(options ClientOptions) (*Client, error)

NewClient creates and returns an instance of Client configured using ClientOptions.

func (*Client) AddEventProcessor Uses

func (client *Client) AddEventProcessor(processor EventProcessor)

AddEventProcessor adds an event processor to the client.

func (*Client) CaptureEvent Uses

func (client *Client) CaptureEvent(event *Event, hint *EventHint, scope EventModifier) *EventID

CaptureEvent captures an event on the currently active client if any.

The event must already be assembled. Typically code would instead use the utility methods like CaptureException. The return value is the event ID. In case Sentry is disabled or event was dropped, the return value will be nil.

func (*Client) CaptureException Uses

func (client *Client) CaptureException(exception error, hint *EventHint, scope EventModifier) *EventID

CaptureException captures an error.

func (*Client) CaptureMessage Uses

func (client *Client) CaptureMessage(message string, hint *EventHint, scope EventModifier) *EventID

CaptureMessage captures an arbitrary message.

func (*Client) Flush Uses

func (client *Client) Flush(timeout time.Duration) bool

Flush waits until the underlying Transport sends any buffered events to the Sentry server, blocking for at most the given timeout. It returns false if the timeout was reached. In that case, some events may not have been sent.

Flush should be called before terminating the program to avoid unintentionally dropping events.

Do not call Flush indiscriminately after every call to CaptureEvent, CaptureException or CaptureMessage. Instead, to have the SDK send events over the network synchronously, configure it to use the HTTPSyncTransport in the call to Init.

func (Client) Options Uses

func (client Client) Options() ClientOptions

Options return ClientOptions for the current Client.

func (*Client) Recover Uses

func (client *Client) Recover(err interface{}, hint *EventHint, scope EventModifier) *EventID

Recover captures a panic. Returns EventID if successfully, or nil if there's no error to recover from.

func (*Client) RecoverWithContext Uses

func (client *Client) RecoverWithContext(
    ctx context.Context,
    err interface{},
    hint *EventHint,
    scope EventModifier,
) *EventID

RecoverWithContext captures a panic and passes relevant context object. Returns EventID if successfully, or nil if there's no error to recover from.

type ClientOptions Uses

type ClientOptions struct {
    // The DSN to use. If the DSN is not set, the client is effectively
    // disabled.
    Dsn string
    // In debug mode, the debug information is printed to stdout to help you
    // understand what sentry is doing.
    Debug bool
    // Configures whether SDK should generate and attach stacktraces to pure
    // capture message calls.
    AttachStacktrace bool
    // The sample rate for event submission in the range [0.0, 1.0]. By default,
    // all events are sent. Thus, as a historical special case, the sample rate
    // 0.0 is treated as if it was 1.0.
    SampleRate float64
    // List of regexp strings that will be used to match against event's message
    // and if applicable, caught errors type and value.
    // If the match is found, then a whole event will be dropped.
    IgnoreErrors []string
    // Before send callback.
    BeforeSend func(event *Event, hint *EventHint) *Event
    // Before breadcrumb add callback.
    BeforeBreadcrumb func(breadcrumb *Breadcrumb, hint *BreadcrumbHint) *Breadcrumb
    // Integrations to be installed on the current Client, receives default
    // integrations.
    Integrations func([]Integration) []Integration
    // io.Writer implementation that should be used with the Debug mode.
    DebugWriter io.Writer
    // The transport to use. Defaults to HTTPTransport.
    Transport Transport
    // The server name to be reported.
    ServerName string
    // The release to be sent with events.
    Release string
    // The dist to be sent with events.
    Dist string
    // The environment to be sent with events.
    Environment string
    // Maximum number of breadcrumbs.
    MaxBreadcrumbs int
    // An optional pointer to http.Client that will be used with a default
    // HTTPTransport. Using your own client will make HTTPTransport, HTTPProxy,
    // HTTPSProxy and CaCerts options ignored.
    HTTPClient *http.Client
    // An optional pointer to http.Transport that will be used with a default
    // HTTPTransport. Using your own transport will make HTTPProxy, HTTPSProxy
    // and CaCerts options ignored.
    HTTPTransport http.RoundTripper
    // An optional HTTP proxy to use.
    // This will default to the HTTP_PROXY environment variable.
    HTTPProxy string
    // An optional HTTPS proxy to use.
    // This will default to the HTTPS_PROXY environment variable.
    // HTTPS_PROXY takes precedence over HTTP_PROXY for https requests.
    HTTPSProxy string
    // An optional set of SSL certificates to use.
    CaCerts *x509.CertPool
}

ClientOptions that configures a SDK Client.

type Dsn Uses

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

Dsn is used as the remote address source to client transport.

func NewDsn Uses

func NewDsn(rawURL string) (*Dsn, error)

NewDsn creates an instance of Dsn by parsing provided url in a string format. If Dsn is not set the client is effectively disabled.

func (Dsn) EnvelopeAPIURL Uses

func (dsn Dsn) EnvelopeAPIURL() *url.URL

EnvelopeAPIURL returns the URL of the envelope endpoint of the project associated with the DSN.

func (Dsn) MarshalJSON Uses

func (dsn Dsn) MarshalJSON() ([]byte, error)

MarshalJSON converts the Dsn struct to JSON.

func (Dsn) RequestHeaders Uses

func (dsn Dsn) RequestHeaders() map[string]string

RequestHeaders returns all the necessary headers that have to be used in the transport.

func (Dsn) StoreAPIURL Uses

func (dsn Dsn) StoreAPIURL() *url.URL

StoreAPIURL returns the URL of the store endpoint of the project associated with the DSN.

func (Dsn) String Uses

func (dsn Dsn) String() string

String formats Dsn struct into a valid string url.

func (*Dsn) UnmarshalJSON Uses

func (dsn *Dsn) UnmarshalJSON(data []byte) error

UnmarshalJSON converts JSON data to the Dsn struct.

type DsnParseError Uses

type DsnParseError struct {
    Message string
}

DsnParseError represents an error that occurs if a Sentry DSN cannot be parsed.

func (DsnParseError) Error Uses

func (e DsnParseError) Error() string

type Event Uses

type Event struct {
    Breadcrumbs []*Breadcrumb          `json:"breadcrumbs,omitempty"`
    Contexts    map[string]interface{} `json:"contexts,omitempty"`
    Dist        string                 `json:"dist,omitempty"`
    Environment string                 `json:"environment,omitempty"`
    EventID     EventID                `json:"event_id,omitempty"`
    Extra       map[string]interface{} `json:"extra,omitempty"`
    Fingerprint []string               `json:"fingerprint,omitempty"`
    Level       Level                  `json:"level,omitempty"`
    Message     string                 `json:"message,omitempty"`
    Platform    string                 `json:"platform,omitempty"`
    Release     string                 `json:"release,omitempty"`
    Sdk         SdkInfo                `json:"sdk,omitempty"`
    ServerName  string                 `json:"server_name,omitempty"`
    Threads     []Thread               `json:"threads,omitempty"`
    Tags        map[string]string      `json:"tags,omitempty"`
    Timestamp   time.Time              `json:"timestamp"`
    Transaction string                 `json:"transaction,omitempty"`
    User        User                   `json:"user,omitempty"`
    Logger      string                 `json:"logger,omitempty"`
    Modules     map[string]string      `json:"modules,omitempty"`
    Request     *Request               `json:"request,omitempty"`
    Exception   []Exception            `json:"exception,omitempty"`

    // Experimental: This is part of a beta feature of the SDK. The fields below
    // are only relevant for transactions.
    Type           string    `json:"type,omitempty"`
    StartTimestamp time.Time `json:"start_timestamp"`
    Spans          []*Span   `json:"spans,omitempty"`
}

Event is the fundamental data structure that is sent to Sentry.

func NewEvent Uses

func NewEvent() *Event

NewEvent creates a new Event.

func (*Event) MarshalJSON Uses

func (e *Event) MarshalJSON() ([]byte, error)

MarshalJSON converts the Event struct to JSON.

type EventHint Uses

type EventHint struct {
    Data               interface{}
    EventID            string
    OriginalException  error
    RecoveredException interface{}
    Context            context.Context
    Request            *http.Request
    Response           *http.Response
}

EventHint contains information that can be associated with an Event.

type EventID Uses

type EventID string

EventID is a hexadecimal string representing a unique uuid4 for an Event. An EventID must be 32 characters long, lowercase and not have any dashes.

func CaptureEvent Uses

func CaptureEvent(event *Event) *EventID

CaptureEvent captures an event on the currently active client if any.

The event must already be assembled. Typically code would instead use the utility methods like CaptureException. The return value is the event ID. In case Sentry is disabled or event was dropped, the return value will be nil.

func CaptureException Uses

func CaptureException(exception error) *EventID

CaptureException captures an error.

func CaptureMessage Uses

func CaptureMessage(message string) *EventID

CaptureMessage captures an arbitrary message.

func LastEventID Uses

func LastEventID() EventID

LastEventID returns an ID of last captured event.

func Recover Uses

func Recover() *EventID

Recover captures a panic.

func RecoverWithContext Uses

func RecoverWithContext(ctx context.Context) *EventID

RecoverWithContext captures a panic and passes relevant context object.

type EventModifier Uses

type EventModifier interface {
    ApplyToEvent(event *Event, hint *EventHint) *Event
}

EventModifier is the interface that wraps the ApplyToEvent method.

ApplyToEvent changes an event based on external data and/or an event hint.

type EventProcessor Uses

type EventProcessor func(event *Event, hint *EventHint) *Event

EventProcessor is a function that processes an event. Event processors are used to change an event before it is sent to Sentry.

type Exception Uses

type Exception struct {
    Type       string      `json:"type,omitempty"`
    Value      string      `json:"value,omitempty"`
    Module     string      `json:"module,omitempty"`
    ThreadID   string      `json:"thread_id,omitempty"`
    Stacktrace *Stacktrace `json:"stacktrace,omitempty"`
}

Exception specifies an error that occurred.

type Frame Uses

type Frame struct {
    Function    string                 `json:"function,omitempty"`
    Symbol      string                 `json:"symbol,omitempty"`
    Module      string                 `json:"module,omitempty"`
    Package     string                 `json:"package,omitempty"`
    Filename    string                 `json:"filename,omitempty"`
    AbsPath     string                 `json:"abs_path,omitempty"`
    Lineno      int                    `json:"lineno,omitempty"`
    Colno       int                    `json:"colno,omitempty"`
    PreContext  []string               `json:"pre_context,omitempty"`
    ContextLine string                 `json:"context_line,omitempty"`
    PostContext []string               `json:"post_context,omitempty"`
    InApp       bool                   `json:"in_app,omitempty"`
    Vars        map[string]interface{} `json:"vars,omitempty"`
}

Frame represents a function call and it's metadata. Frames are associated with a Stacktrace.

func NewFrame Uses

func NewFrame(f runtime.Frame) Frame

NewFrame assembles a stacktrace frame out of runtime.Frame.

type HTTPSyncTransport Uses

type HTTPSyncTransport struct {

    // HTTP Client request timeout. Defaults to 30 seconds.
    Timeout time.Duration
    // contains filtered or unexported fields
}

HTTPSyncTransport is an implementation of Transport interface which blocks after each captured event.

func NewHTTPSyncTransport Uses

func NewHTTPSyncTransport() *HTTPSyncTransport

NewHTTPSyncTransport returns a new pre-configured instance of HTTPSyncTransport.

func (*HTTPSyncTransport) Configure Uses

func (t *HTTPSyncTransport) Configure(options ClientOptions)

Configure is called by the Client itself, providing it it's own ClientOptions.

func (*HTTPSyncTransport) Flush Uses

func (t *HTTPSyncTransport) Flush(_ time.Duration) bool

Flush is a no-op for HTTPSyncTransport. It always returns true immediately.

func (*HTTPSyncTransport) SendEvent Uses

func (t *HTTPSyncTransport) SendEvent(event *Event)

SendEvent assembles a new packet out of Event and sends it to remote server.

type HTTPTransport Uses

type HTTPTransport struct {

    // Size of the transport buffer. Defaults to 30.
    BufferSize int
    // HTTP Client request timeout. Defaults to 30 seconds.
    Timeout time.Duration
    // contains filtered or unexported fields
}

HTTPTransport is a default implementation of Transport interface used by Client.

func NewHTTPTransport Uses

func NewHTTPTransport() *HTTPTransport

NewHTTPTransport returns a new pre-configured instance of HTTPTransport.

func (*HTTPTransport) Configure Uses

func (t *HTTPTransport) Configure(options ClientOptions)

Configure is called by the Client itself, providing it it's own ClientOptions.

func (*HTTPTransport) Flush Uses

func (t *HTTPTransport) Flush(timeout time.Duration) bool

Flush waits until any buffered events are sent to the Sentry server, blocking for at most the given timeout. It returns false if the timeout was reached. In that case, some events may not have been sent.

Flush should be called before terminating the program to avoid unintentionally dropping events.

Do not call Flush indiscriminately after every call to SendEvent. Instead, to have the SDK send events over the network synchronously, configure it to use the HTTPSyncTransport in the call to Init.

func (*HTTPTransport) SendEvent Uses

func (t *HTTPTransport) SendEvent(event *Event)

SendEvent assembles a new packet out of Event and sends it to remote server.

type Hub Uses

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

Hub is the central object that manages scopes and clients.

This can be used to capture events and manage the scope. The default hub that is available automatically.

In most situations developers do not need to interface the hub. Instead toplevel convenience functions are exposed that will automatically dispatch to global (CurrentHub) hub. In some situations this might not be possible in which case it might become necessary to manually work with the hub. This is for instance the case when working with async code.

func CurrentHub Uses

func CurrentHub() *Hub

CurrentHub returns an instance of previously initialized Hub stored in the global namespace.

func GetHubFromContext Uses

func GetHubFromContext(ctx context.Context) *Hub

GetHubFromContext tries to retrieve Hub instance from the given Context struct or return nil if one is not found.

func NewHub Uses

func NewHub(client *Client, scope *Scope) *Hub

NewHub returns an instance of a Hub with provided Client and Scope bound.

func (*Hub) AddBreadcrumb Uses

func (hub *Hub) AddBreadcrumb(breadcrumb *Breadcrumb, hint *BreadcrumbHint)

AddBreadcrumb records a new breadcrumb.

The total number of breadcrumbs that can be recorded are limited by the configuration on the client.

func (*Hub) BindClient Uses

func (hub *Hub) BindClient(client *Client)

BindClient binds a new Client for the current Hub.

func (*Hub) CaptureEvent Uses

func (hub *Hub) CaptureEvent(event *Event) *EventID

CaptureEvent calls the method of a same name on currently bound Client instance passing it a top-level Scope. Returns EventID if successfully, or nil if there's no Scope or Client available.

func (*Hub) CaptureException Uses

func (hub *Hub) CaptureException(exception error) *EventID

CaptureException calls the method of a same name on currently bound Client instance passing it a top-level Scope. Returns EventID if successfully, or nil if there's no Scope or Client available.

func (*Hub) CaptureMessage Uses

func (hub *Hub) CaptureMessage(message string) *EventID

CaptureMessage calls the method of a same name on currently bound Client instance passing it a top-level Scope. Returns EventID if successfully, or nil if there's no Scope or Client available.

func (*Hub) Client Uses

func (hub *Hub) Client() *Client

Client returns top-level Client of the current Hub or nil if no Client is bound.

func (*Hub) Clone Uses

func (hub *Hub) Clone() *Hub

Clone returns a copy of the current Hub with top-most scope and client copied over.

func (*Hub) ConfigureScope Uses

func (hub *Hub) ConfigureScope(f func(scope *Scope))

ConfigureScope runs f in the current scope.

It is useful to set data that applies to all events that share the current scope.

Modifying the scope affects all references to the current scope.

See also WithScope for making isolated temporary changes.

func (*Hub) Flush Uses

func (hub *Hub) Flush(timeout time.Duration) bool

Flush waits until the underlying Transport sends any buffered events to the Sentry server, blocking for at most the given timeout. It returns false if the timeout was reached. In that case, some events may not have been sent.

Flush should be called before terminating the program to avoid unintentionally dropping events.

Do not call Flush indiscriminately after every call to CaptureEvent, CaptureException or CaptureMessage. Instead, to have the SDK send events over the network synchronously, configure it to use the HTTPSyncTransport in the call to Init.

func (*Hub) LastEventID Uses

func (hub *Hub) LastEventID() EventID

LastEventID returns an ID of last captured event for the current Hub.

func (*Hub) PopScope Uses

func (hub *Hub) PopScope()

PopScope pops the most recent scope for the current Hub.

func (*Hub) PushScope Uses

func (hub *Hub) PushScope() *Scope

PushScope pushes a new scope for the current Hub and reuses previously bound Client.

func (*Hub) Recover Uses

func (hub *Hub) Recover(err interface{}) *EventID

Recover calls the method of a same name on currently bound Client instance passing it a top-level Scope. Returns EventID if successfully, or nil if there's no Scope or Client available.

func (*Hub) RecoverWithContext Uses

func (hub *Hub) RecoverWithContext(ctx context.Context, err interface{}) *EventID

RecoverWithContext calls the method of a same name on currently bound Client instance passing it a top-level Scope. Returns EventID if successfully, or nil if there's no Scope or Client available.

func (*Hub) Scope Uses

func (hub *Hub) Scope() *Scope

Scope returns top-level Scope of the current Hub or nil if no Scope is bound.

func (*Hub) WithScope Uses

func (hub *Hub) WithScope(f func(scope *Scope))

WithScope runs f in an isolated temporary scope.

It is useful when extra data should be sent with a single capture call, for instance a different level or tags.

The scope passed to f starts as a clone of the current scope and can be freely modified without affecting the current scope.

It is a shorthand for PushScope followed by PopScope.

type Integration Uses

type Integration interface {
    Name() string
    SetupOnce(client *Client)
}

Integration allows for registering a functions that modify or discard captured events.

type Level Uses

type Level string

Level marks the severity of the event.

const (
    LevelDebug   Level = "debug"
    LevelInfo    Level = "info"
    LevelWarning Level = "warning"
    LevelError   Level = "error"
    LevelFatal   Level = "fatal"
)

Describes the severity of the event.

type Request Uses

type Request struct {
    URL         string            `json:"url,omitempty"`
    Method      string            `json:"method,omitempty"`
    Data        string            `json:"data,omitempty"`
    QueryString string            `json:"query_string,omitempty"`
    Cookies     string            `json:"cookies,omitempty"`
    Headers     map[string]string `json:"headers,omitempty"`
    Env         map[string]string `json:"env,omitempty"`
}

Request contains information on a HTTP request related to the event.

func NewRequest Uses

func NewRequest(r *http.Request) *Request

NewRequest returns a new Sentry Request from the given http.Request.

NewRequest avoids operations that depend on network access. In particular, it does not read r.Body.

type Scope Uses

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

Scope holds contextual data for the current scope.

The scope is an object that can cloned efficiently and stores data that is locally relevant to an event. For instance the scope will hold recorded breadcrumbs and similar information.

The scope can be interacted with in two ways. First, the scope is routinely updated with information by functions such as AddBreadcrumb which will modify the current scope. Second, the current scope can be configured through the ConfigureScope function or Hub method of the same name.

The scope is meant to be modified but not inspected directly. When preparing an event for reporting, the current client adds information from the current scope into the event.

func NewScope Uses

func NewScope() *Scope

NewScope creates a new Scope.

func (*Scope) AddBreadcrumb Uses

func (scope *Scope) AddBreadcrumb(breadcrumb *Breadcrumb, limit int)

AddBreadcrumb adds new breadcrumb to the current scope and optionally throws the old one if limit is reached.

func (*Scope) AddEventProcessor Uses

func (scope *Scope) AddEventProcessor(processor EventProcessor)

AddEventProcessor adds an event processor to the current scope.

func (*Scope) ApplyToEvent Uses

func (scope *Scope) ApplyToEvent(event *Event, hint *EventHint) *Event

ApplyToEvent takes the data from the current scope and attaches it to the event.

func (*Scope) Clear Uses

func (scope *Scope) Clear()

Clear removes the data from the current scope. Not safe for concurrent use.

func (*Scope) ClearBreadcrumbs Uses

func (scope *Scope) ClearBreadcrumbs()

ClearBreadcrumbs clears all breadcrumbs from the current scope.

func (*Scope) Clone Uses

func (scope *Scope) Clone() *Scope

Clone returns a copy of the current scope with all data copied over.

func (*Scope) RemoveContext Uses

func (scope *Scope) RemoveContext(key string)

RemoveContext removes a context from the current scope.

func (*Scope) RemoveExtra Uses

func (scope *Scope) RemoveExtra(key string)

RemoveExtra removes a extra from the current scope.

func (*Scope) RemoveTag Uses

func (scope *Scope) RemoveTag(key string)

RemoveTag removes a tag from the current scope.

func (*Scope) SetContext Uses

func (scope *Scope) SetContext(key string, value interface{})

SetContext adds a context to the current scope.

func (*Scope) SetContexts Uses

func (scope *Scope) SetContexts(contexts map[string]interface{})

SetContexts assigns multiple contexts to the current scope.

func (*Scope) SetExtra Uses

func (scope *Scope) SetExtra(key string, value interface{})

SetExtra adds an extra to the current scope.

func (*Scope) SetExtras Uses

func (scope *Scope) SetExtras(extra map[string]interface{})

SetExtras assigns multiple extras to the current scope.

func (*Scope) SetFingerprint Uses

func (scope *Scope) SetFingerprint(fingerprint []string)

SetFingerprint sets new fingerprint for the current scope.

func (*Scope) SetLevel Uses

func (scope *Scope) SetLevel(level Level)

SetLevel sets new level for the current scope.

func (*Scope) SetRequest Uses

func (scope *Scope) SetRequest(r *http.Request)

SetRequest sets the request for the current scope.

func (*Scope) SetRequestBody Uses

func (scope *Scope) SetRequestBody(b []byte)

SetRequestBody sets the request body for the current scope.

This method should only be called when the body bytes are already available in memory. Typically, the request body is buffered lazily from the Request.Body from SetRequest.

func (*Scope) SetTag Uses

func (scope *Scope) SetTag(key, value string)

SetTag adds a tag to the current scope.

func (*Scope) SetTags Uses

func (scope *Scope) SetTags(tags map[string]string)

SetTags assigns multiple tags to the current scope.

func (*Scope) SetTransaction Uses

func (scope *Scope) SetTransaction(transactionName string)

SetTransaction sets new transaction name for the current transaction.

func (*Scope) SetUser Uses

func (scope *Scope) SetUser(user User)

SetUser sets the user for the current scope.

type SdkInfo Uses

type SdkInfo struct {
    Name         string       `json:"name,omitempty"`
    Version      string       `json:"version,omitempty"`
    Integrations []string     `json:"integrations,omitempty"`
    Packages     []SdkPackage `json:"packages,omitempty"`
}

SdkInfo contains all metadata about about the SDK being used.

type SdkPackage Uses

type SdkPackage struct {
    Name    string `json:"name,omitempty"`
    Version string `json:"version,omitempty"`
}

SdkPackage describes a package that was installed.

type Span Uses

type Span struct {
    TraceID        string                 `json:"trace_id"`
    SpanID         string                 `json:"span_id"`
    ParentSpanID   string                 `json:"parent_span_id,omitempty"`
    Op             string                 `json:"op,omitempty"`
    Description    string                 `json:"description,omitempty"`
    Status         string                 `json:"status,omitempty"`
    Tags           map[string]string      `json:"tags,omitempty"`
    StartTimestamp time.Time              `json:"start_timestamp"`
    EndTimestamp   time.Time              `json:"timestamp"`
    Data           map[string]interface{} `json:"data,omitempty"`
}

Span describes a timed unit of work in a trace.

Experimental: This is part of a beta feature of the SDK.

type Stacktrace Uses

type Stacktrace struct {
    Frames        []Frame `json:"frames,omitempty"`
    FramesOmitted []uint  `json:"frames_omitted,omitempty"`
}

Stacktrace holds information about the frames of the stack.

func ExtractStacktrace Uses

func ExtractStacktrace(err error) *Stacktrace

ExtractStacktrace creates a new Stacktrace based on the given error.

func NewStacktrace Uses

func NewStacktrace() *Stacktrace

NewStacktrace creates a stacktrace using runtime.Callers.

type Thread Uses

type Thread struct {
    ID         string      `json:"id,omitempty"`
    Name       string      `json:"name,omitempty"`
    Stacktrace *Stacktrace `json:"stacktrace,omitempty"`
    Crashed    bool        `json:"crashed,omitempty"`
    Current    bool        `json:"current,omitempty"`
}

Thread specifies threads that were running at the time of an event.

type TraceContext Uses

type TraceContext struct {
    TraceID     string `json:"trace_id"`
    SpanID      string `json:"span_id"`
    Op          string `json:"op,omitempty"`
    Description string `json:"description,omitempty"`
    Status      string `json:"status,omitempty"`
}

TraceContext describes the context of the trace.

Experimental: This is part of a beta feature of the SDK.

type Transport Uses

type Transport interface {
    Flush(timeout time.Duration) bool
    Configure(options ClientOptions)
    SendEvent(event *Event)
}

Transport is used by the Client to deliver events to remote server.

type User Uses

type User struct {
    Email     string `json:"email,omitempty"`
    ID        string `json:"id,omitempty"`
    IPAddress string `json:"ip_address,omitempty"`
    Username  string `json:"username,omitempty"`
}

User describes the user associated with an Event. If this is used, at least an ID or an IP address should be provided.

Directories

PathSynopsis
echo
fasthttp
gin
httpPackage sentryhttp provides Sentry integration for servers based on the net/http package.
iris
martini
negroni

Package sentry imports 28 packages (graph) and is imported by 151 packages. Updated 2020-10-19. Refresh now. Tools for package owners.