stats/opentelemetry: fix flaky TestTraceSpan_WithRetriesAndNameResolutionDelay

This commit fixes the flaky test TestTraceSpan_WithRetriesAndNameResolutionDelay
which was introduced in the previous commit and caused PR #8342 to be reverted.

Root Cause:
The test had race conditions related to timing:
1. The goroutine that updates resolver state could complete before or after
   the delayed resolution event was fully processed and recorded in spans
2. Span export timing was not synchronized with test validation, causing
   the test to sometimes check spans before they were fully exported

Fix:
1. Added 'stateUpdated' event to synchronize between the resolver state
   update completing and span validation beginning
2. Added explicit wait for the stateUpdated event before validating spans
3. Added a 50ms sleep after RPC completion to give the span exporter time
   to process and export all spans before validation

Testing:
- Test now passes consistently (10+ consecutive runs)
- Passes with race detector enabled (-race flag)
- No data races detected

Fixes #8700

Author: ulascansenturk

stats/opentelemetry/e2e_test.go

@@ -1704,6 +1704,7 @@ func (s) TestTraceSpan_WithRetriesAndNameResolutionDelay(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			resolutionWait := grpcsync.NewEvent()
+			stateUpdated := grpcsync.NewEvent()
 			prevHook := internal.NewStreamWaitingForResolver
 			internal.NewStreamWaitingForResolver = func() { resolutionWait.Fire() }
 			defer func() { internal.NewStreamWaitingForResolver = prevHook }()
@@ -1746,13 +1747,32 @@ func (s) TestTraceSpan_WithRetriesAndNameResolutionDelay(t *testing.T) {
 			ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
 			defer cancel()
 
+			// Start the goroutine that will update resolver state once the stream
+			// is waiting for resolution. Use stateUpdated event to ensure the
+			// resolver state is updated before we start validating spans.
 			go func() {
 				<-resolutionWait.Done()
 				rb.UpdateState(resolver.State{Addresses: []resolver.Address{{Addr: ss.Address}}})
+				stateUpdated.Fire()
 			}()
+
 			if err := tt.doCall(ctx, client); err != nil {
 				t.Fatalf("%s call failed: %v", tt.name, err)
 			}
+
+			// Wait for the resolver state to be updated to ensure the delayed
+			// resolution event has been processed.
+			select {
+			case <-stateUpdated.Done():
+			case <-ctx.Done():
+				t.Fatal("Timed out waiting for resolver state update")
+			}
+
+			// Give the span exporter a small amount of time to process and export
+			// all spans from the completed RPC. This reduces flakiness by ensuring
+			// all trace events have been fully recorded before validation.
+			time.Sleep(50 * time.Millisecond)
+
 			spans, err := waitForTraceSpans(ctx, exporter, tt.wantSpanInfos)
 			if err != nil {
 				t.Fatal(err)