apitally 0.14.0rc1__py3-none-any.whl → 0.14.2__py3-none-any.whl

apitally/client/client_asyncio.py

@@ -6,7 +6,7 @@ import random
 import time
 from contextlib import suppress
 from functools import partial
-from typing import Any, AsyncIterator, Dict, Optional, Tuple
+from typing import Any, AsyncIterator, Dict, Optional, Tuple, Union
 from uuid import UUID
 
 import backoff
@@ -29,15 +29,26 @@ retry = partial(
 
 
 class ApitallyClient(ApitallyClientBase):
-    def __init__(self, client_id: str, env: str, request_logging_config: Optional[RequestLoggingConfig] = None) -> None:
+    def __init__(
+        self,
+        client_id: str,
+        env: str,
+        request_logging_config: Optional[RequestLoggingConfig] = None,
+        proxy: Optional[Union[str, httpx.Proxy]] = None,
+    ) -> None:
         super().__init__(client_id=client_id, env=env, request_logging_config=request_logging_config)
+        self.proxy = proxy
         self._stop_sync_loop = False
         self._sync_loop_task: Optional[asyncio.Task] = None
         self._sync_data_queue: asyncio.Queue[Tuple[float, Dict[str, Any]]] = asyncio.Queue()
         self._set_startup_data_task: Optional[asyncio.Task] = None
 
     def get_http_client(self) -> httpx.AsyncClient:
-        return httpx.AsyncClient(base_url=self.hub_url, timeout=REQUEST_TIMEOUT)
+        if httpx.__version__ >= "0.26.0":
+            # `proxy` parameter was added in version 0.26.0
+            return httpx.AsyncClient(base_url=self.hub_url, timeout=REQUEST_TIMEOUT, proxy=self.proxy)
+        else:
+            return httpx.AsyncClient(base_url=self.hub_url, timeout=REQUEST_TIMEOUT, proxies=self.proxy)
 
     def start_sync_loop(self) -> None:
         self._stop_sync_loop = False

apitally/client/client_threading.py

@@ -47,8 +47,15 @@ except NameError:
 
 
 class ApitallyClient(ApitallyClientBase):
-    def __init__(self, client_id: str, env: str, request_logging_config: Optional[RequestLoggingConfig] = None) -> None:
+    def __init__(
+        self,
+        client_id: str,
+        env: str,
+        request_logging_config: Optional[RequestLoggingConfig] = None,
+        proxy: Optional[str] = None,
+    ) -> None:
         super().__init__(client_id=client_id, env=env, request_logging_config=request_logging_config)
+        self.proxies = {"https": proxy} if proxy else None
         self._thread: Optional[Thread] = None
         self._stop_sync_loop = Event()
         self._sync_data_queue: Queue[Tuple[float, Dict[str, Any]]] = Queue()
@@ -145,7 +152,12 @@ class ApitallyClient(ApitallyClientBase):
     @retry(raise_on_giveup=False)
     def _send_startup_data(self, session: requests.Session, data: Dict[str, Any]) -> None:
         logger.debug("Sending startup data to Apitally hub")
-        response = session.post(url=f"{self.hub_url}/startup", json=data, timeout=REQUEST_TIMEOUT)
+        response = session.post(
+            url=f"{self.hub_url}/startup",
+            json=data,
+            timeout=REQUEST_TIMEOUT,
+            proxies=self.proxies,
+        )
         self._handle_hub_response(response)
         self._startup_data_sent = True
         self._startup_data = None
@@ -153,12 +165,22 @@ class ApitallyClient(ApitallyClientBase):
     @retry()
     def _send_sync_data(self, session: requests.Session, data: Dict[str, Any]) -> None:
         logger.debug("Synchronizing data with Apitally hub")
-        response = session.post(url=f"{self.hub_url}/sync", json=data, timeout=REQUEST_TIMEOUT)
+        response = session.post(
+            url=f"{self.hub_url}/sync",
+            json=data,
+            timeout=REQUEST_TIMEOUT,
+            proxies=self.proxies,
+        )
         self._handle_hub_response(response)
 
     def _send_log_data(self, session: requests.Session, uuid: UUID, fp: BufferedReader) -> None:
         logger.debug("Streaming request log data to Apitally hub")
-        response = session.post(url=f"{self.hub_url}/log?uuid={uuid}", data=fp, timeout=REQUEST_TIMEOUT)
+        response = session.post(
+            url=f"{self.hub_url}/log?uuid={uuid}",
+            data=fp,
+            timeout=REQUEST_TIMEOUT,
+            proxies=self.proxies,
+        )
         if response.status_code == 402 and "Retry-After" in response.headers:
             with suppress(ValueError):
                 retry_after = int(response.headers["Retry-After"])

apitally/client/request_logging.py

@@ -35,6 +35,12 @@ EXCLUDE_PATH_PATTERNS = [
     r"/ready$",
     r"/live$",
 ]
+EXCLUDE_USER_AGENT_PATTERNS = [
+    r"health[_- ]?check",
+    r"microsoft-azure-application-lb",
+    r"googlehc",
+    r"kube-probe",
+]
 MASK_QUERY_PARAM_PATTERNS = [
     r"auth",
     r"api-?key",
@@ -99,8 +105,8 @@ class RequestLoggingConfig:
     log_response_body: bool = False
     mask_query_params: List[str] = field(default_factory=list)
     mask_headers: List[str] = field(default_factory=list)
-    mask_request_body_callback: Optional[Callable[[str, str, bytes], Optional[bytes]]] = None
-    mask_response_body_callback: Optional[Callable[[str, str, bytes], Optional[bytes]]] = None
+    mask_request_body_callback: Optional[Callable[[RequestDict], Optional[bytes]]] = None
+    mask_response_body_callback: Optional[Callable[[RequestDict, ResponseDict], Optional[bytes]]] = None
     exclude_paths: List[str] = field(default_factory=list)
     exclude_callback: Optional[Callable[[RequestDict, ResponseDict], bool]] = None
 
@@ -162,7 +168,12 @@ class RequestLogger:
         if not self.enabled or self.suspend_until is not None:
             return
         parsed_url = urlparse(request["url"])
-        if self._should_exclude_path(request["path"] or parsed_url.path) or self._should_exclude(request, response):
+        user_agent = self._get_user_agent(request["headers"])
+        if (
+            self._should_exclude_path(request["path"] or parsed_url.path)
+            or self._should_exclude_user_agent(user_agent)
+            or self._should_exclude(request, response)
+        ):
             return
 
         query = self._mask_query_params(parsed_url.query) if self.config.log_query_params else ""
@@ -178,9 +189,7 @@ class RequestLogger:
             and request["body"] != BODY_TOO_LARGE
         ):
             try:
-                request["body"] = self.config.mask_request_body_callback(
-                    request["method"], request["path"] or parsed_url.path, request["body"]
-                )
+                request["body"] = self.config.mask_request_body_callback(request)
             except Exception:  # pragma: no cover
                 logger.exception("User-provided mask_request_body_callback function raised an exception")
                 request["body"] = None
@@ -197,9 +206,7 @@ class RequestLogger:
             and response["body"] != BODY_TOO_LARGE
         ):
             try:
-                response["body"] = self.config.mask_response_body_callback(
-                    request["method"], request["path"] or parsed_url.path, response["body"]
-                )
+                response["body"] = self.config.mask_response_body_callback(request, response)
             except Exception:  # pragma: no cover
                 logger.exception("User-provided mask_response_body_callback function raised an exception")
                 response["body"] = None
@@ -275,6 +282,10 @@ class RequestLogger:
         patterns = self.config.exclude_paths + EXCLUDE_PATH_PATTERNS
         return self._match_patterns(url_path, patterns)
 
+    @lru_cache(maxsize=1000)
+    def _should_exclude_user_agent(self, user_agent: Optional[str]) -> bool:
+        return self._match_patterns(user_agent, EXCLUDE_USER_AGENT_PATTERNS) if user_agent is not None else False
+
     def _mask_query_params(self, query: str) -> str:
         query_params = parse_qsl(query)
         masked_query_params = [(k, v if not self._should_mask_query_param(k) else MASKED) for k, v in query_params]
@@ -306,6 +317,10 @@ class RequestLogger:
         content_type = next((v for k, v in headers if k.lower() == "content-type"), None)
         return content_type is not None and any(content_type.startswith(t) for t in ALLOWED_CONTENT_TYPES)
 
+    @staticmethod
+    def _get_user_agent(headers: List[Tuple[str, str]]) -> Optional[str]:
+        return next((v for k, v in headers if k.lower() == "user-agent"), None)
+
 
 def _check_writable_fs() -> bool:
     try:

apitally/django.py

@@ -41,6 +41,7 @@ class ApitallyMiddlewareConfig:
     app_version: Optional[str]
     identify_consumer_callback: Optional[Callable[[HttpRequest], Union[str, ApitallyConsumer, None]]]
     urlconfs: List[Optional[str]]
+    proxy: Optional[str]
 
 
 class ApitallyMiddleware:
@@ -71,6 +72,7 @@ class ApitallyMiddleware:
             client_id=self.config.client_id,
             env=self.config.env,
             request_logging_config=self.config.request_logging_config,
+            proxy=self.config.proxy,
         )
         self.client.start_sync_loop()
         self.client.set_startup_data(
@@ -96,6 +98,7 @@ class ApitallyMiddleware:
         app_version: Optional[str] = None,
         identify_consumer_callback: Optional[str] = None,
         urlconf: Optional[Union[List[Optional[str]], str]] = None,
+        proxy: Optional[str] = None,
     ) -> None:
         cls.config = ApitallyMiddlewareConfig(
             client_id=client_id,
@@ -106,6 +109,7 @@ class ApitallyMiddleware:
             if identify_consumer_callback
             else None,
             urlconfs=[urlconf] if urlconf is None or isinstance(urlconf, str) else urlconf,
+            proxy=proxy,
         )
 
     def __call__(self, request: HttpRequest) -> HttpResponse:

apitally/flask.py

@@ -39,11 +39,17 @@ class ApitallyMiddleware:
         request_logging_config: Optional[RequestLoggingConfig] = None,
         app_version: Optional[str] = None,
         openapi_url: Optional[str] = None,
+        proxy: Optional[str] = None,
     ) -> None:
         self.app = app
         self.wsgi_app = app.wsgi_app
         self.patch_handle_exception()
-        self.client = ApitallyClient(client_id=client_id, env=env, request_logging_config=request_logging_config)
+        self.client = ApitallyClient(
+            client_id=client_id,
+            env=env,
+            request_logging_config=request_logging_config,
+            proxy=proxy,
+        )
         self.client.start_sync_loop()
         self.delayed_set_startup_data(app_version, openapi_url)
 

apitally/litestar.py

@@ -4,6 +4,7 @@ import time
 from typing import Callable, Dict, List, Optional, Union
 from warnings import warn
 
+from httpx import Proxy
 from litestar.app import DEFAULT_OPENAPI_CONFIG, Litestar
 from litestar.config.app import AppConfig
 from litestar.connection import Request
@@ -35,8 +36,14 @@ class ApitallyPlugin(InitPluginProtocol):
         app_version: Optional[str] = None,
         filter_openapi_paths: bool = True,
         identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
+        proxy: Optional[Union[str, Proxy]] = None,
     ) -> None:
-        self.client = ApitallyClient(client_id=client_id, env=env, request_logging_config=request_logging_config)
+        self.client = ApitallyClient(
+            client_id=client_id,
+            env=env,
+            request_logging_config=request_logging_config,
+            proxy=proxy,
+        )
         self.app_version = app_version
         self.filter_openapi_paths = filter_openapi_paths
         self.identify_consumer_callback = identify_consumer_callback

apitally/starlette.py

@@ -7,7 +7,7 @@ import time
 from typing import Any, Callable, Dict, List, Optional, Union
 from warnings import warn
 
-from httpx import HTTPStatusError
+from httpx import HTTPStatusError, Proxy
 from starlette.datastructures import Headers
 from starlette.requests import Request
 from starlette.routing import BaseRoute, Match, Router
@@ -38,10 +38,16 @@ class ApitallyMiddleware:
         app_version: Optional[str] = None,
         openapi_url: Optional[str] = "/openapi.json",
         identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
+        proxy: Optional[Union[str, Proxy]] = None,
     ) -> None:
         self.app = app
         self.identify_consumer_callback = identify_consumer_callback
-        self.client = ApitallyClient(client_id=client_id, env=env, request_logging_config=request_logging_config)
+        self.client = ApitallyClient(
+            client_id=client_id,
+            env=env,
+            request_logging_config=request_logging_config,
+            proxy=proxy,
+        )
         self.client.start_sync_loop()
         self._delayed_set_startup_data_task: Optional[asyncio.Task] = None
         self.delayed_set_startup_data(app_version, openapi_url)

{apitally-0.14.0rc1.dist-info → apitally-0.14.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: apitally
-Version: 0.14.0rc1
+Version: 0.14.2
 Summary: Simple API monitoring & analytics for REST APIs built with FastAPI, Flask, Django, Starlette and Litestar.
 Project-URL: Homepage, https://apitally.io
 Project-URL: Documentation, https://docs.apitally.io

{apitally-0.14.0rc1.dist-info → apitally-0.14.2.dist-info}/RECORD

@@ -1,24 +1,24 @@
 apitally/__init__.py,sha256=ShXQBVjyiSOHxoQJS2BvNG395W4KZfqMxZWBAR0MZrE,22
 apitally/common.py,sha256=Y8MRuTUHFUeQkcDrCLUxnqIPRpYIiW8S43T0QUab-_A,1267
-apitally/django.py,sha256=2Wg89-NpHGm1Yc25DjtDRVdvW8H3ugSslhxPOQKiXXY,16497
+apitally/django.py,sha256=xM8zyH8LYr4BxAlhvfpUyau4OF5i_TMcISs3eJ7xvpY,16621
 apitally/django_ninja.py,sha256=-CmrwFFRv7thFOUK_OrOSouhHL9bm5sIBNIQlpyE_2c,166
 apitally/django_rest_framework.py,sha256=-CmrwFFRv7thFOUK_OrOSouhHL9bm5sIBNIQlpyE_2c,166
 apitally/fastapi.py,sha256=IfKfgsmIY8_AtnuMTW2sW4qnkya61CAE2vBoIpcc9tk,169
-apitally/flask.py,sha256=Q-3_nrCPkinZ8QERVoa_jiZaEmZoY43oIdj5UGx2tk4,9170
-apitally/litestar.py,sha256=tEaoqRJJNtbijjyrI3ue82ePhZBUk6A2yuXIjlN5oMQ,12951
+apitally/flask.py,sha256=Th5LsMsTKkWERPrKfSWPhzrp99tg0pDtKXgtlVLx3eo,9279
+apitally/litestar.py,sha256=hAH2-OVVXBDVY8LopfIGv30yYwi-71tSEsKd6648CYc,13098
 apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/starlette.py,sha256=ooXr9StS8gU3y8mfyrscUdMiPIBfYMxX5Y6LfIMYQgA,12370
+apitally/starlette.py,sha256=8WAWQPePJAYy-B5TrxawxAeUqBiSXD15Ay17i2B22jc,12500
 apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/client/client_asyncio.py,sha256=cCCtA8Lf-FOfXCstVZEAT3_0bnwH_dU1xe0YzhfLUYU,6691
+apitally/client/client_asyncio.py,sha256=lRvVKFU6eiapJnB9WrRq6Nuadx-n8NCKwQg-da1vPSM,7064
 apitally/client/client_base.py,sha256=w5AXAbg3hw5Qds5rovCZFtePB9bHNcJsr9l7kDgbroc,3733
-apitally/client/client_threading.py,sha256=lLtr89LXrD2roDeUORJkx7QeQOPQqt162Vo8bSExPh4,7101
+apitally/client/client_threading.py,sha256=MbytG8EopF84nmr5ShAZaq-VviSXYnBfBl7cRFRe1Kg,7479
 apitally/client/consumers.py,sha256=w_AFQhVgdtJVt7pVySBvSZwQg-2JVqmD2JQtVBoMkus,2626
 apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
-apitally/client/request_logging.py,sha256=Ar7bqeJbQ8gMbIt3j-wWRBH0E3OhWF0hYwiLyrBJdU0,12548
+apitally/client/request_logging.py,sha256=5i7Gv4yP7iq4tBgw-ppkhlZd_OwMc719ZvWEm16TCvg,13047
 apitally/client/requests.py,sha256=RdJyvIqQGVHvS-wjpAPUwcO7byOJ6jO8dYqNTU2Furg,3685
 apitally/client/server_errors.py,sha256=axEhOxqV5SWjk0QCZTLVv2UMIaTfqPc81Typ4DXt66A,4646
 apitally/client/validation_errors.py,sha256=6G8WYWFgJs9VH9swvkPXJGuOJgymj5ooWA9OwjUTbuM,1964
-apitally-0.14.0rc1.dist-info/METADATA,sha256=9LAy2ffwdz6zicCpyqYKct_zso_lCtZokjY0USYMc-E,7580
-apitally-0.14.0rc1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-apitally-0.14.0rc1.dist-info/licenses/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.14.0rc1.dist-info/RECORD,,
+apitally-0.14.2.dist-info/METADATA,sha256=AUai6BWmcRZKC2mnN3om1SLIxPkyzPPMRAY-qdu1kus,7577
+apitally-0.14.2.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+apitally-0.14.2.dist-info/licenses/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.14.2.dist-info/RECORD,,