forge-ops-tracker 0.2.0__tar.gz → 0.6.0__tar.gz

{forge_ops_tracker-0.2.0/src/forge_ops_tracker.egg-info → forge_ops_tracker-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forge-ops-tracker
-Version: 0.2.0
+Version: 0.6.0
 Summary: ForgeOps error tracking client: captures unhandled exceptions (Django/Flask middleware, plus explicit capture anywhere else) and delivers them to a ForgeOps instance over HTTP.
 Author: ForgeOps
 License-Expression: MIT
@@ -17,11 +17,18 @@ Provides-Extra: django
 Requires-Dist: django>=4.2; extra == "django"
 Provides-Extra: flask
 Requires-Dist: flask>=2.3; extra == "flask"
+Provides-Extra: celery
+Requires-Dist: celery>=5.3; extra == "celery"
+Provides-Extra: sqlalchemy
+Requires-Dist: sqlalchemy>=2.0; extra == "sqlalchemy"
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pytest-django>=4.8; extra == "test"
 Requires-Dist: flask>=2.3; extra == "test"
+Requires-Dist: flask-login>=0.6; extra == "test"
 Requires-Dist: django>=4.2; extra == "test"
+Requires-Dist: celery>=5.3; extra == "test"
+Requires-Dist: sqlalchemy>=2.0; extra == "test"
 Dynamic: license-file
 
 # forge-ops-tracker
@@ -33,18 +40,15 @@ process that raised them.
 
 ## Installation
 
-Not yet published to PyPI: install directly from this path (or a local checkout, once split into
-its own repo):
-
 ```bash
-pip install -e path/to/forge_ops/sdks/python
+pip install forge-ops-tracker
 ```
 
 For Django or Flask integration, install the matching extra:
 
 ```bash
-pip install -e "path/to/forge_ops/sdks/python[django]"
-pip install -e "path/to/forge_ops/sdks/python[flask]"
+pip install "forge-ops-tracker[django]"
+pip install "forge-ops-tracker[flask]"
 ```
 
 ## Configuration
@@ -75,8 +79,11 @@ forge_ops_tracker.init(dsn="https://<api_key>@your-forgeops-host/api/v1/events")
 
 MIDDLEWARE = [
     ...,
+    "django.contrib.auth.middleware.AuthenticationMiddleware",  # if not already there
     "forge_ops_tracker.integrations.django.ForgeOpsTrackerMiddleware",
     "forge_ops_tracker.integrations.django.ForgeOpsTrackerSessionTrackingMiddleware",
+    "forge_ops_tracker.integrations.django.ForgeOpsTrackerPerformanceTrackingMiddleware",
+    "forge_ops_tracker.integrations.django.ForgeOpsTrackerUserContextMiddleware",
 ]
 ```
 
@@ -145,6 +152,47 @@ loaded, which would leave an eagerly-started thread dead in every forked child;
 first push means each forked worker gets its own live thread regardless of when it was forked
 relative to import.
 
+## Identifying users
+
+```python
+forge_ops_tracker.capture_exception(error, user={"id": user.id, "email": user.email})
+```
+
+Or `set_user(id=None, email=None, username=None)` to attach it for the rest of the current thread
+(a WSGI request, a background worker, a console session) rather than passing it to every
+`capture_exception()` call by hand:
+
+```python
+forge_ops_tracker.set_user(id=request.user.id, email=request.user.email)
+```
+
+Thread-local, not global: a WSGI server (Django/Flask's own deployment model) runs one request per
+thread, so this is the right isolation boundary; not correct under an ASGI/asyncio deployment,
+where several requests can share one OS thread, but this SDK has no async integration today for
+that gap to matter yet. `id`/`email`/`username` are all independently optional; call `set_user()`
+with none of them to clear whatever was set, e.g. once a request finishes. Shows up on an issue's
+own detail page, and as its own affected-users count alongside the regular event count.
+
+**Automatic detection, if you're using either integration above:**
+
+- **Django**: `ForgeOpsTrackerUserContextMiddleware` (see the Django snippet above; must be listed
+  after `django.contrib.auth.middleware.AuthenticationMiddleware`, or whatever else sets
+  `request.user`) reads `request.user` when it's present and `is_authenticated`, and calls
+  `set_user()` for you: `pk` for `id` (present on every model instance, regardless of your own
+  `AUTH_USER_MODEL`), `email` if the attribute exists, and `get_username()` (correct even with a
+  custom `USERNAME_FIELD`) if it does. A no-op for an app with no such middleware installed at all.
+- **Flask**: `init_flask()` detects [Flask-Login](https://flask-login.readthedocs.io/) if it's
+  installed and configured (a genuinely optional dependency this package never requires): `id`
+  comes from `current_user.get_id()` (the only thing Flask-Login's own `UserMixin` actually
+  guarantees); `email`/`username` are read as plain optional attributes, since Flask-Login itself
+  guarantees neither, the common convention most apps' own `User` model follows regardless. A
+  no-op if Flask-Login isn't installed, isn't configured (no `LoginManager` attached to this app),
+  or nobody's logged in.
+
+Both compose with the manual API above rather than replacing it: call `set_user()` yourself
+afterward (e.g. for a custom auth setup neither integration can detect, or to override what was
+auto-detected) and it wins for the rest of that request.
+
 ## `in_app` backtrace frames
 
 Python runs interpreted directly from real `.py` files on disk, so file-path matching against
@@ -160,7 +208,9 @@ By default, the message, backtrace, and any context/tags you attach are scanned
 for likely personal data (email addresses, formatted SSNs/credit cards, known API key/token
 formats, and anything under a suspiciously-named key like `password`, `api_key`, or `ssn`)
 and redacted before the payload ever leaves this process. ForgeOps itself scrubs again on arrival
-regardless, so this is a second, earlier layer, not the only one.
+regardless, so this is a second, earlier layer, not the only one. The user attached via `user=`/
+`set_user()` above is a deliberate exception: it's never scrubbed, since redacting it would defeat
+the whole point of identifying users in the first place.
 
 To disable it:
 
@@ -210,6 +260,62 @@ forge_ops_tracker.init(
 Requires a ForgeOps plan that includes release health; on a plan that doesn't, the periodic
 flushes are simply rejected server-side and dropped, exactly like any other delivery failure.
 
+## Performance monitoring
+
+By default, the Django/Flask integrations also time every request, so a dashboard widget on
+ForgeOps can show which parts of your app are actually slow, not just which ones raise. Bucketed
+by transaction (`"GET /users/<int:id>"`, the matched URL pattern rather than the literal path, so
+a distinct user id doesn't explode into its own separate transaction) and flushed as a small
+periodic aggregate per transaction on the same kind of background thread session tracking above
+uses.
+
+```python
+forge_ops_tracker.init(
+    dsn="...",
+    track_performance=False,        # opt out entirely
+    performance_flush_interval=30,  # seconds; default 60
+)
+```
+
+Requires a ForgeOps plan that includes performance monitoring; on a plan that doesn't, the
+periodic flushes are simply rejected server-side and dropped, exactly like any other delivery
+failure.
+
+### Database queries and Celery tasks
+
+The same automatic instrumentation, on the same `track_performance` flag, also covers:
+
+- **Database queries**, for Django automatically (no extra step beyond the middleware above) and
+  for any SQLAlchemy engine (Flask-SQLAlchemy included) with one extra call:
+
+  ```python
+  from forge_ops_tracker.integrations.sqlalchemy import track_sqlalchemy_queries
+
+  db = SQLAlchemy(app)
+  track_sqlalchemy_queries(db.engine)
+  ```
+
+  Bucketed by `"<VERB> <table>"` (`"SELECT auth_user"`, `"INSERT INTO orders"`), not the raw SQL
+  text: a low-cardinality name in the same spirit as the request transaction name above, and never
+  a literal value even where a query's own parameters aren't already placeholder-bound.
+
+- **Celery tasks**, via a separate integration (Celery is an optional dependency, same as
+  Django/Flask):
+
+  ```python
+  from forge_ops_tracker.integrations.celery import init_celery
+
+  init_celery()
+  ```
+
+  Bucketed by the task's own registered name (`"myapp.tasks.send_email"`). This is also this
+  SDK's only error-reporting integration for Celery: a task that raises is reported the same way
+  an unhandled Django/Flask request exception already is, no separate wiring needed.
+
+Each shows up as its own `kind` (`"controller"`, `"job"`, `"query"`) on the same `performance`
+dashboard dataset, so "slowest queries" and "slowest tasks" are just a filtered version of the
+same widget builder "slowest transactions" already uses.
+
 ## Running the tests
 
 ```bash

{forge_ops_tracker-0.2.0 → forge_ops_tracker-0.6.0}/README.md

@@ -7,18 +7,15 @@ process that raised them.
 
 ## Installation
 
-Not yet published to PyPI: install directly from this path (or a local checkout, once split into
-its own repo):
-
 ```bash
-pip install -e path/to/forge_ops/sdks/python
+pip install forge-ops-tracker
 ```
 
 For Django or Flask integration, install the matching extra:
 
 ```bash
-pip install -e "path/to/forge_ops/sdks/python[django]"
-pip install -e "path/to/forge_ops/sdks/python[flask]"
+pip install "forge-ops-tracker[django]"
+pip install "forge-ops-tracker[flask]"
 ```
 
 ## Configuration
@@ -49,8 +46,11 @@ forge_ops_tracker.init(dsn="https://<api_key>@your-forgeops-host/api/v1/events")
 
 MIDDLEWARE = [
     ...,
+    "django.contrib.auth.middleware.AuthenticationMiddleware",  # if not already there
     "forge_ops_tracker.integrations.django.ForgeOpsTrackerMiddleware",
     "forge_ops_tracker.integrations.django.ForgeOpsTrackerSessionTrackingMiddleware",
+    "forge_ops_tracker.integrations.django.ForgeOpsTrackerPerformanceTrackingMiddleware",
+    "forge_ops_tracker.integrations.django.ForgeOpsTrackerUserContextMiddleware",
 ]
 ```
 
@@ -119,6 +119,47 @@ loaded, which would leave an eagerly-started thread dead in every forked child;
 first push means each forked worker gets its own live thread regardless of when it was forked
 relative to import.
 
+## Identifying users
+
+```python
+forge_ops_tracker.capture_exception(error, user={"id": user.id, "email": user.email})
+```
+
+Or `set_user(id=None, email=None, username=None)` to attach it for the rest of the current thread
+(a WSGI request, a background worker, a console session) rather than passing it to every
+`capture_exception()` call by hand:
+
+```python
+forge_ops_tracker.set_user(id=request.user.id, email=request.user.email)
+```
+
+Thread-local, not global: a WSGI server (Django/Flask's own deployment model) runs one request per
+thread, so this is the right isolation boundary; not correct under an ASGI/asyncio deployment,
+where several requests can share one OS thread, but this SDK has no async integration today for
+that gap to matter yet. `id`/`email`/`username` are all independently optional; call `set_user()`
+with none of them to clear whatever was set, e.g. once a request finishes. Shows up on an issue's
+own detail page, and as its own affected-users count alongside the regular event count.
+
+**Automatic detection, if you're using either integration above:**
+
+- **Django**: `ForgeOpsTrackerUserContextMiddleware` (see the Django snippet above; must be listed
+  after `django.contrib.auth.middleware.AuthenticationMiddleware`, or whatever else sets
+  `request.user`) reads `request.user` when it's present and `is_authenticated`, and calls
+  `set_user()` for you: `pk` for `id` (present on every model instance, regardless of your own
+  `AUTH_USER_MODEL`), `email` if the attribute exists, and `get_username()` (correct even with a
+  custom `USERNAME_FIELD`) if it does. A no-op for an app with no such middleware installed at all.
+- **Flask**: `init_flask()` detects [Flask-Login](https://flask-login.readthedocs.io/) if it's
+  installed and configured (a genuinely optional dependency this package never requires): `id`
+  comes from `current_user.get_id()` (the only thing Flask-Login's own `UserMixin` actually
+  guarantees); `email`/`username` are read as plain optional attributes, since Flask-Login itself
+  guarantees neither, the common convention most apps' own `User` model follows regardless. A
+  no-op if Flask-Login isn't installed, isn't configured (no `LoginManager` attached to this app),
+  or nobody's logged in.
+
+Both compose with the manual API above rather than replacing it: call `set_user()` yourself
+afterward (e.g. for a custom auth setup neither integration can detect, or to override what was
+auto-detected) and it wins for the rest of that request.
+
 ## `in_app` backtrace frames
 
 Python runs interpreted directly from real `.py` files on disk, so file-path matching against
@@ -134,7 +175,9 @@ By default, the message, backtrace, and any context/tags you attach are scanned
 for likely personal data (email addresses, formatted SSNs/credit cards, known API key/token
 formats, and anything under a suspiciously-named key like `password`, `api_key`, or `ssn`)
 and redacted before the payload ever leaves this process. ForgeOps itself scrubs again on arrival
-regardless, so this is a second, earlier layer, not the only one.
+regardless, so this is a second, earlier layer, not the only one. The user attached via `user=`/
+`set_user()` above is a deliberate exception: it's never scrubbed, since redacting it would defeat
+the whole point of identifying users in the first place.
 
 To disable it:
 
@@ -184,6 +227,62 @@ forge_ops_tracker.init(
 Requires a ForgeOps plan that includes release health; on a plan that doesn't, the periodic
 flushes are simply rejected server-side and dropped, exactly like any other delivery failure.
 
+## Performance monitoring
+
+By default, the Django/Flask integrations also time every request, so a dashboard widget on
+ForgeOps can show which parts of your app are actually slow, not just which ones raise. Bucketed
+by transaction (`"GET /users/<int:id>"`, the matched URL pattern rather than the literal path, so
+a distinct user id doesn't explode into its own separate transaction) and flushed as a small
+periodic aggregate per transaction on the same kind of background thread session tracking above
+uses.
+
+```python
+forge_ops_tracker.init(
+    dsn="...",
+    track_performance=False,        # opt out entirely
+    performance_flush_interval=30,  # seconds; default 60
+)
+```
+
+Requires a ForgeOps plan that includes performance monitoring; on a plan that doesn't, the
+periodic flushes are simply rejected server-side and dropped, exactly like any other delivery
+failure.
+
+### Database queries and Celery tasks
+
+The same automatic instrumentation, on the same `track_performance` flag, also covers:
+
+- **Database queries**, for Django automatically (no extra step beyond the middleware above) and
+  for any SQLAlchemy engine (Flask-SQLAlchemy included) with one extra call:
+
+  ```python
+  from forge_ops_tracker.integrations.sqlalchemy import track_sqlalchemy_queries
+
+  db = SQLAlchemy(app)
+  track_sqlalchemy_queries(db.engine)
+  ```
+
+  Bucketed by `"<VERB> <table>"` (`"SELECT auth_user"`, `"INSERT INTO orders"`), not the raw SQL
+  text: a low-cardinality name in the same spirit as the request transaction name above, and never
+  a literal value even where a query's own parameters aren't already placeholder-bound.
+
+- **Celery tasks**, via a separate integration (Celery is an optional dependency, same as
+  Django/Flask):
+
+  ```python
+  from forge_ops_tracker.integrations.celery import init_celery
+
+  init_celery()
+  ```
+
+  Bucketed by the task's own registered name (`"myapp.tasks.send_email"`). This is also this
+  SDK's only error-reporting integration for Celery: a task that raises is reported the same way
+  an unhandled Django/Flask request exception already is, no separate wiring needed.
+
+Each shows up as its own `kind` (`"controller"`, `"job"`, `"query"`) on the same `performance`
+dashboard dataset, so "slowest queries" and "slowest tasks" are just a filtered version of the
+same widget builder "slowest transactions" already uses.
+
 ## Running the tests
 
 ```bash

{forge_ops_tracker-0.2.0 → forge_ops_tracker-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "forge-ops-tracker"
-version = "0.2.0"
+version = "0.6.0"
 description = "ForgeOps error tracking client: captures unhandled exceptions (Django/Flask middleware, plus explicit capture anywhere else) and delivers them to a ForgeOps instance over HTTP."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -32,7 +32,9 @@ Homepage = "https://getforgeops.net"
 [project.optional-dependencies]
 django = ["django>=4.2"]
 flask = ["flask>=2.3"]
-test = ["pytest>=8", "pytest-django>=4.8", "flask>=2.3", "django>=4.2"]
+celery = ["celery>=5.3"]
+sqlalchemy = ["sqlalchemy>=2.0"]
+test = ["pytest>=8", "pytest-django>=4.8", "flask>=2.3", "flask-login>=0.6", "django>=4.2", "celery>=5.3", "sqlalchemy>=2.0"]
 
 [tool.setuptools.packages.find]
 where = ["src"]

forge_ops_tracker-0.6.0/src/forge_ops_tracker/__init__.py

@@ -0,0 +1,193 @@
+"""ForgeOps error tracking client.
+
+    import forge_ops_tracker
+    forge_ops_tracker.init(dsn="https://<api_key>@your-forgeops-host/api/v1/events")
+
+See the README for Django/Flask integration and what gets captured
+automatically vs. what needs an explicit capture_exception() call.
+"""
+
+import re
+import sys
+import threading
+
+from .client import Client
+from .configuration import Configuration
+from .delivery_queue import DeliveryQueue
+from .event_builder import EventBuilder
+from .performance_flusher import PerformanceFlusher
+from .reporter import Reporter
+from .session_flusher import SessionFlusher
+
+__all__ = ["Configuration", "capture_exception", "init", "set_user"]
+
+_configuration = None
+_reporter = None
+_session_flusher = None
+_performance_flusher = None
+_lock = threading.Lock()
+_original_excepthook = None
+# Request-scoped, not global: a WSGI server (Django/Flask's own deployment model, what the
+# integrations in this SDK actually target) runs one request per thread, so thread-local storage
+# is the right isolation boundary, the same reasoning gems/forge_ops_tracker's own
+# Thread.current[:forge_ops_tracker_current_user] already documents. Not correct under an ASGI/
+# asyncio deployment, where several requests can share one OS thread; this SDK has no async
+# integration today for that gap to matter yet.
+_local = threading.local()
+
+
+def _state():
+    global _configuration, _reporter
+    if _reporter is None:
+        with _lock:
+            if _reporter is None:
+                _configuration = Configuration()
+                client = Client(_configuration)
+                delivery_queue = DeliveryQueue(_configuration, client)
+                _reporter = Reporter(_configuration, EventBuilder(_configuration), delivery_queue)
+    return _configuration, _reporter
+
+
+def _session_state():
+    global _session_flusher
+    configuration, _ = _state()
+    if _session_flusher is None:
+        with _lock:
+            if _session_flusher is None:
+                _session_flusher = SessionFlusher(configuration, Client(configuration))
+    return configuration, _session_flusher
+
+
+def _record_session(crashed):
+    """Internal; called by the Django/Flask session-tracking integrations, never by host app
+    code directly (there's nothing for a caller to decide here beyond what the middleware/
+    hook itself already observed)."""
+    configuration, flusher = _session_state()
+    if not configuration.track_sessions or not configuration.is_enabled():
+        return
+    flusher.record_session(crashed=crashed)
+
+
+def _performance_state():
+    global _performance_flusher
+    configuration, _ = _state()
+    if _performance_flusher is None:
+        with _lock:
+            if _performance_flusher is None:
+                _performance_flusher = PerformanceFlusher(configuration, Client(configuration))
+    return configuration, _performance_flusher
+
+
+def _record_performance(transaction_name, duration_ms, kind="controller"):
+    """Internal; called by the Django/Flask/Celery/SQLAlchemy performance-tracking integrations,
+    never by host app code directly, same reasoning as _record_session above. kind
+    ("controller"/"job"/"query") distinguishes what was actually timed; see each integration's
+    own call site for which kind it passes."""
+    configuration, flusher = _performance_state()
+    if not configuration.track_performance or not configuration.is_enabled():
+        return
+    flusher.record(transaction_name, duration_ms, kind=kind)
+
+
+# Neither Django's connection.execute_wrapper nor SQLAlchemy's before/after_cursor_execute events
+# (see integrations/django.py and integrations/sqlalchemy.py) hand over a friendly auto-generated
+# label the way Rails' own sql.active_record payload does; only the raw SQL string. Raw SQL is
+# both too high-cardinality for a transaction_name (every slightly different query shape would
+# become its own bucket) and a real, if usually parameterized, risk of leaking a literal value.
+# Regexes out "<VERB> <table>" ("SELECT auth_user", "INSERT INTO orders") for the two shapes that
+# actually carry a table name in a predictable place; falls back to just the first SQL keyword
+# ("PRAGMA", "BEGIN") for anything else, or the literal string "SQL" if even that fails. Not a
+# real SQL parser, deliberately: the same "close enough, low-cardinality" trade-off Rails' own
+# SCHEMA/cached-query skip already accepts for the Ruby SDK.
+_SELECT_DELETE_RE = re.compile(r"^\s*(SELECT|DELETE)\b.*?\bFROM\s+[\"'`]?(\w+)", re.IGNORECASE | re.DOTALL)
+_INSERT_UPDATE_RE = re.compile(r"^\s*(INSERT INTO|UPDATE)\s+[\"'`]?(\w+)", re.IGNORECASE)
+
+
+def _query_transaction_name(sql):
+    match = _SELECT_DELETE_RE.match(sql) or _INSERT_UPDATE_RE.match(sql)
+    if match:
+        return f"{match.group(1).upper()} {match.group(2)}"
+
+    words = sql.strip().split(None, 1)
+    return words[0].upper() if words else "SQL"
+
+
+def init(dsn=None, **overrides):
+    """Configure the client. Call once at startup (Django settings.py, or
+    right after creating a Flask app). Any Configuration attribute can be
+    overridden by keyword, e.g. init(dsn=..., release=..., environment=...).
+    """
+    configuration, _ = _state()
+    if dsn is not None:
+        configuration.dsn = dsn
+    for key, value in overrides.items():
+        if not hasattr(configuration, key):
+            raise TypeError(f"Configuration has no attribute {key!r}")
+        setattr(configuration, key, value)
+
+    if configuration.install_excepthook:
+        _install_excepthook()
+
+    return configuration
+
+
+def capture_exception(exc=None, context=None, user=None):
+    """Report an exception you've already caught. `exc` defaults to
+    whichever exception is currently being handled, so this can usually
+    just be called as capture_exception() from inside an `except:` block.
+    `user` defaults to whatever set_user() last set for this thread, if
+    anything; pass one explicitly to override that for this one report."""
+    if exc is None:
+        exc = sys.exc_info()[1]
+    if exc is None:
+        return
+
+    _, reporter = _state()
+    reporter.report(exc, context=context, user=user if user is not None else getattr(_local, "user", None))
+
+
+def set_user(id=None, email=None, username=None):
+    """Manually attaches an affected user to whatever gets reported for the rest of this thread
+    (a WSGI request, a background worker, a console session): see capture_exception()'s own doc
+    for why thread-local, not global. id/email/username are all independently optional; call with
+    none of them to clear whatever was set, e.g. once a request finishes."""
+    user = {k: v for k, v in {"id": id, "email": email, "username": username}.items() if v is not None}
+    _local.user = user or None
+
+
+def _install_excepthook():
+    # Reports anything that crashes the whole interpreter (a plain
+    # script, a management command, a worker's own top-level loop) with
+    # no further wiring: the same "unhandled needs no wiring" case
+    # Rails.error/ASP.NET Core's middleware cover automatically. This does
+    # *not* catch a web request's unhandled exception under a WSGI
+    # server: Django/Flask catch that themselves before it ever reaches
+    # here, which is what the integrations in forge_ops_tracker.integrations
+    # are for.
+    global _original_excepthook
+    if _original_excepthook is not None:
+        return  # already installed
+
+    _original_excepthook = sys.excepthook
+
+    def _excepthook(exc_type, exc_value, exc_tb):
+        try:
+            capture_exception(exc_value)
+        finally:
+            _original_excepthook(exc_type, exc_value, exc_tb)
+
+    sys.excepthook = _excepthook
+
+
+def _reset_for_testing():
+    """Not part of the public API: resets module-level state between
+    test cases."""
+    global _configuration, _reporter, _session_flusher, _performance_flusher, _original_excepthook
+    if _original_excepthook is not None:
+        sys.excepthook = _original_excepthook
+    _configuration = None
+    _reporter = None
+    _session_flusher = None
+    _performance_flusher = None
+    _original_excepthook = None
+    _local.user = None

{forge_ops_tracker-0.2.0 → forge_ops_tracker-0.6.0}/src/forge_ops_tracker/client.py

@@ -24,6 +24,9 @@ class Client:
     def deliver_session_checkin(self, payload):
         return self._post(self._configuration.session_checkins_uri(), payload)
 
+    def deliver_performance_samples(self, samples):
+        return self._post(self._configuration.performance_samples_uri(), {"samples": samples})
+
     def _post(self, uri, payload):
         if not uri:
             return False

{forge_ops_tracker-0.2.0 → forge_ops_tracker-0.6.0}/src/forge_ops_tracker/configuration.py

@@ -64,6 +64,14 @@ class Configuration:
         # flushed as one small report on this interval, not one network call per request.
         self.session_flush_interval = 60
 
+        # Whether the Django/Flask integrations time every request and periodically report an
+        # aggregate per transaction: see performance_flusher.py. On by default, same posture as
+        # track_sessions above.
+        self.track_performance = True
+        # Seconds between aggregate performance reports; same "counted in-process, flushed as
+        # one small batch on this interval" reasoning as session_flush_interval above.
+        self.performance_flush_interval = 60
+
     @property
     def api_key(self):
         parsed = self._parsed_dsn()
@@ -95,6 +103,15 @@ class Configuration:
             return uri[: -len("/events")] + "/session_checkins"
         return uri
 
+    def performance_samples_uri(self):
+        """Same derivation again, swapping the trailing /events for /performance_samples."""
+        uri = self.ingestion_uri()
+        if not uri:
+            return None
+        if uri.endswith("/events"):
+            return uri[: -len("/events")] + "/performance_samples"
+        return uri
+
     def is_enabled(self):
         return bool(self.dsn) and bool(self.api_key) and self.environment in self.enabled_environments
 

{forge_ops_tracker-0.2.0 → forge_ops_tracker-0.6.0}/src/forge_ops_tracker/event_builder.py

@@ -35,7 +35,7 @@ class EventBuilder:
     def __init__(self, configuration):
         self._configuration = configuration
 
-    def build(self, exc, context=None):
+    def build(self, exc, context=None, user=None):
         payload = {
             "exception_class": _exception_class_name(exc),
             "message": str(exc),
@@ -48,16 +48,20 @@ class EventBuilder:
             "tags": {},
             "sdk_name": SDK_NAME,
         }
+        if user:
+            payload["user"] = dict(user)
 
         if self._configuration.scrub_pii:
             payload = self._scrub(payload)
 
         return payload
 
-    # exception_class/occurred_at/environment/release/server_name/sdk_name are left
+    # exception_class/occurred_at/environment/release/server_name/sdk_name/user are left
     # alone: structured fields this client or the host app sets
     # deliberately, not free text an exception or its context could
-    # accidentally spill sensitive data into.
+    # accidentally spill sensitive data into. user specifically is a deliberate exemption, not an
+    # oversight: the scrubber's own email pattern would otherwise redact the exact thing this
+    # field exists to carry.
     def _scrub(self, payload):
         payload = dict(payload)
         payload["message"] = pii_scrubber.scrub_string(payload["message"])