ref: Minor code cleanup and ExtractStacktrace benchmarks (#469)

* BenchmarkExtractStacktrace
* reuse reflect for optimize ExtractStacktrace
* small logical optimization ExtractStacktrace
* cleanup and update documentation

client.go

@@ -173,7 +173,8 @@ type ClientOptions struct {
 	Dist string
 	// The environment to be sent with events.
 	Environment string
-	// Maximum number of breadcrumbs.
+	// Maximum number of breadcrumbs
+	// when MaxBreadcrumbs is negative then ignore 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,

hub.go

@@ -281,30 +281,27 @@ func (hub *Hub) AddBreadcrumb(breadcrumb *Breadcrumb, hint *BreadcrumbHint) {
 	}
 
 	options := client.Options()
-	max := defaultMaxBreadcrumbs
-
-	if options.MaxBreadcrumbs != 0 {
-		max = options.MaxBreadcrumbs
-	}
-
+	max := options.MaxBreadcrumbs
 	if max < 0 {
 		return
 	}
 
 	if options.BeforeBreadcrumb != nil {
-		h := &BreadcrumbHint{}
-		if hint != nil {
-			h = hint
+		if hint == nil {
+			hint = &BreadcrumbHint{}
 		}
-		if breadcrumb = options.BeforeBreadcrumb(breadcrumb, h); breadcrumb == nil {
+		if breadcrumb = options.BeforeBreadcrumb(breadcrumb, hint); breadcrumb == nil {
 			Logger.Println("breadcrumb dropped due to BeforeBreadcrumb callback.")
 			return
 		}
 	}
 
-	if max > maxBreadcrumbs {
+	if max == 0 {
+		max = defaultMaxBreadcrumbs
+	} else if max > maxBreadcrumbs {
 		max = maxBreadcrumbs
 	}
+
 	hub.Scope().AddBreadcrumb(breadcrumb, max)
 }
 

integrations.go

@@ -71,10 +71,11 @@ func (ei *environmentIntegration) SetupOnce(client *Client) {
 
 func (ei *environmentIntegration) processor(event *Event, hint *EventHint) *Event {
 	// Initialize maps as necessary.
+	contextNames := []string{"device", "os", "runtime"}
 	if event.Contexts == nil {
-		event.Contexts = make(map[string]Context)
+		event.Contexts = make(map[string]Context, len(contextNames))
 	}
-	for _, name := range []string{"device", "os", "runtime"} {
+	for _, name := range contextNames {
 		if event.Contexts[name] == nil {
 			event.Contexts[name] = make(Context)
 		}

scope.go

@@ -343,7 +343,7 @@ func (scope *Scope) ApplyToEvent(event *Event, hint *EventHint) *Event {
 
 	if len(scope.tags) > 0 {
 		if event.Tags == nil {
-			event.Tags = make(map[string]string)
+			event.Tags = make(map[string]string, len(scope.tags))
 		}
 
 		for key, value := range scope.tags {
@@ -371,7 +371,7 @@ func (scope *Scope) ApplyToEvent(event *Event, hint *EventHint) *Event {
 
 	if len(scope.extra) > 0 {
 		if event.Extra == nil {
-			event.Extra = make(map[string]interface{})
+			event.Extra = make(map[string]interface{}, len(scope.extra))
 		}
 
 		for key, value := range scope.extra {

stacktrace.go

@@ -73,39 +73,38 @@ func ExtractStacktrace(err error) *Stacktrace {
 }
 
 func extractReflectedStacktraceMethod(err error) reflect.Value {
-	var method reflect.Value
+	errValue := reflect.ValueOf(err)
 
-	// https://github.com/pingcap/errors
-	methodGetStackTracer := reflect.ValueOf(err).MethodByName("GetStackTracer")
-	// https://github.com/pkg/errors
-	methodStackTrace := reflect.ValueOf(err).MethodByName("StackTrace")
 	// https://github.com/go-errors/errors
-	methodStackFrames := reflect.ValueOf(err).MethodByName("StackFrames")
+	methodStackFrames := errValue.MethodByName("StackFrames")
+	if methodStackFrames.IsValid() {
+		return methodStackFrames
+	}
+
+	// https://github.com/pkg/errors
+	methodStackTrace := errValue.MethodByName("StackTrace")
+	if methodStackTrace.IsValid() {
+		return methodStackTrace
+	}
 
+	// https://github.com/pingcap/errors
+	methodGetStackTracer := errValue.MethodByName("GetStackTracer")
 	if methodGetStackTracer.IsValid() {
-		stacktracer := methodGetStackTracer.Call(make([]reflect.Value, 0))[0]
+		stacktracer := methodGetStackTracer.Call(nil)[0]
 		stacktracerStackTrace := reflect.ValueOf(stacktracer).MethodByName("StackTrace")
 
 		if stacktracerStackTrace.IsValid() {
-			method = stacktracerStackTrace
+			return stacktracerStackTrace
 		}
 	}
 
-	if methodStackTrace.IsValid() {
-		method = methodStackTrace
-	}
-
-	if methodStackFrames.IsValid() {
-		method = methodStackFrames
-	}
-
-	return method
+	return reflect.Value{}
 }
 
 func extractPcs(method reflect.Value) []uintptr {
 	var pcs []uintptr
 
-	stacktrace := method.Call(make([]reflect.Value, 0))[0]
+	stacktrace := method.Call(nil)[0]
 
 	if stacktrace.Kind() != reflect.Slice {
 		return nil

stacktrace_external_test.go

@@ -255,6 +255,21 @@ func TestExtractStacktrace(t *testing.T) {
 	}
 }
 
+func BenchmarkExtractStacktrace(b *testing.B) {
+	var fs = []func() error{
+		RedPkgErrorsRanger,
+		RedPingcapErrorsRanger,
+		RedGoErrorsRanger,
+	}
+
+	for i := 0; i < b.N; i++ {
+		f := fs[i%len(fs)]
+		err := f()
+
+		sentry.ExtractStacktrace(err)
+	}
+}
+
 func compareStacktrace(t *testing.T, got, want *sentry.Stacktrace) {
 	t.Helper()
 

transport.go

@@ -39,11 +39,13 @@ type Transport interface {
 
 func getProxyConfig(options ClientOptions) func(*http.Request) (*url.URL, error) {
 	if options.HTTPSProxy != "" {
-		return func(_ *http.Request) (*url.URL, error) {
+		return func(*http.Request) (*url.URL, error) {
 			return url.Parse(options.HTTPSProxy)
 		}
-	} else if options.HTTPProxy != "" {
-		return func(_ *http.Request) (*url.URL, error) {
+	}
+
+	if options.HTTPProxy != "" {
+		return func(*http.Request) (*url.URL, error) {
 			return url.Parse(options.HTTPProxy)
 		}
 	}