Method TestRelayContextCollisionMetrics

stats/opentelemetry/e2e_test.go:2349–2400

TestRelayContextCollisionMetrics verifies that when an application acts as both a server and a client using the same context, the client metrics do not inherit or overwrite the server's telemetry metadata (e.g., grpc.method).

(t *testing.T)

// both a server and a client using the same context, the client metrics do not
// inherit or overwrite the server's telemetry metadata (e.g., grpc.method).
func (s) TestRelayContextCollisionMetrics(t *testing.T) {
	backendMetricsOpts, _ := defaultMetricsOptions(t, nil)
	backendServer := setupStubServer(t, backendMetricsOpts, nil)
	backendServer.EmptyCallF = func(_ context.Context, _ *testpb.Empty) (*testpb.Empty, error) {
		return nil, status.Error(codes.Unimplemented, "EmptyCall not implemented")
	}
	defer backendServer.Stop()

	relayMetricsOpts, relayMetricsReader := defaultMetricsOptions(t, nil)
	otelOpts := opentelemetry.Options{MetricsOptions: *relayMetricsOpts}

	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()

	if _, err := relayServer.Client.UnaryCall(ctx, &testpb.SimpleRequest{}); err != nil {
		t.Fatalf("Unexpected UnaryCall error: %v", err)
	}

	// Verify Server Metric Identity is retained.
	if err := checkMetricWithMethod(ctx, relayMetricsReader, "grpc.server.call.started", "grpc.testing.TestService/UnaryCall"); err != nil {
		t.Fatal(err)
	}

	// Verify Client Metric Identity correctly resolved to "grpc.testing.TestService/EmptyCall".
	if err := checkMetricWithMethod(ctx, relayMetricsReader, "grpc.client.attempt.started", "grpc.testing.TestService/EmptyCall"); err != nil {
		t.Fatal(err)
	}
}

// TestRelayContextCollisionTracing verifies that span context is correctly
// propagated from incoming server requests to outgoing client requests without