sentry

// We can change the maximum number of breadcrumbs to be stored
DefaultBreadcrumbs().WithSize(5)

DefaultBreadcrumbs().NewDefault(nil).WithMessage("This is an example")
DefaultBreadcrumbs().NewDefault(map[string]interface{}{
	"example": true,
}).WithMessage("It should give you an idea of how you can use breadcrumbs in your app")

DefaultBreadcrumbs().
	NewNavigation("introduction", "navigation").
	WithCategory("navigation").
	WithMessage("You can use them to represent navigations from one page to another")

DefaultBreadcrumbs().
	NewNavigation("navigation", "http").
	WithCategory("navigation").
	WithMessage("Or to represent changes in the state of your application's workflows")

DefaultBreadcrumbs().
	NewHTTPRequest("GET", "https://example.com/api/v1/awesome", 200, "OK").
	WithLevel(Debug).
	WithMessage("I think we can agree that they're pretty awesome")

NewClient().Capture(Message("Finally, we send the event with all our breadcrumbs included"))

Output:

DefaultClient().Capture(
	Message("This is an example message"),
)

Output:

cl := NewClient(
	Release("v1.0.0"),
)

// Add your 404 handler to the default mux
http.HandleFunc("/", func(res http.ResponseWriter, req *http.Request) {
	cl := cl.With(
		// Set the HTTP request context for your request's client
		HTTPRequest(req).WithHeaders(),
	)

	res.Header().Set("Content-Type", "application/json")
	res.WriteHeader(404)
	res.Write([]byte(`{"error":"Not Found","message":"We could not find the route you requested, please check your URL and try again."}`))

	// Capture the problem using your request's client
	cl.Capture(
		Message("Route Not Found: [%s] %s", req.Method, req.URL.Path),
		Level(Warning),
	)
})

Output:

rootClient := NewClient()
DefaultBreadcrumbs().NewDefault(nil).WithMessage("Breadcrumb in the default context")

breadcrumbs := NewBreadcrumbsList(10)
contextClient := rootClient.With(Breadcrumbs(breadcrumbs))
breadcrumbs.NewDefault(nil).WithMessage("Breadcrumb in the private context")

// Will include only the first breadcrumb
rootClient.Capture(
	Message("Event in default context"),
	Logger("default"),
)

// Will include only the second breadcrumb
contextClient.Capture(
	Message("Event in private context"),
	Logger("private"),
)

Output:

cl := NewClient(
	// You can set this when creating your client
	Culprit("example"),
)

cl.Capture(
	// Or you can set it when sending an event
	Culprit("example"),
)

Output:

cl := NewClient(
	// You can configure the DSN when creating a client
	DSN("https://key:pass@example.com/sentry/1"),
)

cl.Capture(
	// You can also configure the DSN when sending an event
	DSN(""),
	Message("This won't be sent"),
)

Output:

deviceInfo := DeviceContextInfo{
	Architecture: "arm",
	BatteryLevel: 100,
	Family:       "Samsung Galaxy",
	Model:        "Samsung Galaxy S8",
	ModelID:      "SM-G95550",
	Name:         "Samsung Galaxy S8",
	Orientation:  "portrait",
}

cl := NewClient(
	// You can provide this when creating your client
	DeviceContext(&deviceInfo),
)

cl.Capture(
	// Or when you send an event
	DeviceContext(&deviceInfo),
)

Output:

cl := NewClient(
	// You can configure your environment at the client level
	Environment("development"),
)

cl.Capture(
	// ...or at the event level
	Environment("prod"),
)

Output:

id, err := NewEventID()
if err != nil {
	log.Fatalln(err)
}

cl := NewClient()

ctxCl := cl.With(
	// You could set the event ID for a context specific
	// client if you wanted (but you probably shouldn't).
	EventID(id),
)

ctxCl.Capture(
	// The best place to set it is when you are ready to send
	// an event to Sentry.
	EventID(id),
)

Output:

cl := NewClient(
	// You can define extra fields when you create your client
	Extra(map[string]interface{}{
		"redis": map[string]interface{}{
			"host": "redis",
			"port": 6379,
		},
	}),
)

cl.Capture(
	// You can also define extra info when you send the event
	// The extra object will be shallowly merged automatically,
	// so this would send both `redis` and `cache`.
	Extra(map[string]interface{}{
		"cache": map[string]interface{}{
			"key": "user.127.profile",
			"hit": false,
		},
	}),
)

Output:

cl := NewClient()

cl.Capture(
	// You can specify a fingerprint that extends the default behaviour
	Fingerprint("{{ default }}", "http://example.com/my.url"),

	// Or you can define your own
	Fingerprint("myrpc", "POST", "/foo.bar"),
)

Output:

// You can manually populate all this request info in situations
// where you aren't using `net/http` as your HTTP server (or don't
// have access to the http.Request object).
// In all other situations, you're better off using `HTTPRequest(r)`
// and saving yourself the effort of building this up manually.
ri := &HTTPRequestInfo{
	URL:    "http://example.com/my.url",
	Method: "GET",
	Query:  "q=test",

	Cookies: "testing=1",
	Headers: map[string]string{
		"Host": "example.com",
	},
	Env: map[string]string{
		"REMOTE_ADDR": "127.0.0.1",
		"REMOTE_PORT": "18204",
	},
	Data: map[string]interface{}{
		"awesome": true,
	},
}

cl := NewClient()

ctxCl := cl.With(
	// You can provide the HTTP request context in a context-specific
	// derived client
	HTTP(ri),
)

ctxCl.Capture(
	// Or you can provide it when sending an event
	HTTP(ri),
)

Output:

cl := NewClient(
	// You can set the severity level when you create your client
	Level(Debug),
)

cl.Capture(
	// You can also specify it when sending an event
	Level(Error),
)

Output:

cl := NewClient(
	// You can set the logger when you create your client
	Logger("root"),
)

cl.Capture(
	// You can also specify it when sending an event
	Logger("http"),
)

Output:

cl := NewClient()

cl.Capture(
	// You can either use just a simple message
	Message("this is a simple message"),
)

cl.Capture(
	// Or you can provide formatting entries as you would with
	// fmt.Sprintf() calls.
	Message("this is a %s message (%d/7 would use again)", "formatted", 5),
)

Output:

cl := NewClient(
	// You can specify module versions when creating your
	// client
	Modules(map[string]string{
		"redis": "v1",
		"mgo":   "v2",
	}),
)

cl.Capture(
	// And override or expand on them when sending an event
	Modules(map[string]string{
		"redis":     "v2",
		"sentry-go": "v1",
	}),
)

Output:

osInfo := OSContextInfo{
	Version:       "CentOS 7.3",
	Build:         "centos7.3.1611",
	KernelVersion: "3.10.0-514",
	Rooted:        false,
}

cl := NewClient(
	// You can provide this when creating your client
	OSContext(&osInfo),
)

cl.Capture(
	// Or when you send an event
	OSContext(&osInfo),
)

Output:

cl := NewClient(
	// You can set the platform at a client level
	Platform("go"),
)

cl.Capture(
	// Or override it when sending the event
	Platform("go"),
)

Output:

cl := NewClient(
	// You can set the release when you create a client
	Release("v1.0.0"),
)

cl.Capture(
	// You can also set it when you send an event
	Release("v1.0.0-dev"),
)

Output:

cl := NewClient(
	// You can configure this when creating your client
	RuntimeContext("go", runtime.Version()),
)

cl.Capture(
	// Or when sending an event
	RuntimeContext("go", runtime.Version()),
)

Output:

cl := NewClient(
	// You can set the logger when you create your client
	ServerName("web01"),
)

cl.Capture(
	// You can also specify it when sending an event
	ServerName("web01.prod"),
)

Output:

cl := NewClient(
	// You can specify tags when creating your client
	Tags(map[string]string{
		"redis": "v1",
		"mgo":   "v2",
	}),
)

cl.Capture(
	// And override or expand on them when sending an event
	Tags(map[string]string{
		"redis":     "v2",
		"sentry-go": "v1",
	}),
)

Output:

cl := NewClient()

cl.Capture(
	// You can specify the timestamp when sending an event to Sentry
	Timestamp(time.Now()),
)

Output:

cl := NewClient(
	// You can remove specific default fields from your final packet if you do
	// not wish to send them.
	Unset("runtime"),
)

cl.Capture(
	// You can also remove things that you may have added later
	Unset("message"),
)

Output:

cl := NewClient(
	// You can override the send queue on your root client
	// All of its derived clients will inherit this queue
	UseSendQueue(NewSequentialSendQueue(10)),
)

cl.With(
	// Or you can override it on a derived client
	UseSendQueue(NewSequentialSendQueue(10)),
)

Output:

var myTransport Transport

cl := NewClient(
	// You can configure the transport to be used on a client level
	UseTransport(myTransport),
)

cl.Capture(
	// Or for a specific event when it is sent
	UseTransport(myTransport),
)

Output:

user := UserInfo{
	ID:        "17ba08f7cc89a912bf812918",
	Email:     "test@example.com",
	Username:  "Test User",
	IPAddress: "127.0.0.1",
	Extra: map[string]string{
		"role": "Tester",
	},
}

cl := NewClient(
	// You can specify your user when you create your client
	User(&user),
)

cl.Capture(
	// Or when you send an event to Sentry
	User(&user),
)

Output:

cl := NewClient()

cl.Capture(
	// You can specify that a StackTrace should be included when
	// sending your event to Sentry
	StackTrace().
		// You can also gather the stacktrace frames from a specific
		// error if it is created using `pkg/errors`
		ForError(errors.New("example error")).
		// And you can mark frames as "internal" by specifying the
		// internal frame prefixes here.
		WithInternalPrefixes(
			"github.com/SierraSoftworks/sentry-go",
		),
)

Output: