Go gRPC 데드라인 초과? 컨텍스트·리트라이 튜닝

// 나쁜 예: 데드라인 없이 호출
resp, err := client.GetUser(context.Background(), &pb.GetUserRequest{Id: id})

// 좋은 예: 호출별 데드라인을 명시
ctx, cancel := context.WithTimeout(context.Background(), 800*time.Millisecond)
defer cancel()

resp, err := client.GetUser(ctx, &pb.GetUserRequest{Id: id})

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 예: 외부 HTTP 요청 전체에 1500ms 예산
    ctx, cancel := context.WithTimeout(r.Context(), 1500*time.Millisecond)
    defer cancel()

    // 내부 gRPC에는 900ms만 할당(나머지는 직렬화/후처리/여유)
    grpcCtx, grpcCancel := context.WithTimeout(ctx, 900*time.Millisecond)
    defer grpcCancel()

    resp, err := h.userClient.GetUser(grpcCtx, &pb.GetUserRequest{Id: "42"})
    if err != nil {
        // ...
    }
    _ = resp
}

func (s *Server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
    // 나쁜 예: ctx를 사용하지 않는 DB 호출
    user, err := s.repo.FindUser(req.Id) // 내부적으로 context.Background()를 쓰는 경우
    if err != nil {
        return nil, status.Error(codes.Internal, err.Error())
    }
    return &pb.GetUserResponse{Id: user.ID}, nil
}

func (s *Server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
    // 좋은 예: ctx 전파
    user, err := s.repo.FindUser(ctx, req.Id)
    if err != nil {
        // ctx 만료/취소면 적절한 코드로 변환
        if errors.Is(err, context.DeadlineExceeded) {
            return nil, status.Error(codes.DeadlineExceeded, "db timeout")
        }
        if errors.Is(err, context.Canceled) {
            return nil, status.Error(codes.Canceled, "request canceled")
        }
        return nil, status.Error(codes.Internal, err.Error())
    }
    return &pb.GetUserResponse{Id: user.ID}, nil
}

func UnaryClientTimingInterceptor(logger *slog.Logger) grpc.UnaryClientInterceptor {
    return func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
        invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {

        start := time.Now()
        dl, hasDL := ctx.Deadline()
        err := invoker(ctx, method, req, reply, cc, opts...)
        dur := time.Since(start)

        code := status.Code(err)
        if hasDL {
            logger.Info("grpc client call",
                "method", method,
                "code", code.String(),
                "duration_ms", dur.Milliseconds(),
                "deadline_in_ms", time.Until(dl).Milliseconds(),
            )
        } else {
            logger.Info("grpc client call",
                "method", method,
                "code", code.String(),
                "duration_ms", dur.Milliseconds(),
                "deadline", "none",
            )
        }
        return err
    }
}

serviceCfg := `{
  "methodConfig": [{
    "name": [{"service": "user.UserService", "method": "GetUser"}],
    "retryPolicy": {
      "maxAttempts": 3,
      "initialBackoff": "0.05s",
      "maxBackoff": "0.2s",
      "backoffMultiplier": 2.0,
      "retryableStatusCodes": ["UNAVAILABLE", "RESOURCE_EXHAUSTED"]
    },
    "timeout": "0.8s"
  }]
}`

conn, err := grpc.NewClient(
    target,
    grpc.WithTransportCredentials(insecure.NewCredentials()),
    grpc.WithDefaultServiceConfig(serviceCfg),
)
if err != nil { panic(err) }

func CallWithRetry[T any](ctx context.Context, attempts int, base time.Duration, fn func(context.Context) (T, error)) (T, error) {
    var zero T
    for i := 0; i < attempts; i++ {
        if err := ctx.Err(); err != nil {
            return zero, err
        }

        // 각 시도에 짧은 서브 타임아웃을 부여(남은 시간보다 작게)
        perTry := 200 * time.Millisecond
        if dl, ok := ctx.Deadline(); ok {
            remain := time.Until(dl)
            if remain < perTry {
                perTry = remain
            }
        }
        tryCtx, cancel := context.WithTimeout(ctx, perTry)
        v, err := fn(tryCtx)
        cancel()

        if err == nil {
            return v, nil
        }

        c := status.Code(err)
        // DeadlineExceeded는 보통 재시도 가치가 낮으므로 제외
        if c != codes.Unavailable && c != codes.ResourceExhausted {
            return zero, err
        }

        // backoff + jitter
        sleep := base * time.Duration(1<<i)
        if sleep > 300*time.Millisecond {
            sleep = 300 * time.Millisecond
        }
        jitter := time.Duration(rand.Int63n(int64(sleep / 2)))
        timer := time.NewTimer(sleep/2 + jitter)
        select {
        case <-ctx.Done():
            timer.Stop()
            return zero, ctx.Err()
        case <-timer.C:
        }
    }
    return zero, status.Error(codes.Unavailable, "retry attempts exhausted")
}

select {
case <-ctx.Done():
    return nil, status.Error(codes.Canceled, "client canceled")
case res := <-workCh:
    return res, nil
}