snapshot of https://github.com/grpc/grpc-go.git (master, 2026-09-15; blobs > 131072B omitted)

2026-09-15 20:40:15 +05:00
commit e241b33f26
1365 changed files with 339570 additions and 0 deletions
--- a/interop/stress/client/main.go
+++ b/interop/stress/client/main.go
@@ -0,0 +1,364 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// client starts an interop client to do stress test and a metrics server to report qps.
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	rand "math/rand/v2"
+	"net"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/google"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/interop"
+	"google.golang.org/grpc/resolver"
+	"google.golang.org/grpc/status"
+	"google.golang.org/grpc/testdata"
+
+	_ "google.golang.org/grpc/xds/googledirectpath" // Register xDS resolver required for c2p directpath.
+
+	testgrpc "google.golang.org/grpc/interop/grpc_testing"
+	metricspb "google.golang.org/grpc/interop/stress/grpc_testing"
+)
+
+const (
+	googleDefaultCredsName = "google_default_credentials"
+	computeEngineCredsName = "compute_engine_channel_creds"
+)
+
+var (
+	serverAddresses       = flag.String("server_addresses", "localhost:8080", "a list of server addresses")
+	testCases             = flag.String("test_cases", "", "a list of test cases along with the relative weights")
+	testDurationSecs      = flag.Int("test_duration_secs", -1, "test duration in seconds")
+	numChannelsPerServer  = flag.Int("num_channels_per_server", 1, "Number of channels (i.e connections) to each server")
+	numStubsPerChannel    = flag.Int("num_stubs_per_channel", 1, "Number of client stubs per each connection to server")
+	metricsPort           = flag.Int("metrics_port", 8081, "The port at which the stress client exposes QPS metrics")
+	useTLS                = flag.Bool("use_tls", false, "Connection uses TLS if true, else plain TCP")
+	testCA                = flag.Bool("use_test_ca", false, "Whether to replace platform root CAs with test CA as the CA root")
+	tlsServerName         = flag.String("server_host_override", "foo.test.google.fr", "The server name use to verify the hostname returned by TLS handshake if it is not empty. Otherwise, --server_host is used.")
+	caFile                = flag.String("ca_file", "", "The file containing the CA root cert file")
+	customCredentialsType = flag.String("custom_credentials_type", "", "Custom credentials type to use")
+
+	totalNumCalls int64
+	logger        = grpclog.Component("stress")
+)
+
+// testCaseWithWeight contains the test case type and its weight.
+type testCaseWithWeight struct {
+	name   string
+	weight int
+}
+
+// parseTestCases converts test case string to a list of struct testCaseWithWeight.
+func parseTestCases(testCaseString string) []testCaseWithWeight {
+	testCaseStrings := strings.Split(testCaseString, ",")
+	testCases := make([]testCaseWithWeight, len(testCaseStrings))
+	for i, str := range testCaseStrings {
+		testCaseNameAndWeight := strings.Split(str, ":")
+		if len(testCaseNameAndWeight) != 2 {
+			panic(fmt.Sprintf("invalid test case with weight: %s", str))
+		}
+		// Check if test case is supported.
+		testCaseName := strings.ToLower(testCaseNameAndWeight[0])
+		switch testCaseName {
+		case
+			"empty_unary",
+			"large_unary",
+			"client_streaming",
+			"server_streaming",
+			"ping_pong",
+			"empty_stream",
+			"timeout_on_sleeping_server",
+			"cancel_after_begin",
+			"cancel_after_first_response",
+			"status_code_and_message",
+			"custom_metadata":
+		default:
+			panic(fmt.Sprintf("unknown test type: %s", testCaseNameAndWeight[0]))
+		}
+		testCases[i].name = testCaseName
+		w, err := strconv.Atoi(testCaseNameAndWeight[1])
+		if err != nil {
+			panic(fmt.Sprintf("%v", err))
+		}
+		testCases[i].weight = w
+	}
+	return testCases
+}
+
+// weightedRandomTestSelector defines a weighted random selector for test case types.
+type weightedRandomTestSelector struct {
+	tests       []testCaseWithWeight
+	totalWeight int
+}
+
+// newWeightedRandomTestSelector constructs a weightedRandomTestSelector with the given list of testCaseWithWeight.
+func newWeightedRandomTestSelector(tests []testCaseWithWeight) *weightedRandomTestSelector {
+	var totalWeight int
+	for _, t := range tests {
+		totalWeight += t.weight
+	}
+	return &weightedRandomTestSelector{tests, totalWeight}
+}
+
+func (selector weightedRandomTestSelector) getNextTest() string {
+	random := rand.IntN(selector.totalWeight)
+	var weightSofar int
+	for _, test := range selector.tests {
+		weightSofar += test.weight
+		if random < weightSofar {
+			return test.name
+		}
+	}
+	panic("no test case selected by weightedRandomTestSelector")
+}
+
+// gauge stores the qps of one interop client (one stub).
+type gauge struct {
+	mutex sync.RWMutex
+	val   int64
+}
+
+func (g *gauge) set(v int64) {
+	g.mutex.Lock()
+	defer g.mutex.Unlock()
+	g.val = v
+}
+
+func (g *gauge) get() int64 {
+	g.mutex.RLock()
+	defer g.mutex.RUnlock()
+	return g.val
+}
+
+// server implements metrics server functions.
+type server struct {
+	metricspb.UnimplementedMetricsServiceServer
+	mutex sync.RWMutex
+	// gauges is a map from /stress_test/server_<n>/channel_<n>/stub_<n>/qps to its qps gauge.
+	gauges map[string]*gauge
+}
+
+// newMetricsServer returns a new metrics server.
+func newMetricsServer() *server {
+	return &server{gauges: make(map[string]*gauge)}
+}
+
+// GetAllGauges returns all gauges.
+func (s *server) GetAllGauges(_ *metricspb.EmptyMessage, stream metricspb.MetricsService_GetAllGaugesServer) error {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+
+	for name, gauge := range s.gauges {
+		if err := stream.Send(&metricspb.GaugeResponse{Name: name, Value: &metricspb.GaugeResponse_LongValue{LongValue: gauge.get()}}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetGauge returns the gauge for the given name.
+func (s *server) GetGauge(_ context.Context, in *metricspb.GaugeRequest) (*metricspb.GaugeResponse, error) {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+
+	if g, ok := s.gauges[in.Name]; ok {
+		return &metricspb.GaugeResponse{Name: in.Name, Value: &metricspb.GaugeResponse_LongValue{LongValue: g.get()}}, nil
+	}
+	return nil, status.Errorf(codes.InvalidArgument, "gauge with name %s not found", in.Name)
+}
+
+// createGauge creates a gauge using the given name in metrics server.
+func (s *server) createGauge(name string) *gauge {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	if _, ok := s.gauges[name]; ok {
+		// gauge already exists.
+		panic(fmt.Sprintf("gauge %s already exists", name))
+	}
+	var g gauge
+	s.gauges[name] = &g
+	return &g
+}
+
+func startServer(server *server, port int) {
+	lis, err := net.Listen("tcp", ":"+strconv.Itoa(port))
+	if err != nil {
+		logger.Fatalf("failed to listen: %v", err)
+	}
+
+	s := grpc.NewServer()
+	metricspb.RegisterMetricsServiceServer(s, server)
+	s.Serve(lis)
+}
+
+// performRPCs uses weightedRandomTestSelector to select test case and runs the tests.
+func performRPCs(gauge *gauge, conn *grpc.ClientConn, selector *weightedRandomTestSelector, stop <-chan bool) {
+	client := testgrpc.NewTestServiceClient(conn)
+	var numCalls int64
+	ctx := context.Background()
+	startTime := time.Now()
+	for {
+		test := selector.getNextTest()
+		switch test {
+		case "empty_unary":
+			interop.DoEmptyUnaryCall(ctx, client)
+		case "large_unary":
+			interop.DoLargeUnaryCall(ctx, client)
+		case "client_streaming":
+			interop.DoClientStreaming(ctx, client)
+		case "server_streaming":
+			interop.DoServerStreaming(ctx, client)
+		case "ping_pong":
+			interop.DoPingPong(ctx, client)
+		case "empty_stream":
+			interop.DoEmptyStream(ctx, client)
+		case "timeout_on_sleeping_server":
+			interop.DoTimeoutOnSleepingServer(ctx, client)
+		case "cancel_after_begin":
+			interop.DoCancelAfterBegin(ctx, client)
+		case "cancel_after_first_response":
+			interop.DoCancelAfterFirstResponse(ctx, client)
+		case "status_code_and_message":
+			interop.DoStatusCodeAndMessage(ctx, client)
+		case "custom_metadata":
+			interop.DoCustomMetadata(ctx, client)
+		}
+		numCalls++
+		defer func() { atomic.AddInt64(&totalNumCalls, numCalls) }()
+		gauge.set(int64(float64(numCalls) / time.Since(startTime).Seconds()))
+
+		select {
+		case <-stop:
+			return
+		default:
+		}
+	}
+}
+
+func logParameterInfo(addresses []string, tests []testCaseWithWeight) {
+	logger.Infof("server_addresses: %s", *serverAddresses)
+	logger.Infof("test_cases: %s", *testCases)
+	logger.Infof("test_duration_secs: %d", *testDurationSecs)
+	logger.Infof("num_channels_per_server: %d", *numChannelsPerServer)
+	logger.Infof("num_stubs_per_channel: %d", *numStubsPerChannel)
+	logger.Infof("metrics_port: %d", *metricsPort)
+	logger.Infof("use_tls: %t", *useTLS)
+	logger.Infof("use_test_ca: %t", *testCA)
+	logger.Infof("server_host_override: %s", *tlsServerName)
+	logger.Infof("custom_credentials_type: %s", *customCredentialsType)
+
+	logger.Infoln("addresses:")
+	for i, addr := range addresses {
+		logger.Infof("%d. %s\n", i+1, addr)
+	}
+	logger.Infoln("tests:")
+	for i, test := range tests {
+		logger.Infof("%d. %v\n", i+1, test)
+	}
+}
+
+func newConn(address string, useTLS, testCA bool, tlsServerName string) (*grpc.ClientConn, error) {
+	var opts []grpc.DialOption
+	if *customCredentialsType != "" {
+		if *customCredentialsType == googleDefaultCredsName {
+			opts = append(opts, grpc.WithCredentialsBundle(google.NewDefaultCredentials()))
+		} else if *customCredentialsType == computeEngineCredsName {
+			opts = append(opts, grpc.WithCredentialsBundle(google.NewComputeEngineCredentials()))
+		} else {
+			logger.Fatalf("Unknown custom credentials: %v", *customCredentialsType)
+		}
+	} else if useTLS {
+		var sn string
+		if tlsServerName != "" {
+			sn = tlsServerName
+		}
+		var creds credentials.TransportCredentials
+		if testCA {
+			var err error
+			if *caFile == "" {
+				*caFile = testdata.Path("x509/server_ca_cert.pem")
+			}
+			creds, err = credentials.NewClientTLSFromFile(*caFile, sn)
+			if err != nil {
+				logger.Fatalf("Failed to create TLS credentials: %v", err)
+			}
+		} else {
+			creds = credentials.NewClientTLSFromCert(nil, sn)
+		}
+		opts = append(opts, grpc.WithTransportCredentials(creds))
+	} else {
+		opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	}
+	return grpc.NewClient(address, opts...)
+}
+
+func main() {
+	flag.Parse()
+	resolver.SetDefaultScheme("dns")
+	addresses := strings.Split(*serverAddresses, ",")
+	tests := parseTestCases(*testCases)
+	logParameterInfo(addresses, tests)
+	testSelector := newWeightedRandomTestSelector(tests)
+	metricsServer := newMetricsServer()
+
+	var wg sync.WaitGroup
+	wg.Add(len(addresses) * *numChannelsPerServer * *numStubsPerChannel)
+	stop := make(chan bool)
+
+	for serverIndex, address := range addresses {
+		for connIndex := 0; connIndex < *numChannelsPerServer; connIndex++ {
+			conn, err := newConn(address, *useTLS, *testCA, *tlsServerName)
+			if err != nil {
+				logger.Fatalf("Fail to dial: %v", err)
+			}
+			defer conn.Close()
+			for clientIndex := 0; clientIndex < *numStubsPerChannel; clientIndex++ {
+				name := fmt.Sprintf("/stress_test/server_%d/channel_%d/stub_%d/qps", serverIndex+1, connIndex+1, clientIndex+1)
+				go func() {
+					defer wg.Done()
+					g := metricsServer.createGauge(name)
+					performRPCs(g, conn, testSelector, stop)
+				}()
+			}
+
+		}
+	}
+	go startServer(metricsServer, *metricsPort)
+	if *testDurationSecs > 0 {
+		time.Sleep(time.Duration(*testDurationSecs) * time.Second)
+		close(stop)
+	}
+	wg.Wait()
+	fmt.Fprintf(os.Stdout, "Total calls made: %v\n", totalNumCalls)
+	logger.Infof(" ===== ALL DONE ===== ")
+}
--- a/interop/stress/grpc_testing/metrics.pb.go
+++ b/interop/stress/grpc_testing/metrics.pb.go
@@ -0,0 +1,309 @@
+// Copyright 2015-2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Contains the definitions for a metrics service and the type of metrics
+// exposed by the service.
+//
+// Currently, 'Gauge' (i.e a metric that represents the measured value of
+// something at an instant of time) is the only metric type supported by the
+// service.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.12
+// 	protoc        v5.27.1
+// source: interop/stress/grpc_testing/metrics.proto
+
+package grpc_testing
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// Response message containing the gauge name and value
+type GaugeResponse struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	Name  string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	// Types that are valid to be assigned to Value:
+	//
+	//	*GaugeResponse_LongValue
+	//	*GaugeResponse_DoubleValue
+	//	*GaugeResponse_StringValue
+	Value         isGaugeResponse_Value `protobuf_oneof:"value"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GaugeResponse) Reset() {
+	*x = GaugeResponse{}
+	mi := &file_interop_stress_grpc_testing_metrics_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GaugeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GaugeResponse) ProtoMessage() {}
+
+func (x *GaugeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_interop_stress_grpc_testing_metrics_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GaugeResponse.ProtoReflect.Descriptor instead.
+func (*GaugeResponse) Descriptor() ([]byte, []int) {
+	return file_interop_stress_grpc_testing_metrics_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GaugeResponse) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *GaugeResponse) GetValue() isGaugeResponse_Value {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+func (x *GaugeResponse) GetLongValue() int64 {
+	if x != nil {
+		if x, ok := x.Value.(*GaugeResponse_LongValue); ok {
+			return x.LongValue
+		}
+	}
+	return 0
+}
+
+func (x *GaugeResponse) GetDoubleValue() float64 {
+	if x != nil {
+		if x, ok := x.Value.(*GaugeResponse_DoubleValue); ok {
+			return x.DoubleValue
+		}
+	}
+	return 0
+}
+
+func (x *GaugeResponse) GetStringValue() string {
+	if x != nil {
+		if x, ok := x.Value.(*GaugeResponse_StringValue); ok {
+			return x.StringValue
+		}
+	}
+	return ""
+}
+
+type isGaugeResponse_Value interface {
+	isGaugeResponse_Value()
+}
+
+type GaugeResponse_LongValue struct {
+	LongValue int64 `protobuf:"varint,2,opt,name=long_value,json=longValue,proto3,oneof"`
+}
+
+type GaugeResponse_DoubleValue struct {
+	DoubleValue float64 `protobuf:"fixed64,3,opt,name=double_value,json=doubleValue,proto3,oneof"`
+}
+
+type GaugeResponse_StringValue struct {
+	StringValue string `protobuf:"bytes,4,opt,name=string_value,json=stringValue,proto3,oneof"`
+}
+
+func (*GaugeResponse_LongValue) isGaugeResponse_Value() {}
+
+func (*GaugeResponse_DoubleValue) isGaugeResponse_Value() {}
+
+func (*GaugeResponse_StringValue) isGaugeResponse_Value() {}
+
+// Request message containing the gauge name
+type GaugeRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GaugeRequest) Reset() {
+	*x = GaugeRequest{}
+	mi := &file_interop_stress_grpc_testing_metrics_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GaugeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GaugeRequest) ProtoMessage() {}
+
+func (x *GaugeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_interop_stress_grpc_testing_metrics_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GaugeRequest.ProtoReflect.Descriptor instead.
+func (*GaugeRequest) Descriptor() ([]byte, []int) {
+	return file_interop_stress_grpc_testing_metrics_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *GaugeRequest) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+type EmptyMessage struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *EmptyMessage) Reset() {
+	*x = EmptyMessage{}
+	mi := &file_interop_stress_grpc_testing_metrics_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *EmptyMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EmptyMessage) ProtoMessage() {}
+
+func (x *EmptyMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_interop_stress_grpc_testing_metrics_proto_msgTypes[2]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EmptyMessage.ProtoReflect.Descriptor instead.
+func (*EmptyMessage) Descriptor() ([]byte, []int) {
+	return file_interop_stress_grpc_testing_metrics_proto_rawDescGZIP(), []int{2}
+}
+
+var File_interop_stress_grpc_testing_metrics_proto protoreflect.FileDescriptor
+
+const file_interop_stress_grpc_testing_metrics_proto_rawDesc = "" +
+	"\n" +
+	")interop/stress/grpc_testing/metrics.proto\x12\fgrpc.testing\"\x97\x01\n" +
+	"\rGaugeResponse\x12\x12\n" +
+	"\x04name\x18\x01 \x01(\tR\x04name\x12\x1f\n" +
+	"\n" +
+	"long_value\x18\x02 \x01(\x03H\x00R\tlongValue\x12#\n" +
+	"\fdouble_value\x18\x03 \x01(\x01H\x00R\vdoubleValue\x12#\n" +
+	"\fstring_value\x18\x04 \x01(\tH\x00R\vstringValueB\a\n" +
+	"\x05value\"\"\n" +
+	"\fGaugeRequest\x12\x12\n" +
+	"\x04name\x18\x01 \x01(\tR\x04name\"\x0e\n" +
+	"\fEmptyMessage2\xa0\x01\n" +
+	"\x0eMetricsService\x12I\n" +
+	"\fGetAllGauges\x12\x1a.grpc.testing.EmptyMessage\x1a\x1b.grpc.testing.GaugeResponse0\x01\x12C\n" +
+	"\bGetGauge\x12\x1a.grpc.testing.GaugeRequest\x1a\x1b.grpc.testing.GaugeResponseB4Z2google.golang.org/grpc/interop/stress/grpc_testingb\x06proto3"
+
+var (
+	file_interop_stress_grpc_testing_metrics_proto_rawDescOnce sync.Once
+	file_interop_stress_grpc_testing_metrics_proto_rawDescData []byte
+)
+
+func file_interop_stress_grpc_testing_metrics_proto_rawDescGZIP() []byte {
+	file_interop_stress_grpc_testing_metrics_proto_rawDescOnce.Do(func() {
+		file_interop_stress_grpc_testing_metrics_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_interop_stress_grpc_testing_metrics_proto_rawDesc), len(file_interop_stress_grpc_testing_metrics_proto_rawDesc)))
+	})
+	return file_interop_stress_grpc_testing_metrics_proto_rawDescData
+}
+
+var file_interop_stress_grpc_testing_metrics_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_interop_stress_grpc_testing_metrics_proto_goTypes = []any{
+	(*GaugeResponse)(nil), // 0: grpc.testing.GaugeResponse
+	(*GaugeRequest)(nil),  // 1: grpc.testing.GaugeRequest
+	(*EmptyMessage)(nil),  // 2: grpc.testing.EmptyMessage
+}
+var file_interop_stress_grpc_testing_metrics_proto_depIdxs = []int32{
+	2, // 0: grpc.testing.MetricsService.GetAllGauges:input_type -> grpc.testing.EmptyMessage
+	1, // 1: grpc.testing.MetricsService.GetGauge:input_type -> grpc.testing.GaugeRequest
+	0, // 2: grpc.testing.MetricsService.GetAllGauges:output_type -> grpc.testing.GaugeResponse
+	0, // 3: grpc.testing.MetricsService.GetGauge:output_type -> grpc.testing.GaugeResponse
+	2, // [2:4] is the sub-list for method output_type
+	0, // [0:2] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_interop_stress_grpc_testing_metrics_proto_init() }
+func file_interop_stress_grpc_testing_metrics_proto_init() {
+	if File_interop_stress_grpc_testing_metrics_proto != nil {
+		return
+	}
+	file_interop_stress_grpc_testing_metrics_proto_msgTypes[0].OneofWrappers = []any{
+		(*GaugeResponse_LongValue)(nil),
+		(*GaugeResponse_DoubleValue)(nil),
+		(*GaugeResponse_StringValue)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_interop_stress_grpc_testing_metrics_proto_rawDesc), len(file_interop_stress_grpc_testing_metrics_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   3,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_interop_stress_grpc_testing_metrics_proto_goTypes,
+		DependencyIndexes: file_interop_stress_grpc_testing_metrics_proto_depIdxs,
+		MessageInfos:      file_interop_stress_grpc_testing_metrics_proto_msgTypes,
+	}.Build()
+	File_interop_stress_grpc_testing_metrics_proto = out.File
+	file_interop_stress_grpc_testing_metrics_proto_goTypes = nil
+	file_interop_stress_grpc_testing_metrics_proto_depIdxs = nil
+}
--- a/interop/stress/grpc_testing/metrics.proto
+++ b/interop/stress/grpc_testing/metrics.proto
@@ -0,0 +1,51 @@
+// Copyright 2015-2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Contains the definitions for a metrics service and the type of metrics
+// exposed by the service.
+//
+// Currently, 'Gauge' (i.e a metric that represents the measured value of
+// something at an instant of time) is the only metric type supported by the
+// service.
+syntax = "proto3";
+
+option go_package = "google.golang.org/grpc/interop/stress/grpc_testing";
+
+package grpc.testing;
+
+// Response message containing the gauge name and value
+message GaugeResponse {
+  string name = 1;
+  oneof value {
+    int64 long_value = 2;
+    double double_value = 3;
+    string string_value = 4;
+  }
+}
+
+// Request message containing the gauge name
+message GaugeRequest {
+  string name = 1;
+}
+
+message EmptyMessage {}
+
+service MetricsService {
+  // Returns the values of all the gauges that are currently being maintained by
+  // the service
+  rpc GetAllGauges(EmptyMessage) returns (stream GaugeResponse);
+
+  // Returns the value of one gauge
+  rpc GetGauge(GaugeRequest) returns (GaugeResponse);
+}
--- a/interop/stress/grpc_testing/metrics_grpc.pb.go
+++ b/interop/stress/grpc_testing/metrics_grpc.pb.go
@@ -0,0 +1,190 @@
+// Copyright 2015-2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Contains the definitions for a metrics service and the type of metrics
+// exposed by the service.
+//
+// Currently, 'Gauge' (i.e a metric that represents the measured value of
+// something at an instant of time) is the only metric type supported by the
+// service.
+
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.6.2
+// - protoc             v5.27.1
+// source: interop/stress/grpc_testing/metrics.proto
+
+package grpc_testing
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	MetricsService_GetAllGauges_FullMethodName = "/grpc.testing.MetricsService/GetAllGauges"
+	MetricsService_GetGauge_FullMethodName     = "/grpc.testing.MetricsService/GetGauge"
+)
+
+// MetricsServiceClient is the client API for MetricsService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type MetricsServiceClient interface {
+	// Returns the values of all the gauges that are currently being maintained by
+	// the service
+	GetAllGauges(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GaugeResponse], error)
+	// Returns the value of one gauge
+	GetGauge(ctx context.Context, in *GaugeRequest, opts ...grpc.CallOption) (*GaugeResponse, error)
+}
+
+type metricsServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewMetricsServiceClient(cc grpc.ClientConnInterface) MetricsServiceClient {
+	return &metricsServiceClient{cc}
+}
+
+func (c *metricsServiceClient) GetAllGauges(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GaugeResponse], error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &MetricsService_ServiceDesc.Streams[0], MetricsService_GetAllGauges_FullMethodName, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &grpc.GenericClientStream[EmptyMessage, GaugeResponse]{ClientStream: stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type MetricsService_GetAllGaugesClient = grpc.ServerStreamingClient[GaugeResponse]
+
+func (c *metricsServiceClient) GetGauge(ctx context.Context, in *GaugeRequest, opts ...grpc.CallOption) (*GaugeResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(GaugeResponse)
+	err := c.cc.Invoke(ctx, MetricsService_GetGauge_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// MetricsServiceServer is the server API for MetricsService service.
+// All implementations must embed UnimplementedMetricsServiceServer
+// for forward compatibility.
+type MetricsServiceServer interface {
+	// Returns the values of all the gauges that are currently being maintained by
+	// the service
+	GetAllGauges(*EmptyMessage, grpc.ServerStreamingServer[GaugeResponse]) error
+	// Returns the value of one gauge
+	GetGauge(context.Context, *GaugeRequest) (*GaugeResponse, error)
+	mustEmbedUnimplementedMetricsServiceServer()
+}
+
+// UnimplementedMetricsServiceServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedMetricsServiceServer struct{}
+
+func (UnimplementedMetricsServiceServer) GetAllGauges(*EmptyMessage, grpc.ServerStreamingServer[GaugeResponse]) error {
+	return status.Error(codes.Unimplemented, "method GetAllGauges not implemented")
+}
+func (UnimplementedMetricsServiceServer) GetGauge(context.Context, *GaugeRequest) (*GaugeResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method GetGauge not implemented")
+}
+func (UnimplementedMetricsServiceServer) mustEmbedUnimplementedMetricsServiceServer() {}
+func (UnimplementedMetricsServiceServer) testEmbeddedByValue()                        {}
+
+// UnsafeMetricsServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to MetricsServiceServer will
+// result in compilation errors.
+type UnsafeMetricsServiceServer interface {
+	mustEmbedUnimplementedMetricsServiceServer()
+}
+
+func RegisterMetricsServiceServer(s grpc.ServiceRegistrar, srv MetricsServiceServer) {
+	// If the following call panics, it indicates UnimplementedMetricsServiceServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&MetricsService_ServiceDesc, srv)
+}
+
+func _MetricsService_GetAllGauges_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(EmptyMessage)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(MetricsServiceServer).GetAllGauges(m, &grpc.GenericServerStream[EmptyMessage, GaugeResponse]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type MetricsService_GetAllGaugesServer = grpc.ServerStreamingServer[GaugeResponse]
+
+func _MetricsService_GetGauge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GaugeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MetricsServiceServer).GetGauge(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: MetricsService_GetGauge_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MetricsServiceServer).GetGauge(ctx, req.(*GaugeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// MetricsService_ServiceDesc is the grpc.ServiceDesc for MetricsService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var MetricsService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "grpc.testing.MetricsService",
+	HandlerType: (*MetricsServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetGauge",
+			Handler:    _MetricsService_GetGauge_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "GetAllGauges",
+			Handler:       _MetricsService_GetAllGauges_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "interop/stress/grpc_testing/metrics.proto",
+}
--- a/interop/stress/metrics_client/main.go
+++ b/interop/stress/metrics_client/main.go
@@ -0,0 +1,86 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Binary metrics_client is a client to retrieve metrics from the server.
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/grpclog"
+	metricspb "google.golang.org/grpc/interop/stress/grpc_testing"
+)
+
+var (
+	metricsServerAddress = flag.String("metrics_server_address", "", "The metrics server addresses in the format <hostname>:<port>")
+	totalOnly            = flag.Bool("total_only", false, "If true, this prints only the total value of all gauges")
+
+	logger = grpclog.Component("stress")
+)
+
+func printMetrics(client metricspb.MetricsServiceClient, totalOnly bool) {
+	stream, err := client.GetAllGauges(context.Background(), &metricspb.EmptyMessage{})
+	if err != nil {
+		logger.Fatalf("failed to call GetAllGauges: %v", err)
+	}
+
+	var (
+		overallQPS int64
+		rpcStatus  error
+	)
+	for {
+		gaugeResponse, err := stream.Recv()
+		if err != nil {
+			rpcStatus = err
+			break
+		}
+		if _, ok := gaugeResponse.GetValue().(*metricspb.GaugeResponse_LongValue); !ok {
+			panic(fmt.Sprintf("gauge %s is not a long value", gaugeResponse.Name))
+		}
+		v := gaugeResponse.GetLongValue()
+		if !totalOnly {
+			logger.Infof("%s: %d", gaugeResponse.Name, v)
+		}
+		overallQPS += v
+	}
+	if rpcStatus != io.EOF {
+		logger.Fatalf("failed to finish server streaming: %v", rpcStatus)
+	}
+	logger.Infof("overall qps: %d", overallQPS)
+}
+
+func main() {
+	flag.Parse()
+	if *metricsServerAddress == "" {
+		logger.Fatal("-metrics_server_address is unset")
+	}
+
+	conn, err := grpc.NewClient(*metricsServerAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	if err != nil {
+		logger.Fatalf("grpc.NewClient(%q) = %v", metricsServerAddress, err)
+	}
+	defer conn.Close()
+
+	c := metricspb.NewMetricsServiceClient(conn)
+	printMetrics(c, *totalOnly)
+}