arize-phoenix 4.36.0__py3-none-any.whl → 5.0.0__py3-none-any.whl

phoenix/server/rate_limiters.py

@@ -0,0 +1,191 @@
+import re
+import time
+from collections import defaultdict
+from functools import partial
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    DefaultDict,
+    List,
+    Optional,
+    Pattern,  # import from re module when we drop support for 3.8
+    Union,
+)
+
+from fastapi import HTTPException, Request
+
+from phoenix.config import get_env_enable_prometheus
+from phoenix.exceptions import PhoenixException
+
+
+class UnavailableTokensError(PhoenixException):
+    pass
+
+
+class TokenBucket:
+    """
+    An implementation of the token-bucket algorithm for use as a rate limiter.
+
+    Args:
+        per_second_request_rate (float): The allowed request rate.
+        enforcement_window_minutes (float): The time window over which the rate limit is enforced.
+    """
+
+    def __init__(
+        self,
+        per_second_request_rate: float,
+        enforcement_window_seconds: float = 1,
+    ):
+        self.enforcement_window = enforcement_window_seconds
+        self.rate = per_second_request_rate
+
+        now = time.time()
+        self.last_checked = now
+        self.tokens = self.max_tokens()
+
+    def max_tokens(self) -> float:
+        return self.rate * self.enforcement_window
+
+    def available_tokens(self) -> float:
+        now = time.time()
+        time_since_last_checked = now - self.last_checked
+        self.tokens = min(self.max_tokens(), self.rate * time_since_last_checked + self.tokens)
+        self.last_checked = now
+        return self.tokens
+
+    def make_request_if_ready(self) -> None:
+        if self.available_tokens() < 1:
+            if get_env_enable_prometheus():
+                from phoenix.server.prometheus import RATE_LIMITER_THROTTLES
+
+                RATE_LIMITER_THROTTLES.inc()
+            raise UnavailableTokensError
+        self.tokens -= 1
+
+
+class ServerRateLimiter:
+    """
+    This rate limiter holds a cache of token buckets that enforce rate limits.
+
+    The cache is kept in partitions that rotate every `partition_seconds`. Each user's rate limiter
+    can be accessed from all active partitions, the number of active partitions is set with
+    `active_partitions`. This guarantees that a user's rate limiter will sit in the cache for at
+    least:
+
+        minimum_cache_lifetime = (active_partitions - 1) * partition_seconds
+
+    Every time the cache is accessed, inactive partitions are purged. If enough time has passed,
+    the entire cache is purged.
+    """
+
+    def __init__(
+        self,
+        per_second_rate_limit: float = 0.5,
+        enforcement_window_seconds: float = 5,
+        partition_seconds: float = 60,
+        active_partitions: int = 2,
+    ):
+        self.bucket_factory = partial(
+            TokenBucket,
+            per_second_request_rate=per_second_rate_limit,
+            enforcement_window_seconds=enforcement_window_seconds,
+        )
+        self.partition_seconds = partition_seconds
+        self.active_partitions = active_partitions
+        self.num_partitions = active_partitions + 2  # two overflow partitions to avoid edge cases
+        self._reset_rate_limiters()
+        self._last_cleanup_time = time.time()
+
+    def _reset_rate_limiters(self) -> None:
+        self.cache_partitions: List[DefaultDict[Any, TokenBucket]] = [
+            defaultdict(self.bucket_factory) for _ in range(self.num_partitions)
+        ]
+
+    def _current_partition_index(self, timestamp: float) -> int:
+        return (
+            int(timestamp // self.partition_seconds) % self.num_partitions
+        )  # a cyclic bucket index
+
+    def _active_partition_indices(self, current_index: int) -> List[int]:
+        return [(current_index - ii) % self.num_partitions for ii in range(self.active_partitions)]
+
+    def _inactive_partition_indices(self, current_index: int) -> List[int]:
+        active_indices = set(self._active_partition_indices(current_index))
+        all_indices = set(range(self.num_partitions))
+        return list(all_indices - active_indices)
+
+    def _cleanup_expired_limiters(self, request_time: float) -> None:
+        time_since_last_cleanup = request_time - self._last_cleanup_time
+        if time_since_last_cleanup >= ((self.num_partitions - 1) * self.partition_seconds):
+            # Reset the cache to avoid "looping" back to the same partitions
+            self._reset_rate_limiters()
+            self._last_cleanup_time = request_time
+            return
+
+        current_partition_index = self._current_partition_index(request_time)
+        inactive_indices = self._inactive_partition_indices(current_partition_index)
+        for ii in inactive_indices:
+            self.cache_partitions[ii] = defaultdict(self.bucket_factory)
+        self._last_cleanup_time = request_time
+
+    def _fetch_token_bucket(self, key: str, request_time: float) -> TokenBucket:
+        current_partition_index = self._current_partition_index(request_time)
+        active_indices = self._active_partition_indices(current_partition_index)
+        bucket: Optional[TokenBucket] = None
+        for ii in active_indices:
+            partition = self.cache_partitions[ii]
+            if key in partition:
+                bucket = partition.pop(key)
+                break
+
+        current_partition = self.cache_partitions[current_partition_index]
+        if key not in current_partition and bucket is not None:
+            current_partition[key] = bucket
+        return current_partition[key]
+
+    def make_request(self, key: str) -> None:
+        request_time = time.time()
+        self._cleanup_expired_limiters(request_time)
+        rate_limiter = self._fetch_token_bucket(key, request_time)
+        rate_limiter.make_request_if_ready()
+        if get_env_enable_prometheus():
+            from phoenix.server.prometheus import RATE_LIMITER_CACHE_SIZE
+
+            RATE_LIMITER_CACHE_SIZE.set(sum(len(partition) for partition in self.cache_partitions))
+
+
+def fastapi_ip_rate_limiter(
+    rate_limiter: ServerRateLimiter, paths: Optional[List[Union[str, Pattern[str]]]] = None
+) -> Callable[[Request], Coroutine[Any, Any, Request]]:
+    async def dependency(request: Request) -> Request:
+        if paths is None or any(path_match(request.url.path, path) for path in paths):
+            client = request.client
+            if client:  # bypasses rate limiter if no client
+                client_ip = client.host
+                try:
+                    rate_limiter.make_request(client_ip)
+                except UnavailableTokensError:
+                    raise HTTPException(status_code=429, detail="Too Many Requests")
+        return request
+
+    return dependency
+
+
+def fastapi_route_rate_limiter(
+    rate_limiter: ServerRateLimiter,
+) -> Callable[[Request], Coroutine[Any, Any, Request]]:
+    async def dependency(request: Request) -> Request:
+        try:
+            rate_limiter.make_request(request.url.path)
+        except UnavailableTokensError:
+            raise HTTPException(status_code=429, detail="Too Many Requests")
+        return request
+
+    return dependency
+
+
+def path_match(path: str, match_pattern: Union[str, Pattern[str]]) -> bool:
+    if isinstance(match_pattern, re.Pattern):
+        return bool(match_pattern.match(path))
+    return path == match_pattern

phoenix/server/static/.vite/manifest.json

@@ -1,32 +1,32 @@
 {
-  "_components-Dte7_KRd.js": {
-    "file": "assets/components-Dte7_KRd.js",
+  "_components-REunxTt6.js": {
+    "file": "assets/components-REunxTt6.js",
     "name": "components",
     "imports": [
-      "_vendor-BC3OPQuM.js",
-      "_vendor-arizeai-NjB3cZzD.js",
-      "_pages-CnTvEGEN.js",
+      "_vendor-B5IC0ivG.js",
+      "_vendor-arizeai-aFbT4kl1.js",
+      "_pages-1VrMk2pW.js",
       "_vendor-three-DwGkEfCM.js",
-      "_vendor-codemirror-gE_JCOgX.js"
+      "_vendor-codemirror-BEGorXSV.js"
     ]
   },
-  "_pages-CnTvEGEN.js": {
-    "file": "assets/pages-CnTvEGEN.js",
+  "_pages-1VrMk2pW.js": {
+    "file": "assets/pages-1VrMk2pW.js",
     "name": "pages",
     "imports": [
-      "_vendor-BC3OPQuM.js",
-      "_components-Dte7_KRd.js",
-      "_vendor-arizeai-NjB3cZzD.js",
-      "_vendor-recharts-BXLYwcXF.js",
-      "_vendor-codemirror-gE_JCOgX.js"
+      "_vendor-B5IC0ivG.js",
+      "_vendor-arizeai-aFbT4kl1.js",
+      "_components-REunxTt6.js",
+      "_vendor-recharts-6nUU7gU_.js",
+      "_vendor-codemirror-BEGorXSV.js"
     ]
   },
   "_vendor-!~{003}~.js": {
     "file": "assets/vendor-DxkFTwjz.css",
     "src": "_vendor-!~{003}~.js"
   },
-  "_vendor-BC3OPQuM.js": {
-    "file": "assets/vendor-BC3OPQuM.js",
+  "_vendor-B5IC0ivG.js": {
+    "file": "assets/vendor-B5IC0ivG.js",
     "name": "vendor",
     "imports": [
       "_vendor-three-DwGkEfCM.js"
@@ -35,25 +35,25 @@
       "assets/vendor-DxkFTwjz.css"
     ]
   },
-  "_vendor-arizeai-NjB3cZzD.js": {
-    "file": "assets/vendor-arizeai-NjB3cZzD.js",
+  "_vendor-arizeai-aFbT4kl1.js": {
+    "file": "assets/vendor-arizeai-aFbT4kl1.js",
     "name": "vendor-arizeai",
     "imports": [
-      "_vendor-BC3OPQuM.js"
+      "_vendor-B5IC0ivG.js"
     ]
   },
-  "_vendor-codemirror-gE_JCOgX.js": {
-    "file": "assets/vendor-codemirror-gE_JCOgX.js",
+  "_vendor-codemirror-BEGorXSV.js": {
+    "file": "assets/vendor-codemirror-BEGorXSV.js",
     "name": "vendor-codemirror",
     "imports": [
-      "_vendor-BC3OPQuM.js"
+      "_vendor-B5IC0ivG.js"
     ]
   },
-  "_vendor-recharts-BXLYwcXF.js": {
-    "file": "assets/vendor-recharts-BXLYwcXF.js",
+  "_vendor-recharts-6nUU7gU_.js": {
+    "file": "assets/vendor-recharts-6nUU7gU_.js",
     "name": "vendor-recharts",
     "imports": [
-      "_vendor-BC3OPQuM.js"
+      "_vendor-B5IC0ivG.js"
     ]
   },
   "_vendor-three-DwGkEfCM.js": {
@@ -61,18 +61,18 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-fq1-hCK4.js",
+    "file": "assets/index-DAPJxlCw.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
-      "_vendor-BC3OPQuM.js",
-      "_vendor-arizeai-NjB3cZzD.js",
-      "_pages-CnTvEGEN.js",
-      "_components-Dte7_KRd.js",
+      "_vendor-B5IC0ivG.js",
+      "_vendor-arizeai-aFbT4kl1.js",
+      "_pages-1VrMk2pW.js",
+      "_components-REunxTt6.js",
       "_vendor-three-DwGkEfCM.js",
-      "_vendor-recharts-BXLYwcXF.js",
-      "_vendor-codemirror-gE_JCOgX.js"
+      "_vendor-recharts-6nUU7gU_.js",
+      "_vendor-codemirror-BEGorXSV.js"
     ]
   }
 }