plainx-sentry 0.1.0__py3-none-any.whl

plainx/sentry/__init__.py

@@ -0,0 +1,3 @@
+from .middleware import SentryMiddleware, SentryWorkerMiddleware
+
+__all__ = ["SentryMiddleware", "SentryWorkerMiddleware"]

plainx/sentry/config.py

@@ -0,0 +1,20 @@
+import sentry_sdk
+from plain.packages import PackageConfig
+from plain.runtime import settings
+
+
+class PlainxSentryConfig(PackageConfig):
+    name = "plainx.sentry"
+    label = "plainxsentry"
+
+    def ready(self):
+        if settings.SENTRY_DSN and settings.SENTRY_AUTO_INIT:
+            sentry_sdk.init(
+                settings.SENTRY_DSN,
+                release=settings.SENTRY_RELEASE,
+                environment=settings.SENTRY_ENVIRONMENT,
+                send_default_pii=settings.SENTRY_PII_ENABLED,
+                traces_sample_rate=settings.SENTRY_TRACES_SAMPLE_RATE,
+                profiles_sample_rate=settings.SENTRY_PROFILES_SAMPLE_RATE,
+                **settings.SENTRY_INIT_KWARGS,
+            )

plainx/sentry/default_settings.py

@@ -0,0 +1,16 @@
+from os import environ
+
+SENTRY_AUTO_INIT: bool = True
+SENTRY_INIT_KWARGS: dict = {}
+SENTRY_PII_ENABLED: bool = True
+
+# Re-use the standard Sentry env vars
+SENTRY_DSN: str = environ.get("SENTRY_DSN", "")
+SENTRY_RELEASE: str = environ.get("SENTRY_RELEASE", "")
+SENTRY_ENVIRONMENT: str = environ.get("SENTRY_ENVIRONMENT", "production")
+
+# These aren't built in as Sentry env vars?
+SENTRY_TRACES_SAMPLE_RATE: float = float(environ.get("SENTRY_TRACES_SAMPLE_RATE", 0.0))
+SENTRY_PROFILES_SAMPLE_RATE: float = float(
+    environ.get("SENTRY_PROFILES_SAMPLE_RATE", 0.0)
+)

plainx/sentry/jinja.py

@@ -0,0 +1,59 @@
+import sentry_sdk
+from plain.runtime import settings
+from plain.templates.jinja.extensions import InclusionTagExtension
+
+
+class SentryJSExtension(InclusionTagExtension):
+    tags = {"sentry_js"}
+    template_name = "sentry/js.html"
+
+    def get_context(self, context, *args, **kwargs):
+        if not settings.SENTRY_DSN:
+            return {}
+
+        sentry_public_key = settings.SENTRY_DSN.split("//")[1].split("@")[0]
+
+        sentry_context = {
+            "sentry_public_key": sentry_public_key,
+            "sentry_init": {
+                "release": settings.SENTRY_RELEASE,
+                "environment": settings.SENTRY_ENVIRONMENT,
+                "sendDefaultPii": bool(settings.SENTRY_PII_ENABLED),
+            },
+        }
+
+        if "request" in context:
+            # Use request.user by default (avoids accidental "user" variable confusion)
+            user = getattr(context["request"], "user", None)
+        else:
+            # Get user directly if no request (like in server error context)
+            user = context.get("user", None)
+
+        if user:
+            sentry_context["sentry_init"]["initialScope"] = {"user": {"id": user.id}}
+            if settings.SENTRY_PII_ENABLED:
+                if email := getattr(user, "email", None):
+                    sentry_context["sentry_init"]["initialScope"]["user"][
+                        "email"
+                    ] = email
+                if username := getattr(user, "username", None):
+                    sentry_context["sentry_init"]["initialScope"]["user"][
+                        "username"
+                    ] = username
+
+        return sentry_context
+
+
+class SentryFeedbackExtension(SentryJSExtension):
+    tags = {"sentry_feedback"}
+
+    def get_context(self, context, *args, **kwargs):
+        context = super().get_context(context, *args, **kwargs)
+        context["sentry_dialog_event_id"] = sentry_sdk.last_event_id()
+        return context
+
+
+extensions = [
+    SentryJSExtension,
+    SentryFeedbackExtension,
+]

plainx/sentry/middleware.py

@@ -0,0 +1,146 @@
+import sentry_sdk
+from plain.runtime import settings
+from sentry_sdk.tracing import TRANSACTION_SOURCE_TASK
+from sentry_sdk.utils import capture_internal_exceptions
+
+try:
+    from plain.models.db import connection
+except ImportError:
+    connection = None
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def trace_db(execute, sql, params, many, context):
+    with sentry_sdk.start_span(op="db", description=sql) as span:
+        # Mostly borrowed from the Sentry Django integration...
+        data = {
+            "db.params": params,
+            "db.executemany": many,
+            "db.system": connection.vendor,
+            "db.name": connection.settings_dict.get("NAME"),
+            "db.user": connection.settings_dict.get("USER"),
+            "server.address": connection.settings_dict.get("HOST"),
+            "server.port": connection.settings_dict.get("PORT"),
+        }
+
+        sentry_sdk.add_breadcrumb(message=sql, category="query", data=data)
+
+        for k, v in data.items():
+            span.set_data(k, v)
+
+        result = execute(sql, params, many, context)
+
+    return result
+
+
+class SentryMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        def event_processor(event, hint):
+            # request gets attached directly to an event,
+            # not necessarily in the "context"
+            request_info = event.setdefault("request", {})
+            request_info["url"] = request.build_absolute_uri()
+            request_info["method"] = request.method
+            request_info["query_string"] = request.META.get("QUERY_STRING", "")
+            # Headers and env need some PII filtering, ideally,
+            # among other filters... similar for GET/POST data?
+            # request_info["headers"] = dict(request.headers)
+            try:
+                request_info["data"] = request.body.decode("utf-8")
+            except Exception:
+                pass
+
+            if user := getattr(request, "user", None):
+                event["user"] = {"id": str(user.pk)}
+                if settings.SENTRY_PII_ENABLED:
+                    if email := getattr(user, "email", None):
+                        event["user"]["email"] = email
+                    if username := getattr(user, "username", None):
+                        event["user"]["username"] = username
+
+            return event
+
+        with sentry_sdk.configure_scope() as scope:
+            # Reset the scope (and breadcrumbs) for each request
+            scope.clear()
+            scope.add_event_processor(event_processor)
+
+        # Sentry's Django integration patches the WSGIHandler.
+        # We could make our own WSGIHandler and patch it or call it directly from gunicorn,
+        # but putting our middleware at the top of MIDDLEWARE is pretty close and easier.
+        with sentry_sdk.start_transaction(
+            op="http.server", name=request.path_info
+        ) as transaction:
+            if connection:
+                # Also get spans for db queries
+                with connection.execute_wrapper(trace_db):
+                    response = self.get_response(request)
+            else:
+                # No db presumably
+                response = self.get_response(request)
+
+            if resolver_match := getattr(request, "resolver_match", None):
+                # Rename the transaction using a pattern,
+                # and attach other url/views tags we can use to filter
+                transaction.name = f"route:{resolver_match.route}"
+                transaction.set_tag("url_namespace", resolver_match.namespace)
+                transaction.set_tag("url_name", resolver_match.url_name)
+                transaction.set_tag("view_name", resolver_match.view_name)
+                transaction.set_tag("view_class", resolver_match._func_path)
+                # Don't need to filter on this, but do want the context to view
+                transaction.set_context(
+                    "url_params",
+                    {
+                        "args": resolver_match.args,
+                        "kwargs": resolver_match.kwargs,
+                    },
+                )
+
+            transaction.set_http_status(response.status_code)
+
+        return response
+
+
+class SentryWorkerMiddleware:
+    def __init__(self, run_job):
+        self.run_job = run_job
+
+    def __call__(self, job):
+        def event_processor(event, hint):
+            with capture_internal_exceptions():
+                # Attach it directly to any events
+                extra = event.setdefault("extra", {})
+                extra["plain.worker"] = {"job": job.as_json()}
+            return event
+
+        with sentry_sdk.configure_scope() as scope:
+            # Reset the scope (and breadcrumbs) for each job
+            scope.clear()
+            scope.add_event_processor(event_processor)
+
+        with sentry_sdk.start_transaction(
+            op="plain.worker.job",
+            name=f"job:{job.job_class}",
+            source=TRANSACTION_SOURCE_TASK,
+        ) as transaction:
+            if connection:
+                # Also get spans for db queries
+                with connection.execute_wrapper(trace_db):
+                    job_result = self.run_job(job)
+            else:
+                # No db presumably
+                job_result = self.run_job(job)
+
+            with capture_internal_exceptions():
+                # Don't need to filter on this, but do want the context to view
+                transaction.set_context("job", job.as_json())
+
+            transaction.set_status("ok")
+
+        return job_result

plainx/sentry/templates/sentry/js.html

@@ -0,0 +1,13 @@
+{% if sentry_public_key|default("") -%}
+<script src="https://js.sentry-cdn.com/{{ sentry_public_key }}.min.js" crossorigin="anonymous"></script>
+{{ sentry_init|json_script("sentry_init") }}
+<script>
+var sentryInit = JSON.parse(document.getElementById("sentry_init").textContent);
+Sentry.onLoad(function() {
+    Sentry.init(sentryInit);
+});
+{% if sentry_dialog_event_id|default("") -%}
+Sentry.showReportDialog({ eventId: "{{ sentry_dialog_event_id }}" });
+{%- endif %}
+</script>
+{%- endif %}

plainx_sentry-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: plainx-sentry
+Version: 0.1.0
+Summary: 
+Author: Dave Gaeddert
+Author-email: dave.gaeddert@dropseed.dev
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: sentry-sdk (>=1.8.0,<2.0.0)

plainx_sentry-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+plainx/sentry/__init__.py,sha256=Klz3mH_itM2RXzJ_sWWJRIoZcS0jCRxWrhVVIPsG5FY,123
+plainx/sentry/config.py,sha256=pxvKwy6V7aYmZLe2tA7DiQF84R1ovvBMR0rE0CVFT1Y,716
+plainx/sentry/default_settings.py,sha256=DNX6OQ0-BqfjyWuszW7JnZhiDn0tGtS3Fa2W7VbTIF8,564
+plainx/sentry/jinja.py,sha256=hI6g65GQpaP_-LesTiXINeH7YyNdOYRJUSMQ1pnjQfA,2003
+plainx/sentry/middleware.py,sha256=tw2ZMBRfH7eze0ZDqxo-meLSOaD2lVUSBYC99z5izZs,5597
+plainx/sentry/templates/sentry/js.html,sha256=aOjWAwuUaecGbC-5yZWP1aaGyYAcM-GK0dru-4VOYoE,491
+plainx_sentry-0.1.0.dist-info/METADATA,sha256=sNoU_R76H5uYQVKLhG0HrxEib-xPAPOa58Ie5Y1HQNI,352
+plainx_sentry-0.1.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+plainx_sentry-0.1.0.dist-info/RECORD,,

plainx_sentry-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.8.1
+Root-Is-Purelib: true
+Tag: py3-none-any