[OpenAI] Add traceback for internal server errors for HTTP inference endpoint (#1026)

Before this PR, it is hard to see what the root cause of an error is
when we hit an `INTERNAL_SERVER_ERROR`.

This PR adds Traceback. We test that the traceback is indeed there in
the unit test by mocking an error.

Author: CharlieFRuan

skyrl-train/skyrl_train/inference_engines/inference_engine_client_http_endpoint.py

@@ -164,6 +164,9 @@ async def handle_openai_request(raw_request: Request, endpoint: str) -> JSONResp
         )
         return JSONResponse(content=error_response.model_dump(), status_code=HTTPStatus.BAD_REQUEST.value)
     except Exception as e:
+        # Log full traceback server-side for debugging, but don't expose to client (CWE-209)
+        tb = traceback.format_exc()
+        logger.error(f"Error when handling {endpoint} request in SkyRL:\n{tb}")
         error_response = ErrorResponse(
             error=ErrorInfo(
                 message=f"Error when handling {endpoint} request in SkyRL: {str(e)}",

skyrl-train/tests/gpu/gpu_ci/test_inference_engine_client_http_endpoint.py

@@ -16,6 +16,7 @@
 from http import HTTPStatus
 from typing import Any, Dict, List, Union, Tuple
 from pathlib import Path
+from unittest.mock import patch
 import ray
 import threading
 import requests
@@ -25,12 +26,14 @@
 from litellm import completion as litellm_completion
 from litellm import acompletion as litellm_async_completion
 from litellm import atext_completion as litellm_async_text_completion
+import logging
 
 from skyrl_train.config import SkyRLConfig
 from skyrl_train.inference_engines.inference_engine_client import InferenceEngineClient
 from skyrl_train.inference_engines.base import ConversationType
 from tests.gpu.utils import init_worker_with_type, get_test_prompts
 from skyrl_train.inference_engines.utils import get_sampling_params_for_backend
+import skyrl_train.inference_engines.inference_engine_client_http_endpoint as http_endpoint_module
 from skyrl_train.inference_engines.inference_engine_client_http_endpoint import (
     serve,
     wait_for_server_ready,
@@ -595,9 +598,12 @@ class TestSchema(BaseModel):
 
 # TODO(Charlie): sglang has slightly different error response format. We need to handle it.
 @pytest.mark.vllm
-def test_http_endpoint_error_handling(ray_init_fixture):
+def test_http_endpoint_error_handling(ray_init_fixture, caplog):
     """
-    Test error handling for various invalid requests.
+    Test error handling for various invalid requests and internal server errors.
+
+    Tests validation errors (400) for invalid requests and verifies that internal
+    server errors (500) are logged with traceback server-side (not exposed to client).
     """
     try:
         cfg = get_test_actor_config(num_inference_engines=2, model=MODEL_QWEN2_5)
@@ -718,6 +724,37 @@ def test_http_endpoint_error_handling(ray_init_fixture):
         r = requests.post(f"{base_url}/v1/completions", json=bad_payload)
         assert r.status_code == HTTPStatus.BAD_REQUEST
 
+        # Test internal server errors (500) return proper error responses
+        # Traceback is logged server-side only (not exposed to client per CWE-209)
+        caplog.set_level(logging.ERROR)
+        original_client = http_endpoint_module._global_inference_engine_client
+
+        internal_error_cases = [
+            (
+                "chat_completion",
+                "/v1/chat/completions",
+                {"messages": [{"role": "user", "content": "Hello"}]},
+                KeyError("choices"),
+            ),
+            ("completion", "/v1/completions", {"prompt": "Hello"}, RuntimeError("Simulated internal error")),
+        ]
+        for method_name, endpoint, extra_payload, exception in internal_error_cases:
+
+            async def mock_raises(*args, exc=exception, **kwargs):
+                raise exc
+
+            caplog.clear()
+            with patch.object(original_client, method_name, side_effect=mock_raises):
+                response = requests.post(f"{base_url}{endpoint}", json={"model": MODEL_QWEN2_5, **extra_payload})
+            assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+            error_data = response.json()
+            error_message = error_data["error"]["message"]
+            assert str(exception) in error_message or type(exception).__name__ in error_message
+            assert "Traceback" not in error_message  # Not exposed to client (CWE-209)
+            assert error_data["error"]["code"] == 500
+            assert "Traceback (most recent call last):" in caplog.text  # Logged server-side
+            assert type(exception).__name__ in caplog.text
+
     finally:
         shutdown_server(host=SERVER_HOST, port=server_port, max_wait_seconds=5)
         if server_thread.is_alive():