[OPIK-5689] [BE] fix: stop retrying rate-limited LLM calls and reduce log verbosity

apps/opik-backend/src/main/java/com/comet/opik/api/resources/v1/events/BaseRedisSubscriber.java

@@ -483,7 +483,7 @@ private Mono<List<ProcessingResult>> postProcessFailureMessages(List<ProcessingR
         var nonRetryable = failures.stream()
                 .filter(failure -> !isRetryableException(failure.error()))
                 .map(failure -> {
-                    log.error("Non-retryable error for messageId '{}', removing from stream",
+                    log.warn("Non-retryable error for messageId '{}', removing from stream",
                             failure.messageId(), failure.error());
                     return failure.messageId();
                 })

apps/opik-backend/src/main/java/com/comet/opik/api/resources/v1/events/OnlineScoringTraceThreadLlmAsJudgeScorer.java

@@ -99,12 +99,9 @@ protected void score(@NonNull TraceThreadToScoreLlmAsJudge message) {
                 .subscribe(
                         unused -> log.info("Processed trace threads for projectId '{}', ruleId '{}' for workspace '{}'",
                                 message.projectId(), message.ruleId(), message.workspaceId()),
-                        error -> {
-                            log.error(
-                                    "Error processing trace thread for projectId '{}', ruleId '{}' for workspace '{}': {}",
-                                    message.projectId(), message.ruleId(), message.workspaceId(), error.getMessage());
-                            log.error("Error processing trace thread scoring", error);
-                        });
+                        error -> log.error(
+                                "Error processing trace thread for projectId '{}', ruleId '{}' for workspace '{}'",
+                                message.projectId(), message.ruleId(), message.workspaceId(), error));
     }
 
     private Mono<Void> processThreadScores(TraceThreadToScoreLlmAsJudge message, String currentThreadId) {

apps/opik-backend/src/main/java/com/comet/opik/domain/llm/ChatCompletionService.java

@@ -66,7 +66,7 @@ public ChatCompletionResponse create(@NonNull ChatCompletionRequest rawRequest,
             providerError
                     .ifPresent(llmProviderError -> failHandlingLLMProviderError(runtimeException, llmProviderError));
 
-            log.error(UNEXPECTED_ERROR_CALLING_LLM_PROVIDER, runtimeException);
+            log.warn(UNEXPECTED_ERROR_CALLING_LLM_PROVIDER, runtimeException);
             throw new InternalServerErrorException(buildDetailedErrorMessage(runtimeException), runtimeException);
         }
 
@@ -117,7 +117,7 @@ public ChatResponse scoreTrace(@NonNull ChatRequest chatRequest,
             providerError
                     .ifPresent(llmProviderError -> failHandlingLLMProviderError(runtimeException, llmProviderError));
 
-            log.error(UNEXPECTED_ERROR_CALLING_LLM_PROVIDER, runtimeException);
+            log.warn(UNEXPECTED_ERROR_CALLING_LLM_PROVIDER, runtimeException);
             throw new InternalServerErrorException(buildDetailedErrorMessage(runtimeException), runtimeException);
         }
     }

apps/opik-backend/src/main/java/com/comet/opik/infrastructure/llm/openai/OpenAiErrorMessage.java

@@ -34,6 +34,9 @@ private Integer getCode(OpenAiError error) {
             case "invalid_api_key" -> 401;
             case "internal_error" -> 500;
             case "invalid_request_error" -> 400;
+            case "rate_limit_exceeded" -> 429;
+            case "insufficient_quota" -> 402;
+            case "model_not_found" -> 404;
             default -> null;
         };
     }

apps/opik-backend/src/test/java/com/comet/opik/infrastructure/llm/openai/OpenAiErrorMessageTest.java

@@ -0,0 +1,73 @@
+package com.comet.opik.infrastructure.llm.openai;
+
+import io.dropwizard.jersey.errors.ErrorMessage;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class OpenAiErrorMessageTest {
+
+    static Stream<Arguments> errorCodeMappings() {
+        return Stream.of(
+                Arguments.of("invalid_api_key", 401, "some error message"),
+                Arguments.of("internal_error", 500, "some error message"),
+                Arguments.of("invalid_request_error", 400, "some error message"),
+                Arguments.of("rate_limit_exceeded", 429, "some error message"),
+                Arguments.of("insufficient_quota", 402, "some error message"),
+                Arguments.of("model_not_found", 404, "some error message"));
+    }
+
+    @ParameterizedTest
+    @MethodSource("errorCodeMappings")
+    void toErrorMessageWhenErrorCodeReturnsExpectedHttpStatus(String errorCode, int expectedHttpStatus,
+            String message) {
+        var error = new OpenAiErrorMessage(
+                new OpenAiErrorMessage.OpenAiError(message, errorCode, "some_type"));
+
+        var expected = new ErrorMessage(expectedHttpStatus, message);
+        var actual = error.toErrorMessage();
+
+        assertThat(actual)
+                .usingRecursiveComparison()
+                .isEqualTo(expected);
+    }
+
+    static Stream<Arguments> unknownErrorCodeCases() {
+        return Stream.of(
+                Arguments.of("unknown_code", "unknown error"),
+                Arguments.of("some_other_error", "another error"));
+    }
+
+    @ParameterizedTest
+    @MethodSource("unknownErrorCodeCases")
+    void toErrorMessageWhenErrorCodeUnknownReturns500WithDetails(String errorCode, String message) {
+        var error = new OpenAiErrorMessage(
+                new OpenAiErrorMessage.OpenAiError(message, errorCode, "some_type"));
+
+        var expected = new ErrorMessage(500, message, errorCode);
+        var actual = error.toErrorMessage();
+
+        assertThat(actual)
+                .usingRecursiveComparison()
+                .isEqualTo(expected);
+    }
+
+    static Stream<Arguments> nullMessageCases() {
+        return Stream.of(
+                Arguments.of("rate_limit_exceeded"),
+                Arguments.of("unknown_code"));
+    }
+
+    @ParameterizedTest
+    @MethodSource("nullMessageCases")
+    void toErrorMessageWhenMessageNullReturnsNull(String errorCode) {
+        var error = new OpenAiErrorMessage(
+                new OpenAiErrorMessage.OpenAiError(null, errorCode, "some_type"));
+
+        assertThat(error.toErrorMessage()).isNull();
+    }
+}