Add centralized reliability handling for Aurora and OSDG API integrations

[mayur-rane024]

Summary

This PR introduces a focused backend reliability layer for external Aurora and OSDG API integrations.

The goal is to improve resilience around upstream API interactions while preserving existing frontend contracts and application behavior.

Why

The current backend integrations with Aurora and OSDG rely on direct upstream API calls with limited retry, timeout, and resilience handling.

This PR introduces a small centralized reliability layer to improve:

• resilience against transient upstream failures,
• safer handling of rate-limited providers,
• and consistency of external API interactions,

while intentionally preserving the existing frontend/API behavior and keeping the implementation modular.

What this PR adds

• centralized API request handling
• retry + exponential backoff for transient upstream failures
• practical timeout handling
• lightweight in-memory rate limiting
• typed upstream exceptions
• provider-specific API wrappers
• minimal no-network pytest coverage

Scope intentionally avoided

To keep this PR modular and reviewable, this does NOT include:

• frontend changes
• deployment/CI updates
• Flask architecture rewrites
• async workers/queues
• ML pipeline refactors
• response schema redesigns
• Redis/Celery/background job systems

Files added

• backend/services/errors.py
• backend/services/rate_limiter.py
• backend/services/api_client.py
• backend/services/external_apis.py

Integration updates

• backend/aurora_api.py
• backend/app.py

Tests

Added isolated pytest coverage for:

• retry behavior
• timeout handling
• rate limiting
• invalid upstream responses
• typed exception handling

Verification

Executed successfully:

python -m pytest backend/tests
python -m compileall backend

Result:

• 7 tests passed

Notes

This PR intentionally keeps the implementation small and focused to avoid overlap with existing deployment, frontend caching, logging, and response-standardization work already being discussed in the repository.

[Copilot]

Pull request overview

This PR adds a small backend reliability layer around the Aurora and OSDG upstream API calls (timeouts, retries/backoff, local rate limiting, and typed exceptions) and wires it into the existing Flask endpoints while aiming to keep the frontend contract unchanged.

Changes:

• Added APIClient + typed upstream exceptions + in-memory sliding-window rate limiter under backend/services/.
• Introduced provider-specific wrappers (classify_with_aurora, classify_with_osdg) and updated Aurora/OSDG integrations to use them.
• Added pytest coverage for retries/backoff, timeouts, rate limiting, and invalid upstream responses.

Reviewed changes

Copilot reviewed 9 out of 10 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
backend/services/errors.py	Adds typed exceptions for upstream failures.
backend/services/rate_limiter.py	Adds a thread-safe in-memory sliding window rate limiter.
backend/services/api_client.py	Adds centralized request handling with timeouts, retries, and JSON parsing.
backend/services/external_apis.py	Adds provider-specific wrappers for Aurora/OSDG calls.
backend/aurora_api.py	Switches Aurora integration to use the centralized wrapper/client.
backend/app.py	Updates Flask endpoints to use typed upstream error handling for Aurora/OSDG.
backend/tests/conftest.py	Ensures tests can import backend modules via sys.path.
backend/tests/test_api_client.py	Adds no-network tests for retry/timeout/limiting/response validation.
backend/services/__init__.py	Declares the services package.
.gitignore	Ignores Python bytecode and pytest cache artifacts.

Comments suppressed due to low confidence (1)

backend/app.py:190

• The OSDG handler catches UpstreamAPIError but always returns HTTP 500 and doesn’t surface provider/status_code, which defeats the purpose of typed upstream errors and is inconsistent with the Aurora endpoint above. Consider returning e.status_code or 502 (or similar) and including e.provider in the response for easier debugging.

    try:
        osdg_result = classify_with_osdg(projectDescription)
    except UpstreamAPIError as e:
        print(f"OSDG API request failed: {str(e)}")
        return jsonify({
            "error": f"Failed to connect to OSDG API: {str(e)}",
            "message": "OSDG API classification failed"
        }), 500

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.