sql-dialect-master 1.1.2__tar.gz → 1.1.4__tar.gz

{sql_dialect_master-1.1.2 → sql_dialect_master-1.1.4}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: sql-dialect-master
-Version: 1.1.2
+Version: 1.1.4
 Summary: SQL Dialect Master - Multi-database SQL conversion engine
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sqlglot>=25.0.0
+Requires-Dist: sqlglot<31.0.0,>=30.18.0
 Requires-Dist: streamlit>=1.38.0
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: uvicorn>=0.30.0
@@ -16,10 +16,15 @@ Requires-Dist: hypothesis>=6.112.0; extra == "dev"
 Requires-Dist: pytest>=8.3.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
 Requires-Dist: httpx>=0.27.0; extra == "dev"
+Requires-Dist: requests>=2.31.0; extra == "dev"
 Provides-Extra: qa
 Requires-Dist: ruff>=0.6; extra == "qa"
 Requires-Dist: bandit>=1.7; extra == "qa"
 Requires-Dist: pip-audit>=2.7; extra == "qa"
+Requires-Dist: build>=1.2.2; extra == "qa"
+Requires-Dist: twine>=5.1; extra == "qa"
+Requires-Dist: setuptools>=75.0.0; extra == "qa"
+Requires-Dist: wheel>=0.45; extra == "qa"
 Provides-Extra: semantic
 Requires-Dist: duckdb>=1.5.5; extra == "semantic"
 Requires-Dist: psycopg[binary]>=3.3.5; extra == "semantic"
@@ -31,7 +36,7 @@ Dynamic: license-file
 
 Enterprise-grade multi-database SQL conversion engine supporting 12 database dialects.
 
-Current release: 1.1.2
+Current release: 1.1.4
 
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -77,16 +82,18 @@ cd sql-dialect-master
 python -m pip install -e .
 ```
 
-For development and testing, install the optional development dependencies:
+For development, testing, quality checks, and local builds, use the project's
+Python environment and install the optional tooling:
 
 ```bash
-python -m pip install -e ".[dev]"
+python -m venv .venv
+.venv/bin/python -m pip install -e ".[dev,qa]"
 ```
 
 For database-backed semantic tests:
 
 ```bash
-python -m pip install -e ".[dev,semantic]"
+.venv/bin/python -m pip install -e ".[dev,semantic]"
 ```
 
 ### Run Streamlit UI (Recommended)
@@ -95,6 +102,13 @@ python -m pip install -e ".[dev,semantic]"
 streamlit run sdm_local_v2.py
 ```
 
+After installing the package, the same workspace can be launched from any
+working directory with:
+
+```bash
+sdm-streamlit
+```
+
 Open http://localhost:8501 in your browser.
 
 ### Run FastAPI Backend
@@ -105,6 +119,16 @@ uvicorn backend.api.main:app --reload
 
 API docs available at http://localhost:8000/docs
 
+Set `SDM_API_KEY` in `.env` to require credentials for `/api/*` endpoints.
+Clients may send `X-API-Key` or `Authorization: Bearer <key>`. Health probes
+use the separate `SDM_HEALTH_PROBE_TOKEN` setting. An empty API key preserves
+local access.
+
+`SDM_API_WORKERS` (default 4) and `SDM_API_QUEUE_SIZE` (default 4) bound CPU
+work. When all slots are occupied, requests receive HTTP 503 and a
+`Retry-After` header. `SDM_REQUEST_TIMEOUT` returns HTTP 504 when a request
+times out; running threads retain their capacity until they finish.
+
 ## 📖 Usage Examples
 
 ### Python SDK

{sql_dialect_master-1.1.2 → sql_dialect_master-1.1.4}/README.md

@@ -2,7 +2,7 @@
 
 Enterprise-grade multi-database SQL conversion engine supporting 12 database dialects.
 
-Current release: 1.1.2
+Current release: 1.1.4
 
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -48,16 +48,18 @@ cd sql-dialect-master
 python -m pip install -e .
 ```
 
-For development and testing, install the optional development dependencies:
+For development, testing, quality checks, and local builds, use the project's
+Python environment and install the optional tooling:
 
 ```bash
-python -m pip install -e ".[dev]"
+python -m venv .venv
+.venv/bin/python -m pip install -e ".[dev,qa]"
 ```
 
 For database-backed semantic tests:
 
 ```bash
-python -m pip install -e ".[dev,semantic]"
+.venv/bin/python -m pip install -e ".[dev,semantic]"
 ```
 
 ### Run Streamlit UI (Recommended)
@@ -66,6 +68,13 @@ python -m pip install -e ".[dev,semantic]"
 streamlit run sdm_local_v2.py
 ```
 
+After installing the package, the same workspace can be launched from any
+working directory with:
+
+```bash
+sdm-streamlit
+```
+
 Open http://localhost:8501 in your browser.
 
 ### Run FastAPI Backend
@@ -76,6 +85,16 @@ uvicorn backend.api.main:app --reload
 
 API docs available at http://localhost:8000/docs
 
+Set `SDM_API_KEY` in `.env` to require credentials for `/api/*` endpoints.
+Clients may send `X-API-Key` or `Authorization: Bearer <key>`. Health probes
+use the separate `SDM_HEALTH_PROBE_TOKEN` setting. An empty API key preserves
+local access.
+
+`SDM_API_WORKERS` (default 4) and `SDM_API_QUEUE_SIZE` (default 4) bound CPU
+work. When all slots are occupied, requests receive HTTP 503 and a
+`Retry-After` header. `SDM_REQUEST_TIMEOUT` returns HTTP 504 when a request
+times out; running threads retain their capacity until they finish.
+
 ## 📖 Usage Examples
 
 ### Python SDK

sql_dialect_master-1.1.4/backend/api/auth.py

@@ -0,0 +1,29 @@
+"""Optional shared API-key protection for business endpoints."""
+from __future__ import annotations
+
+import secrets
+
+from fastapi import HTTPException, Request
+
+from backend.core.config import settings
+
+
+async def require_api_access(request: Request) -> None:
+    """Require a configured key for /api endpoints while keeping probes separate."""
+    key = settings.api_key
+    if key is None or not request.url.path.startswith("/api/"):
+        return
+    expected = key.get_secret_value()
+    if not expected:
+        return
+    supplied = request.headers.get("X-API-Key", "")
+    if not supplied:
+        scheme, _, credential = request.headers.get("Authorization", "").partition(" ")
+        if scheme.lower() == "bearer":
+            supplied = credential
+    if not supplied or not secrets.compare_digest(supplied.encode("utf-8"), expected.encode("utf-8")):
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid or missing API key",
+            headers={"WWW-Authenticate": "Bearer"},
+        )

{sql_dialect_master-1.1.2 → sql_dialect_master-1.1.4}/backend/api/main.py

@@ -11,12 +11,14 @@ Enterprise-grade multi-database SQL conversion API:
 Exact counts are derived from the canonical data files at runtime —
 see backend.core.metadata — and must not be restated here.
 """
+import asyncio
 import logging
 import time
+from contextlib import asynccontextmanager
 from datetime import datetime
 from typing import Any, Dict, List, Optional
 
-from fastapi import FastAPI, HTTPException, Query, Request
+from fastapi import Depends, FastAPI, HTTPException, Query, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel, ConfigDict, Field
@@ -31,10 +33,43 @@ from backend.core.transpiler import SQLTranspiler
 from backend.core.type_mapping import TypeMapper
 
 from backend.api.readiness import health_probe_response
-
-# Configure logging for the application
-logger = setup_logging(level=logging.INFO)
+from backend.api.auth import require_api_access
+from backend.api.workers import BoundedWorkerPool, WorkerCapacityError
+from backend.api.rate_limit_store import InMemoryRateLimitStore
+
+# Configure logging for the application from the validated settings object.
+# Keep an INFO fallback for defensive compatibility with custom settings
+# objects, while normal AppSettings values are resolved from SDM_LOG_LEVEL.
+_log_level = getattr(logging, settings.log_level.upper(), logging.INFO)
+logger = setup_logging(level=_log_level, log_file=settings.log_file or None)
 api_logger = logging.getLogger(__name__)
+_worker_pool = BoundedWorkerPool(settings.api_workers, settings.api_queue_size)
+
+
+@asynccontextmanager
+async def lifespan(application: FastAPI):
+    """Manage the service worker pool for a normal ASGI startup/shutdown."""
+    pool = BoundedWorkerPool(settings.api_workers, settings.api_queue_size)
+    application.state.worker_pool = pool
+    try:
+        yield
+    finally:
+        pool.shutdown()
+        del application.state.worker_pool
+
+
+async def _run_cpu_bound(func, *args):
+    """Run parser/transpiler work off-loop with the configured timeout."""
+    try:
+        pool = getattr(app.state, "worker_pool", _worker_pool)
+        return await pool.run(func, *args, timeout=settings.request_timeout)
+    except WorkerCapacityError as exc:
+        raise HTTPException(status_code=503, detail=str(exc), headers={"Retry-After": "1"}) from exc
+    except asyncio.TimeoutError as exc:
+        raise HTTPException(
+            status_code=504,
+            detail="Request processing timed out",
+        ) from exc
 
 # API metadata
 API_VERSION = settings.api_version
@@ -86,6 +121,8 @@ print(response.json()["target_sql"])
 
 # Initialize FastAPI app with enhanced metadata
 app = FastAPI(
+    dependencies=[Depends(require_api_access)],
+    lifespan=lifespan,
     title=API_TITLE,
     description=API_DESCRIPTION,
     version=API_VERSION,
@@ -137,7 +174,7 @@ app.add_middleware(
     allow_origins=ALLOWED_ORIGINS,
     allow_credentials=True,
     allow_methods=["GET", "POST", "OPTIONS"],  # Restrict to needed methods
-    allow_headers=["Content-Type", "Authorization", "X-Request-ID"],
+    allow_headers=["Content-Type", "Authorization", "X-API-Key", "X-Request-ID"],
 )
 
 # Add security headers
@@ -147,6 +184,7 @@ app.add_middleware(SecurityHeadersMiddleware)
 rate_limiter = RateLimiter(
     requests_per_window=settings.rate_limit_requests,
     window_seconds=settings.rate_limit_window,
+    store=None if settings.rate_limit_enabled else InMemoryRateLimitStore(),
 )
 app.add_middleware(
     RateLimitMiddleware,
@@ -173,9 +211,8 @@ async def add_process_time_header(request: Request, call_next):
     response.headers["X-API-Version"] = API_VERSION
 
     # Log request details
-    api_logger.info(
-        f"{request.method} {request.url.path} - {response.status_code} - {process_time:.4f}s"
-    )
+    api_logger.info("%s %r - %s - %.4fs", request.method, request.url.path,
+                    response.status_code, process_time)
     return response
 
 # Dialect info for enhanced responses (from centralized config)
@@ -199,7 +236,10 @@ class ConvertRequest(BaseModel):
     sql: str = Field(..., description="Source SQL statement to convert")
     source_dialect: str = Field(..., description="Source database dialect")
     target_dialect: str = Field(..., description="Target database dialect")
-    pretty: bool = Field(True, description="Format output SQL with indentation")
+    pretty: bool = Field(
+        settings.transpiler_pretty_default,
+        description="Format output SQL with indentation",
+    )
 
     model_config = ConfigDict(json_schema_extra={
         "example": {
@@ -263,6 +303,20 @@ class NL2SQLResponse(BaseModel):
     explanation: str = Field("", description="Explanation of generated SQL")
     confidence: float = Field(0.0, description="Confidence score (0.0-1.0)")
     suggestions: List[str] = Field(default_factory=list, description="Improvement suggestions")
+    parameter_style: Optional[str] = Field(
+        None,
+        description=(
+            "Placeholder style for generated DML: numeric ($1 in PostgreSQL/Redshift, "
+            ":1 in Oracle), named (@p1 in T-SQL), format (%s in MySQL), or qmark (?)"
+        ),
+    )
+    parameters: List[str] = Field(
+        default_factory=list,
+        description="Ordered placeholders that callers must bind for generated DML",
+    )
+    evidence: Optional[Dict[str, Any]] = Field(
+        None, description="Structured evidence supporting the confidence score",
+    )
 
 class ParseRequest(BaseModel):
     """SQL parse request model."""
@@ -402,11 +456,14 @@ async def convert_sql(request: ConvertRequest):
             detail=f"Unsupported target dialect: {request.target_dialect}. Supported: {SUPPORTED_DIALECTS}"
         )
 
-    result = transpiler.transpile(
+    # sqlglot parsing/transpilation is CPU-bound.  Keep it off the event loop
+    # so one large request cannot stall unrelated async requests.
+    result = await _run_cpu_bound(
+        transpiler.transpile,
         request.sql,
         source_dialect,
         target_dialect,
-        request.pretty
+        request.pretty,
     )
     return ConvertResponse(
         success=result.success,
@@ -431,7 +488,9 @@ async def parse_sql(request: ParseRequest):
     """
     dialect = normalize_dialect(request.dialect)
     parser = SQLParser(dialect)
-    elements = parser.extract_elements(request.sql)
+    elements = await _run_cpu_bound(parser.extract_elements, request.sql)
+    if "error" in elements:
+        raise HTTPException(status_code=422, detail=elements["error"] or "SQL parsing failed")
     return {
         "success": True,
         "dialect": dialect,
@@ -455,10 +514,18 @@ async def list_functions(
     - `/api/functions?category=string` - List all string functions
     - `/api/functions?limit=100` - Get first 100 functions
     """
+    normalized_category = category.strip().lower() if category is not None else None
+    if category is not None:
+        if normalized_category not in func_encyclopedia.CATEGORIES:
+            raise HTTPException(
+                status_code=400,
+                detail=(f"Unknown function category: {category}. Available categories: "
+                        + ", ".join(func_encyclopedia.CATEGORIES)),
+            )
     if search:
         functions = func_encyclopedia.search(search, limit)
     elif category:
-        functions = func_encyclopedia.list_by_category(category)
+        functions = func_encyclopedia.list_by_category(normalized_category)[:limit]
     else:
         functions = func_encyclopedia.functions[:limit]
 
@@ -598,7 +665,8 @@ async def generate_sql(request: NL2SQLRequest):
                 "dotted identifier"
             ),
         )
-    result = nl2sql_generator.generate(
+    result = await _run_cpu_bound(
+        nl2sql_generator.generate,
         request.text,
         dialect,
         request.table_hint,
@@ -611,7 +679,10 @@ async def generate_sql(request: NL2SQLRequest):
         dialect=dialect,
         explanation=result.explanation,
         confidence=result.confidence,
-        suggestions=result.suggestions
+        suggestions=list(result.suggestions[: settings.nl2sql_max_suggestions]),
+        parameter_style=result.parameter_style,
+        parameters=list(result.parameters),
+        evidence=result.evidence.to_dict() if result.evidence is not None else None,
     )
 
 @app.get("/health", tags=["system"])
@@ -678,6 +749,7 @@ async def get_stats():
 async def custom_http_exception_handler(request: Request, exc: HTTPException):
     return JSONResponse(
         status_code=exc.status_code,
+        headers=exc.headers,
         content={
             "success": False,
             "error": {

{sql_dialect_master-1.1.2 → sql_dialect_master-1.1.4}/backend/api/middleware.py

@@ -14,10 +14,11 @@ from typing import Dict
 from fastapi import Request, Response
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.concurrency import run_in_threadpool
 
 from backend.core.exceptions import ErrorCode
 
-from .rate_limit_store import RateLimitStore, create_rate_limit_store
+from .rate_limit_store import InMemoryRateLimitStore, RateLimitStore, create_rate_limit_store
 from .readiness import health_probe_response
 
 logger = logging.getLogger(__name__)
@@ -69,13 +70,17 @@ class RateLimitMiddleware(BaseHTTPMiddleware):
         super().__init__(app)
         if max_body_bytes <= 0:
             raise ValueError("max_body_bytes must be positive")
-        self.limiter = limiter or RateLimiter()
+        self.limiter = limiter or RateLimiter(store=None if enabled else InMemoryRateLimitStore())
         self.enabled = enabled
         self.max_body_bytes = max_body_bytes
 
     async def _read_bounded_body(self, request: Request) -> Response | None:
         """Consume and cache request bodies without trusting Content-Length."""
-        if request.method in {"GET", "HEAD"}:
+        # HEAD has no response body by definition and some ASGI servers do
+        # not expose a request stream for it.  GET bodies are unusual but
+        # still need the same bound so an oversized payload cannot bypass
+        # request-size protection by changing the HTTP method.
+        if request.method == "HEAD":
             return None
         content_length = request.headers.get("content-length")
         if content_length:
@@ -83,6 +88,8 @@ class RateLimitMiddleware(BaseHTTPMiddleware):
                 declared_length = int(content_length)
             except ValueError:
                 return JSONResponse(status_code=400, content={"success": False, "error": {"code": 400, "message": "Invalid Content-Length"}, "timestamp": datetime.now().isoformat()})
+            if declared_length < 0:
+                return JSONResponse(status_code=400, content={"success": False, "error": {"code": 400, "message": "Invalid Content-Length"}, "timestamp": datetime.now().isoformat()})
             if declared_length > self.max_body_bytes:
                 return JSONResponse(status_code=413, content={"success": False, "error": {"code": 413, "message": "Request body exceeds the maximum allowed size", "max_bytes": self.max_body_bytes}, "timestamp": datetime.now().isoformat()})
 
@@ -97,6 +104,30 @@ class RateLimitMiddleware(BaseHTTPMiddleware):
         return None
 
     async def dispatch(self, request: Request, call_next) -> Response:
+        is_health_probe = (
+            request.url.path in {"/health", "/", "/ready", "/health/deep"}
+            and request.method in {"GET", "HEAD"}
+        )
+
+        # Apply rate limiting before JSON/body parsing.  This prevents a
+        # client from spending unbounded CPU on invalid payloads while still
+        # keeping the request-size guard active when rate limiting is disabled.
+        rate_limit_checked = False
+        remaining = reset_time = None
+        if self.enabled and not is_health_probe:
+            client_id = self._get_client_id(request)
+            # Redis checks use a synchronous client; a stalled store must not
+            # block the event loop used by unrelated liveness/API requests.
+            is_allowed, remaining, reset_time = await run_in_threadpool(self.limiter.is_allowed, client_id)
+            rate_limit_checked = True
+            if not is_allowed:
+                logger.warning("Rate limit exceeded for client: %s", _sanitize_log_value(client_id))
+                return JSONResponse(
+                    status_code=429,
+                    content={"success": False, "error": {"code": 429, "message": "Rate limit exceeded", "retry_after": reset_time}, "timestamp": datetime.now().isoformat()},
+                    headers={"X-RateLimit-Limit": str(self.limiter._requests_per_window), "X-RateLimit-Remaining": "0", "X-RateLimit-Reset": str(reset_time), "Retry-After": str(reset_time)},
+                )
+
         body_error = await self._read_bounded_body(request)
         if body_error is not None:
             return body_error
@@ -118,24 +149,15 @@ class RateLimitMiddleware(BaseHTTPMiddleware):
 
         if not self.enabled:
             return await call_next(request)
-        if request.url.path in {"/health", "/", "/ready", "/health/deep"} and request.method in {"GET", "HEAD"}:
+        if is_health_probe:
             if request.url.path in {"/ready", "/health/deep"}:
                 return await health_probe_response(request)
             return await call_next(request)
-
-        client_id = self._get_client_id(request)
-        is_allowed, remaining, reset_time = self.limiter.is_allowed(client_id)
-        if not is_allowed:
-            logger.warning("Rate limit exceeded for client: %s", _sanitize_log_value(client_id))
-            return JSONResponse(
-                status_code=429,
-                content={"success": False, "error": {"code": 429, "message": "Rate limit exceeded", "retry_after": reset_time}, "timestamp": datetime.now().isoformat()},
-                headers={"X-RateLimit-Limit": str(self.limiter._requests_per_window), "X-RateLimit-Remaining": "0", "X-RateLimit-Reset": str(reset_time), "Retry-After": str(reset_time)},
-            )
         response = await call_next(request)
-        response.headers["X-RateLimit-Limit"] = str(self.limiter._requests_per_window)
-        response.headers["X-RateLimit-Remaining"] = str(remaining)
-        response.headers["X-RateLimit-Reset"] = str(reset_time)
+        if rate_limit_checked:
+            response.headers["X-RateLimit-Limit"] = str(self.limiter._requests_per_window)
+            response.headers["X-RateLimit-Remaining"] = str(remaining)
+            response.headers["X-RateLimit-Reset"] = str(reset_time)
         return response
 
     def _get_client_id(self, request: Request) -> str:
@@ -167,14 +189,19 @@ class StructuredLoggingMiddleware(BaseHTTPMiddleware):
         """Normalize standard HTTP 4xx JSON responses while preserving domain-specific codes."""
         code_by_status = {
             400: ErrorCode.BAD_REQUEST.value,
+            401: ErrorCode.UNAUTHORIZED.value,
             404: ErrorCode.NOT_FOUND.value,
             405: ErrorCode.METHOD_NOT_ALLOWED.value,
             413: ErrorCode.PAYLOAD_TOO_LARGE.value,
             422: ErrorCode.VALIDATION_FAILED.value,
             429: ErrorCode.RATE_LIMITED.value,
+            503: ErrorCode.SERVICE_UNAVAILABLE.value,
+            504: ErrorCode.REQUEST_TIMEOUT.value,
         }
         if response.status_code not in code_by_status:
             return response
+        if "json" not in response.headers.get("content-type", "").lower():
+            return response
 
         try:
             if hasattr(response, "body"):
@@ -188,6 +215,16 @@ class StructuredLoggingMiddleware(BaseHTTPMiddleware):
         except (AttributeError, UnicodeDecodeError, json.JSONDecodeError):
             return response
 
+        if response.status_code == 503 and isinstance(payload, dict) and "checks" in payload:
+            # Readiness has a public diagnostics schema of its own. Preserve
+            # status/checks when the service is unhealthy, including after
+            # consuming the downstream streaming response to decode JSON.
+            headers = dict(response.headers)
+            headers.pop("content-length", None)
+            headers.pop("content-type", None)
+            payload.setdefault("request_id", request_id)
+            return JSONResponse(status_code=503, content=payload, headers=headers)
+
         error = payload.get("error") if isinstance(payload, dict) else None
         expected_code = code_by_status[response.status_code]
         if not isinstance(error, dict):

{sql_dialect_master-1.1.2 → sql_dialect_master-1.1.4}/backend/api/rate_limit_store.py

@@ -65,6 +65,8 @@ class InMemoryRateLimitStore:
 class RedisRateLimitStore:
     """Atomic fixed-window store backed by Redis for multi-worker deployments."""
 
+    DEFAULT_TIMEOUT_SECONDS = 3.0
+
     _SCRIPT = """
     local count = redis.call('INCR', KEYS[1])
     if count == 1 then
@@ -74,14 +76,29 @@ class RedisRateLimitStore:
     return {count, ttl}
     """
 
-    def __init__(self, url: str, namespace: str = "sdm:rate-limit:") -> None:
+    def __init__(
+        self,
+        url: str,
+        namespace: str = "sdm:rate-limit:",
+        timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS,
+    ) -> None:
         if not url:
             raise ValueError("Redis URL is required when rate-limit backend is redis")
+        if timeout_seconds <= 0:
+            raise ValueError("timeout_seconds must be positive")
         try:
             import redis
         except ImportError as exc:
             raise RuntimeError("Redis rate limiting requires the optional 'redis' package") from exc
-        self._client = redis.Redis.from_url(url, decode_responses=False)
+        # Bound both connection establishment and command execution.  A
+        # stalled Redis node must not block API startup or every request that
+        # checks the distributed rate-limit store.
+        self._client = redis.Redis.from_url(
+            url,
+            decode_responses=False,
+            socket_connect_timeout=timeout_seconds,
+            socket_timeout=timeout_seconds,
+        )
         self._client.ping()
         self._script = self._client.register_script(self._SCRIPT)
         self._namespace = namespace

{sql_dialect_master-1.1.2 → sql_dialect_master-1.1.4}/backend/api/readiness.py

@@ -7,6 +7,7 @@ import logging
 import os
 import secrets
 import time
+import uuid
 import weakref
 from datetime import datetime
 from typing import Any
@@ -16,6 +17,8 @@ from fastapi.responses import JSONResponse
 
 logger = logging.getLogger(__name__)
 
+from backend.core.config import settings
+
 _READINESS_CACHE_TTL_SECONDS = 5.0
 _READINESS_TIMEOUT_SECONDS = 3.0
 _READINESS_LOCKS: weakref.WeakKeyDictionary[asyncio.AbstractEventLoop, asyncio.Lock] = weakref.WeakKeyDictionary()
@@ -26,22 +29,37 @@ _HEALTH_PROBE_PATHS = {"/ready", "/health/deep"}
 
 def _probe_allowed(request: Request) -> bool:
     """Allow health probes only from loopback or with the configured probe secret."""
-    token = os.getenv("SDM_HEALTH_PROBE_TOKEN", "").strip()
+    configured = settings.health_probe_token
+    token = configured.get_secret_value().strip() if configured else ""
+    # Keep process-level test/dev overrides effective after module import;
+    # production configuration still comes from the validated singleton above
+    # (including values loaded from .env).
+    if not token:
+        token = os.environ.get("SDM_HEALTH_PROBE_TOKEN", "").strip()
     supplied = request.headers.get("X-Health-Probe-Token", "")
     if token and supplied and secrets.compare_digest(supplied, token):
         return True
+    # Once a token is configured, require it even for loopback callers.  This
+    # avoids trusting an unverified X-Forwarded-For chain in front of a proxy.
+    if token:
+        return False
     client = request.client
     return bool(client and client.host in {"127.0.0.1", "::1", "localhost"})
 
 
-def _health_probe_denied_response() -> JSONResponse:
+def _health_probe_denied_response(request: Request) -> JSONResponse:
     """Return a stable denial response for public health probe requests."""
+    request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4())
+    headers = {"X-Request-ID": request_id}
+    content = {
+        "success": False,
+        "error": {"code": 403, "message": "health probe access denied"},
+    }
+    content["request_id"] = request_id
     return JSONResponse(
         status_code=403,
-        content={
-            "success": False,
-            "error": {"code": 403, "message": "health probe access denied"},
-        },
+        content=content,
+        headers=headers,
     )
 
 
@@ -50,7 +68,7 @@ async def health_probe_response(request: Request) -> JSONResponse:
     if request.url.path not in _HEALTH_PROBE_PATHS or request.method not in {"GET", "HEAD"}:
         raise ValueError("health_probe_response called for a non-probe request")
     if not _probe_allowed(request):
-        return _health_probe_denied_response()
+        return _health_probe_denied_response(request)
     if request.url.path == "/ready":
         return await readiness_response(request)
     return await deep_health_response(request)