서비스 메시 없이 gRPC 서비스 간 회로 차단기를 애플리케이션 레이어에서 직접 다루기

// 개념적 예시 — sony/gobreaker 기준, import 경로는 github.com/sony/gobreaker
package circuitbreaker
 
import (
    "sync"
 
    "github.com/sony/gobreaker"
)
 
type MultiServiceBreaker struct {
    mu       sync.RWMutex
    breakers map[string]*gobreaker.CircuitBreaker
    settings gobreaker.Settings
}
 
func NewMultiServiceBreaker(settings gobreaker.Settings) *MultiServiceBreaker {
    return &MultiServiceBreaker{
        breakers: make(map[string]*gobreaker.CircuitBreaker),
        settings: settings,
    }
}
 
func (m *MultiServiceBreaker) Get(service string) *gobreaker.CircuitBreaker {
    m.mu.RLock()
    cb, ok := m.breakers[service]
    m.mu.RUnlock()
    if ok {
        return cb
    }
 
    m.mu.Lock()
    defer m.mu.Unlock()
    if cb, ok = m.breakers[service]; ok {
        return cb
    }
    s := m.settings
    s.Name = service
    cb = gobreaker.NewCircuitBreaker(s)
    m.breakers[service] = cb
    return cb
}

package circuitbreaker
 
import (
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)
 
func isFailure(err error) bool {
    if err == nil {
        return false
    }
    s, ok := status.FromError(err)
    if !ok {
        return true
    }
    switch s.Code() {
    case codes.Unavailable, codes.Internal, codes.Unknown:
        return true
    case codes.DeadlineExceeded:
        return true // 팀 정책에 따라 false로 변경 가능
    default:
        return false
    }
}

package circuitbreaker
 
import (
    "context"
    "errors"
    "strings"
 
    "github.com/sony/gobreaker"
    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)
 
// method 파라미터는 "/package.ServiceName/MethodName" 형태로 전달됩니다.
// 회로 차단기 키로 서비스 이름만 뽑아 씁니다.
func extractServiceName(fullMethod string) string {
    trimmed := strings.TrimPrefix(fullMethod, "/")
    if idx := strings.Index(trimmed, "/"); idx > 0 {
        return trimmed[:idx]
    }
    return trimmed
}
 
func CircuitBreakerInterceptor(msb *MultiServiceBreaker) grpc.UnaryClientInterceptor {
    return func(
        ctx context.Context,
        method string,
        req, reply any,
        cc *grpc.ClientConn,
        invoker grpc.UnaryInvoker,
        opts ...grpc.CallOption,
    ) error {
        svcName := extractServiceName(method)
        cb := msb.Get(svcName)
 
        var callErr error
        _, cbErr := cb.Execute(func() (any, error) {
            callErr = invoker(ctx, method, req, reply, cc, opts...)
            if isFailure(callErr) {
                // gobreaker에 실패로 집계시키기 위해 원본 에러를 그대로 반환
                return nil, callErr
            }
            // NOT_FOUND 등 비즈니스 오류는 gobreaker에 성공으로 신고하고,
            // 원본 에러는 밖에서 호출자에게 그대로 돌려줍니다.
            return nil, nil
        })
 
        switch {
        case errors.Is(cbErr, gobreaker.ErrOpenState):
            return status.Errorf(codes.Unavailable, "circuit breaker open for %s", svcName)
        case errors.Is(cbErr, gobreaker.ErrTooManyRequests):
            // Half-Open 상태에서 허용 한도(MaxRequests)를 초과한 경우
            return status.Errorf(codes.Unavailable, "circuit breaker probing limit for %s", svcName)
        }
        return callErr
    }
}

// 개념적 예시 — grpc-spring-boot-starter + Resilience4j
@Component
@GrpcGlobalClientInterceptor
public class CircuitBreakerClientInterceptor implements ClientInterceptor {
 
    private final CircuitBreakerRegistry registry;
 
    public CircuitBreakerClientInterceptor(CircuitBreakerRegistry registry) {
        this.registry = registry;
    }
 
    @Override
    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
            MethodDescriptor<ReqT, RespT> method,
            CallOptions callOptions,
            Channel next) {
 
        String cbName = method.getServiceName();
        CircuitBreaker cb = registry.circuitBreaker(cbName);
 
        return new ForwardingClientCall.SimpleForwardingClientCall<>(
                next.newCall(method, callOptions)) {
 
            private long startNanos;
 
            @Override
            public void start(Listener<RespT> responseListener, Metadata headers) {
                cb.acquirePermission(); // Open 상태면 CallNotPermittedException 발생
                startNanos = System.nanoTime();
 
                super.start(new ForwardingClientCallListener
                        .SimpleForwardingClientCallListener<>(responseListener) {
                    @Override
                    public void onClose(Status status, Metadata trailers) {
                        long elapsed = System.nanoTime() - startNanos;
                        if (isGrpcFailure(status)) {
                            cb.onError(elapsed, TimeUnit.NANOSECONDS, toException(status));
                        } else {
                            cb.onSuccess(elapsed, TimeUnit.NANOSECONDS);
                        }
                        super.onClose(status, trailers);
                    }
                }, headers);
            }
        };
    }
 
    private boolean isGrpcFailure(Status status) {
        return status.getCode() == Status.Code.UNAVAILABLE
            || status.getCode() == Status.Code.INTERNAL
            || status.getCode() == Status.Code.UNKNOWN
            || status.getCode() == Status.Code.DEADLINE_EXCEEDED;
    }
 
    // 독자가 조직 규약에 맞게 구현할 헬퍼입니다.
    // 가장 단순하게는 status.asRuntimeException()을 그대로 반환하면 됩니다.
    private Throwable toException(Status status) {
        return status.asRuntimeException();
    }
}