Error Handling

1
2

// 서버 측 구현 예시 (Go)
return nil, status.Errorf(codes.InvalidArgument, "필드 값 %s이(가) 유효하지 않습니다", value)

1
2
3
4
5
6
7
8

// 오류 상세 정보 예시 (proto 정의)
message BadRequest {
  message FieldViolation {
    string field = 1;
    string description = 2;
  }
  repeated FieldViolation field_violations = 1;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 필드 유효성 검사 오류에 대한 상세 정보 추가
Metadata.Key<BadRequest> badRequestKey = 
    ProtoUtils.keyForProto(BadRequest.getDefaultInstance());
Metadata trailers = new Metadata();

BadRequest badRequest = BadRequest.newBuilder()
    .addFieldViolations(FieldViolation.newBuilder()
        .setField("email")
        .setDescription("올바른 이메일 형식이 아닙니다")
        .build())
    .build();

trailers.put(badRequestKey, badRequest);

return Status.INVALID_ARGUMENT
    .withDescription("요청에 유효하지 않은 필드가 있습니다")
    .asRuntimeException(trailers);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

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

// 서버 측에서 오류 반환
func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    if req.Id <= 0 {
        return nil, status.Errorf(codes.InvalidArgument, "사용자 ID는 양수여야 합니다: %v", req.Id)
    }
    
    user, err := s.repository.FindUser(req.Id)
    if err != nil {
        return nil, status.Errorf(codes.Internal, "내부 오류: %v", err)
    }
    
    if user == nil {
        return nil, status.Errorf(codes.NotFound, "ID가 %d인 사용자를 찾을 수 없습니다", req.Id)
    }
    
    return user, nil
}

// 클라이언트 측에서 오류 처리
resp, err := client.GetUser(ctx, &pb.GetUserRequest{Id: -1})
if err != nil {
    st, ok := status.FromError(err)
    if ok {
        switch st.Code() {
        case codes.InvalidArgument:
            log.Printf("잘못된 인수: %v", st.Message())
        case codes.NotFound:
            log.Printf("사용자를 찾을 수 없음: %v", st.Message())
        default:
            log.Printf("gRPC 오류: %v", st)
        }
    } else {
        log.Printf("일반 오류: %v", err)
    }
    return
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// 서버 측에서 오류 반환
@Override
public void getUser(GetUserRequest request, StreamObserver<User> responseObserver) {
    try {
        if (request.getId() <= 0) {
            responseObserver.onError(
                Status.INVALID_ARGUMENT
                    .withDescription("사용자 ID는 양수여야 합니다: " + request.getId())
                    .asRuntimeException());
            return;
        }
        
        User user = repository.findUser(request.getId());
        if (user == null) {
            responseObserver.onError(
                Status.NOT_FOUND
                    .withDescription("ID가 " + request.getId() + "인 사용자를 찾을 수 없습니다")
                    .asRuntimeException());
            return;
        }
        
        responseObserver.onNext(user);
        responseObserver.onCompleted();
    } catch (Exception e) {
        responseObserver.onError(
            Status.INTERNAL
                .withDescription("내부 오류: " + e.getMessage())
                .withCause(e)  // 원인 예외 추가 (전송되지 않음, 로깅용)
                .asRuntimeException());
    }
}

// 클라이언트 측에서 오류 처리
try {
    User user = blockingStub.getUser(GetUserRequest.newBuilder().setId(-1).build());
    // 성공적인 응답 처리
} catch (StatusRuntimeException e) {
    Status status = e.getStatus();
    switch (status.getCode()) {
        case INVALID_ARGUMENT:
            logger.log(Level.WARNING, "잘못된 인수: {0}", status.getDescription());
            break;
        case NOT_FOUND:
            logger.log(Level.INFO, "사용자를 찾을 수 없음: {0}", status.getDescription());
            break;
        default:
            logger.log(Level.SEVERE, "gRPC 오류: {0}", status);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 서버 측에서 오류 반환
def GetUser(self, request, context):
    if request.id <= 0:
        context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
        context.set_details(f"사용자 ID는 양수여야 합니다: {request.id}")
        return pb.User()  # 더미 응답
    
    try:
        user = self.repository.find_user(request.id)
        if not user:
            context.set_code(grpc.StatusCode.NOT_FOUND)
            context.set_details(f"ID가 {request.id}인 사용자를 찾을 수 없습니다")
            return pb.User()  # 더미 응답
        return user
    except Exception as e:
        context.set_code(grpc.StatusCode.INTERNAL)
        context.set_details(f"내부 오류: {str(e)}")
        return pb.User()  # 더미 응답

# 클라이언트 측에서 오류 처리
try:
    response = stub.GetUser(pb.GetUserRequest(id=-1))
    # 성공적인 응답 처리
except grpc.RpcError as e:
    status_code = e.code()
    if status_code == grpc.StatusCode.INVALID_ARGUMENT:
        print(f"잘못된 인수: {e.details()}")
    elif status_code == grpc.StatusCode.NOT_FOUND:
        print(f"사용자를 찾을 수 없음: {e.details()}")
    else:
        print(f"gRPC 오류: {status_code} - {e.details()}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public class ErrorInterceptor implements ServerInterceptor {
    @Override
    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
            ServerCall<ReqT, RespT> call, 
            Metadata headers,
            ServerCallHandler<ReqT, RespT> next) {
        
        ServerCall.Listener<ReqT> listener = next.startCall(call, headers);
        
        return new ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT>(listener) {
            @Override
            public void onHalfClose() {
                try {
                    super.onHalfClose();
                } catch (RuntimeException ex) {
                    handleException(call, ex);
                    throw ex;
                }
            }
            
            private void handleException(ServerCall<ReqT, RespT> call, RuntimeException ex) {
                Status status;
                if (ex instanceof IllegalArgumentException) {
                    status = Status.INVALID_ARGUMENT.withDescription(ex.getMessage());
                } else if (ex instanceof ResourceNotFoundException) {
                    status = Status.NOT_FOUND.withDescription(ex.getMessage());
                } else {
                    status = Status.INTERNAL.withDescription("내부 서버 오류");
                }
                
                call.close(status, new Metadata());
            }
        };
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// 오류 매핑 함수
func mapToStatusError(err error) error {
    switch {
    case errors.Is(err, ErrNotFound):
        return status.Error(codes.NotFound, err.Error())
    case errors.Is(err, ErrInvalidInput):
        return status.Error(codes.InvalidArgument, err.Error())
    case errors.Is(err, ErrPermissionDenied):
        return status.Error(codes.PermissionDenied, err.Error())
    case errors.Is(err, ErrUnauthenticated):
        return status.Error(codes.Unauthenticated, err.Error())
    case errors.Is(err, ErrAlreadyExists):
        return status.Error(codes.AlreadyExists, err.Error())
    default:
        // 내부 오류는 자세한 정보를 노출하지 않음
        return status.Error(codes.Internal, "내부 서버 오류가 발생했습니다")
    }
}

// 서비스 구현에서 사용
func (s *server) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.User, error) {
    user, err := s.service.CreateUser(req.Name, req.Email)
    if err != nil {
        return nil, mapToStatusError(err)
    }
    return user, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// Java에서의 재시도 예시
public Response callWithRetry(Request request) {
    int maxRetries = 3;
    int retryCount = 0;
    long retryDelayMs = 100;
    
    while (true) {
        try {
            return stub.serviceMethod(request);
        } catch (StatusRuntimeException e) {
            retryCount++;
            if (retryCount > maxRetries || !isRetryable(e.getStatus().getCode())) {
                throw e;  // 최대 재시도 횟수 초과 또는 재시도 불가능한 오류
            }
            
            logger.warning("재시도 가능한 오류 발생, 재시도 중… (" + retryCount + "/" + maxRetries + ")");
            try {
                Thread.sleep(retryDelayMs * (1 << (retryCount - 1)));  // 지수 백오프
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                throw e;
            }
        }
    }
}

private boolean isRetryable(Status.Code code) {
    return code == Status.Code.UNAVAILABLE || 
           code == Status.Code.RESOURCE_EXHAUSTED ||
           code == Status.Code.DEADLINE_EXCEEDED;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// 간단한 서킷 브레이커 구현 예시
public class CircuitBreaker {
    private final int failureThreshold;
    private final long resetTimeout;
    private int failureCount;
    private long lastFailureTime;
    private State state;
    
    public enum State {
        CLOSED,    // 정상 작동
        OPEN,      // 서킷 열림 (호출 중단)
        HALF_OPEN  // 시험 작동
    }
    
    public CircuitBreaker(int failureThreshold, long resetTimeoutMs) {
        this.failureThreshold = failureThreshold;
        this.resetTimeout = resetTimeoutMs;
        this.state = State.CLOSED;
        this.failureCount = 0;
    }
    
    public synchronized <T> T execute(Supplier<T> operation) throws Exception {
        if (state == State.OPEN) {
            if (System.currentTimeMillis() - lastFailureTime > resetTimeout) {
                state = State.HALF_OPEN;
            } else {
                throw new CircuitBreakerOpenException("서킷 브레이커가 열려 있습니다");
            }
        }
        
        try {
            T result = operation.get();
            if (state == State.HALF_OPEN) {
                reset();  // 성공 시 상태 재설정
            }
            return result;
        } catch (Exception e) {
            recordFailure(e);
            throw e;
        }
    }
    
    private synchronized void recordFailure(Exception e) {
        failureCount++;
        lastFailureTime = System.currentTimeMillis();
        
        if (state == State.HALF_OPEN || failureCount >= failureThreshold) {
            state = State.OPEN;
        }
    }
    
    private synchronized void reset() {
        failureCount = 0;
        state = State.CLOSED;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Java에서의 타임아웃 설정 예시
ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 50051)
    .usePlaintext()
    .build();

// 클라이언트 스텁 생성 시 데드라인 설정
UserServiceGrpc.UserServiceBlockingStub stub = UserServiceGrpc.newBlockingStub(channel)
    .withDeadlineAfter(5, TimeUnit.SECONDS);

// 개별 호출에 대한 타임아웃 설정도 가능
try {
    // 기본 클라이언트 스텁에서 메서드별 타임아웃 설정
    User user = stub.withDeadlineAfter(1, TimeUnit.SECONDS)
        .getUser(GetUserRequest.newBuilder().setId(123).build());
} catch (StatusRuntimeException e) {
    if (e.getStatus().getCode() == Status.Code.DEADLINE_EXCEEDED) {
        logger.severe("호출 타임아웃");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func (s *server) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.User, error) {
    // 입력 검증
    if req.Name == "" {
        return nil, status.Error(codes.InvalidArgument, "이름은 필수 필드입니다")
    }
    
    if !isValidEmail(req.Email) {
        return nil, status.Error(codes.InvalidArgument, "유효하지 않은 이메일 형식입니다")
    }
    
    // 비즈니스 로직 실행
    user, err := s.service.CreateUser(req.Name, req.Email)
    if err != nil {
        return nil, mapToStatusError(err)
    }
    
    return user, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func (s *server) ProcessData(ctx context.Context, req *pb.ProcessDataRequest) (*pb.ProcessDataResponse, error) {
    // 컨텍스트에서 데드라인 확인
    deadline, ok := ctx.Deadline()
    if !ok {
        // 기본 타임아웃 설정
        var cancel context.CancelFunc
        ctx, cancel = context.WithTimeout(ctx, 30*time.Second)
        defer cancel()
    } else {
        // 남은 처리 시간 계산
        remaining := time.Until(deadline) - 100*time.Millisecond
        if remaining <= 0 {
            return nil, status.Error(codes.DeadlineExceeded, "데드라인이 너무 짧습니다")
        }
    }
    
    // 하위 서비스 호출 시 컨텍스트 전파
    result, err := s.dataProcessor.Process(ctx, req.Data)
    if err != nil {
        return nil, err
    }
    
    return &pb.ProcessDataResponse{Result: result}, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public User getUser(GetUserRequest request) {
    User user = new User();
    
    // 기본 사용자 정보 조회
    try {
        UserInfo info = userInfoService.getUserInfo(request.getId());
        user.setId(info.getId());
        user.setName(info.getName());
        user.setEmail(info.getEmail());
    } catch (StatusRuntimeException e) {
        logger.severe("사용자 기본 정보 조회 실패: " + e.getMessage());
        if (e.getStatus().getCode() != Status.Code.NOT_FOUND) {
            throw e;  // NOT_FOUND가 아닌 경우에만 예외 전파
        }
        // NOT_FOUND인 경우, 기본값으로 계속 진행
        user.setId(request.getId());
        user.setName("Unknown");
    }
    
    // 사용자 프로필 조회 (선택적 기능)
    try {
        UserProfile profile = profileService.getProfile(request.getId());
        user.setProfilePicture(profile.getPictureUrl());
        user.setBio(profile.getBio());
    } catch (StatusRuntimeException e) {
        // 프로필 정보가 없어도 기본 사용자 정보는 반환
        logger.warning("사용자 프로필 조회 실패, 기본값 사용: " + e.getMessage());
        user.setProfilePicture("default.png");
    }
    
    return user;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

@Override
public void processRequest(Request request, StreamObserver<Response> responseObserver) {
    try {
        // 비즈니스 로직 처리
        Response response = processBusinessLogic(request);
        responseObserver.onNext(response);
        
        // 트레일러 메타데이터 추가
        Metadata trailers = new Metadata();
        Metadata.Key<String> processingTimeKey = 
            Metadata.Key.of("processing-time-ms", Metadata.ASCII_STRING_MARSHALLER);
        trailers.put(processingTimeKey, String.valueOf(processingTime));
        
        // 완료 시 트레일러 전송
        ((ServerCallStreamObserver<Response>) responseObserver).setTrailers(trailers);
        
        responseObserver.onCompleted();
    } catch (Exception e) {
        // 오류 처리 및 트레일러 메타데이터 추가
        Metadata trailers = new Metadata();
        Metadata.Key<String> errorDetailsKey = 
            Metadata.Key.of("error-details", Metadata.ASCII_STRING_MARSHALLER);
        trailers.put(errorDetailsKey, "오류 세부 정보: " + e.getMessage());
        
        Status status = Status.INTERNAL
            .withDescription("처리 중 오류 발생")
            .withCause(e);
        
        responseObserver.onError(status.asRuntimeException(trailers));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

ClientCall<Request, Response> call = channel.newCall(
    ServiceGrpc.getProcessRequestMethod(), CallOptions.DEFAULT);

call.start(new ClientCall.Listener<Response>() {
    @Override
    public void onClose(Status status, Metadata trailers) {
        if (!status.isOk()) {
            String errorDetails = trailers.get(
                Metadata.Key.of("error-details", Metadata.ASCII_STRING_MARSHALLER));
            logger.severe("오류 발생: " + status + ", 세부 정보: " + errorDetails);
        }
    }
    
    @Override
    public void onMessage(Response response) {
        // 응답 처리
    }
}, new Metadata());

call.sendMessage(request);
call.halfClose();
call.request(1);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

// 서버 측 구현
public void processRequest(Request request, StreamObserver<Response> responseObserver) {
    try {
        // 비즈니스 로직 처리
    } catch (ValidationException e) {
        // 구조화된 오류 정보 생성
        ErrorDetails errorDetails = ErrorDetails.newBuilder()
            .setCode("VALIDATION_ERROR")
            .setMessage(e.getMessage())
            .addFields(FieldError.newBuilder()
                .setField(e.getField())
                .setDescription(e.getDescription())
                .build())
            .build();
        
        // 바이너리 메타데이터로 변환
        Metadata.Key<byte[]> errorDetailsKey = 
            Metadata.Key.of("error-details-bin", Metadata.BINARY_BYTE_MARSHALLER);
        Metadata trailers = new Metadata();
        trailers.put(errorDetailsKey, errorDetails.toByteArray());
        
        // 오류 상태와 함께 트레일러 전송
        responseObserver.onError(
            Status.INVALID_ARGUMENT
                .withDescription("유효성 검사 오류")
                .asRuntimeException(trailers));
    }
}

// 클라이언트 측 처리
try {
    Response response = stub.processRequest(request);
    // 성공적인 응답 처리
} catch (StatusRuntimeException e) {
    if (e.getStatus().getCode() == Status.Code.INVALID_ARGUMENT) {
        Metadata trailers = e.getTrailers();
        if (trailers != null) {
            Metadata.Key<byte[]> errorDetailsKey = 
                Metadata.Key.of("error-details-bin", Metadata.BINARY_BYTE_MARSHALLER);
            byte[] errorDetailsBytes = trailers.get(errorDetailsKey);
            
            if (errorDetailsBytes != null) {
                try {
                    ErrorDetails errorDetails = ErrorDetails.parseFrom(errorDetailsBytes);
                    logger.severe("유효성 검사 오류: " + errorDetails.getMessage());
                    for (FieldError field : errorDetails.getFieldsList()) {
                        logger.severe("필드 오류: " + field.getField() + " - " + field.getDescription());
                    }
                } catch (InvalidProtocolBufferException ipbe) {
                    logger.severe("오류 세부 정보 파싱 실패");
                }
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// 서버 측 구현
@Override
public void listUsers(ListUsersRequest request, StreamObserver<User> responseObserver) {
    try {
        // 페이지네이션 파라미터 검증
        if (request.getPageSize() <= 0) {
            responseObserver.onError(
                Status.INVALID_ARGUMENT
                    .withDescription("페이지 크기는 양수여야 합니다")
                    .asRuntimeException());
            return;
        }
        
        // 사용자 목록 조회 및 스트리밍
        List<User> users = userRepository.findUsers(request.getPageToken(), request.getPageSize());
        
        for (User user : users) {
            // 각 사용자를 스트림으로 전송
            responseObserver.onNext(user);
            
            // 컨텍스트 취소 여부 확인
            if (Context.current().isCancelled()) {
                logger.info("클라이언트가 스트림을 취소했습니다");
                return;
            }
        }
        
        responseObserver.onCompleted();
    } catch (Exception e) {
        logger.severe("사용자 목록 조회 중 오류: " + e.getMessage());
        responseObserver.onError(
            Status.INTERNAL
                .withDescription("내부 서버 오류")
                .asRuntimeException());
    }
}

// 클라이언트 측 구현
ListUsersRequest request = ListUsersRequest.newBuilder()
    .setPageSize(10)
    .build();

Iterator<User> users = blockingStub.listUsers(request);

try {
    while (users.hasNext()) {
        User user = users.next();
        // 사용자 처리
    }
} catch (StatusRuntimeException e) {
    if (e.getStatus().getCode() == Status.Code.INTERNAL) {
        logger.severe("서버 내부 오류: " + e.getStatus().getDescription());
    } else {
        logger.severe("스트리밍 오류: " + e.getStatus());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

// 서버 측 구현
@Override
public StreamObserver<User> createUsers(final StreamObserver<CreateUsersResponse> responseObserver) {
    return new StreamObserver<User>() {
        private int successCount = 0;
        private final List<String> failedUsers = new ArrayList<>();
        
        @Override
        public void onNext(User user) {
            try {
                // 사용자 유효성 검사
                if (user.getName().isEmpty()) {
                    failedUsers.add("ID: " + user.getId() + " - 이름은 필수 필드입니다");
                    return;
                }
                
                // 사용자 생성
                userRepository.createUser(user);
                successCount++;
            } catch (Exception e) {
                failedUsers.add("ID: " + user.getId() + " - " + e.getMessage());
            }
        }
        
        @Override
        public void onError(Throwable t) {
            logger.severe("클라이언트 스트림 오류: " + t.getMessage());
            Status status = Status.fromThrowable(t);
            responseObserver.onError(status.asRuntimeException());
        }
        
        @Override
        public void onCompleted() {
            // 모든 결과 요약하여 응답
            CreateUsersResponse response = CreateUsersResponse.newBuilder()
                .setSuccessCount(successCount)
                .addAllFailedUsers(failedUsers)
                .build();
            
            responseObserver.onNext(response);
            responseObserver.onCompleted();
        }
    };
}

// 클라이언트 측 구현
StreamObserver<CreateUsersResponse> responseObserver = new StreamObserver<CreateUsersResponse>() {
    @Override
    public void onNext(CreateUsersResponse response) {
        logger.info("성공적으로 생성된 사용자 수: " + response.getSuccessCount());
        for (String failure : response.getFailedUsersList()) {
            logger.warning("사용자 생성 실패: " + failure);
        }
    }
    
    @Override
    public void onError(Throwable t) {
        Status status = Status.fromThrowable(t);
        logger.severe("스트림 오류: " + status);
    }
    
    @Override
    public void onCompleted() {
        logger.info("스트림 완료");
    }
};

StreamObserver<User> requestObserver = asyncStub.createUsers(responseObserver);

try {
    for (User user : users) {
        requestObserver.onNext(user);
        
        // 일시 중단을 요청받았는지 확인
        if (Thread.currentThread().isInterrupted()) {
            throw new InterruptedException();
        }
    }
    
    requestObserver.onCompleted();
} catch (RuntimeException e) {
    requestObserver.onError(e);
    throw e;
} catch (InterruptedException e) {
    requestObserver.onError(Status.CANCELLED.withDescription("취소됨").asRuntimeException());
    Thread.currentThread().interrupt();
}