Fundamentals and Core Concepts

// Before optimization
message CustomerProfile {
  string id = 1;
  string first_name = 2;
  string last_name = 3;
  string email = 4;
  string phone_number = 5;
  string street_address = 6;
  string city = 7;
  string state = 8;
  string postal_code = 9;
  string country = 10;
  repeated Order recent_orders = 11;  // Potentially large nested data
}

// After optimization
message CustomerProfile {
  string id = 1;
  string first_name = 2;
  string last_name = 3;
  string email = 4;
  string phone_number = 5;
  
  // Group related fields
  Address address = 6;
  
  // Use message references instead of embedding
  repeated string recent_order_ids = 7;  // Just IDs, not full orders
}

message Address {
  string street = 1;
  string city = 2;
  string state = 3;
  string postal_code = 4;
  string country = 5;
}

package grpc_benchmark

import (
	"context"
	"testing"
	"time"

	"github.com/example/service/proto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func BenchmarkUnaryRequest(b *testing.B) {
	// Connect to the gRPC server
	conn, err := grpc.Dial("localhost:50051", 
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithBlock())
	if err != nil {
		b.Fatalf("failed to connect: %v", err)
	}
	defer conn.Close()
	
	client := proto.NewUserServiceClient(conn)
	ctx := context.Background()
	
	// Prepare request data
	req := &proto.GetUserRequest{
		UserId: "user123",
	}
	
	// Reset timer before the loop
	b.ResetTimer()
	
	// Run the benchmark
	for i := 0; i < b.N; i++ {
		_, err := client.GetUser(ctx, req)
		if err != nil {
			b.Fatalf("request failed: %v", err)
		}
	}
}

func BenchmarkStreamingRequest(b *testing.B) {
	// Connect to the gRPC server
	conn, err := grpc.Dial("localhost:50051", 
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithBlock())
	if err != nil {
		b.Fatalf("failed to connect: %v", err)
	}
	defer conn.Close()
	
	client := proto.NewDataServiceClient(conn)
	ctx := context.Background()
	
	// Reset timer before the loop
	b.ResetTimer()
	
	// Run the benchmark
	for i := 0; i < b.N; i++ {
		stream, err := client.StreamData(ctx, &proto.StreamDataRequest{
			BatchSize: 100,
		})
		if err != nil {
			b.Fatalf("stream creation failed: %v", err)
		}
		
		// Consume the stream
		count := 0
		for {
			_, err := stream.Recv()
			if err != nil {
				break
			}
			count++
		}
	}
}

package main

import (
	"log"
	"net"
	"runtime"
	"time"

	"github.com/example/service/proto"
	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
	grpc_recovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery"
	"golang.org/x/net/context"
	"google.golang.org/grpc"
	"google.golang.org/grpc/keepalive"
)

func main() {
	// Use all available CPU cores
	runtime.GOMAXPROCS(runtime.NumCPU())
	
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	
	// Configure server options for performance
	opts := []grpc.ServerOption{
		// Enable keepalive to detect dead connections
		grpc.KeepaliveParams(keepalive.ServerParameters{
			MaxConnectionIdle:     15 * time.Second, // If a client is idle for 15 seconds, send a GOAWAY
			MaxConnectionAge:      30 * time.Second, // If any connection is alive for more than 30 seconds, send a GOAWAY
			MaxConnectionAgeGrace: 5 * time.Second,  // Allow 5 seconds for pending RPCs to complete before forcibly closing connections
			Time:                  5 * time.Second,  // Ping the client if it is idle for 5 seconds to ensure the connection is still active
			Timeout:               1 * time.Second,  // Wait 1 second for the ping ack before assuming the connection is dead
		}),
		// Configure keepalive enforcement policy
		grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
			MinTime:             5 * time.Second, // If a client pings more than once every 5 seconds, terminate the connection
			PermitWithoutStream: true,            // Allow pings even when there are no active streams
		}),
		// Set maximum message sizes
		grpc.MaxRecvMsgSize(4 * 1024 * 1024), // 4MB
		grpc.MaxSendMsgSize(4 * 1024 * 1024), // 4MB
		// Add middleware for recovery
		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
			grpc_recovery.UnaryServerInterceptor(),
		)),
		grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(
			grpc_recovery.StreamServerInterceptor(),
		)),
	}
	
	// Create a new gRPC server with the configured options
	server := grpc.NewServer(opts...)
	
	// Register your service implementations
	proto.RegisterUserServiceServer(server, &userService{})
	
	log.Println("Starting optimized gRPC server on :50051")
	if err := server.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

// Service implementation
type userService struct {
	proto.UnimplementedUserServiceServer
}

func (s *userService) GetUser(ctx context.Context, req *proto.GetUserRequest) (*proto.User, error) {
	// Implementation...
	return &proto.User{
		Id:   req.UserId,
		Name: "Example User",
	}, nil
}