arcane-flask 2.2.2__tar.gz → 3.1.0__tar.gz

{arcane_flask-2.2.2 → arcane_flask-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arcane-flask
-Version: 2.2.2
+Version: 3.1.0
 Summary: Utility functions for flask apps.
 Author: Arcane
 Author-email: product@wearcane.com
@@ -88,6 +88,101 @@ If the function exceeds the timeout, the decorator will return:
 
 **Note:** Set the `timeout` parameter to a value a few seconds less than your Cloud Run or server timeout configuration to ensure proper error handling.
 
+## Activity tracking
+
+Tracking records request usage (user, service, function, status code, execution time, optional metadata) and sends it to a configurable sink via a **ports & adapters** setup. You pass a **tracker** (adapter) and a **service name** at startup; every request is then tracked automatically.
+
+### Register tracking at app startup
+
+Use `init_tracking(app, tracker, service_name)`. The tracker is any implementation of `TrackingPort` (e.g. `LogTrackingAdapter` or `PubSubTrackingAdapter`).
+
+**Log adapter** (development or debugging; events go to the Python logger at INFO):
+
+```python
+from arcane.flask import init_tracking
+from arcane.flask.tracking import LogTrackingAdapter
+
+app = Flask(__name__)
+tracker = LogTrackingAdapter()
+init_tracking(app, tracker, service_name="my-service")
+```
+
+**PubSub adapter** (production; events go to a Google Cloud Pub/Sub topic):
+
+```python
+from arcane.flask import init_tracking
+from arcane.flask.tracking import PubSubTrackingAdapter
+from arcane.pubsub import Client as PubSubClient
+
+app = Flask(__name__)
+pubsub_client = PubSubClient()
+tracker = PubSubTrackingAdapter(
+    pubsub_client=pubsub_client,
+    project="my-project",
+    topic="activity-tracker",  # optional; default is "activity-tracker"
+)
+init_tracking(app, tracker, service_name="my-service")
+```
+
+**Custom columns (PubSub only)**
+By default the PubSub adapter sends all standard fields. You can restrict which fields are published by passing `columns`:
+
+```python
+tracker = PubSubTrackingAdapter(
+    pubsub_client=pubsub_client,
+    project="my-project",
+    topic="activity-tracker",
+    columns=["user_email", "service", "status_code", "execution_time"],
+)
+```
+
+### Undecorated routes are tracked
+
+Routes that do **not** use `check_access_rights` are still tracked. The middleware fills in a baseline event using the request: `function_name` comes from Flask’s `request.endpoint` (the view function name), `service` from the `service_name` you passed to `init_tracking`, and `email` is empty.
+
+### Enriching context during the request
+
+Use `enrich_tracking()` inside any route (with or without `check_access_rights`) to add or merge key/value pairs into the event’s `additional_info`. Multiple calls in the same request are merged.
+
+```python
+from arcane.flask.tracking import enrich_tracking
+
+@app.route("/process")
+def process():
+    enrich_tracking({"labels": ["feed"]})
+    size = read_file_size()
+    enrich_tracking({"file_size": size})
+    return {"status": "ok"}, 200
+```
+
+The emitted event will include `additional_info={"labels": ["feed"], "file_size": ...}`.
+
+### Excluding endpoints
+
+Pass `excluded_endpoints` so some views (e.g. health checks) are not tracked:
+
+```python
+init_tracking(
+    app,
+    tracker,
+    service_name="my-service",
+    excluded_endpoints=frozenset({"health", "readiness"}),
+)
+```
+
+### Custom adapter
+
+Implement the `TrackingPort` interface and pass it to `init_tracking`:
+
+```python
+from arcane.flask.tracking import TrackingPort, ActivityEvent
+
+class MyTrackingAdapter(TrackingPort):
+    def emit(self, event: ActivityEvent) -> None:
+        # send event to your backend (Kafka, HTTP, etc.)
+        ...
+```
+
 ## Structured logging labels
 
 The `arcane.flask.logs` module lets you add structured labels to every log

{arcane_flask-2.2.2 → arcane_flask-3.1.0}/README.md

@@ -62,6 +62,101 @@ If the function exceeds the timeout, the decorator will return:
 
 **Note:** Set the `timeout` parameter to a value a few seconds less than your Cloud Run or server timeout configuration to ensure proper error handling.
 
+## Activity tracking
+
+Tracking records request usage (user, service, function, status code, execution time, optional metadata) and sends it to a configurable sink via a **ports & adapters** setup. You pass a **tracker** (adapter) and a **service name** at startup; every request is then tracked automatically.
+
+### Register tracking at app startup
+
+Use `init_tracking(app, tracker, service_name)`. The tracker is any implementation of `TrackingPort` (e.g. `LogTrackingAdapter` or `PubSubTrackingAdapter`).
+
+**Log adapter** (development or debugging; events go to the Python logger at INFO):
+
+```python
+from arcane.flask import init_tracking
+from arcane.flask.tracking import LogTrackingAdapter
+
+app = Flask(__name__)
+tracker = LogTrackingAdapter()
+init_tracking(app, tracker, service_name="my-service")
+```
+
+**PubSub adapter** (production; events go to a Google Cloud Pub/Sub topic):
+
+```python
+from arcane.flask import init_tracking
+from arcane.flask.tracking import PubSubTrackingAdapter
+from arcane.pubsub import Client as PubSubClient
+
+app = Flask(__name__)
+pubsub_client = PubSubClient()
+tracker = PubSubTrackingAdapter(
+    pubsub_client=pubsub_client,
+    project="my-project",
+    topic="activity-tracker",  # optional; default is "activity-tracker"
+)
+init_tracking(app, tracker, service_name="my-service")
+```
+
+**Custom columns (PubSub only)**
+By default the PubSub adapter sends all standard fields. You can restrict which fields are published by passing `columns`:
+
+```python
+tracker = PubSubTrackingAdapter(
+    pubsub_client=pubsub_client,
+    project="my-project",
+    topic="activity-tracker",
+    columns=["user_email", "service", "status_code", "execution_time"],
+)
+```
+
+### Undecorated routes are tracked
+
+Routes that do **not** use `check_access_rights` are still tracked. The middleware fills in a baseline event using the request: `function_name` comes from Flask’s `request.endpoint` (the view function name), `service` from the `service_name` you passed to `init_tracking`, and `email` is empty.
+
+### Enriching context during the request
+
+Use `enrich_tracking()` inside any route (with or without `check_access_rights`) to add or merge key/value pairs into the event’s `additional_info`. Multiple calls in the same request are merged.
+
+```python
+from arcane.flask.tracking import enrich_tracking
+
+@app.route("/process")
+def process():
+    enrich_tracking({"labels": ["feed"]})
+    size = read_file_size()
+    enrich_tracking({"file_size": size})
+    return {"status": "ok"}, 200
+```
+
+The emitted event will include `additional_info={"labels": ["feed"], "file_size": ...}`.
+
+### Excluding endpoints
+
+Pass `excluded_endpoints` so some views (e.g. health checks) are not tracked:
+
+```python
+init_tracking(
+    app,
+    tracker,
+    service_name="my-service",
+    excluded_endpoints=frozenset({"health", "readiness"}),
+)
+```
+
+### Custom adapter
+
+Implement the `TrackingPort` interface and pass it to `init_tracking`:
+
+```python
+from arcane.flask.tracking import TrackingPort, ActivityEvent
+
+class MyTrackingAdapter(TrackingPort):
+    def emit(self, event: ActivityEvent) -> None:
+        # send event to your backend (Kafka, HTTP, etc.)
+        ...
+```
+
 ## Structured logging labels
 
 The `arcane.flask.logs` module lets you add structured labels to every log

{arcane_flask-2.2.2 → arcane_flask-3.1.0}/arcane/flask/authentication.py

@@ -1,22 +1,20 @@
+import asyncio
 import functools
 import inspect
-import time
 import json
 from typing import Callable, Optional, Union, Dict
 import logging
 
 import backoff
 from firebase_admin import auth as firebase_auth
-from flask import request
+from flask import g, request
 from pydash import get
-from google.cloud.exceptions import ServiceUnavailable
 
 from arcane.core import CLIENTS_PARAM, ALL_CLIENTS_RIGHTS, RightsLevelEnum, GOOGLE_EXCEPTIONS_TO_RETRY, BadRequestError
 from arcane.datastore import Client as DatastoreClient
 from arcane.pubsub import Client as PubSubClient
-import concurrent.futures
 
-from .tracking import send_tracking_information
+from arcane.flask.tracking.context import tracking_ctx, TrackingContext
 
 CLIENTS_KIND = 'base-clients'
 USERS_KIND = 'users'
@@ -72,109 +70,123 @@ def check_access_rights(service: str,
 
         @functools.wraps(job_func)
         def wrapper(*args, **kwargs):
-            start = time.time()
             is_appengine_cron = request.headers.get('X-Appengine-Cron', False)
 
-            if is_appengine_cron:
-                logging.info("App Engine calls service : " + service)
-                return job_func(*args, **kwargs)
-
             claims = {}
             origin = ''
-            # Check feature rights
-            if auth_enabled:
-                token = str(request.headers.get('Authorization', '')).split(' ').pop()
-                origin = str(request.headers.get('origin', ''))
-                try:
-                    claims = verify_token(token)
-                except (firebase_auth.ExpiredIdTokenError,
-                        firebase_auth.RevokedIdTokenError,
-                        firebase_auth.InvalidIdTokenError) as e:
-                    if required_rights != RightsLevelEnum.NONE:
-                        return {'detail': 'You don\'t have access to Adscale resources\n', 'firebase_log': str(e)}, 401
-                except ValueError as e:
-                    return {'detail': str(e)}, 401
+            _inner_additional_info = [None]
 
-                try:
-                    _check_feature_right_access(
-                        claims,
-                        required_rights,
-                        service_user_right
-                    )
-                except BadRequestError:
-                    rights = _get_level_access_for_a_feature_from_claims(claims, service_user_right)
-                    return {'detail': f"You don't have access to this resource : your rights are "
-                            f"'{rights_mapper.get(str(rights), '0')}' for service '{service}'. "
-                            f"You need '{rights_mapper.get(str(required_rights), '0')}'.",
-                            'claims': f"Your current rights are {json.dumps(claims, indent=4, sort_keys=True)}"}, 401
-
-            # Fill authorized_clients
-            if receive_rights_per_client:
-                if not auth_enabled:
-                    authorized_clients = [ALL_CLIENTS_RIGHTS]
-                else:
-                    # Value defined for service to service calls
-                    service_authorized_clients = claims.get('authorized_clients')
-                    db_user_id = claims.get('db_user_id')
-                    if service_authorized_clients and not db_user_id:
-                        authorized_clients = service_authorized_clients
+            async def async_execution():
+                nonlocal claims, origin
+
+                if is_appengine_cron:
+                    logging.info("App Engine calls service : " + service)
+                    if asyncio.iscoroutinefunction(job_func):
+                        return await job_func(*args, **kwargs)
+                    else:
+                        return job_func(*args, **kwargs)
+
+                # Check feature rights
+                if auth_enabled:
+                    token = str(request.headers.get('Authorization', '')).split(' ').pop()
+                    origin = str(request.headers.get('origin', ''))
+                    try:
+                        claims = verify_token(token)
+                    except (firebase_auth.ExpiredIdTokenError,
+                            firebase_auth.RevokedIdTokenError,
+                            firebase_auth.InvalidIdTokenError) as e:
+                        if required_rights != RightsLevelEnum.NONE:
+                            return {'detail': 'You don\'t have access to Adscale resources\n', 'firebase_log': str(e)}, 401
+                    except ValueError as e:
+                        return {'detail': str(e)}, 401
+
+                    try:
+                        _check_feature_right_access(
+                            claims,
+                            required_rights,
+                            service_user_right
+                        )
+                    except BadRequestError:
+                        rights = _get_level_access_for_a_feature_from_claims(claims, service_user_right)
+                        return {'detail': f"You don't have access to this resource : your rights are "
+                                f"'{rights_mapper.get(str(rights), '0')}' for service '{service}'. "
+                                f"You need '{rights_mapper.get(str(required_rights), '0')}'.",
+                                'claims': f"Your current rights are {json.dumps(claims, indent=4, sort_keys=True)}"}, 401
+
+                # Fill authorized_clients
+                if receive_rights_per_client:
+                    if not auth_enabled:
+                        authorized_clients = [ALL_CLIENTS_RIGHTS]
                     else:
-                        if not db_user_id:
-                            authorized_clients = []
+                        # Value defined for service to service calls
+                        service_authorized_clients = claims.get('authorized_clients')
+                        db_user_id = claims.get('db_user_id')
+                        if service_authorized_clients and not db_user_id:
+                            authorized_clients = service_authorized_clients
                         else:
-                            user = datastore_client.get_entity(USERS_KIND, int(db_user_id))
-                            if user is None:
+                            if not db_user_id:
                                 authorized_clients = []
                             else:
-                                authorized_clients = user.get('authorized_clients', [])
-
-                if ALL_CLIENTS_RIGHTS in authorized_clients:
-                    authorized_clients.remove(ALL_CLIENTS_RIGHTS)
-                    clients_query = datastore_client.query()
-                    clients_query.kind = CLIENTS_KIND
-                    clients_query.keys_only()
-                    authorized_clients = [client_entity.key.name for client_entity in clients_query.fetch()]
-
-                kwargs[CLIENTS_PARAM] = sorted(set(authorized_clients))
-            try:
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(job_func, *args, **kwargs)
-                    func_response = future.result(timeout=timeout)
-            except concurrent.futures.TimeoutError:
-                func_response = {'detail': 'Request Timeout'}, 504
-            except Exception as e:
-                func_response = {'detail': f'Server Error: {str(e)}'}, 500
-
-            end = time.time()
-
-            additionnal_info = {}
-            for key, path in kwargs_name_and_path_to_get.items():
-                additionnal_info[key] = get(kwargs, path)
-            if len(additionnal_info.keys()) == 0:
-                additionnal_info = None
-
-            if auth_enabled:
-                status_code = 200
-                if type(func_response) == tuple and type(func_response[1]) == int and func_response[1] >= 100 and func_response[1] < 599:
-                    status_code = func_response[1]
-                elif type(func_response) == int and func_response >= 100 and func_response < 599:
-                    status_code = func_response
+                                user = datastore_client.get_entity(USERS_KIND, int(db_user_id))
+                                if user is None:
+                                    authorized_clients = []
+                                else:
+                                    authorized_clients = user.get('authorized_clients', [])
+
+                    if ALL_CLIENTS_RIGHTS in authorized_clients:
+                        authorized_clients.remove(ALL_CLIENTS_RIGHTS)
+                        clients_query = datastore_client.query()
+                        clients_query.kind = CLIENTS_KIND
+                        clients_query.keys_only()
+                        authorized_clients = [client_entity.key.name for client_entity in clients_query.fetch()]
+
+                    kwargs[CLIENTS_PARAM] = sorted(set(authorized_clients))
 
                 try:
-                    send_tracking_information(
-                        email=claims['email'],
-                        service=service,
-                        function_name=job_func.__name__,
-                        origin=origin,
-                        project=project,
-                        execution_time=end - start,
-                        additionnal_info=additionnal_info,
-                        status_code=status_code,
-                        pubsub_client=pubsub_client,
-                        datastore_client=datastore_client)
-                except (KeyError, ServiceUnavailable):
-                    # Failing to send tracking info should not impact feature usability
-                    pass
+                    if asyncio.iscoroutinefunction(job_func):
+                        func_response = await asyncio.wait_for(job_func(*args, **kwargs), timeout=timeout)
+                    else:
+                        # Synchronous function - wrap in executor for timeout handling
+                        if timeout is not None:
+                            loop = asyncio.get_event_loop()
+                            func_response = await asyncio.wait_for(
+                                loop.run_in_executor(None, lambda: job_func(*args, **kwargs)),
+                                timeout=timeout
+                            )
+                        else:
+                            func_response = job_func(*args, **kwargs)
+                    inner_ctx = tracking_ctx.get()
+                    if inner_ctx is not None:
+                        _inner_additional_info[0] = inner_ctx.additional_info
+                    return func_response
+                except asyncio.TimeoutError:
+                    return {'detail': 'Request Timeout'}, 504
+                except Exception as e:
+                    return {'detail': f'Server Error: {str(e)}'}, 500
+
+            # Run the async execution in a new event loop
+            func_response = asyncio.run(async_execution())
+
+            additionnal_info = {key: get(kwargs, path) for key, path in kwargs_name_and_path_to_get.items()}
+            # Merge enrich_tracking() data from inside the route: asyncio.run() isolates ContextVar writes
+            # to a copy of the context, so we capture it via closure and merge here.
+            # Kwargs-derived paths take precedence over enrich_tracking() data.
+            if _inner_additional_info[0]:
+                additionnal_info = {**_inner_additional_info[0], **additionnal_info}
+            # Set tracking context here (same context as after_request) so init_tracking can read it
+            if claims or origin:
+                ctx = tracking_ctx.get()
+                if ctx is None:
+                    ctx = TrackingContext()
+                    tracking_ctx.set(ctx)
+                ctx.email = claims.get('email', '')
+                ctx.origin = origin
+                ctx.service = service
+                ctx.function_name = job_func.__name__
+            ctx = tracking_ctx.get()
+            if ctx is not None:
+                ctx.additional_info = additionnal_info or None
+            g.tracking_additional_info = additionnal_info or None  # backward compat
 
             return func_response
 

arcane_flask-3.1.0/arcane/flask/tracking/__init__.py

@@ -0,0 +1,19 @@
+"""Tracking package: ports & adapters for activity tracking."""
+
+from .adapters import LogTrackingAdapter, PubSubTrackingAdapter, DEFAULT_COLUMNS
+from .context import TrackingContext, tracking_ctx, enrich_tracking
+from .events import ActivityEvent
+from .flask_integration import init_tracking
+from .ports import TrackingPort
+
+__all__ = [
+    "ActivityEvent",
+    "TrackingPort",
+    "TrackingContext",
+    "tracking_ctx",
+    "enrich_tracking",
+    "init_tracking",
+    "LogTrackingAdapter",
+    "PubSubTrackingAdapter",
+    "DEFAULT_COLUMNS"
+]

arcane_flask-3.1.0/arcane/flask/tracking/adapters/__init__.py

@@ -0,0 +1,10 @@
+"""Tracking adapters (Log, PubSub)."""
+
+from .log import LogTrackingAdapter
+from .pubsub import PubSubTrackingAdapter, DEFAULT_COLUMNS
+
+__all__ = [
+    "LogTrackingAdapter",
+    "PubSubTrackingAdapter",
+    "DEFAULT_COLUMNS",
+]

arcane_flask-3.1.0/arcane/flask/tracking/adapters/log.py

@@ -0,0 +1,31 @@
+"""Log adapter: emits tracking events as structured log lines at INFO."""
+
+import logging
+from typing import TYPE_CHECKING
+
+from ..ports import TrackingPort
+
+if TYPE_CHECKING:
+    from ..events import ActivityEvent
+
+logger = logging.getLogger(__name__)
+
+
+class LogTrackingAdapter(TrackingPort):
+    """Emits each tracking event as a single INFO log line with key fields.
+    This is used for testing / mocking
+    """
+
+    def emit(self, event: "ActivityEvent") -> None:
+        extra = ""
+        if event.additional_info:
+            extra = " " + str(event.additional_info)
+        logger.info(
+            "TRACK %s %s/%s [%s] %.3fs%s",
+            event.email,
+            event.service,
+            event.function_name,
+            event.status_code,
+            event.execution_time,
+            extra,
+        )

arcane_flask-3.1.0/arcane/flask/tracking/adapters/pubsub.py

@@ -0,0 +1,65 @@
+"""PubSub adapter: emits tracking events to Google Cloud Pub/Sub."""
+
+import json
+from typing import Optional, List, Any
+
+from ..events import ActivityEvent
+from ..ports import TrackingPort
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Wire-format keys (additionnal_info matches existing consumer schema)
+DEFAULT_COLUMNS = (
+    "user_email",
+    "service",
+    "execution_time",
+    "additionnal_info",
+    "status_code",
+    "timestamp",
+    "function_name",
+    "insert_id",
+    "origin",
+)
+
+
+def _event_to_parameters(event: ActivityEvent) -> dict:
+    """Build the full parameters dict from an ActivityEvent (wire format)."""
+    return {
+        "user_email": event.email,
+        "service": event.service,
+        "execution_time": event.execution_time,
+        "additionnal_info": json.dumps(event.additional_info) if event.additional_info is not None else None,
+        "status_code": event.status_code,
+        "timestamp": event.timestamp.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "function_name": event.function_name,
+        "insert_id": event.insert_id,
+        "origin": event.origin,
+    }
+
+
+class PubSubTrackingAdapter(TrackingPort):
+    """Emits tracking events to a Pub/Sub topic. Optional columns filter which fields are sent."""
+
+    def __init__(
+        self,
+        pubsub_client: Any,
+        project: str,
+        topic: str = "activity-tracker",
+        columns: Optional[List[str]] = None,
+    ):
+        self._client = pubsub_client
+        self._project = project
+        self._topic = topic
+        self._columns = list(columns) if columns is not None else list(DEFAULT_COLUMNS)
+
+    def emit(self, event: ActivityEvent) -> None:
+        params = _event_to_parameters(event)
+        logger.debug(f"PubSubTrackingAdapter: emitting event: {params}")
+        filtered = {k: params[k] for k in self._columns if k in params}
+        self._client.push_to_topic(
+            project=self._project,
+            topic_name=self._topic,
+            parameters=filtered,
+        )
+        logger.debug(f"PubSubTrackingAdapter: event emitted for topic {self._topic}: {filtered}")

arcane_flask-3.1.0/arcane/flask/tracking/context.py

@@ -0,0 +1,40 @@
+"""Request-scoped tracking context (framework-agnostic, uses contextvars)."""
+
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+
+
+@dataclass
+class TrackingContext:
+    """
+    Mutable accumulator for tracking data during a request.
+    Populated by auth decorator and/or enrich_tracking(); read by init_tracking in after_request.
+    """
+
+    email: str = ""
+    service: str = ""
+    function_name: str = ""
+    origin: str = ""
+    additional_info: Optional[Dict[str, Any]] = None
+
+
+tracking_ctx: ContextVar[Optional[TrackingContext]] = ContextVar(
+    "tracking_ctx",
+    default=None,
+)
+
+
+def enrich_tracking(additional_info: dict[str, Any]) -> None:
+    """
+    Merge key/value pairs into the current request's tracking context to enrich additional_info field
+    Creates the context lazily if it does not exist (safe for undecorated routes).
+    Multiple calls accumulate; later values overwrite same key.
+    """
+    ctx = tracking_ctx.get()
+    if ctx is None:
+        ctx = TrackingContext()
+        tracking_ctx.set(ctx)
+    if ctx.additional_info is None:
+        ctx.additional_info = {}
+    ctx.additional_info.update(additional_info)

arcane_flask-3.1.0/arcane/flask/tracking/events.py

@@ -0,0 +1,24 @@
+"""Centralized schema for tracking events (framework-agnostic)."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Optional, Dict
+import uuid
+
+
+@dataclass(frozen=True)
+class ActivityEvent:
+    """
+    Immutable snapshot of one tracking event.
+    All adapters serialize from this; all producers create it.
+    """
+
+    email: str
+    service: str
+    function_name: str
+    origin: str
+    status_code: int
+    execution_time: float
+    additional_info: Optional[dict] = None
+    timestamp: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    insert_id: str = field(default_factory=lambda: str(uuid.uuid4()))

arcane_flask-3.1.0/arcane/flask/tracking/flask_integration.py

@@ -0,0 +1,65 @@
+"""Flask-specific wiring for tracking: request hooks that read context and emit via TrackingPort."""
+
+import logging
+import time
+from typing import TYPE_CHECKING
+
+from flask import g, request
+
+from .context import tracking_ctx, TrackingContext
+from .events import ActivityEvent
+from .ports import TrackingPort
+
+if TYPE_CHECKING:
+    from flask import Flask
+
+logger = logging.getLogger(__name__)
+
+# Endpoints that should not be tracked (e.g. health checks)
+EXCLUDED_ENDPOINTS = frozenset()
+
+
+def init_tracking(app: "Flask", tracker: TrackingPort, service_name: str, excluded_endpoints: frozenset = None) -> None:
+    """
+    Register before_request and after_request hooks to track every request.
+    Uses TrackingContext (populated by auth decorator and/or enrich_tracking).
+    If no context was set, builds a baseline from the request (function_name from endpoint, etc.).
+    """
+    excluded = excluded_endpoints if excluded_endpoints is not None else EXCLUDED_ENDPOINTS
+
+    @app.before_request
+    def _start_timer():
+        tracking_ctx.set(None)
+        g.request_start = time.time()
+        logger.debug("Tracking: request started, timer set.")
+
+    @app.after_request
+    def _track_request(response):
+        if request.endpoint in excluded:
+            return response
+
+        ctx = tracking_ctx.get()
+        if ctx is None:
+            ctx = TrackingContext(
+                function_name=request.endpoint or request.path,
+                origin=request.headers.get("Origin", ""),
+                service=service_name,
+                email="",
+            )
+
+        execution_time = time.time() - getattr(g, "request_start", time.time())
+        event = ActivityEvent(
+            email=ctx.email,
+            service=ctx.service or service_name,
+            function_name=ctx.function_name or (request.endpoint or request.path),
+            origin=ctx.origin,
+            status_code=response.status_code,
+            execution_time=execution_time,
+            additional_info=ctx.additional_info,
+        )
+        try:
+            tracker.emit(event)
+            logger.debug(f"Tracking: event emitted: {event} for request {request.endpoint}")
+        except Exception:
+            logger.exception("Tracking: failed to emit event for request")
+        return response

arcane_flask-3.1.0/arcane/flask/tracking/ports.py

@@ -0,0 +1,14 @@
+"""Port (abstraction) for emitting tracking events."""
+
+from abc import ABC, abstractmethod
+
+from .events import ActivityEvent
+
+
+class TrackingPort(ABC):
+    """Abstract port for emitting activity tracking events. Implementations (adapters) handle transport."""
+
+    @abstractmethod
+    def emit(self, event: ActivityEvent) -> None:
+        """Emit a tracking event to the configured sink."""
+        ...

{arcane_flask-2.2.2 → arcane_flask-3.1.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "arcane-flask"
 
-version = "2.2.2"
+version = "3.1.0"
 
 
 description = "Utility functions for flask apps."

arcane_flask-2.2.2/arcane/flask/tracking.py

@@ -1,49 +0,0 @@
-from datetime import datetime
-import pytz
-import uuid
-import json
-from typing import Optional, Dict
-
-from .log import adscale_log
-from .services import ServiceEnum
-from arcane.datastore import Client as DatastoreClient
-from arcane.pubsub import Client as PubSubClient
-
-PUBSUB_ACTIVITY_TRACKING_TOPIC = 'activity-tracker'
-
-
-def send_tracking_information(
-    email: str,
-    service: str,
-    function_name: str,
-    origin: str,
-    project: str,
-    execution_time: float,
-    additionnal_info: Optional[Dict],
-    status_code: int,
-    pubsub_client: PubSubClient,
-    datastore_client: DatastoreClient) -> None:
-    """ Send pubsub message to the tracking cloud function"""
-
-    users_query = datastore_client.query(kind='users')
-    users_query.add_filter('email', '=', email)
-    if users_query is None:
-        adscale_log(ServiceEnum.TRACKING, f'User {email} is not an Adscale User. Tracking info will not be saved.')
-    else:
-        timestamp = datetime.now(tz=pytz.timezone('Europe/Paris')).strftime("%Y-%m-%dT%H:%M:%SZ")
-        insert_id = str(uuid.uuid4())
-
-        pubsub_client.push_to_topic(
-            project=project,
-            topic_name=PUBSUB_ACTIVITY_TRACKING_TOPIC,
-            parameters={'user_email': email,
-                        'service': service,
-                        'execution_time': execution_time,
-                        'additionnal_info': json.dumps(additionnal_info) if additionnal_info is not None else None,
-                        'status_code': status_code,
-                        'timestamp': timestamp,
-                        'function_name': function_name,
-                        'insert_id': insert_id,
-                        'origin': origin
-                        }
-        )