fastapi-proxykit 0.1.0__py3-none-any.whl

fastapi_proxykit/__init__.py

@@ -0,0 +1,13 @@
+from fastapi_proxykit.router import proxy_router
+from fastapi_proxykit.models import ProxyConfig, ProxyRoute, BreakerConfig, ObservabilityConfig, ClientConfig
+from fastapi_proxykit.errors import ProxyErrorResponse
+
+__all__ = [
+    "proxy_router",
+    "ProxyConfig",
+    "ProxyRoute",
+    "BreakerConfig",
+    "ObservabilityConfig",
+    "ClientConfig",
+    "ProxyErrorResponse",
+]

fastapi_proxykit/breaker.py

@@ -0,0 +1,24 @@
+import functools
+
+import pybreaker
+
+from fastapi_proxykit.models import BreakerConfig
+
+
+@functools.lru_cache(maxsize=None)
+def _create_breaker_cached(
+    route_name: str, failure_threshold: int, timeout: int
+) -> pybreaker.CircuitBreaker:
+    """Cached internal factory — one breaker instance per (route_name, failure_threshold, timeout)."""
+    breaker = pybreaker.CircuitBreaker(
+        name=route_name,
+        fail_max=failure_threshold,
+        reset_timeout=timeout,
+        exclude=[pybreaker.CircuitBreakerError],
+    )
+    return breaker
+
+
+def create_breaker(route_name: str, config: BreakerConfig) -> pybreaker.CircuitBreaker:
+    """Create (or return cached) a pybreaker circuit breaker for a given route."""
+    return _create_breaker_cached(route_name, config.failure_threshold, config.timeout)

fastapi_proxykit/client.py

@@ -0,0 +1,20 @@
+import httpx
+from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
+
+from fastapi_proxykit.models import ClientConfig
+
+
+def create_http_client(config: ClientConfig, tracer_provider=None) -> httpx.AsyncClient:
+    """Create a shared httpx.AsyncClient with connection pooling and optional OTel instrumentation."""
+    client = httpx.AsyncClient(
+        timeout=httpx.Timeout(config.timeout),
+        limits=httpx.Limits(
+            max_connections=config.max_connections,
+            max_keepalive_connections=config.max_connections,
+        ),
+    )
+    if tracer_provider:
+        HTTPXClientInstrumentor.instrument_client(
+            client=client, tracer_provider=tracer_provider
+        )
+    return client

fastapi_proxykit/errors.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class ProxyErrorResponse(BaseModel):
+    error: str
+    message: str
+    route: str

fastapi_proxykit/models.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+
+class BreakerConfig(BaseModel):
+    failure_threshold: int = Field(default=5, ge=1, description="Failures before opening circuit")
+    timeout: int = Field(default=30, ge=1, description="Seconds before transitioning from open to half-open")
+
+
+class ObservabilityConfig(BaseModel):
+    tracer: Optional[object] = Field(default=None, description="OpenTelemetry tracer")
+    meter: Optional[object] = Field(default=None, description="OpenTelemetry meter")
+    logger: Optional[object] = Field(default=None, description="standard logger")
+
+
+class ClientConfig(BaseModel):
+    timeout: float = Field(default=10.0, gt=0)
+    max_connections: int = Field(default=100, ge=1)
+
+
+class ProxyRoute(BaseModel):
+    path_prefix: str = Field(description="Route path prefix, e.g. /api/users")
+    target_base_url: str = Field(description="Target base URL, e.g. https://users.example.com")
+    breaker: BreakerConfig = Field(default_factory=BreakerConfig)
+    strip_prefix: bool = Field(
+        default=False,
+        description="Strip path_prefix from forwarded URL (default: forward as-is)",
+    )
+    openapi_url: Optional[str] = Field(
+        default=None,
+        description="Override URL for target's OpenAPI spec. "
+                    "Defaults to {target_base_url}/openapi.json",
+    )
+    include_in_openapi: bool = Field(
+        default=True,
+        description="Include this route's target OpenAPI paths in the proxy's /docs",
+    )
+
+
+class ProxyConfig(BaseModel):
+    routes: list[ProxyRoute] = Field(min_length=1)
+    observability: ObservabilityConfig = Field(default_factory=ObservabilityConfig)
+    client: ClientConfig = Field(default_factory=ClientConfig)

fastapi_proxykit/openapi.py

@@ -0,0 +1,82 @@
+import httpx
+import structlog
+
+logger = structlog.get_logger()
+
+
+async def fetch_target_openapi(
+    target_base_url: str,
+    explicit_url: str | None,
+    timeout: float = 5.0,
+) -> dict | None:
+    """
+    Fetch OpenAPI spec from a target service.
+
+    If explicit_url is provided, use it. Otherwise, construct
+    {target_base_url.rstrip('/')}/openapi.json.
+
+    Returns None if the fetch fails or the response is not valid JSON.
+    """
+    url = explicit_url or f"{target_base_url.rstrip('/')}/openapi.json"
+    try:
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return response.json()
+    except Exception as exc:
+        logger.warning(
+            "proxy.openapi.fetch_failed",
+            target_base_url=target_base_url,
+            openapi_url=url,
+            exc=exc,
+        )
+        return None
+
+
+def merge_openapi_schemas(
+    proxy_spec: dict,
+    target_specs: list[dict],
+    path_prefix: str,
+) -> dict:
+    """
+    Merge target OpenAPI paths into the proxy's OpenAPI schema.
+
+    For each path in target_specs:
+      - If the path starts with the last segment of path_prefix (e.g., "/users" for prefix "/api/users"),
+        replace that segment with path_prefix (e.g., "/users" → "/api/users", "/users/{id}" → "/api/users/{id}")
+      - Otherwise, prepend path_prefix to the path
+      - Deduplicate: if a path already exists in proxy_spec, skip it
+      - Copy only the path item (no component/schema resolution — out of scope)
+
+    Returns the merged spec dict.
+    """
+    result = {
+        "openapi": proxy_spec.get("openapi", "3.1.0"),
+        "info": proxy_spec.get("info", {"title": "Proxy API", "version": "1.0.0"}),
+        "paths": dict(proxy_spec.get("paths", {})),
+    }
+
+    # Get the last segment of path_prefix for substitution matching
+    prefix_segments = path_prefix.strip("/").split("/")
+    last_prefix_segment = prefix_segments[-1] if prefix_segments else ""
+
+    for spec in target_specs:
+        if not spec:
+            logger.debug("proxy.openapi.skipping_empty_spec")
+            continue
+        target_paths = spec.get("paths", {})
+        for path, path_item in target_paths.items():
+            # Check if path starts with the last segment of prefix (for substitution)
+            if last_prefix_segment and path.startswith(f"/{last_prefix_segment}"):
+                # Replace the first occurrence of /{last_segment} with path_prefix
+                rest_of_path = path[len(f"/{last_prefix_segment}"):]
+                prefixed = path_prefix.rstrip("/") + rest_of_path
+            else:
+                # Otherwise, simply prepend the prefix
+                prefixed = f"{path_prefix.rstrip('/')}/{path.lstrip('/')}"
+            prefixed = "/" + prefixed.strip("/")
+            if prefixed not in result["paths"]:
+                result["paths"][prefixed] = path_item
+                logger.debug("proxy.openapi.path_merged", path=prefixed)
+
+    return result

fastapi_proxykit/router.py

@@ -0,0 +1,218 @@
+from contextlib import asynccontextmanager
+
+from fastapi import APIRouter, Request, Response
+import httpx
+import pybreaker
+import time
+import structlog
+from opentelemetry.trace import StatusCode
+from opentelemetry import metrics
+
+from fastapi_proxykit.models import ProxyConfig, ProxyRoute
+from fastapi_proxykit.breaker import create_breaker
+from fastapi_proxykit.client import create_http_client
+from fastapi_proxykit.errors import ProxyErrorResponse
+from fastapi_proxykit.openapi import fetch_target_openapi, merge_openapi_schemas
+
+
+def proxy_router(config: ProxyConfig) -> APIRouter:
+    """Create a pluggable proxy router for a FastAPI app."""
+    tracer = config.observability.tracer
+    http_client = create_http_client(config.client, tracer_provider=tracer)
+
+    @asynccontextmanager
+    async def lifespan(app: APIRouter):
+        yield
+        await http_client.aclose()
+
+    router = APIRouter(lifespan=lifespan)
+
+    route_map: dict[str, ProxyRoute] = {r.path_prefix: r for r in config.routes}
+    breakers: dict[str, pybreaker.CircuitBreaker] = {
+        r.path_prefix: create_breaker(r.path_prefix, r.breaker) for r in config.routes
+    }
+
+    async def _build_merged_openapi() -> dict:
+        """Fetch and merge all target OpenAPI specs."""
+        merged = {
+            "openapi": "3.1.0",
+            "info": {"title": "Proxy API", "version": "1.0.0"},
+            "paths": {},
+        }
+        for route in config.routes:
+            if not route.include_in_openapi:
+                continue
+            openapi_fetch_url = route.openapi_url or f"{route.target_base_url}/openapi.json"
+            spec = await fetch_target_openapi(route.target_base_url, openapi_fetch_url)
+            if spec:
+                merged = merge_openapi_schemas(merged, [spec], route.path_prefix)
+            else:
+                logger.warning(
+                    "proxy.openapi.skipping_route",
+                    route=route.path_prefix,
+                    reason="fetch_failed",
+                )
+        return merged
+
+    # Lazily built and cached merged spec
+    _cached_openapi: dict | None = None
+
+    @router.get("/openapi.json", include_in_schema=False)
+    async def get_openapi(request: Request) -> dict:
+        nonlocal _cached_openapi
+        if _cached_openapi is None:
+            _cached_openapi = await _build_merged_openapi()
+        return _cached_openapi
+
+    @router.get("/docs", include_in_schema=False)
+    async def get_docs():
+        from fastapi.responses import RedirectResponse
+        return RedirectResponse(url="/docs")
+
+    @router.get("/redoc", include_in_schema=False)
+    async def get_redoc():
+        from fastapi.responses import RedirectResponse
+        return RedirectResponse(url="/redoc")
+
+    # Observability instruments
+    meter = config.observability.meter
+    request_counter = None
+    request_latency = None
+    if meter:
+        request_counter = meter.create_counter(
+            name="proxy.requests",
+            description="Total proxy requests",
+            unit="1",
+        )
+        request_latency = meter.create_histogram(
+            name="proxy.request.duration",
+            description="Proxy request duration in seconds",
+            unit="s",
+        )
+
+    logger = config.observability.logger or structlog.get_logger()
+
+    async def _make_request(
+        method: str, target_url: str, request: Request
+    ) -> httpx.Response:
+        """Bare HTTP request — called inside breaker.call() for circuit management."""
+        resp = await http_client.request(
+            method=method,
+            url=target_url,
+            headers=dict(request.headers),
+            content=await request.body(),
+            params=request.query_params,
+        )
+        return resp
+
+    @router.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"])
+    async def proxy_request(path: str, request: Request) -> Response:
+        # Longest-prefix match with normalized slashes
+        matched_route: ProxyRoute | None = None
+        matched_prefix: str | None = None
+        for prefix in route_map:
+            normalized_prefix = prefix if prefix.startswith("/") else "/" + prefix
+            normalized_path = "/" + path
+            if normalized_path.startswith(normalized_prefix):
+                if matched_prefix is None or len(prefix) > len(matched_prefix):
+                    matched_prefix = prefix
+                    matched_route = route_map[prefix]
+
+        if matched_route is None:
+            return Response(status_code=404, content="No matching route")
+
+        # Strip the matched prefix from the path to get the actual target path
+        if matched_route.strip_prefix:
+            prefix_len = len(matched_route.path_prefix)
+            if not matched_route.path_prefix.startswith("/"):
+                prefix_len -= 1
+            remaining_path = path[prefix_len:] if len(path) > prefix_len else ""
+        else:
+            remaining_path = path
+        target_url = f"{matched_route.target_base_url.rstrip('/')}/{remaining_path.lstrip('/')}"
+        breaker = breakers[matched_route.path_prefix]
+
+        span = None
+        if tracer:
+            span = tracer.start_span(f"proxy/{matched_route.path_prefix}")
+            span.set_attribute("route", matched_route.path_prefix)
+            span.set_attribute("target_url", target_url)
+
+        start_time = time.perf_counter()
+        try:
+            resp = await breaker.call(_make_request, request.method, target_url, request)
+            duration = time.perf_counter() - start_time
+            result = Response(
+                content=resp.content,
+                status_code=resp.status_code,
+                headers=dict(resp.headers),
+            )
+            if span:
+                span.set_attribute("http.status_code", result.status_code)
+
+            if request_counter:
+                request_counter.add(1, {"route": matched_route.path_prefix, "status": str(result.status_code)})
+            if request_latency:
+                request_latency.record(duration, {"route": matched_route.path_prefix})
+
+            logger.info(
+                "proxy.request.forwarded",
+                route=matched_route.path_prefix,
+                method=request.method,
+                path=path,
+                status_code=result.status_code,
+                duration_ms=round(duration * 1000, 2),
+            )
+
+            return result
+        except pybreaker.CircuitBreakerError as exc:
+            duration = time.perf_counter() - start_time
+            if span:
+                span.set_attribute("http.status_code", 503)
+                span.record_exception(exc)
+                span.set_status(StatusCode.ERROR, str(exc))
+            logger.error("proxy.circuit_breaker.open", route=matched_route.path_prefix)
+            return Response(
+                status_code=503,
+                content=ProxyErrorResponse(
+                    error="circuit_breaker_open",
+                    message="Target service unavailable",
+                    route=matched_route.path_prefix,
+                ).model_dump_json(),
+                media_type="application/json",
+            )
+        except httpx.TimeoutException as exc:
+            breaker.increment_failure()
+            if span:
+                span.record_exception(exc)
+                span.set_status(StatusCode.ERROR, str(exc))
+            logger.error("proxy.timeout", route=matched_route.path_prefix, exc=exc)
+            return Response(
+                status_code=504,
+                content=ProxyErrorResponse(
+                    error="timeout",
+                    message="Gateway timeout",
+                    route=matched_route.path_prefix,
+                ).model_dump_json(),
+                media_type="application/json",
+            )
+        except Exception as exc:
+            breaker.increment_failure()
+            if span:
+                span.record_exception(exc)
+                span.set_status(StatusCode.ERROR, str(exc))
+            logger.error("proxy.error", route=matched_route.path_prefix, exc=exc)
+            return Response(
+                status_code=503,
+                content=ProxyErrorResponse(
+                    error="connection_error",
+                    message="Target service unavailable",
+                    route=matched_route.path_prefix,
+                ).model_dump_json(),
+                media_type="application/json",
+            )
+        finally:
+            if span:
+                span.end()
+
+    return router

fastapi_proxykit-0.1.0.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.3
+Name: fastapi-proxykit
+Version: 0.1.0
+Summary: A production-ready FastAPI plugin for transparent HTTP proxying with per-route circuit breakers and OpenTelemetry observability.
+Keywords: fastapi,proxy,http-proxy,circuit-breaker,opentelemetry,resilience
+Author: Satyam Soni
+Author-email: Satyam Soni <satyam_soni1@epam.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Networking
+Requires-Dist: fastapi>=0.135.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: opentelemetry-api>=1.40.0
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.61b0
+Requires-Dist: opentelemetry-sdk>=1.40.0
+Requires-Dist: pybreaker>=1.4.1
+Requires-Dist: structlog>=24.0.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Python-3.13+-3775A9?style=for-the-badge&logo=python&logoColor=white" alt="Python" />
+  <img src="https://img.shields.io/badge/FastAPI-0.115+-009688?style=for-the-badge&logo=fastapi&logoColor=white" alt="FastAPI" />
+  <img src="https://img.shields.io/github/license/satyamsoni2211/fastapi_proxykit?style=for-the-badge&color=green" alt="License" />
+  <img src="https://img.shields.io/github/stars/satyamsoni2211/fastapi_proxykit?style=for-the-badge&color=yellow" alt="Stars" />
+  <img src="https://img.shields.io/badge/Install%20from%20source-✓-success?style=for-the-badge" alt="Installable" />
+</p>
+
+<h1 align="center">⚡ fastapi-proxykit</h1>
+
+<p align="center">
+  <b>Production-ready transparent proxy routes for FastAPI</b><br>
+  Turn your FastAPI app into a resilient API gateway with per-route circuit breakers, OpenTelemetry observability, and automatic OpenAPI merging — zero boilerplate.
+</p>
+
+<p align="center">
+  <a href="#-features">Features</a> •
+  <a href="#-quick-start">Quick Start</a> •
+  <a href="#-installation">Installation</a> •
+  <a href="#-configuration">Configuration</a> •
+  <a href="#-examples">Examples</a> •
+  <a href="#-why-use-it">Why?</a> •
+  <a href="#-license">License</a>
+</p>
+
+<div align="center">
+  <img src="https://via.placeholder.com/900x450/0d1117/58a6ff?text=fastapi-proxykit+in+action" alt="fastapi-proxykit architecture" width="900" />
+  <!-- Replace with real diagram later (e.g. Excalidraw: client → FastAPI → proxykit → multiple backends with traces & breakers) -->
+</div>
+
+## ✨ Features
+
+- 🔀 **Transparent proxying** — preserve path, query params, headers automatically
+- 🛡️ **Per-route circuit breakers** — isolated resilience with `pybreaker` (no cascading failures)
+- 📊 **Full OpenTelemetry support** — tracing, metrics, custom tracer/meter injection
+- 📖 **Automatic OpenAPI merging** — unified `/docs` from all backend services
+- ⚡ **Non-blocking I/O** — `httpx.AsyncClient` with pooling & configurable limits
+- 🧩 **Declarative config** — clean Pydantic-powered routes & settings
+- 🛠 **Structured errors** — consistent JSON responses (503 breaker open, 504 timeout, etc.)
+- 🔌 **Lifespan-aware** — client auto cleanup on shutdown
+- 🆓 **Zero external agents** required for observability
+
+## 🚀 Quick Start
+
+```bash
+# Clone & install from source
+git clone https://github.com/satyamsoni2211/fastapi_proxykit.git
+cd fastapi_proxykit
+pip install .          # or: uv pip install .
+```
+
+```python
+from fastapi import FastAPI
+from fastapi_proxykit import proxy_router, ProxyConfig, ProxyRoute, BreakerConfig
+
+app = FastAPI()
+
+app.include_router(
+    proxy_router(
+        ProxyConfig(
+            routes=[
+                ProxyRoute(
+                    path_prefix="/api/users",
+                    target_base_url="https://users.example.com",
+                    breaker=BreakerConfig(failure_threshold=5, timeout=30),
+                    strip_prefix=True,
+                ),
+                ProxyRoute(
+                    path_prefix="/api/orders",
+                    target_base_url="https://orders.example.com",
+                    breaker=BreakerConfig(failure_threshold=3, timeout=15),
+                ),
+            ]
+        )
+    )
+)
+```
+
+→ `GET /api/users/42` proxies to `https://users.example.com/42`
+
+## 📦 Installation
+
+```bash
+# From source (recommended for now)
+pip install git+https://github.com/satyamsoni2211/fastapi_proxykit.git
+# or clone & install locally
+git clone https://github.com/satyamsoni2211/fastapi_proxykit.git
+cd fastapi_proxykit
+pip install .
+```
+
+**Requirements**: Python 3.13+
+
+## ⚙️ Configuration
+
+Full power via `ProxyConfig`:
+
+```python
+from fastapi_proxykit import ProxyConfig, ProxyRoute, BreakerConfig, ObservabilityConfig, ClientConfig
+
+config = ProxyConfig(
+    routes=[
+        ProxyRoute(
+            path_prefix="/api/v1/users",
+            target_base_url="https://users-service.internal",
+            strip_prefix=True,
+            breaker=BreakerConfig(failure_threshold=5, timeout=30),
+            include_in_openapi=True,
+        ),
+        # ... more routes
+    ],
+    observability=ObservabilityConfig(
+        tracer=your_tracer,   # opentelemetry trace.get_tracer()
+        meter=your_meter,     # opentelemetry metrics.get_meter()
+        logger=your_logger,   # optional structlog / logging
+    ),
+    client=ClientConfig(
+        timeout=15.0,
+        max_connections=200,
+    ),
+)
+```
+
+### Unified OpenAPI (recommended)
+
+```python
+app = FastAPI(openapi_url=None, docs_url=None, redoc_url=None)
+app.include_router(proxy_router(config))
+```
+
+→ All backend OpenAPI specs merged at `/docs` with prefixed paths.
+
+## 📚 Examples
+
+See the [`examples/`](./examples) folder:
+
+- `api_gateway/` — Multi-service gateway with different breaker settings
+- `legacy_facade/` — Modern prefix for legacy backend
+- `multi_env/` — Route to dev/staging/prod based on env
+
+Run any example:
+```bash
+uv run python -m uvicorn examples.api_gateway.main:app --reload --port 8000
+```
+
+## 🤔 Why fastapi-proxykit? — Real Developer Benefits
+
+Building proxy/routing logic in FastAPI often means repeating the same boilerplate — manual `httpx` calls, error handling, timeouts, resilience patterns, tracing, and fragmented docs. **fastapi-proxykit** eliminates this repetition with a **single, configurable, production-grade component**.
+
+Here's how it directly benefits you as a developer:
+
+- **Save hours (or days) of repetitive coding**  
+  Instead of hand-writing proxy endpoints for every backend service (with custom path handling, headers forwarding, timeouts, etc.), you define routes declaratively once via `ProxyRoute`. Drop it in with `app.include_router(proxy_router(config))` — instant transparent proxying. No more duplicating `async def proxy_xxx(...)` functions.
+
+- **Prevent cascading failures & protect your backends**  
+  Per-route circuit breakers (`pybreaker`) isolate failures: if `/api/users` backend flakes out (e.g., 5 failures in a row), that route "opens" automatically — returning fast 503s instead of hanging clients or hammering the failing service. Other routes (e.g., `/api/orders`) keep working normally. This is huge for microservices/gateway patterns — no more "one slow service kills the whole app".
+
+- **Debug & monitor like a pro — zero extra instrumentation**  
+  Full OpenTelemetry integration (traces, metrics, optional structured logs) out-of-the-box. Inject your existing tracer/meter/logger — every proxied request gets spans with target URL, status, duration, errors, etc.  
+  → Quickly spot slow backends, high-latency routes, error spikes, or retry storms in production. No manual `@tracer.start_as_current_span()` everywhere.
+
+- **Unified Swagger/OpenAPI docs — one `/docs` to rule them all**  
+  Automatically fetches each backend's `/openapi.json`, prefixes paths (e.g., `/api/users/*` → shows as `/api/users/...` in UI), and merges into your app's docs.  
+  → Developers/consumers see a single, complete API surface instead of jumping between 5+ service docs. Great for internal APIs, partner integrations, or self-documenting gateways.
+
+- **Scale confidently with non-blocking, pooled I/O**  
+  Uses `httpx.AsyncClient` under the hood with configurable connection limits, timeouts, and pooling. Fully async — no thread blocking, supports high concurrency without spiking CPU/memory.  
+  → Your gateway stays responsive even under heavy load or when proxying many slow backends.
+
+- **Consistent, client-friendly errors — no ugly 502s**  
+  Structured JSON responses for failures:  
+  ```json
+  {"error": "circuit_breaker_open", "message": "Target service temporarily unavailable"}
+  ```  
+  or 504 on timeout. Easy for frontend/mobile clients to handle gracefully.
+
+- **Clean separation for complex architectures**  
+  Ideal for:  
+  - **Microservices gateway** — route `/users`, `/orders`, `/payments` to isolated services with different resilience rules  
+  - **Legacy modernization** — facade old APIs behind modern prefixes without rewriting clients  
+  - **Multi-env routing** — `/dev/*` → dev cluster, `/prod/*` → production  
+  - **Observability-first teams** — plug into existing OTEL collectors (Jaeger, Zipkin, Prometheus, etc.) without changing code
+
+In short: **fastapi-proxykit** turns painful, error-prone proxy boilerplate into a **declarative, resilient, observable feature** — letting you focus on business logic instead of infrastructure plumbing.
+
+Many FastAPI developers end up reinventing 80% of this themselves. With proxykit, you get it right the first time — resilient, observable, and maintainable.
+
+
+
+| Without proxykit                          | With fastapi-proxykit                          |
+|-------------------------------------------|------------------------------------------------|
+| Manual httpx per endpoint                 | One config → all routes                        |
+| No resilience → cascading failures        | Per-route circuit breakers                     |
+| Fragmented /docs per service              | Merged, prefixed OpenAPI in single UI          |
+| Custom tracing boilerplate                | Automatic OpenTelemetry spans & metrics        |
+| Risk of blocking I/O                      | Fully async + pooled connections               |
+
+## Contributing
+
+Contributions welcome!  
+1. Fork the repo  
+2. Create feature branch (`git checkout -b feature/amazing-thing`)  
+3. Commit (`git commit -m 'Add amazing thing'`)  
+4. Push & open PR
+
+## 📄 License
+
+MIT License — see [`LICENSE`](./LICENSE)
+
+---
+
+<p align="center">
+  Made with ❤️ by <a href="https://github.com/satyamsoni2211">Satyam Soni</a> •
+  <a href="https://x.com/_satyamsoni_">@_satyamsoni_</a>
+</p>
+
+<p align="center">
+  <a href="https://github.com/satyamsoni2211/fastapi_proxykit/issues/new?labels=enhancement&title=Feature+request">Suggest Feature</a>
+  ·
+  <a href="https://github.com/satyamsoni2211/fastapi_proxykit/issues/new?labels=bug&title=Bug">Report Bug</a>
+</p>

fastapi_proxykit-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+fastapi_proxykit/__init__.py,sha256=S5mcqjIzsFnJ0opam0LP4J21YqfqCqjeA8x8EKl2_oQ,380
+fastapi_proxykit/breaker.py,sha256=CJWuEG-bWXYClIZzdXCyRDTuw08C0M9B5xsHy88z980,812
+fastapi_proxykit/client.py,sha256=Mg2PSATe4XJqvbzRToy8707zFTCs9xRMdP0gojSYFe8,730
+fastapi_proxykit/errors.py,sha256=TrgDG2Ol-M1GP8qFzMCVnTjBtJ_7PYmpPmBQqP1OM6I,117
+fastapi_proxykit/models.py,sha256=4F4PUP-SJy7CPLeoJgJFcugYKsmQDNtvyalE-79UDGA,1732
+fastapi_proxykit/openapi.py,sha256=XNjdnVkit32cyIpSAG8tra-ryEqfaqMyM3r6VGZUNZU,3038
+fastapi_proxykit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_proxykit/router.py,sha256=cMhvqMRk7hTDfZXNjqDqqF3IWGJYYcejflJs9FL1qU0,8532
+fastapi_proxykit-0.1.0.dist-info/WHEEL,sha256=9sjN42GvvIkyGb9JrWAWXnA96E2dxDe0tzHzrLxUlD4,81
+fastapi_proxykit-0.1.0.dist-info/METADATA,sha256=4Mt7H8uo2f7Hyn1U-T0Ib2Hay5_pMfF4njTiZnGcZeA,11120
+fastapi_proxykit-0.1.0.dist-info/RECORD,,

fastapi_proxykit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.10.11
+Root-Is-Purelib: true
+Tag: py3-none-any