Recover and RecoverWithContext with arbitrary types

client.go

@@ -284,19 +284,12 @@ func (client *Client) Recover(err interface{}, hint *EventHint, scope EventModif
 		err = recover()
 	}
 
-	if err != nil {
-		if err, ok := err.(error); ok {
-			event := client.eventFromException(err, LevelFatal)
-			return client.CaptureEvent(event, hint, scope)
-		}
-
-		if err, ok := err.(string); ok {
-			event := client.eventFromMessage(err, LevelFatal)
-			return client.CaptureEvent(event, hint, scope)
-		}
-	}
-
-	return nil
+	// Normally we would not pass a nil Context, but RecoverWithContext doesn't
+	// use the Context for communicating deadline nor cancelation. All it does
+	// is store the Context in the EventHint and there nil means the Context is
+	// not available.
+	//nolint: staticcheck
+	return client.RecoverWithContext(nil, err, hint, scope)
 }
 
 // RecoverWithContext captures a panic and passes relevant context object.
@@ -310,24 +303,29 @@ func (client *Client) RecoverWithContext(
 	if err == nil {
 		err = recover()
 	}
+	if err == nil {
+		return nil
+	}
 
-	if err != nil {
-		if hint.Context == nil && ctx != nil {
-			hint.Context = ctx
-		}
-
-		if err, ok := err.(error); ok {
-			event := client.eventFromException(err, LevelFatal)
-			return client.CaptureEvent(event, hint, scope)
+	if ctx != nil {
+		if hint == nil {
+			hint = &EventHint{}
 		}
-
-		if err, ok := err.(string); ok {
-			event := client.eventFromMessage(err, LevelFatal)
-			return client.CaptureEvent(event, hint, scope)
+		if hint.Context == nil {
+			hint.Context = ctx
 		}
 	}
 
-	return nil
+	var event *Event
+	switch err := err.(type) {
+	case error:
+		event = client.eventFromException(err, LevelFatal)
+	case string:
+		event = client.eventFromMessage(err, LevelFatal)
+	default:
+		event = client.eventFromMessage(fmt.Sprintf("%#v", err), LevelFatal)
+	}
+	return client.CaptureEvent(event, hint, scope)
 }
 
 // Flush waits until the underlying Transport sends any buffered events to the

client_test.go

@@ -1,6 +1,8 @@
 package sentry
 
 import (
+	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"sync"
@@ -393,3 +395,81 @@ func BenchmarkProcessEvent(b *testing.B) {
 		c.processEvent(&Event{}, nil, nil)
 	}
 }
+
+func TestRecover(t *testing.T) {
+	tests := []struct {
+		v    interface{} // for panic(v)
+		want *Event
+	}{
+		{
+			errors.New("panic error"),
+			&Event{
+				Exception: []Exception{
+					{
+						Type:       "*errors.errorString",
+						Value:      "panic error",
+						Stacktrace: &Stacktrace{Frames: []Frame{}},
+					},
+				},
+			},
+		},
+		{"panic string", &Event{Message: "panic string"}},
+		// Arbitrary types should be converted to string:
+		{101010, &Event{Message: "101010"}},
+		{[]string{"", "", "hello"}, &Event{Message: `[]string{"", "", "hello"}`}},
+		{&struct{ Field string }{"test"}, &Event{Message: `&struct { Field string }{Field:"test"}`}},
+	}
+	checkEvent := func(t *testing.T, events []*Event, want *Event) {
+		t.Helper()
+		if len(events) != 1 {
+			b, err := json.MarshalIndent(events, "", "  ")
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Fatalf("events = %s\ngot %d events, want 1", b, len(events))
+		}
+		got := events[0]
+		opts := cmp.Transformer("SimplifiedEvent", func(e *Event) *Event {
+			return &Event{
+				Message:   e.Message,
+				Exception: e.Exception,
+				Level:     e.Level,
+			}
+		})
+		if diff := cmp.Diff(want, got, opts); diff != "" {
+			t.Errorf("(-want +got):\n%s", diff)
+		}
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(fmt.Sprintf("Recover/%v", tt.v), func(t *testing.T) {
+			client, scope, transport := setupClientTest()
+			func() {
+				defer client.Recover(nil, nil, scope)
+				panic(tt.v)
+			}()
+			tt.want.Level = LevelFatal
+			checkEvent(t, transport.Events(), tt.want)
+		})
+		t.Run(fmt.Sprintf("RecoverWithContext/%v", tt.v), func(t *testing.T) {
+			client, scope, transport := setupClientTest()
+			var called bool
+			client.AddEventProcessor(func(event *Event, hint *EventHint) *Event {
+				called = true
+				if hint.Context != context.TODO() {
+					t.Fatal("unexpected context value")
+				}
+				return event
+			})
+			func() {
+				defer client.RecoverWithContext(context.TODO(), nil, nil, scope)
+				panic(tt.v)
+			}()
+			tt.want.Level = LevelFatal
+			checkEvent(t, transport.Events(), tt.want)
+			if !called {
+				t.Error("event processor not called, could not test that hint has context")
+			}
+		})
+	}
+}