// main.go
package main

import (
    "context"
    "log"
    "net"
    
    "google.golang.org/grpc"
    "google.golang.org/grpc/reflection"
    
    pb "github.com/company/proto/user/service"
)

// UserService实现
type userService struct {
    pb.UnimplementedUserServiceServer
}

// 创建用户
func (s *userService) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.CreateUserResponse, error) {
    // 创建用户逻辑
    user := &pb.User{
        Id:       1,
        Username: req.Username,
        Email:    req.Email,
        Phone:    req.Phone,
        Status:   pb.UserStatus_USER_STATUS_ACTIVE,
        Profile:  req.Profile,
    }
    
    return &pb.CreateUserResponse{User: user}, nil
}

// 获取用户
func (s *userService) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
    // 获取用户逻辑
    user := &pb.User{
        Id:       req.UserId,
        Username: "testuser",
        Email:    "test@example.com",
        Status:   pb.UserStatus_USER_STATUS_ACTIVE,
    }
    
    return &pb.GetUserResponse{User: user}, nil
}

func main() {
    // 创建gRPC服务器
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    
    s := grpc.NewServer()
    pb.RegisterUserServiceServer(s, &userService{})
    reflection.Register(s)
    
    log.Println("Server started on :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("Failed to serve: %v", err)
    }
}

// performance_test.go
package main

import (
    "testing"
    "time"
    
    "github.com/company/proto/user"
)

func BenchmarkUserSerialization(b *testing.B) {
    // 创建测试用户
    testUser := &user.User{
        Id:       12345,
        Username: "testuser",
        Email:    "test@example.com",
        Phone:    "1234567890",
        Status:   user.UserStatus_USER_STATUS_ACTIVE,
        Profile: &user.UserProfile{
            FirstName: "Test",
            LastName:  "User",
            Bio:       "This is a test user",
        },
        CreatedAt: time.Now().Unix(),
        UpdatedAt: time.Now().Unix(),
    }
    
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        // 序列化
        data, err := testUser.Marshal()
        if err != nil {
            b.Fatal(err)
        }
        
        // 反序列化
        var user2 user.User
        err = user2.Unmarshal(data)
        if err != nil {
            b.Fatal(err)
        }
    }
}

func BenchmarkUserSize(b *testing.B) {
    testUser := &user.User{
        Id:       12345,
        Username: "testuser",
        Email:    "test@example.com",
        Phone:    "1234567890",
        Status:   user.UserStatus_USER_STATUS_ACTIVE,
    }
    
    data, _ := testUser.Marshal()
    b.Logf("Serialized size: %d bytes", len(data))
}

// grpc_server.go
package main

import (
    "context"
    "net"
    
    "google.golang.org/grpc"
    "google.golang.org/grpc/keepalive"
    "google.golang.org/grpc/reflection"
)

func createOptimizedServer() *grpc.Server {
    // gRPC服务器配置
    opts := []grpc.ServerOption{
        // 连接保活配置
        grpc.KeepaliveParams(keepalive.ServerParameters{
            Time:    10 * time.Second,
            Timeout: 3 * time.Second,
        }),
        
        // 连接保活策略
        grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
            MinTime:             5 * time.Second,
            PermitWithoutStream: true,
        }),
        
        // 最大接收消息大小
        grpc.MaxRecvMsgSize(4 * 1024 * 1024), // 4MB
        
        // 最大发送消息大小
        grpc.MaxSendMsgSize(4 * 1024 * 1024), // 4MB
        
        // 最大并发流
        grpc.MaxConcurrentStreams(1000),
        
        // 压缩配置
        grpc.RPCCompressor(grpc.NewGZIPCompressor()),
        grpc.RPCDecompressor(grpc.NewGZIPDecompressor()),
    }
    
    return grpc.NewServer(opts...)
}

func createOptimizedClient() (*grpc.ClientConn, error) {
    // gRPC客户端配置
    opts := []grpc.DialOption{
        grpc.WithInsecure(),
        
        // 连接保活配置
        grpc.WithKeepaliveParams(keepalive.ClientParameters{
            Time:                10 * time.Second,
            Timeout:             3 * time.Second,
            PermitWithoutStream: true,
        }),
        
        // 最大接收消息大小
        grpc.WithMaxMsgSize(4 * 1024 * 1024), // 4MB
        
        // 压缩配置
        grpc.WithCompressor(grpc.NewGZIPCompressor()),
        grpc.WithDecompressor(grpc.NewGZIPDecompressor()),
        
        // 负载均衡
        grpc.WithBalancerName("round_robin"),
    }
    
    return grpc.Dial("localhost:50051", opts...)
}

// connection_pool.go
package main

import (
    "sync"
    "time"
    
    "google.golang.org/grpc"
)

type ConnectionPool struct {
    connections []*grpc.ClientConn
    current     int
    mutex       sync.RWMutex
    maxSize     int
}

func NewConnectionPool(maxSize int) *ConnectionPool {
    return &ConnectionPool{
        connections: make([]*grpc.ClientConn, 0, maxSize),
        maxSize:     maxSize,
    }
}

func (p *ConnectionPool) GetConnection() (*grpc.ClientConn, error) {
    p.mutex.Lock()
    defer p.mutex.Unlock()
    
    if len(p.connections) == 0 {
        conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
        if err != nil {
            return nil, err
        }
        p.connections = append(p.connections, conn)
    }
    
    conn := p.connections[p.current]
    p.current = (p.current + 1) % len(p.connections)
    
    return conn, nil
}

func (p *ConnectionPool) AddConnection(conn *grpc.ClientConn) {
    p.mutex.Lock()
    defer p.mutex.Unlock()
    
    if len(p.connections) < p.maxSize {
        p.connections = append(p.connections, conn)
    }
}

func (p *ConnectionPool) Close() {
    p.mutex.Lock()
    defer p.mutex.Unlock()
    
    for _, conn := range p.connections {
        conn.Close()
    }
    p.connections = nil
}

// object_pool.go
package main

import (
    "sync"
    
    "github.com/company/proto/user"
)

type UserPool struct {
    pool sync.Pool
}

func NewUserPool() *UserPool {
    return &UserPool{
        pool: sync.Pool{
            New: func() interface{} {
                return &user.User{}
            },
        },
    }
}

func (p *UserPool) Get() *user.User {
    return p.pool.Get().(*user.User)
}

func (p *UserPool) Put(u *user.User) {
    // 重置对象状态
    u.Reset()
    p.pool.Put(u)
}

// 使用示例
func processUser(data []byte) error {
    pool := NewUserPool()
    user := pool.Get()
    defer pool.Put(user)
    
    err := user.Unmarshal(data)
    if err != nil {
        return err
    }
    
    // 处理用户数据
    return nil
}

// batch_processor.go
package main

import (
    "context"
    "sync"
    
    "github.com/company/proto/user/service"
)

type BatchProcessor struct {
    batchSize int
    timeout   time.Duration
    processor func([]*user.User) error
}

func NewBatchProcessor(batchSize int, timeout time.Duration, 
                      processor func([]*user.User) error) *BatchProcessor {
    return &BatchProcessor{
        batchSize: batchSize,
        timeout:   timeout,
        processor: processor,
    }
}

func (bp *BatchProcessor) ProcessUsers(users []*user.User) error {
    var wg sync.WaitGroup
    errChan := make(chan error, len(users)/bp.batchSize+1)
    
    for i := 0; i < len(users); i += bp.batchSize {
        end := i + bp.batchSize
        if end > len(users) {
            end = len(users)
        }
        
        batch := users[i:end]
        
        wg.Add(1)
        go func(batch []*user.User) {
            defer wg.Done()
            
            ctx, cancel := context.WithTimeout(context.Background(), bp.timeout)
            defer cancel()
            
            select {
            case <-ctx.Done():
                errChan <- ctx.Err()
            default:
                errChan <- bp.processor(batch)
            }
        }(batch)
    }
    
    wg.Wait()
    close(errChan)
    
    // 检查错误
    for err := range errChan {
        if err != nil {
            return err
        }
    }
    
    return nil
}

// service_registry.go
package main

import (
    "context"
    "fmt"
    "time"
    
    "go.etcd.io/etcd/clientv3"
)

type ServiceRegistry struct {
    client *clientv3.Client
    lease  clientv3.Lease
}

func NewServiceRegistry(endpoints []string) (*ServiceRegistry, error) {
    client, err := clientv3.New(clientv3.Config{
        Endpoints:   endpoints,
        DialTimeout: 5 * time.Second,
    })
    if err != nil {
        return nil, err
    }
    
    return &ServiceRegistry{
        client: client,
        lease:  clientv3.NewLease(client),
    }, nil
}

func (sr *ServiceRegistry) RegisterService(serviceName, serviceAddr string, ttl int64) error {
    // 创建租约
    leaseResp, err := sr.lease.Grant(context.Background(), ttl)
    if err != nil {
        return err
    }
    
    // 注册服务
    key := fmt.Sprintf("/services/%s/%s", serviceName, serviceAddr)
    _, err = sr.client.Put(context.Background(), key, serviceAddr, 
                          clientv3.WithLease(leaseResp.ID))
    if err != nil {
        return err
    }
    
    // 保持租约
    ch, kaerr := sr.client.KeepAlive(context.Background(), leaseResp.ID)
    if kaerr != nil {
        return kaerr
    }
    
    go func() {
        for ka := range ch {
            _ = ka
        }
    }()
    
    return nil
}

func (sr *ServiceRegistry) DiscoverServices(serviceName string) ([]string, error) {
    key := fmt.Sprintf("/services/%s/", serviceName)
    resp, err := sr.client.Get(context.Background(), key, clientv3.WithPrefix())
    if err != nil {
        return nil, err
    }
    
    var services []string
    for _, kv := range resp.Kvs {
        services = append(services, string(kv.Value))
    }
    
    return services, nil
}

// load_balancer.go
package main

import (
    "context"
    "math/rand"
    "sync"
    "time"
    
    "google.golang.org/grpc"
    "google.golang.org/grpc/balancer/roundrobin"
)

type LoadBalancer struct {
    services []string
    current  int
    mutex    sync.RWMutex
}

func NewLoadBalancer(services []string) *LoadBalancer {
    return &LoadBalancer{
        services: services,
    }
}

func (lb *LoadBalancer) GetService() string {
    lb.mutex.Lock()
    defer lb.mutex.Unlock()
    
    if len(lb.services) == 0 {
        return ""
    }
    
    service := lb.services[lb.current]
    lb.current = (lb.current + 1) % len(lb.services)
    
    return service
}

func (lb *LoadBalancer) GetRandomService() string {
    lb.mutex.RLock()
    defer lb.mutex.RUnlock()
    
    if len(lb.services) == 0 {
        return ""
    }
    
    return lb.services[rand.Intn(len(lb.services))]
}

// 加权轮询负载均衡
type WeightedLoadBalancer struct {
    services []WeightedService
    current  int
    mutex    sync.RWMutex
}

type WeightedService struct {
    Address string
    Weight  int
}

func NewWeightedLoadBalancer(services []WeightedService) *WeightedLoadBalancer {
    return &WeightedLoadBalancer{
        services: services,
    }
}

func (wlb *WeightedLoadBalancer) GetService() string {
    wlb.mutex.Lock()
    defer wlb.mutex.Unlock()
    
    if len(wlb.services) == 0 {
        return ""
    }
    
    // 加权轮询算法
    totalWeight := 0
    for _, service := range wlb.services {
        totalWeight += service.Weight
    }
    
    if totalWeight == 0 {
        return wlb.services[0].Address
    }
    
    currentWeight := 0
    for i, service := range wlb.services {
        currentWeight += service.Weight
        if wlb.current < currentWeight {
            wlb.current++
            return service.Address
        }
    }
    
    wlb.current = 0
    return wlb.services[0].Address
}

// user_client.go
package main

import (
    "context"
    "time"
    
    "google.golang.org/grpc"
    "google.golang.org/grpc/keepalive"
    
    pb "github.com/company/proto/user/service"
)

type UserClient struct {
    conn   *grpc.ClientConn
    client pb.UserServiceClient
}

func NewUserClient(addr string) (*UserClient, error) {
    opts := []grpc.DialOption{
        grpc.WithInsecure(),
        grpc.WithKeepaliveParams(keepalive.ClientParameters{
            Time:                10 * time.Second,
            Timeout:             3 * time.Second,
            PermitWithoutStream: true,
        }),
    }
    
    conn, err := grpc.Dial(addr, opts...)
    if err != nil {
        return nil, err
    }
    
    return &UserClient{
        conn:   conn,
        client: pb.NewUserServiceClient(conn),
    }, nil
}

func (uc *UserClient) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.CreateUserResponse, error) {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()
    
    return uc.client.CreateUser(ctx, req)
}

func (uc *UserClient) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()
    
    return uc.client.GetUser(ctx, req)
}

func (uc *UserClient) Close() error {
    return uc.conn.Close()
}

// middleware.go
package main

import (
    "context"
    "log"
    "time"
    
    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

// 日志中间件
func LoggingInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    start := time.Now()
    
    log.Printf("RPC: %s, Request: %v", info.FullMethod, req)
    
    resp, err := handler(ctx, req)
    
    duration := time.Since(start)
    log.Printf("RPC: %s, Duration: %v, Error: %v", info.FullMethod, duration, err)
    
    return resp, err
}

// 认证中间件
func AuthInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    // 检查认证信息
    if !isAuthenticated(ctx) {
        return nil, status.Errorf(codes.Unauthenticated, "Authentication required")
    }
    
    return handler(ctx, req)
}

// 限流中间件
type RateLimiter struct {
    tokens chan struct{}
    ticker *time.Ticker
}

func NewRateLimiter(rate int, burst int) *RateLimiter {
    rl := &RateLimiter{
        tokens: make(chan struct{}, burst),
    }
    
    // 填充令牌桶
    for i := 0; i < burst; i++ {
        rl.tokens <- struct{}{}
    }
    
    // 定期添加令牌
    rl.ticker = time.NewTicker(time.Second / time.Duration(rate))
    go func() {
        for range rl.ticker.C {
            select {
            case rl.tokens <- struct{}{}:
            default:
            }
        }
    }()
    
    return rl
}

func (rl *RateLimiter) Allow() bool {
    select {
    case <-rl.tokens:
        return true
    default:
        return false
    }
}

func RateLimitInterceptor(rl *RateLimiter) grpc.UnaryServerInterceptor {
    return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
        if !rl.Allow() {
            return nil, status.Errorf(codes.ResourceExhausted, "Rate limit exceeded")
        }
        
        return handler(ctx, req)
    }
}

// 重试中间件
func RetryInterceptor(maxRetries int, backoff time.Duration) grpc.UnaryClientInterceptor {
    return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
        var lastErr error
        
        for i := 0; i <= maxRetries; i++ {
            err := invoker(ctx, method, req, reply, cc, opts...)
            if err == nil {
                return nil
            }
            
            lastErr = err
            
            if i < maxRetries {
                time.Sleep(backoff * time.Duration(1<<uint(i)))
            }
        }
        
        return lastErr
    }
}

// circuit_breaker.go
package main

import (
    "context"
    "sync"
    "time"
)

type CircuitBreakerState int

const (
    StateClosed CircuitBreakerState = iota
    StateOpen
    StateHalfOpen
)

type CircuitBreaker struct {
    maxFailures int
    timeout     time.Duration
    state       CircuitBreakerState
    failures    int
    lastFailure time.Time
    mutex       sync.RWMutex
}

func NewCircuitBreaker(maxFailures int, timeout time.Duration) *CircuitBreaker {
    return &CircuitBreaker{
        maxFailures: maxFailures,
        timeout:     timeout,
        state:       StateClosed,
    }
}

func (cb *CircuitBreaker) Call(fn func() error) error {
    cb.mutex.Lock()
    defer cb.mutex.Unlock()
    
    if cb.state == StateOpen {
        if time.Since(cb.lastFailure) > cb.timeout {
            cb.state = StateHalfOpen
        } else {
            return ErrCircuitBreakerOpen
        }
    }
    
    err := fn()
    
    if err != nil {
        cb.failures++
        cb.lastFailure = time.Now()
        
        if cb.failures >= cb.maxFailures {
            cb.state = StateOpen
        }
        
        return err
    }
    
    cb.failures = 0
    cb.state = StateClosed
    
    return nil
}

var ErrCircuitBreakerOpen = errors.New("circuit breaker is open")

// health_check.go
package main

import (
    "context"
    "sync"
    "time"
    
    "google.golang.org/grpc"
    "google.golang.org/grpc/health/grpc_health_v1"
)

type HealthChecker struct {
    services map[string]HealthStatus
    mutex    sync.RWMutex
}

type HealthStatus struct {
    Status    grpc_health_v1.HealthCheckResponse_ServingStatus
    LastCheck time.Time
    Error     error
}

func NewHealthChecker() *HealthChecker {
    return &HealthChecker{
        services: make(map[string]HealthStatus),
    }
}

func (hc *HealthChecker) CheckService(serviceName string, client grpc_health_v1.HealthClient) {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    resp, err := client.Check(ctx, &grpc_health_v1.HealthCheckRequest{
        Service: serviceName,
    })
    
    hc.mutex.Lock()
    defer hc.mutex.Unlock()
    
    if err != nil {
        hc.services[serviceName] = HealthStatus{
            Status:    grpc_health_v1.HealthCheckResponse_NOT_SERVING,
            LastCheck: time.Now(),
            Error:     err,
        }
    } else {
        hc.services[serviceName] = HealthStatus{
            Status:    resp.Status,
            LastCheck: time.Now(),
            Error:     nil,
        }
    }
}

func (hc *HealthChecker) GetServiceStatus(serviceName string) HealthStatus {
    hc.mutex.RLock()
    defer hc.mutex.RUnlock()
    
    return hc.services[serviceName]
}

func (hc *HealthChecker) StartPeriodicCheck(serviceName string, client grpc_health_v1.HealthClient, interval time.Duration) {
    ticker := time.NewTicker(interval)
    go func() {
        for range ticker.C {
            hc.CheckService(serviceName, client)
        }
    }()
}

// metrics.go
package main

import (
    "context"
    "time"
    
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)

var (
    // RPC请求总数
    rpcRequestsTotal = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "rpc_requests_total",
            Help: "Total number of RPC requests",
        },
        []string{"method", "status"},
    )
    
    // RPC请求延迟
    rpcRequestDuration = promauto.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "rpc_request_duration_seconds",
            Help:    "RPC request duration in seconds",
            Buckets: prometheus.DefBuckets,
        },
        []string{"method"},
    )
    
    // 活跃连接数
    activeConnections = promauto.NewGauge(
        prometheus.GaugeOpts{
            Name: "active_connections",
            Help: "Number of active connections",
        },
    )
    
    // 序列化大小
    serializationSize = promauto.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "serialization_size_bytes",
            Help:    "Size of serialized messages in bytes",
            Buckets: prometheus.ExponentialBuckets(100, 2, 15),
        },
        []string{"message_type"},
    )
)

// 监控中间件
func MetricsInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    start := time.Now()
    
    resp, err := handler(ctx, req)
    
    duration := time.Since(start).Seconds()
    status := "success"
    if err != nil {
        status = "error"
    }
    
    rpcRequestsTotal.WithLabelValues(info.FullMethod, status).Inc()
    rpcRequestDuration.WithLabelValues(info.FullMethod).Observe(duration)
    
    return resp, err
}

// performance_analyzer.go
package main

import (
    "context"
    "fmt"
    "runtime"
    "time"
)

type PerformanceAnalyzer struct {
    startTime time.Time
    metrics   map[string]interface{}
}

func NewPerformanceAnalyzer() *PerformanceAnalyzer {
    return &PerformanceAnalyzer{
        startTime: time.Now(),
        metrics:   make(map[string]interface{}),
    }
}

func (pa *PerformanceAnalyzer) AnalyzeSerialization(data []byte, messageType string) {
    // 记录序列化大小
    pa.metrics[fmt.Sprintf("serialization_size_%s", messageType)] = len(data)
    
    // 记录内存使用
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    pa.metrics["memory_alloc"] = m.Alloc
    pa.metrics["memory_total_alloc"] = m.TotalAlloc
    pa.metrics["memory_sys"] = m.Sys
}

func (pa *PerformanceAnalyzer) AnalyzeRPC(method string, duration time.Duration, success bool) {
    key := fmt.Sprintf("rpc_%s", method)
    
    if pa.metrics[key] == nil {
        pa.metrics[key] = make(map[string]interface{})
    }
    
    rpcMetrics := pa.metrics[key].(map[string]interface{})
    
    // 更新统计信息
    if rpcMetrics["count"] == nil {
        rpcMetrics["count"] = 0
        rpcMetrics["total_duration"] = time.Duration(0)
        rpcMetrics["success_count"] = 0
        rpcMetrics["error_count"] = 0
    }
    
    rpcMetrics["count"] = rpcMetrics["count"].(int) + 1
    rpcMetrics["total_duration"] = rpcMetrics["total_duration"].(time.Duration) + duration
    
    if success {
        rpcMetrics["success_count"] = rpcMetrics["success_count"].(int) + 1
    } else {
        rpcMetrics["error_count"] = rpcMetrics["error_count"].(int) + 1
    }
}

func (pa *PerformanceAnalyzer) GetReport() map[string]interface{} {
    report := make(map[string]interface{})
    
    // 运行时间
    report["uptime"] = time.Since(pa.startTime)
    
    // 内存统计
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    report["memory"] = map[string]interface{}{
        "alloc":         m.Alloc,
        "total_alloc":   m.TotalAlloc,
        "sys":           m.Sys,
        "num_gc":        m.NumGC,
        "gc_cpu_fraction": m.GCCPUFraction,
    }
    
    // 自定义指标
    for key, value := range pa.metrics {
        report[key] = value
    }
    
    return report
}

// logger.go
package main

import (
    "context"
    "time"
    
    "github.com/sirupsen/logrus"
    "google.golang.org/grpc"
)

type Logger struct {
    *logrus.Logger
}

func NewLogger() *Logger {
    logger := logrus.New()
    logger.SetFormatter(&logrus.JSONFormatter{
        TimestampFormat: time.RFC3339,
    })
    
    return &Logger{Logger: logger}
}

func (l *Logger) LogRPC(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    start := time.Now()
    
    // 记录请求
    l.WithFields(logrus.Fields{
        "method":  info.FullMethod,
        "request": req,
    }).Info("RPC request started")
    
    resp, err := handler(ctx, req)
    
    duration := time.Since(start)
    
    // 记录响应
    fields := logrus.Fields{
        "method":   info.FullMethod,
        "duration": duration,
        "success":  err == nil,
    }
    
    if err != nil {
        fields["error"] = err.Error()
        l.WithFields(fields).Error("RPC request failed")
    } else {
        l.WithFields(fields).Info("RPC request completed")
    }
    
    return resp, err
}

func (l *Logger) LogSerialization(messageType string, size int, duration time.Duration) {
    l.WithFields(logrus.Fields{
        "message_type": messageType,
        "size":         size,
        "duration":     duration,
    }).Info("Message serialized")
}

// log_aggregator.go
package main

import (
    "context"
    "time"
    
    "github.com/elastic/go-elasticsearch/v8"
    "github.com/sirupsen/logrus"
)

type LogAggregator struct {
    esClient *elasticsearch.Client
    logger   *logrus.Logger
}

func NewLogAggregator(esEndpoint string) (*LogAggregator, error) {
    esClient, err := elasticsearch.NewClient(elasticsearch.Config{
        Addresses: []string{esEndpoint},
    })
    if err != nil {
        return nil, err
    }
    
    return &LogAggregator{
        esClient: esClient,
        logger:   logrus.New(),
    }, nil
}

func (la *LogAggregator) SendLog(level string, message string, fields map[string]interface{}) error {
    logEntry := map[string]interface{}{
        "timestamp": time.Now(),
        "level":     level,
        "message":   message,
        "service":   "protobuf-service",
    }
    
    for key, value := range fields {
        logEntry[key] = value
    }
    
    _, err := la.esClient.Index(
        "protobuf-logs",
        strings.NewReader(toJSON(logEntry)),
        la.esClient.Index.WithDocumentID(generateID()),
    )
    
    return err
}

func (la *LogAggregator) QueryLogs(query map[string]interface{}) ([]map[string]interface{}, error) {
    // 实现日志查询逻辑
    return nil, nil
}

// error_tracker.go
package main

import (
    "context"
    "fmt"
    "runtime"
    "time"
    
    "github.com/sirupsen/logrus"
)

type ErrorTracker struct {
    errors   []ErrorInfo
    mutex    sync.RWMutex
    maxSize  int
}

type ErrorInfo struct {
    Timestamp   time.Time
    Error       error
    StackTrace  string
    Context     map[string]interface{}
    Service     string
    Method      string
}

func NewErrorTracker(maxSize int) *ErrorTracker {
    return &ErrorTracker{
        errors:  make([]ErrorInfo, 0, maxSize),
        maxSize: maxSize,
    }
}

func (et *ErrorTracker) TrackError(ctx context.Context, err error, service, method string, contextData map[string]interface{}) {
    et.mutex.Lock()
    defer et.mutex.Unlock()
    
    // 获取堆栈跟踪
    stackTrace := make([]byte, 4096)
    n := runtime.Stack(stackTrace, false)
    
    errorInfo := ErrorInfo{
        Timestamp:  time.Now(),
        Error:      err,
        StackTrace: string(stackTrace[:n]),
        Context:    contextData,
        Service:    service,
        Method:     method,
    }
    
    // 添加到错误列表
    if len(et.errors) >= et.maxSize {
        et.errors = et.errors[1:]
    }
    et.errors = append(et.errors, errorInfo)
    
    // 记录到日志
    logrus.WithFields(logrus.Fields{
        "error":      err.Error(),
        "service":    service,
        "method":     method,
        "context":    contextData,
        "stack":      string(stackTrace[:n]),
    }).Error("Error tracked")
}

func (et *ErrorTracker) GetRecentErrors(count int) []ErrorInfo {
    et.mutex.RLock()
    defer et.mutex.RUnlock()
    
    if count > len(et.errors) {
        count = len(et.errors)
    }
    
    start := len(et.errors) - count
    return et.errors[start:]
}

func (et *ErrorTracker) GetErrorStats() map[string]interface{} {
    et.mutex.RLock()
    defer et.mutex.RUnlock()
    
    stats := make(map[string]interface{})
    errorCounts := make(map[string]int)
    serviceCounts := make(map[string]int)
    
    for _, errorInfo := range et.errors {
        errorType := fmt.Sprintf("%T", errorInfo.Error)
        errorCounts[errorType]++
        serviceCounts[errorInfo.Service]++
    }
    
    stats["total_errors"] = len(et.errors)
    stats["error_types"] = errorCounts
    stats["service_errors"] = serviceCounts
    
    return stats
}