Method TestRelayContextCollisionTracing

stats/opentelemetry/e2e_test.go:2406–2471

TestRelayContextCollisionTracing verifies that span context is correctly propagated from incoming server requests to outgoing client requests without the client span accidentally adopting the server's identity or breaking the trace chain.

(t *testing.T)

// the client span accidentally adopting the server's identity or breaking the
// trace chain.
func (s) TestRelayContextCollisionTracing(t *testing.T) {
	backendTraceOpts, _ := defaultTraceOptions(t)
	backendServer := setupStubServer(t, nil, backendTraceOpts)
	backendServer.EmptyCallF = func(_ context.Context, _ *testpb.Empty) (*testpb.Empty, error) {
		return nil, status.Error(codes.Unimplemented, "EmptyCall not implemented")
	}
	defer backendServer.Stop()

	relayTraceOpts, relayTraceExporter := defaultTraceOptions(t)
	otelOpts := opentelemetry.Options{TraceOptions: *relayTraceOpts}

	relayServer := &stubserver.StubServer{
		UnaryCallF: func(ctx context.Context, _ *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
			relayCC, err := grpc.NewClient(
				backendServer.Address,
				grpc.WithTransportCredentials(insecure.NewCredentials()),
				opentelemetry.DialOption(otelOpts),
			)
			if err != nil {
				return nil, fmt.Errorf("failed to create relay client: %v", err)
			}
			defer relayCC.Close()
			client := testgrpc.NewTestServiceClient(relayCC)
			_, err = client.EmptyCall(ctx, &testpb.Empty{})
			if status.Code(err) != codes.Unimplemented {
				t.Errorf("Expected Unimplemented error, got: %v", err)
			}
			return &testpb.SimpleResponse{}, nil
		},
	}
	if err := relayServer.Start([]grpc.ServerOption{opentelemetry.ServerOption(otelOpts)}, opentelemetry.DialOption(otelOpts)); err != nil {
		t.Fatalf("Failed to start relay server: %v", err)
	}
	defer relayServer.Stop()

	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
	defer cancel()

	_, _ = relayServer.Client.UnaryCall(ctx, &testpb.SimpleRequest{})

	wantSpans := []traceSpanInfo{
		{name: "Recv.", spanKind: "server"},
		{name: "Sent.grpc.testing.TestService.EmptyCall", spanKind: "client"},
	}
	spans, err := waitForTraceSpans(ctx, relayTraceExporter, wantSpans)
	if err != nil {
		t.Fatalf("Failed to wait for spans: %v", err)
	}

	var srvTraceID, cliTraceID oteltrace.TraceID
	for _, span := range spans {
		if span.Name == "Recv." && span.SpanKind == oteltrace.SpanKindServer {
			srvTraceID = span.SpanContext.TraceID()
		}
		if span.Name == "Sent.grpc.testing.TestService.EmptyCall" && span.SpanKind == oteltrace.SpanKindClient {
			cliTraceID = span.SpanContext.TraceID()
		}
	}