Merge pull request #20 from apilytics/flask

Add a middleware for sending metrics from Flask applications

Author: ruohola

CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add `apilytics.flask.apilytics_middleware` for sending metrics from Flask applications.
+
+### Fixed
+
+- Fix FastAPI middleware suggested installation order; it should ideally be the *last* one added.
+
 ## [1.5.0] - 2022-03-17
 
 ### Added

README.md

@@ -54,10 +54,26 @@ from fastapi import FastAPI
 
 app = FastAPI()
 
-# Ideally the first middleware you add.
+# Ideally the last middleware you add.
 app.add_middleware(ApilyticsMiddleware, api_key=os.getenv("APILYTICS_API_KEY"))
 ```
 
+### Flask
+
+`app.py`:
+
+```python
+import os
+
+from apilytics.flask import apilytics_middleware
+from flask import Flask
+
+app = Flask(__name__)
+
+# Ideally wrap your app with the middleware before you do anything else with it.
+app = apilytics_middleware(app, api_key=os.getenv("APILYTICS_API_KEY"))
+```
+
 ### Other Python Frameworks
 
 You can easily build your own middleware which measures the execution time and sends the metrics:

apilytics/core.py

@@ -60,6 +60,7 @@ def __init__(
         ip: Optional[str] = None,
         apilytics_integration: Optional[str] = None,
         integrated_library: Optional[str] = None,
+        prevent_send_on_exit: bool = False,
     ) -> None:
         """
         Initialize the context manager with info from the HTTP request object.
@@ -79,6 +80,8 @@ def __init__(
                 e.g. "apilytics-python-django". No need to pass this when calling from user code.
             integrated_library: Name and version of the integration that this is used in,
                 e.g. "django/3.2.1". No need to pass this when calling from user code.
+            prevent_send_on_exit: Don't immediately send the metrics when the context
+                manager exits. Useful for advanced deferred sending scenarios.
         """
         self._api_key = api_key
         self._path = path
@@ -96,6 +99,8 @@ def __init__(
             library=integrated_library or "",
         )
 
+        self._prevent_send_on_exit = prevent_send_on_exit
+
     def __enter__(self) -> "ApilyticsSender":
         """Start the timer, measuring how long the ``with`` block takes to execute."""
         self._start_time_ns = time.perf_counter_ns()
@@ -107,15 +112,9 @@ def __exit__(
         exc_val: Optional[BaseException],
         exc_tb: Optional[types.TracebackType],
     ) -> None:
-        """Send metrics to Apilytics in a fire-and-forget background task."""
-        self._end_time_ns = time.perf_counter_ns()
-        if not hasattr(self, "_executor"):
-            # Use only a single background thread and share the pool to minimize
-            # resource hogging.
-            self.__class__._executor = concurrent.futures.ThreadPoolExecutor(
-                max_workers=1
-            )
-        self._executor.submit(self._send_metrics)
+        if self._prevent_send_on_exit:
+            return
+        self.send()
 
     def set_response_info(
         self, *, status_code: Optional[int] = None, response_size: Optional[int] = None
@@ -133,6 +132,17 @@ def set_response_info(
         self._status_code = status_code
         self._response_size = response_size
 
+    def send(self) -> None:
+        """Send metrics to Apilytics in a fire-and-forget background task."""
+        self._end_time_ns = time.perf_counter_ns()
+        if not hasattr(self, "_executor"):
+            # Use only a single background thread and share the pool to minimize
+            # resource hogging.
+            self.__class__._executor = concurrent.futures.ThreadPoolExecutor(
+                max_workers=1
+            )
+        self._executor.submit(self._send_metrics)
+
     def _send_metrics(self) -> None:
         memory_usage, memory_total = _get_used_and_total_memory()
         cpu_usage = _get_cpu_usage()

apilytics/fastapi.py

@@ -12,13 +12,13 @@ class ApilyticsMiddleware(starlette.middleware.base.BaseHTTPMiddleware):
     """
     FastAPI middleware that sends API analytics data to Apilytics (https://apilytics.io).
 
-    This should ideally be the first middleware you add to your app.
+    This should ideally be the last middleware you add to your app.
 
     Examples:
         main.py::
 
-            from fastapi import FastAPI
             from apilytics.fastapi import ApilyticsMiddleware
+            from fastapi import FastAPI
 
             app = FastAPI()
 

apilytics/flask.py

@@ -0,0 +1,62 @@
+from typing import Optional, TypeVar, cast
+
+import flask
+
+import apilytics.core
+
+__all__ = ["apilytics_middleware"]
+
+T = TypeVar("T", bound=flask.Flask)
+
+
+def apilytics_middleware(app: T, api_key: Optional[str]) -> T:
+    """
+    Flask middleware that sends API analytics data to Apilytics (https://apilytics.io).
+
+    This should ideally be the outermost middleware you wrap your app with.
+
+    Examples:
+        app.py::
+
+            from apilytics.flask import apilytics_middleware
+            from flask import Flask
+
+            app = Flask(__name__)
+
+            app = apilytics_middleware(app, api_key="<your-api-key>")
+    """
+    if not api_key:
+        return app
+
+    def before_request() -> None:
+        with apilytics.core.ApilyticsSender(
+            api_key=cast(str, api_key),  # Type not inferred from the early return.
+            path=flask.request.path,
+            query=flask.request.query_string.decode(flask.request.url_charset),
+            method=flask.request.method,
+            request_size=len(flask.request.data),
+            user_agent=flask.request.headers.get("user-agent"),
+            ip=flask.request.headers.get("x-forwarded-for", "").split(",")[0].strip(),
+            apilytics_integration="apilytics-python-flask",
+            integrated_library=f"flask/{flask.__version__}",
+            prevent_send_on_exit=True,
+        ) as sender:
+            flask.g.apilytics_sender = sender
+
+    def after_request(response: flask.Response) -> flask.Response:
+        sender = flask.g.apilytics_sender
+        size = response.headers.get("content-length")
+        sender.set_response_info(
+            status_code=response.status_code,
+            response_size=int(size) if size is not None else None,
+        )
+        return response
+
+    def teardown_request(exc: Optional[BaseException]) -> None:
+        sender = flask.g.apilytics_sender
+        sender.send()
+
+    app.before_request(before_request)
+    app.after_request(after_request)
+    app.teardown_request(teardown_request)
+    return app