client_test.go

package sentry

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"net/url"
	"slices"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"testing/synctest"
	"time"

	"github.com/getsentry/sentry-go/internal/debuglog"
	"github.com/getsentry/sentry-go/internal/testutils"
	"github.com/getsentry/sentry-go/protocol"
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	pkgErrors "github.com/pkg/errors"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

const testDsn = "https://whatever@sentry.io/1337"

func TestNewClientAllowsEmptyDSN(t *testing.T) {
	transport := &MockTransport{}
	client, err := NewClient(ClientOptions{
		Transport: transport,
	})
	if err != nil {
		t.Fatalf("expected no error when creating client without a DSN but got %v", err)
	}
	defer client.Close()

	if !client.IsEnabled() {
		t.Fatal("client with an empty DSN should remain enabled")
	}

	client.CaptureException(context.Background(), errors.New("custom error"))
	assertEqual(t, transport.lastEvent.Exception[0].Value, "custom error")
}

func TestNewClientRejectsMalformedDSN(t *testing.T) {
	client, err := NewClient(ClientOptions{Dsn: "not-a-dsn"})

	require.Error(t, err)
	assert.Nil(t, client)
}

func TestNoopClient(t *testing.T) {
	first := NewNoopClient()
	second := NewNoopClient()
	var nilClient *Client

	assert.False(t, first.IsEnabled())
	assert.False(t, second.IsEnabled())
	assert.False(t, nilClient.IsEnabled())
	assert.Same(t, first, second)

	first.SetSDKIdentifier("custom")
	assert.Equal(t, sdkIdentifier, first.GetSDKIdentifier())

	captures := []struct {
		name    string
		capture func() *EventID
	}{
		{"message", func() *EventID { return first.CaptureMessage(context.Background(), "message") }},
		{"exception", func() *EventID { return first.CaptureException(context.Background(), errors.New("exception")) }},
		{"event", func() *EventID { return first.CaptureEvent(context.Background(), &Event{Message: "event"}) }},
		{"nil event", func() *EventID { return CaptureEvent(ContextWithClient(context.Background(), first), nil) }},
		{"check-in", func() *EventID {
			return first.CaptureCheckIn(context.Background(), &CheckIn{MonitorSlug: "cron", Status: CheckInStatusOK}, nil)
		}},
		{"recovered value", func() *EventID {
			return Recover(ContextWithClient(context.Background(), first), "panic")
		}},
	}
	for _, tt := range captures {
		t.Run(tt.name, func(t *testing.T) {
			assert.Nil(t, tt.capture())
		})
	}

	assert.False(t, first.Flush(time.Second))
	assert.False(t, first.FlushWithContext(context.Background()))
	assert.NotPanics(t, first.Close)
}

type customComplexError struct {
	Message string
}

func (e customComplexError) Error() string {
	return "customComplexError: " + e.Message
}

func (e customComplexError) AnswerToLife() string {
	return "42"
}

func setupClientTest() (*Client, *Scope, *MockTransport) {
	scope := NewScope()
	transport := &MockTransport{}
	client, _ := NewClient(ClientOptions{
		Dsn:       "http://whatever@example.com/1337",
		Transport: transport,
		// keep default buffers enabled
		Integrations: func(_ []Integration) []Integration {
			return []Integration{}
		},
	})

	return client, scope, transport
}

func newCaptureTestClient(t *testing.T, options ClientOptions) (*Client, *MockTransport) {
	t.Helper()
	transport := new(MockTransport)
	options.Transport = transport
	options.Integrations = func([]Integration) []Integration { return nil }
	client, err := NewClient(options)
	require.NoError(t, err)
	t.Cleanup(client.Close)
	return client, transport
}

func TestCaptureMessageRouting(t *testing.T) {
	for _, test := range []struct {
		name        string
		capture     func(context.Context, *Client) *EventID
		destination string
	}{
		{"global fallback", func(ctx context.Context, _ *Client) *EventID {
			return CaptureMessage(ctx, "message")
		}, "global"},
		{"nil scope preserves enrichment", func(ctx context.Context, _ *Client) *EventID {
			return CaptureMessage(ContextWithScope(ctx, nil), "message")
		}, "global"},
		{"nil client preserves global fallback", func(ctx context.Context, _ *Client) *EventID {
			return CaptureMessage(ContextWithClient(ctx, nil), "message")
		}, "global"},
		{"nil client preserves local binding", func(ctx context.Context, local *Client) *EventID {
			return CaptureMessage(ContextWithClient(ContextWithClient(ctx, local), nil), "message")
		}, "local"},
		{"inherited local binding", func(ctx context.Context, local *Client) *EventID {
			ctx, cancel := context.WithCancel(ContextWithClient(ctx, local))
			defer cancel()
			return CaptureMessage(ctx, "message")
		}, "local"},
		{"replacement binding", func(ctx context.Context, local *Client) *EventID {
			return CaptureMessage(ContextWithClient(ContextWithClient(ctx, local), ClientFromContext(ctx)), "message")
		}, "global"},
		{"direct receiver overrides context client", func(ctx context.Context, local *Client) *EventID {
			return local.CaptureMessage(ContextWithClient(ctx, ClientFromContext(ctx)), "message")
		}, "local"},
		{"explicit noop", func(ctx context.Context, _ *Client) *EventID {
			return CaptureMessage(ContextWithClient(ctx, NewNoopClient()), "message")
		}, "none"},
		{"no initialized client", func(_ context.Context, _ *Client) *EventID {
			setGlobalClient(nil)
			return CaptureMessage(nil, "message") //nolint:staticcheck // Exercise the nil-context no-op fallback.
		}, "none"},
	} {
		t.Run(test.name, func(t *testing.T) {
			global, globalTransport := newCaptureTestClient(t, ClientOptions{})
			local, localTransport := newCaptureTestClient(t, ClientOptions{})
			previous := globalClientSnapshot()
			setGlobalClient(global)
			t.Cleanup(func() { setGlobalClient(previous) })
			scope := NewScope()
			scope.SetTag("source", test.name)
			id := test.capture(ContextWithScope(context.Background(), scope), local)
			if test.destination == "none" {
				assert.Nil(t, id)
				assert.Empty(t, globalTransport.Events())
				assert.Empty(t, localTransport.Events())
				return
			}
			require.NotNil(t, id)
			target, other := globalTransport, localTransport
			if test.destination == "local" {
				target, other = localTransport, globalTransport
			}
			events := target.Events()
			require.Len(t, events, 1)
			assert.Empty(t, other.Events())
			assert.Equal(t, "message", events[0].Message)
			assert.Equal(t, test.name, events[0].Tags["source"])
		})
	}
}

func TestBackgroundCaptureStartsNewTrace(t *testing.T) {
	client, transport := newCaptureTestClient(t, ClientOptions{})
	ctx := ContextWithClient(context.Background(), client)

	require.NotNil(t, CaptureMessage(ctx, "first"))
	require.NotNil(t, CaptureMessage(ctx, "second"))
	require.Len(t, transport.Events(), 2)
	first := transport.Events()[0].Contexts["trace"][traceIDContextKey]
	second := transport.Events()[1].Contexts["trace"][traceIDContextKey]
	assert.NotEmpty(t, first)
	assert.NotEqual(t, first, second)
}

func TestInitFailureKeepsGlobalClient(t *testing.T) {
	client, _ := newCaptureTestClient(t, ClientOptions{})
	previousClient := globalClientSnapshot()
	setGlobalClient(client)
	t.Cleanup(func() { setGlobalClient(previousClient) })

	assert.Error(t, Init(ClientOptions{Dsn: "not-a-dsn"}))
	assert.Same(t, client, ClientFromContext(context.Background()))
}

func TestGlobalClientConcurrentAccess(t *testing.T) {
	first, _ := newCaptureTestClient(t, ClientOptions{})
	second, _ := newCaptureTestClient(t, ClientOptions{})
	previousClient := globalClientSnapshot()
	setGlobalClient(first)
	t.Cleanup(func() { setGlobalClient(previousClient) })

	var wg sync.WaitGroup
	for range 8 {
		wg.Go(func() {
			for range 1_000 {
				setGlobalClient(first)
				if client := ClientFromContext(context.Background()); client != first && client != second {
					t.Errorf("unexpected global client: %p", client)
					return
				}
				setGlobalClient(second)
			}
		})
	}
	wg.Wait()
}

func TestWithScopeCreatesIndependentRoots(t *testing.T) {
	client, transport := newCaptureTestClient(t, ClientOptions{})
	global := cleanGlobalScope(t)
	global.SetTag("global-before", "before")

	firstCtx, _ := WithScope(context.Background())
	secondCtx, _ := WithScope(context.Background())
	global.SetTag("global-after", "after")
	require.NotNil(t, CaptureMessage(ContextWithClient(firstCtx, client), "first root"))
	require.NotNil(t, CaptureMessage(ContextWithClient(secondCtx, client), "second root"))
	require.Len(t, transport.Events(), 2)
	assert.Equal(t, "before", transport.Events()[0].Tags["global-before"])
	assert.Equal(t, "after", transport.Events()[0].Tags["global-after"])
	assert.NotEqual(t, transport.Events()[0].Contexts["trace"][traceIDContextKey], transport.Events()[1].Contexts["trace"][traceIDContextKey])
}

func TestWithScopeClonesParentTrace(t *testing.T) {
	client, transport := newCaptureTestClient(t, ClientOptions{})
	parent := NewScope()
	parent.SetTag("source", "parent")
	parent.SetPropagationContext(PropagationContext{
		TraceID: TraceIDFromHex("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
		DynamicSamplingContext: DynamicSamplingContext{
			Entries: map[string]string{"release": "parent"},
		},
	})

	ctx, child := WithScope(ContextWithScope(context.Background(), parent))
	propagation := child.propagationContextSnapshot()
	propagation.DynamicSamplingContext.Entries["release"] = "child"
	child.SetPropagationContext(propagation)
	child.SetTag("child-only", "value")
	assert.Equal(t, "parent", parent.propagationContextSnapshot().DynamicSamplingContext.Entries["release"])
	assert.Equal(t, "child", child.propagationContextSnapshot().DynamicSamplingContext.Entries["release"])
	require.NotNil(t, CaptureMessage(ContextWithClient(ctx, client), "child"))
	require.Len(t, transport.Events(), 1)

	assert.Equal(t, "parent", transport.Events()[0].Tags["source"])
	assert.NotContains(t, parent.tags, "child-only")
	assert.Equal(t, parent.propagationContextSnapshot().TraceID.String(), transport.Events()[0].Contexts["trace"][traceIDContextKey])
}

func TestCaptureMessageCopiesHintAndUsesContext(t *testing.T) {
	type key struct{}
	providedCtx := context.WithValue(context.Background(), key{}, "provided")
	captureCtx := context.WithValue(context.Background(), key{}, "capture")
	provided := &EventHint{Context: providedCtx, Data: "data"}

	var received *EventHint
	client, _ := newCaptureTestClient(t, ClientOptions{
		BeforeSend: func(event *Event, hint *EventHint) *Event {
			received = hint
			return event
		},
	})
	captureCtx = ContextWithClient(captureCtx, client)
	captureCtx = ContextWithScope(captureCtx, NewScope())
	require.NotNil(t, CaptureMessage(captureCtx, "message", WithEventHint(provided)))

	require.NotNil(t, received)
	assert.NotSame(t, provided, received)
	assert.Equal(t, "data", received.Data)
	assert.Equal(t, "provided", received.Context.Value(key{}))
	assert.Same(t, providedCtx, provided.Context)

	require.NotNil(t, CaptureMessage(captureCtx, "message with inferred hint context", WithEventHint(&EventHint{})))
	assert.Equal(t, "capture", received.Context.Value(key{}))
}

func TestCaptureMessagePreservesActiveSpanTraceContext(t *testing.T) {
	for _, test := range []struct {
		name                       string
		directClient, withoutScope bool
	}{
		{name: "package capture"},
		{name: "client capture", directClient: true},
		{name: "without scope", withoutScope: true},
	} {
		t.Run(test.name, func(t *testing.T) {
			client, transport := newCaptureTestClient(t, ClientOptions{})
			ctx := ContextWithClient(context.Background(), client)
			if test.withoutScope {
				cleanGlobalScope(t)
			} else {
				ctx = ContextWithScope(ctx, NewScope())
			}
			transaction := StartTransaction(ctx, "request", WithOpName("http.server"))
			transaction.SetData("http.request.method", http.MethodGet)
			capture := CaptureMessage
			if test.directClient {
				capture = client.CaptureMessage
			}
			require.NotNil(t, capture(transaction.Context(), "message"))
			require.Equal(t, Context{
				traceIDContextKey: transaction.TraceID.String(),
				spanIDContextKey:  transaction.SpanID.String(),
				"op":              "http.server",
				"data":            map[string]interface{}{"http.request.method": http.MethodGet},
			}, requireSingleEvent(t, transport).Contexts[traceContextKey])
		})
	}
}

func TestCaptureMessageEmptyString(t *testing.T) {
	client, scope, transport := setupClientTest()
	ctx := ContextWithClient(ContextWithScope(context.Background(), scope), client)
	CaptureMessage(ctx, "")
	want := &Event{
		Exception: []Exception{
			{
				Type:       "sentry.usageError",
				Value:      "CaptureMessage called with empty message",
				Stacktrace: &Stacktrace{},
			},
		},
	}
	got := transport.lastEvent
	opts := cmp.Options{
		cmpopts.IgnoreFields(Event{}, "sdkMetaData", "serializedTags", "serializedContexts", "serializedBreadcrumbs", "serializedException", "serializedUser", "serializationSafe"),
		cmp.Transformer("SimplifiedEvent", func(e *Event) *Event {
			return &Event{
				Exception: e.Exception,
			}
		}),
	}

	if diff := cmp.Diff(want, got, opts); diff != "" {
		t.Errorf("(-want +got):\n%s", diff)
	}
}

type customErr struct{}

func (e *customErr) Error() string {
	return "wat"
}

type customErrWithCause struct{ cause error }

func (e *customErrWithCause) Error() string {
	return "err"
}

func (e *customErrWithCause) Cause() error {
	return e.cause
}

type wrappedError struct{ original error }

func (e wrappedError) Error() string {
	return "wrapped: " + e.original.Error()
}

func (e wrappedError) Unwrap() error {
	return e.original
}

type captureExceptionTestGroup struct {
	name  string
	tests []captureExceptionTest
}

type captureExceptionTest struct {
	name string
	err  error
	want []Exception
}

func TestCaptureException(t *testing.T) {
	basicTests := []captureExceptionTest{
		{
			name: "NilError",
			err:  nil,
			want: []Exception{
				{
					Type:       "sentry.usageError",
					Value:      "CaptureException called with nil error",
					Stacktrace: &Stacktrace{},
				},
			},
		},
		{
			name: "SimpleError",
			err:  errors.New("custom error"),
			want: []Exception{
				{
					Type:       "*errors.errorString",
					Value:      "custom error",
					Stacktrace: &Stacktrace{},
				},
			},
		},
	}

	errorChainTests := []captureExceptionTest{
		{
			name: "MostRecentErrorHasStack",
			err:  pkgErrors.WithStack(&customErr{}),
			want: []Exception{
				{
					Type:       "*sentry.customErr",
					Value:      "wat",
					Stacktrace: nil,
					Mechanism: &Mechanism{
						Type:             MechanismTypeChained,
						ExceptionID:      1,
						ParentID:         new(0),
						Source:           MechanismTypeUnwrap,
						IsExceptionGroup: false,
					},
				},
				{
					Type:       "*errors.withStack",
					Value:      "wat",
					Stacktrace: &Stacktrace{},
					Mechanism: &Mechanism{
						Type:             MechanismTypeGeneric,
						ExceptionID:      0,
						ParentID:         nil,
						Source:           "",
						IsExceptionGroup: false,
					},
				},
			},
		},
		{
			name: "ChainWithNilCause",
			err:  &customErrWithCause{cause: nil},
			want: []Exception{
				{
					Type:       "*sentry.customErrWithCause",
					Value:      "err",
					Stacktrace: &Stacktrace{},
				},
			},
		},
		{
			name: "ChainWithoutStacktrace",
			err:  &customErrWithCause{cause: &customErr{}},
			want: []Exception{
				{
					Type:       "*sentry.customErr",
					Value:      "wat",
					Stacktrace: nil,
					Mechanism: &Mechanism{
						Type:             MechanismTypeChained,
						ExceptionID:      1,
						ParentID:         new(0),
						Source:           "cause",
						IsExceptionGroup: false,
					},
				},
				{
					Type:       "*sentry.customErrWithCause",
					Value:      "err",
					Stacktrace: &Stacktrace{},
					Mechanism: &Mechanism{
						Type:             MechanismTypeGeneric,
						ExceptionID:      0,
						ParentID:         nil,
						Source:           "",
						IsExceptionGroup: false,
					},
				},
			},
		},
		{
			name: "Go113Unwrap",
			err:  wrappedError{original: errors.New("original")},
			want: []Exception{
				{
					Type:       "*errors.errorString",
					Value:      "original",
					Stacktrace: nil,
					Mechanism: &Mechanism{
						Type:             MechanismTypeChained,
						ExceptionID:      1,
						ParentID:         new(0),
						Source:           MechanismTypeUnwrap,
						IsExceptionGroup: false,
					},
				},
				{
					Type:       "sentry.wrappedError",
					Value:      "wrapped: original",
					Stacktrace: &Stacktrace{},
					Mechanism: &Mechanism{
						Type:             MechanismTypeGeneric,
						ExceptionID:      0,
						ParentID:         nil,
						Source:           "",
						IsExceptionGroup: false,
					},
				},
			},
		},
		{
			name: "URLErrorQueryIsFiltered",
			err:  wrappedError{original: &url.Error{Op: "Post", URL: "http://user@auth/api?token=secret&q=a%20b#frag", Err: errors.New("timeout")}},
			want: []Exception{
				{
					Type:  "*errors.errorString",
					Value: "timeout",
					Mechanism: &Mechanism{
						Type:        MechanismTypeChained,
						ExceptionID: 2,
						ParentID:    new(1),
						Source:      MechanismTypeUnwrap,
					},
				},
				{
					Type:  "*url.Error",
					Value: `Post "http://auth/api?token=[Filtered]&q=a%20b": timeout`,
					Mechanism: &Mechanism{
						Type:        MechanismTypeChained,
						ExceptionID: 1,
						ParentID:    new(0),
						Source:      MechanismTypeUnwrap,
					},
				},
				{
					Type:       "sentry.wrappedError",
					Value:      `wrapped: Post "http://auth/api?token=[Filtered]&q=a%20b": timeout`,
					Stacktrace: &Stacktrace{},
					Mechanism:  &Mechanism{Type: MechanismTypeGeneric},
				},
			},
		},
		{
			name: "URLErrorUnparseableURLIsFiltered",
			err:  &url.Error{Op: "parse", URL: "http://user:p@ss@host/%zz?token=secret", Err: url.EscapeError("%zz")},
			want: []Exception{
				{
					Type:  "url.EscapeError",
					Value: `invalid URL escape "%zz"`,
					Mechanism: &Mechanism{
						Type:        MechanismTypeChained,
						ExceptionID: 1,
						ParentID:    new(0),
						Source:      MechanismTypeUnwrap,
					},
				},
				{
					Type:       "*url.Error",
					Value:      `parse "[Filtered]": invalid URL escape "%zz"`,
					Stacktrace: &Stacktrace{},
					Mechanism:  &Mechanism{Type: MechanismTypeGeneric},
				},
			},
		},
	}

	tests := []captureExceptionTestGroup{
		{
			name:  "Basic",
			tests: basicTests,
		},
		{
			name:  "ErrorChain",
			tests: errorChainTests,
		},
	}

	for _, grp := range tests {
		for _, tt := range grp.tests {
			tt := tt
			t.Run(grp.name+"/"+tt.name, func(t *testing.T) {
				client, _, transport := setupClientTest()
				CaptureException(ContextWithClient(context.Background(), client), tt.err)
				if transport.lastEvent == nil {
					t.Fatal("missing event")
				}
				got := transport.lastEvent.Exception
				if diff := cmp.Diff(tt.want, got); diff != "" {
					t.Errorf("Event mismatch (-want +got):\n%s", diff)
				}
			})
		}
	}
}

func TestCaptureEvent(t *testing.T) {
	client, _, transport := setupClientTest()

	eventID := EventID("0123456789abcdef")
	timestamp := time.Now().UTC()
	serverName := "testServer"

	client.CaptureEvent(context.Background(), &Event{
		EventID:    eventID,
		Timestamp:  timestamp,
		ServerName: serverName,
	})

	if transport.lastEvent == nil {
		t.Fatal("missing event")
	}
	want := &Event{
		EventID:    eventID,
		Timestamp:  timestamp,
		ServerName: serverName,
		Level:      LevelInfo,
		Platform:   "go",
		Sdk: SdkInfo{
			Name:    "sentry.go",
			Version: SDKVersion,
			Packages: []SdkPackage{
				{
					// FIXME: name format doesn't follow spec in
					// https://docs.sentry.io/development/sdk-dev/event-payloads/sdk/
					Name:    "sentry-go",
					Version: SDKVersion,
				},
				// TODO: perhaps the list of packages is incomplete or there
				// should not be any package at all. We may include references
				// to used integrations like http, echo, gin, etc.
			},
		},
	}
	got := transport.lastEvent
	opts := cmp.Options{cmpopts.IgnoreFields(Event{}, "Release", "Contexts"), cmpopts.IgnoreFields(Event{}, "sdkMetaData", "serializedTags", "serializedContexts", "serializedBreadcrumbs", "serializedException", "serializedUser", "serializationSafe")}
	if diff := cmp.Diff(want, got, opts); diff != "" {
		t.Errorf("Event mismatch (-want +got):\n%s", diff)
	}
}

func TestCaptureEventShouldSendEventWithMessage(t *testing.T) {
	client, scope, transport := setupClientTest()
	event := NewEvent()
	event.Message = "event message"
	client.CaptureEvent(ContextWithScope(context.Background(), scope), event)
	assertEqual(t, transport.lastEvent.Message, "event message")
}

func TestCaptureEventNil(t *testing.T) {
	client, scope, transport := setupClientTest()
	ctx := ContextWithClient(ContextWithScope(context.Background(), scope), client)
	CaptureEvent(ctx, nil)
	want := &Event{
		Exception: []Exception{
			{
				Type:       "sentry.usageError",
				Value:      "CaptureEvent called with nil event",
				Stacktrace: &Stacktrace{},
			},
		},
	}
	got := transport.lastEvent
	assert.Equal(t, LevelError, got.Level)
	opts := cmp.Options{
		cmpopts.IgnoreFields(Event{}, "sdkMetaData", "serializedTags", "serializedContexts", "serializedBreadcrumbs", "serializedException", "serializedUser", "serializationSafe"),
		cmp.Transformer("SimplifiedEvent", func(e *Event) *Event {
			return &Event{
				Exception: e.Exception,
			}
		}),
	}
	if diff := cmp.Diff(want, got, opts); diff != "" {
		t.Errorf("(-want +got):\n%s", diff)
	}
}

func TestCaptureLevelPrecedence(t *testing.T) {
	tests := []struct {
		name       string
		scopeLevel Level
		capture    func(ctx context.Context, client *Client)
		want       Level
	}{
		{
			name:       "capture helper default below scope",
			scopeLevel: LevelWarning,
			capture: func(ctx context.Context, client *Client) {
				client.CaptureException(ctx, errors.New("boom"))
			},
			want: LevelWarning,
		},
		{
			name:       "event above scope",
			scopeLevel: LevelWarning,
			capture: func(ctx context.Context, client *Client) {
				client.CaptureEvent(ctx, &Event{Level: LevelDebug})
			},
			want: LevelDebug,
		},
		{
			name:       "capture option above event",
			scopeLevel: LevelWarning,
			capture: func(ctx context.Context, _ *Client) {
				CaptureEvent(ctx, &Event{Level: LevelDebug}, WithLevel(LevelFatal))
			},
			want: LevelFatal,
		},
		{
			name: "capture helper default reaches scope processors",
			capture: func(ctx context.Context, client *Client) {
				client.CaptureException(ctx, errors.New("boom"))
			},
			want: LevelError,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			client, transport := newCaptureTestClient(t, ClientOptions{})
			scope := NewScope()
			scope.SetLevel(test.scopeLevel)
			var observed Level
			scope.AddEventProcessor(func(event *Event, _ *EventHint) *Event {
				observed = event.Level
				scope.SetTag("processed", "yes")
				return event
			})
			ctx := ContextWithClient(ContextWithScope(context.Background(), scope), client)
			test.capture(ctx, client)
			require.Len(t, transport.Events(), 1)
			assert.Equal(t, test.want, transport.Events()[0].Level)
			assert.Equal(t, test.want, observed)
		})
	}
}

func TestCaptureUpdatesLastEventID(t *testing.T) {
	tests := []struct {
		name       string
		capture    func(context.Context, *Client) *EventID
		wantChange bool
	}{
		{
			name: "message",
			capture: func(ctx context.Context, client *Client) *EventID {
				return client.CaptureMessage(ctx, "next")
			},
			wantChange: true,
		},
		{
			name: "exception",
			capture: func(ctx context.Context, client *Client) *EventID {
				return client.CaptureException(ctx, errors.New("next"))
			},
			wantChange: true,
		},
		{
			name: "event",
			capture: func(ctx context.Context, client *Client) *EventID {
				return client.CaptureEvent(ctx, NewEvent())
			},
			wantChange: true,
		},
		{
			name: "check-in",
			capture: func(ctx context.Context, client *Client) *EventID {
				return client.CaptureCheckIn(ctx, &CheckIn{MonitorSlug: "cron", Status: CheckInStatusOK}, nil)
			},
		},
		{
			name: "transaction",
			capture: func(ctx context.Context, client *Client) *EventID {
				return client.CaptureEvent(ctx, &Event{Type: transactionType})
			},
		},
		{
			name: "dropped event",
			capture: func(ctx context.Context, client *Client) *EventID {
				client.AddEventProcessor(func(*Event, *EventHint) *Event { return nil })
				return client.CaptureMessage(ctx, "dropped")
			},
		},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			client, _ := newCaptureTestClient(t, ClientOptions{})
			ctx := ContextWithScope(context.Background(), NewScope())
			previousID := client.CaptureMessage(ctx, "previous")
			require.NotNil(t, previousID)

			capturedID := test.capture(ctx, client)
			if test.wantChange {
				require.NotNil(t, capturedID)
				assert.Equal(t, *capturedID, LastEventID(ctx))
			} else {
				assert.Equal(t, *previousID, LastEventID(ctx))
			}
		})
	}

	client, _ := newCaptureTestClient(t, ClientOptions{})
	require.NotNil(t, client.CaptureMessage(context.Background(), "no scope"))
	assert.Empty(t, LastEventID(context.Background()))

	scope := NewScope()
	ctx := ContextWithScope(context.Background(), scope)
	capturedID := client.CaptureMessage(ctx, "lifecycle")
	require.NotNil(t, capturedID)
	clone := scope.Clone()
	scope.Clear()
	assert.Empty(t, clone.lastEventIDSnapshot())
	assert.Equal(t, *capturedID, scope.lastEventIDSnapshot())
}

func TestCaptureCheckIn(t *testing.T) {
	tests := []struct {
		name           string
		checkIn        *CheckIn
		monitorConfig  *MonitorConfig
		expectNilEvent bool
	}{
		{
			name:           "Nil CheckIn",
			checkIn:        nil,
			monitorConfig:  nil,
			expectNilEvent: true,
		},
		{
			name: "Nil MonitorConfig",
			checkIn: &CheckIn{
				ID:          "66e1a05b182346f2aee5fd7f0dc9b44e",
				MonitorSlug: "cron",
				Status:      CheckInStatusOK,
				Duration:    time.Second * 10,
			},
			monitorConfig: nil,
		},
		{
			name: "IntervalSchedule",
			checkIn: &CheckIn{
				ID:          "66e1a05b182346f2aee5fd7f0dc9b44e",
				MonitorSlug: "cron",
				Status:      CheckInStatusInProgress,
				Duration:    time.Second * 10,
			},
			monitorConfig: &MonitorConfig{
				Schedule:              IntervalSchedule(1, MonitorScheduleUnitHour),
				CheckInMargin:         10,
				MaxRuntime:            5000,
				Timezone:              "Asia/Singapore",
				FailureIssueThreshold: 5,
				RecoveryThreshold:     10,
			},
		},
		{
			name: "CronSchedule",
			checkIn: &CheckIn{
				ID:          "66e1a05b182346f2aee5fd7f0dc9b44e",
				MonitorSlug: "cron",
				Status:      CheckInStatusInProgress,
				Duration:    time.Second * 10,
			},
			monitorConfig: &MonitorConfig{
				Schedule:              CrontabSchedule("40 * * * *"),
				CheckInMargin:         10,
				MaxRuntime:            5000,
				Timezone:              "Asia/Singapore",
				FailureIssueThreshold: 5,
				RecoveryThreshold:     10,
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			client, _, transport := setupClientTest()
			client.CaptureCheckIn(context.Background(), tt.checkIn, tt.monitorConfig)
			capturedEvent := transport.lastEvent

			if tt.expectNilEvent && capturedEvent == nil {
				// Event is nil as expected, nothing else to check
				return
			}

			if capturedEvent == nil {
				t.Fatal("missing event")
			}

			if capturedEvent.Type != checkInType {
				t.Errorf("Event type mismatch: want %s, got %s", checkInType, capturedEvent.Type)
			}

			if diff := cmp.Diff(capturedEvent.CheckIn, tt.checkIn); diff != "" {
				t.Errorf("CheckIn mismatch (-want +got):\n%s", diff)
			}

			if diff := cmp.Diff(capturedEvent.MonitorConfig, tt.monitorConfig); diff != "" {
				t.Errorf("CheckIn mismatch (-want +got):\n%s", diff)
			}
		})
	}
}

func TestCaptureCheckInExistingID(t *testing.T) {
	client, _, _ := setupClientTest()

	monitorConfig := &MonitorConfig{
		Schedule:      IntervalSchedule(1, MonitorScheduleUnitDay),
		CheckInMargin: 30,
		MaxRuntime:    30,
		Timezone:      "UTC",
	}

	checkInID := client.CaptureCheckIn(context.Background(), &CheckIn{
		MonitorSlug: "cron",
		Status:      CheckInStatusInProgress,
		Duration:    time.Second,
	}, monitorConfig)

	checkInID2 := client.CaptureCheckIn(context.Background(), &CheckIn{
		ID:          *checkInID,
		MonitorSlug: "cron",
		Status:      CheckInStatusOK,
		Duration:    time.Minute,
	}, monitorConfig)

	if *checkInID != *checkInID2 {
		t.Errorf("Expecting equivalent CheckInID: %s and %s", *checkInID, *checkInID2)
	}
}

func TestSampleRateCanDropEvent(t *testing.T) {
	client, scope, transport := setupClientTest()
	client.options.SampleRate = 0.000000000000001

	client.CaptureMessage(ContextWithScope(context.Background(), scope), "Foo")

	if transport.lastEvent != nil {
		t.Error("expected event to be dropped")
	}
}

func TestApplyToScopeCanDropEvent(t *testing.T) {
	client, scope, transport := setupClientTest()
	scope.AddEventProcessor(func(*Event, *EventHint) *Event { return nil })

	client.AddEventProcessor(func(event *Event, _ *EventHint) *Event {
		t.Error("client processor ran after the scope dropped the event")
		return event
	})

	client.CaptureMessage(ContextWithScope(context.Background(), scope), "Foo")

	if transport.lastEvent != nil {
		t.Error("expected event to be dropped")
	}
}

func TestBeforeSendCanDropEvent(t *testing.T) {
	client, scope, transport := setupClientTest()
	client.options.BeforeSend = func(_ *Event, _ *EventHint) *Event {
		return nil
	}

	client.CaptureMessage(ContextWithScope(context.Background(), scope), "Foo")

	if transport.lastEvent != nil {
		t.Error("expected event to be dropped")
	}
}

func TestBeforeSendGetAccessToEventHint(t *testing.T) {
	client, scope, transport := setupClientTest()
	client.options.BeforeSend = func(event *Event, hint *EventHint) *Event {
		if ex, ok := hint.OriginalException.(customComplexError); ok {
			event.Message = event.Exception[0].Value + " " + ex.AnswerToLife()
		}
		return event
	}
	ex := customComplexError{Message: "Foo"}

	ctx := ContextWithClient(ContextWithScope(context.Background(), scope), client)
	CaptureException(ctx, ex, WithEventHint(&EventHint{OriginalException: ex}))

	assertEqual(t, transport.lastEvent.Message, "customComplexError: Foo 42")
}

func TestBeforeSendTransactionCanDropTransaction(t *testing.T) {
	transport := &MockTransport{}
	ctx := NewTestContext(ClientOptions{
		EnableTracing:    true,
		TracesSampleRate: 1.0,
		Transport:        transport,
		BeforeSend: func(event *Event, _ *EventHint) *Event {
			t.Error("beforeSend should not be called")
			return event
		},
		BeforeSendTransaction: func(event *Event, _ *EventHint) *Event {
			assertEqual(t, event.Transaction, "Foo")
			return nil
		},
	})

	transaction := StartTransaction(ctx,
		"Foo",
	)
	transaction.Finish()

	if transport.lastEvent != nil {
		t.Error("expected event to be dropped")
	}
}

func TestBeforeSendTransactionIsCalled(t *testing.T) {
	transport := &MockTransport{}
	ctx := NewTestContext(ClientOptions{
		EnableTracing:    true,
		TracesSampleRate: 1.0,
		Transport:        transport,
		BeforeSend: func(event *Event, _ *EventHint) *Event {
			t.Error("beforeSend should not be called")
			return event
		},
		BeforeSendTransaction: func(event *Event, _ *EventHint) *Event {
			assertEqual(t, event.Transaction, "Foo")
			event.Transaction = "Bar"
			return event
		},
	})

	transaction := StartTransaction(ctx,
		"Foo",
	)
	transaction.Finish()

	lastEvent := transport.lastEvent
	assertEqual(t, lastEvent.Transaction, "Bar")
	// Make sure it's the same span
	assertEqual(t, lastEvent.Contexts["trace"]["span_id"], transaction.SpanID.String())
}

func TestIgnoreErrors(t *testing.T) {
	tests := map[string]struct {
		ignoreErrors []string
		message      string
		expectDrop   bool
	}{
		"No Match": {
			message:      "Foo",
			ignoreErrors: []string{"Bar", "Baz"},
			expectDrop:   false,
		},
		"Partial Match": {
			message:      "FooBar",
			ignoreErrors: []string{"Foo", "Baz"},
			expectDrop:   true,
		},
		"Exact Match": {
			message:      "Foo Bar",
			ignoreErrors: []string{"\\bFoo\\b", "Baz"},
			expectDrop:   true,
		},
		"Wildcard Match": {
			message:      "Foo",
			ignoreErrors: []string{"F*", "Bar"},
			expectDrop:   true,
		},
		"Match string but not pattern": {
			message:      "(Foo)",
			ignoreErrors: []string{"(Foo)"},
			expectDrop:   true,
		},
	}

	for name, tt := range tests {
		t.Run(name, func(t *testing.T) {
			transport := &MockTransport{}
			client, err := NewClient(ClientOptions{
				Transport:    transport,
				IgnoreErrors: tt.ignoreErrors,
			})
			if err != nil {
				t.Fatal(err)
			}

			client.CaptureMessage(context.Background(), tt.message)

			dropped := transport.lastEvent == nil
			if tt.expectDrop != dropped {
				t.Errorf("expected event to be dropped")
			}
		})
	}
}

func TestIgnoreTransactions(t *testing.T) {
	tests := map[string]struct {
		ignoreTransactions []string
		transaction        string
		expectDrop         bool
	}{
		"No Match": {
			transaction:        "Foo",
			ignoreTransactions: []string{"Bar", "Baz"},
			expectDrop:         false,
		},
		"Partial Match": {
			transaction:        "FooBar",
			ignoreTransactions: []string{"Foo", "Baz"},
			expectDrop:         true,
		},
		"Exact Match": {
			transaction:        "Foo Bar",
			ignoreTransactions: []string{"\\bFoo\\b", "Baz"},
			expectDrop:         true,
		},
		"Wildcard Match": {
			transaction:        "Foo",
			ignoreTransactions: []string{"F*", "Bar"},
			expectDrop:         true,
		},
		"Match string but not pattern": {
			transaction:        "(Foo)",
			ignoreTransactions: []string{"(Foo)"},
			expectDrop:         true,
		},
	}

	for name, tt := range tests {
		t.Run(name, func(t *testing.T) {
			transport := &MockTransport{}
			ctx := NewTestContext(ClientOptions{
				EnableTracing:      true,
				TracesSampleRate:   1.0,
				Transport:          transport,
				IgnoreTransactions: tt.ignoreTransactions,
			})

			transaction := StartTransaction(ctx,
				tt.transaction,
			)
			transaction.Finish()

			dropped := transport.lastEvent == nil
			if tt.expectDrop != dropped {
				t.Errorf("expected event to be dropped")
			}
		})
	}
}

func TestTraceIgnoreStatusCode_EmptyCode(t *testing.T) {
	transport := &MockTransport{}
	ctx := NewTestContext(ClientOptions{
		EnableTracing:    true,
		TracesSampleRate: 1.0,
		Transport:        transport,
	})

	transaction := StartTransaction(ctx, "test")
	// Transaction has no http.response.status_code
	transaction.Finish()

	dropped := transport.lastEvent == nil
	assertEqual(t, dropped, false, "expected transaction to not be dropped")
}

func TestTraceIgnoreStatusCodes(t *testing.T) {
	tests := map[string]struct {
		ignoreStatusCodes [][]int
		statusCode        interface{}
		expectDrop        bool
	}{
		"Default behavior: ignoreStatusCodes = nil, should drop 404s": {
			statusCode:        404,
			ignoreStatusCodes: nil,
			expectDrop:        true,
		},
		"Specify No ignored codes": {
			statusCode:        404,
			ignoreStatusCodes: [][]int{},
			expectDrop:        false,
		},
		"Status code not in ignore ranges": {
			statusCode:        500,
			ignoreStatusCodes: [][]int{{400, 405}},
			expectDrop:        false,
		},
		"404 in ignore range": {
			statusCode:        404,
			ignoreStatusCodes: [][]int{{400, 405}},
			expectDrop:        true,
		},
		"403 in ignore range": {
			statusCode:        403,
			ignoreStatusCodes: [][]int{{400, 405}},
			expectDrop:        true,
		},
		"200 not ignored": {
			statusCode:        200,
			ignoreStatusCodes: [][]int{{400, 405}},
			expectDrop:        false,
		},
		"wrong code not ignored": {
			statusCode:        "something",
			ignoreStatusCodes: [][]int{{400, 405}},
			expectDrop:        false,
		},
		"Single status code as single-element slice": {
			statusCode:        404,
			ignoreStatusCodes: [][]int{{404}},
			expectDrop:        true,
		},
		"Single status code not in single-element slice": {
			statusCode:        500,
			ignoreStatusCodes: [][]int{{404}},
			expectDrop:        false,
		},
		"Multiple single codes": {
			statusCode:        500,
			ignoreStatusCodes: [][]int{{404}, {500}},
			expectDrop:        true,
		},
		"Multiple ranges - code in first range": {
			statusCode:        404,
			ignoreStatusCodes: [][]int{{400, 405}, {500, 599}},
			expectDrop:        true,
		},
		"Multiple ranges - code in second range": {
			statusCode:        500,
			ignoreStatusCodes: [][]int{{400, 405}, {500, 599}},
			expectDrop:        true,
		},
		"Multiple ranges - code not in any range": {
			statusCode:        200,
			ignoreStatusCodes: [][]int{{400, 405}, {500, 599}},
			expectDrop:        false,
		},
		"Mixed single codes and ranges": {
			statusCode:        404,
			ignoreStatusCodes: [][]int{{404}, {500, 599}},
			expectDrop:        true,
		},
		"Mixed single codes and ranges - code in range": {
			statusCode:        500,
			ignoreStatusCodes: [][]int{{404}, {500, 599}},
			expectDrop:        true,
		},
		"Mixed single codes and ranges - code not matched": {
			statusCode:        200,
			ignoreStatusCodes: [][]int{{404}, {500, 599}},
			expectDrop:        false,
		},
	}

	for name, tt := range tests {
		t.Run(name, func(t *testing.T) {
			transport := &MockTransport{}
			ctx := NewTestContext(ClientOptions{
				EnableTracing:          true,
				TracesSampleRate:       1.0,
				Transport:              transport,
				TraceIgnoreStatusCodes: tt.ignoreStatusCodes,
			})

			transaction := StartTransaction(ctx, "test")
			child := transaction.StartChild("child")
			child.Finish()
			firstExportAfterFinish := name == "404 in ignore range" || name == "Single status code as single-element slice"
			var baggage string
			if !firstExportAfterFinish {
				baggage = transaction.ToBaggage()
			}
			// Simulate HTTP response data like the integrations do
			transaction.SetData("http.response.status_code", tt.statusCode)
			transaction.Finish()
			if !firstExportAfterFinish {
				assertBaggageStringsEqual(t, baggage, transaction.ToBaggage())
			}

			dropped := transport.lastEvent == nil
			if tt.expectDrop != dropped {
				if tt.expectDrop {
					t.Errorf("expected transaction with status code %d to be dropped", tt.statusCode)
				} else {
					t.Errorf("expected transaction with status code %d not to be dropped", tt.statusCode)
				}
			}
			if firstExportAfterFinish {
				require.Equal(t, SampledFalse, transaction.Sampled)
				require.NotNil(t, CaptureMessage(transaction.Context(), "after finish"))
				dsc, err := DynamicSamplingContextFromHeader([]byte(GetBaggage(transaction.Context())))
				require.NoError(t, err)
				require.Equal(t, "true", dsc.Entries["sampled"])
				require.Equal(t, "1", dsc.Entries["sample_rate"])
				require.Equal(t, dsc.Entries, transport.Events()[0].sdkMetaData.dsc.Entries)
			}
		})
	}
}

func TestSampleRate(t *testing.T) {
	tests := []struct {
		SampleRate float64
		// tolerated range is [SampleRate-MaxDelta, SampleRate+MaxDelta]
		MaxDelta float64
	}{
		{0.00, 0.0},
		{0.25, 0.2},
		{0.50, 0.2},
		{0.75, 0.2},
		{1.00, 0.0},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(fmt.Sprint(tt.SampleRate), func(t *testing.T) {
			var (
				total   uint64
				sampled uint64
			)
			// Call sample from multiple goroutines sharing a client to uncover data races.
			var wg sync.WaitGroup
			for i := 0; i < 4; i++ {
				wg.Add(1)
				go func() {
					defer wg.Done()
					for j := 0; j < 10000; j++ {
						atomic.AddUint64(&total, 1)
						s := sample(tt.SampleRate)
						switch tt.SampleRate {
						case 0:
							if s {
								panic("sampled true when rate is 0")
							}
						case 1:
							if !s {
								panic("sampled false when rate is 1")
							}
						}
						if s {
							atomic.AddUint64(&sampled, 1)
						}
					}
				}()
			}
			wg.Wait()

			rate := float64(sampled) / float64(total)
			if !(tt.SampleRate-tt.MaxDelta <= rate && rate <= tt.SampleRate+tt.MaxDelta) {
				t.Errorf("effective sample rate was %f, want %f±%f", rate, tt.SampleRate, tt.MaxDelta)
			}
		})
	}
}
func TestClient_ParseOrgID(t *testing.T) {
	c, err := NewClient(ClientOptions{
		Dsn: "https://example@o1.ingest.us.sentry.io/1337",
	})
	if err != nil {
		t.Fatal(err)
	}
	assert.Equal(t, uint64(1), c.dsn.GetOrgID(), "Custom org id should override the DSN parsed one")
}

func TestClient_ParseOrgIDInvalid(t *testing.T) {
	c, err := NewClient(ClientOptions{
		// org id is MaxUint64 + 1, should be considered empty
		Dsn: "https://example@o18446744073709551616.ingest.us.sentry.io/1337",
	})
	if err != nil {
		t.Fatal(err)
	}
	assert.Equal(t, uint64(0), c.dsn.GetOrgID(), "Custom org id should override the DSN parsed one")
}

func TestClientOptions_OrgIDShouldOverrideParsed(t *testing.T) {
	c, err := NewClient(ClientOptions{
		Dsn:   "https://example@o1.ingest.us.sentry.io/1337",
		OrgID: 2,
	})
	if err != nil {
		t.Fatal(err)
	}
	assert.Equal(t, uint64(2), c.dsn.GetOrgID(), "Custom org id should override the DSN parsed one")
}

func BenchmarkProcessEvent(b *testing.B) {
	c, err := NewClient(ClientOptions{
		SampleRate: 0.25,
		Transport:  &MockTransport{},
	})
	if err != nil {
		b.Fatal(err)
	}
	for i := 0; i < b.N; i++ {
		c.CaptureEvent(context.Background(), &Event{})
	}
}

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{},
					},
				},
			},
		},
		{"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.Options{
			cmpopts.IgnoreFields(Event{}, "sdkMetaData", "serializedTags", "serializedContexts", "serializedBreadcrumbs", "serializedException", "serializedUser", "serializationSafe"),
			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()
			captureCtx := ContextWithClient(ContextWithScope(context.TODO(), scope), client)
			var called bool
			client.AddEventProcessor(func(event *Event, hint *EventHint) *Event {
				called = true
				if hint.Context != captureCtx {
					t.Fatal("unexpected context value")
				}
				return event
			})
			func() {
				defer Recover(captureCtx, nil)
				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")
			}
		})
	}
}

func TestNoopClientRecover(t *testing.T) {
	client := NewNoopClient()

	func() {
		defer func() {
			if recovered := recover(); recovered != nil {
				t.Fatalf("noop client did not recover panic: %v", recovered)
			}
		}()
		defer Recover(ContextWithClient(context.Background(), client), nil)
		panic("panic handled by noop client")
	}()
}

func TestCustomMaxSpansProperty(t *testing.T) {
	client, _, _ := setupClientTest()
	assertEqual(t, client.Options().MaxSpans, defaultMaxSpans)

	client.options.MaxSpans = 2000
	assertEqual(t, client.Options().MaxSpans, 2000)

	properClient, _ := NewClient(ClientOptions{
		MaxSpans:  3000,
		Transport: &MockTransport{},
	})

	assertEqual(t, properClient.Options().MaxSpans, 3000)
}

func TestSDKIdentifier(t *testing.T) {
	client, _, _ := setupClientTest()
	assertEqual(t, client.GetSDKIdentifier(), "sentry.go")

	client.SetSDKIdentifier("sentry.go.test")
	assertEqual(t, client.GetSDKIdentifier(), "sentry.go.test")
}

// wrappedTransport forwards to Transport, calling send instead of the wrapped
// SendEnvelope when set.
type wrappedTransport struct {
	Transport
	send func(context.Context, *protocol.Envelope) error
}

func (t *wrappedTransport) SendEnvelope(ctx context.Context, envelope *protocol.Envelope) error {
	if t.send != nil {
		return t.send(ctx, envelope)
	}
	return t.Transport.SendEnvelope(ctx, envelope)
}

func TestClientRoutesEventsByDelivery(t *testing.T) {
	for _, tt := range []struct {
		name     string
		inner    Transport
		buffered bool
	}{
		{"wrapped async is buffered", NewHTTPTransport(), true},
		{"custom transport is buffered", &NoopTransport{}, true},
	} {
		t.Run(tt.name, func(t *testing.T) {
			synctest.Test(t, func(t *testing.T) {
				release := make(chan struct{})
				gate := &wrappedTransport{Transport: tt.inner, send: func(ctx context.Context, envelope *protocol.Envelope) error {
					<-release
					return tt.inner.SendEnvelope(ctx, envelope)
				}}
				client, err := NewClient(ClientOptions{
					Dsn:       testDsn,
					Transport: gate,
					HTTPClient: &http.Client{Transport: roundTripperFunc(func(*http.Request) (*http.Response, error) {
						return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
					})},
				})
				require.NoError(t, err)
				var returned atomic.Bool
				go func() {
					client.CaptureMessage(context.Background(), "message")
					returned.Store(true)
				}()
				synctest.Wait()
				// Buffered captures return while the worker waits on the transport.
				require.Equal(t, tt.buffered, returned.Load())
				close(release)
				client.Close()
			})
		})
	}
}

func TestClientSetsUpTransport(t *testing.T) {
	for _, tt := range []struct {
		name      string
		transport Transport
		blocking  bool
	}{
		{"default", nil, false},
		{"async", NewHTTPTransport(), false},
		{"sync", NewHTTPSyncTransport(), true},
		{"wrapped sync", &wrappedTransport{Transport: NewHTTPSyncTransport()}, true},
	} {
		t.Run(tt.name, func(t *testing.T) {
			synctest.Test(t, func(t *testing.T) {
				release := make(chan struct{})
				unblock := sync.OnceFunc(func() { close(release) })
				var requests, captures atomic.Int32
				client, err := NewClient(ClientOptions{
					Dsn:       testDsn,
					Transport: tt.transport,
					HTTPClient: &http.Client{Transport: roundTripperFunc(func(*http.Request) (*http.Response, error) {
						requests.Add(1)
						<-release
						return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
					})},
					HTTPTransport: roundTripperFunc(func(*http.Request) (*http.Response, error) {
						t.Error("HTTPClient must take precedence over HTTPTransport")
						return nil, errors.New("unexpected request")
					}),
				})
				require.NoError(t, err)
				defer func() { unblock(); client.Close() }()
				ctx, _ := WithScope(ContextWithClient(context.Background(), client))
				go func() {
					assert.NotNil(t, client.CaptureMessage(ctx, "inline capture"))
					captures.Add(1)
				}()
				synctest.Wait()
				require.EqualValues(t, 1, requests.Load())
				require.Equal(t, !tt.blocking, captures.Load() == 1)
				unblock()
				synctest.Wait()
				require.EqualValues(t, 1, captures.Load())

				NewLogger(ctx).Info().Emit("batched log")
				NewMeter(ctx).Count("batched.metric", 1)
				synctest.Wait()
				require.EqualValues(t, 1, requests.Load(), "partial batches stay buffered with every transport")
				require.True(t, client.Flush(testutils.FlushTimeout()))
				require.EqualValues(t, 3, requests.Load())
			})
		})
	}
}

type namedIntegration struct{ name string }

func (n *namedIntegration) Name() string        { return n.name }
func (n *namedIntegration) SetupOnce(_ *Client) {}

func TestTelemetryEnvelopeCarriesIntegrations(t *testing.T) {
	var (
		mu     sync.Mutex
		bodies [][]byte
	)
	requestReceived := make(chan struct{}, 1)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		b, err := io.ReadAll(r.Body)
		require.NoError(t, err)
		mu.Lock()
		bodies = append(bodies, b)
		mu.Unlock()
		w.WriteHeader(http.StatusOK)
		select {
		case requestReceived <- struct{}{}:
		default:
		}
	}))
	defer srv.Close()

	dsn := strings.Replace(srv.URL, "//", "//pubkey@", 1) + "/1"
	client, err := NewClient(ClientOptions{
		Dsn: dsn,
		Integrations: func(defaults []Integration) []Integration {
			return append(defaults, &namedIntegration{name: "CustomRegressionIntegration"})
		},
	})
	require.NoError(t, err)
	t.Cleanup(func() { client.Close() })

	client.CaptureMessage(context.Background(), "ping")
	require.True(t, client.Flush(testutils.FlushTimeout()), "flush timed out")

	select {
	case <-requestReceived:
	case <-time.After(testutils.FlushTimeout()):
		t.Fatal("server never received an envelope")
	}

	mu.Lock()
	require.NotEmpty(t, bodies, "expected at least one envelope to be sent")
	body := bodies[0]
	mu.Unlock()
	nl := bytes.IndexByte(body, '\n')
	require.Positive(t, nl, "envelope body missing header newline")
	var header struct {
		Sdk struct {
			Name         string   `json:"name"`
			Integrations []string `json:"integrations"`
		} `json:"sdk"`
	}
	require.NoError(t, json.Unmarshal(body[:nl], &header))

	assert.Equal(t, sdkIdentifier, header.Sdk.Name)
	assert.Contains(t, header.Sdk.Integrations, "CustomRegressionIntegration")
}

func TestClient_SetupTelemetryBuffer_NoDSN(t *testing.T) {
	var buf bytes.Buffer
	debuglog.SetOutput(&buf)
	defer debuglog.SetOutput(&bytes.Buffer{})

	client, err := NewClient(ClientOptions{})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if client.telemetryProcessor == nil {
		t.Fatal("expected telemetryProcessor to not be nil when DSN is missing")
	}
	require.IsType(t, &NoopTransport{}, client.Transport)
	t.Cleanup(client.Close)
}

type multiClientEnv struct {
	client1, client2       *Client
	transport1, transport2 *MockTransport
	ctx1, ctx2             context.Context
	traceID1, traceID2     TraceID
}

func setupMultiClientEnv(t *testing.T) *multiClientEnv {
	t.Helper()
	mkClient := func(dsn, release string) (*Client, *MockTransport) {
		tr := &MockTransport{}
		c, err := NewClient(ClientOptions{
			Dsn:       dsn,
			Release:   release,
			Transport: tr,
			Integrations: func(_ []Integration) []Integration {
				return []Integration{}
			},
		})
		require.NoError(t, err)
		return c, tr
	}

	e := &multiClientEnv{}
	e.client1, e.transport1 = mkClient("https://public@example.com/sentry/1", "release-1")
	e.client2, e.transport2 = mkClient("https://public@example.com/sentry/2", "release-2")
	e.traceID1 = TraceIDFromHex("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1")
	e.traceID2 = TraceIDFromHex("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2")

	var scope1 *Scope
	e.ctx1, scope1 = WithScope(context.Background())
	e.ctx1 = ContextWithClient(e.ctx1, e.client1)
	scope1.SetPropagationContext(PropagationContext{TraceID: e.traceID1})
	var scope2 *Scope
	e.ctx2, scope2 = WithScope(context.Background())
	e.ctx2 = ContextWithClient(e.ctx2, e.client2)
	scope2.SetPropagationContext(PropagationContext{TraceID: e.traceID2})

	t.Cleanup(func() {
		e.client1.Close()
		e.client2.Close()
	})
	return e
}

func (e *multiClientEnv) resetTransports() {
	e.transport1.mu.Lock()
	e.transport1.events = nil
	e.transport1.mu.Unlock()
	e.transport2.mu.Lock()
	e.transport2.events = nil
	e.transport2.mu.Unlock()
}

func (e *multiClientEnv) flushAll() {
	e.client1.Flush(5 * time.Second)
	e.client2.Flush(5 * time.Second)
}

func eventTraceID(t *testing.T, ev *Event) TraceID {
	t.Helper()
	traceCtx, ok := ev.Contexts["trace"]
	require.True(t, ok, "event should have a trace context")
	tid, ok := traceCtx["trace_id"].(string)
	require.True(t, ok, "trace context should contain a trace ID string")
	return TraceIDFromHex(tid)
}

func TestClient_MultiClientSetup(t *testing.T) {
	t.Run("signals_route_to_correct_client", func(t *testing.T) {
		e := setupMultiClientEnv(t)

		e.client1.CaptureMessage(e.ctx1, "msg-from-client1")
		e.client2.CaptureMessage(e.ctx2, "msg-from-client2")

		require.Len(t, e.transport1.Events(), 1)
		require.Len(t, e.transport2.Events(), 1)
		assert.Equal(t, "msg-from-client1", e.transport1.Events()[0].Message)
		assert.Equal(t, "msg-from-client2", e.transport2.Events()[0].Message)
		assert.Equal(t, e.traceID1, eventTraceID(t, e.transport1.Events()[0]),
			"event on client1 should carry scope1's trace ID")
		assert.Equal(t, e.traceID2, eventTraceID(t, e.transport2.Events()[0]),
			"event on client2 should carry scope2's trace ID")
		e.resetTransports()

		NewLogger(e.ctx1).Info().WithCtx(e.ctx1).Emit("log-from-client1")
		NewLogger(e.ctx2).Info().WithCtx(e.ctx2).Emit("log-from-client2")
		e.flushAll()

		require.Len(t, e.transport1.Events(), 1, "client1 transport should have 1 log event")
		require.Len(t, e.transport2.Events(), 1, "client2 transport should have 1 log event")
		require.Len(t, e.transport1.Events()[0].Logs, 1)
		require.Len(t, e.transport2.Events()[0].Logs, 1)
		assert.Equal(t, "log-from-client1", e.transport1.Events()[0].Logs[0].Body)
		assert.Equal(t, "log-from-client2", e.transport2.Events()[0].Logs[0].Body)
		assert.Equal(t, e.traceID1, e.transport1.Events()[0].Logs[0].TraceID,
			"log on client1 should carry scope1's trace ID")
		assert.Equal(t, e.traceID2, e.transport2.Events()[0].Logs[0].TraceID,
			"log on client2 should carry scope2's trace ID")
		e.resetTransports()

		NewMeter(e.ctx1).Count("counter-from-client1", 1)
		NewMeter(e.ctx2).Count("counter-from-client2", 2)
		e.flushAll()

		require.Len(t, e.transport1.Events(), 1, "client1 transport should have 1 metric event")
		require.Len(t, e.transport2.Events(), 1, "client2 transport should have 1 metric event")
		require.Len(t, e.transport1.Events()[0].Metrics, 1)
		require.Len(t, e.transport2.Events()[0].Metrics, 1)
		assert.Equal(t, "counter-from-client1", e.transport1.Events()[0].Metrics[0].Name)
		assert.Equal(t, "counter-from-client2", e.transport2.Events()[0].Metrics[0].Name)
	})

	t.Run("signals_respect_emit_context_client", func(t *testing.T) {
		for _, test := range []struct {
			name    string
			derived bool
		}{
			{name: "unrelated context"},
			{name: "derived context", derived: true},
		} {
			t.Run(test.name, func(t *testing.T) {
				e := setupMultiClientEnv(t)
				logger := NewLogger(e.ctx1)
				meter := NewMeter(e.ctx1)
				emitCtx, wantTraceID := e.ctx2, e.traceID2
				if test.derived {
					emitCtx = ContextWithClient(e.ctx1, e.client2)
					wantTraceID = e.traceID1
					assert.Same(t, ScopeFromContext(e.ctx1), ScopeFromContext(emitCtx))
				}
				logger.Info().WithCtx(emitCtx).Emit("cross-context-log")
				meter.WithCtx(emitCtx).Count("cross-context-count", 1)
				e.flushAll()

				assert.Empty(t, e.transport1.Events(), "creation-time client should not receive the signals")
				events := e.transport2.Events()
				slices.SortFunc(events, func(a, b *Event) int { return strings.Compare(a.Type, b.Type) })
				require.Len(t, events, 2, "emit-context client should receive the signals")
				require.Len(t, events[0].Logs, 1)
				require.Len(t, events[1].Metrics, 1)
				assert.Equal(t, "cross-context-log", events[0].Logs[0].Body)
				assert.Equal(t, "cross-context-count", events[1].Metrics[0].Name)
				assert.Equal(t, wantTraceID, events[0].Logs[0].TraceID)
				assert.Equal(t, wantTraceID, events[1].Metrics[0].TraceID)
				assert.Equal(t, "release-2", events[0].Logs[0].Attributes["sentry.release"].AsString())
				assert.Equal(t, "release-2", events[1].Metrics[0].Attributes["sentry.release"].AsString())
			})
		}
	})

	t.Run("signals_created_without_client_can_use_emit_context", func(t *testing.T) {
		e := setupMultiClientEnv(t)
		disabledCtx := ContextWithClient(context.Background(), NewNoopClient())
		logger := NewLogger(disabledCtx)
		meter := NewMeter(disabledCtx)

		logger.Info().WithCtx(e.ctx2).Emit("enabled-context-log")
		meter.WithCtx(e.ctx2).Count("enabled-context-count", 1)
		NewLogger(e.ctx2).Info().WithCtx(disabledCtx).Emit("suppressed")
		NewMeter(e.ctx2).WithCtx(disabledCtx).Count("suppressed", 1)
		e.flushAll()

		assert.Empty(t, e.transport1.Events())
		require.Len(t, e.transport2.Events(), 2)
	})

	t.Run("signals_use_creation_context_as_fallback", func(t *testing.T) {
		e := setupMultiClientEnv(t)
		logger := NewLogger(e.ctx1)
		meter := NewMeter(e.ctx1)

		logger.Info().WithCtx(context.TODO()).Emit("fallback-context-log")
		meter.WithCtx(context.TODO()).Count("fallback-context-count", 1)
		e.flushAll()

		events := e.transport1.Events()
		slices.SortFunc(events, func(a, b *Event) int { return strings.Compare(a.Type, b.Type) })
		require.Len(t, events, 2)
		assert.Empty(t, e.transport2.Events())
		assert.Equal(t, e.traceID1, events[0].Logs[0].TraceID)
		assert.Equal(t, e.traceID1, events[1].Metrics[0].TraceID)
	})
	t.Run("explicit client owns the transaction and concurrent DSC", func(t *testing.T) {
		creator, creatorTransport := newCaptureTestClient(t, ClientOptions{EnableTracing: true, TracesSampleRate: 1, Release: "creator"})
		override, overrideTransport := newCaptureTestClient(t, ClientOptions{EnableTracing: true, TracesSampleRate: 1, Release: "override"})
		ctx, _ := WithScope(ContextWithClient(context.Background(), creator))
		root := StartTransaction(ctx, "root")
		child := StartSpan(ContextWithClient(root.Context(), override), "child")
		var wg sync.WaitGroup
		headers := make(chan string, 16)
		for range 16 {
			wg.Add(1)
			go func() {
				defer wg.Done()
				headers <- child.ToBaggage()
				CaptureMessage(child.Context(), "capture")
			}()
		}
		wg.Wait()
		close(headers)
		want := DynamicSamplingContextFromTransaction(root)
		require.Equal(t, "creator", want.Entries["release"])
		for header := range headers {
			got, err := DynamicSamplingContextFromHeader([]byte(header))
			require.NoError(t, err)
			require.Equal(t, want, got)
		}
		require.Len(t, overrideTransport.Events(), 16)
		for _, event := range overrideTransport.Events() {
			require.Equal(t, want.Entries, event.sdkMetaData.dsc.Entries)
		}
		child.Finish()
		root.Finish()
		require.Len(t, creatorTransport.Events(), 1)
		require.Equal(t, transactionType, creatorTransport.Events()[0].Type)
		require.Equal(t, want.Entries, creatorTransport.Events()[0].sdkMetaData.dsc.Entries)
	})
	t.Run("unbound transaction follows later Init with frozen DSC", func(t *testing.T) {
		previousClient := globalClientSnapshot()
		t.Cleanup(func() {
			setGlobalClient(previousClient)
		})
		initClient := func(release string, transport *MockTransport) {
			require.NoError(t, Init(ClientOptions{
				EnableTracing: true, TracesSampleRate: 1, Release: release,
				Transport: transport, Integrations: func([]Integration) []Integration { return nil },
			}))
			t.Cleanup(globalClientSnapshot().Close)
		}
		first, second := &MockTransport{}, &MockTransport{}
		initClient("first", first)
		ctx := ContextWithScope(context.Background(), NewScope())
		root := StartTransaction(ctx, "unbound")
		frozen := root.ToBaggage()
		require.Contains(t, frozen, "sentry-release=first")
		frozenDSC, err := DynamicSamplingContextFromHeader([]byte(frozen))
		require.NoError(t, err)
		initClient("second", second)
		root.Finish()
		assert.Empty(t, first.Events())
		events := second.Events()
		require.Len(t, events, 1)
		assert.Equal(t, transactionType, events[0].Type)
		assert.Equal(t, frozenDSC.Entries, events[0].sdkMetaData.dsc.Entries)
	})
}