plainx-sentry 0.10.1__tar.gz → 0.11.0__tar.gz

plainx_sentry-0.11.0/.claude/rules/plain-code.md

@@ -0,0 +1,33 @@
+---
+paths:
+  - "**/*.py"
+---
+
+# Code Quality
+
+## Fix Formatting and Linting
+
+```
+uv run plain fix [path]
+```
+
+Automatically fixes formatting and linting issues using ruff and biome.
+
+Options:
+
+- `--unsafe-fixes` - Apply ruff unsafe fixes
+- `--add-noqa` - Add noqa comments to suppress errors
+
+## Check Without Fixing
+
+```
+uv run plain code check [path]
+```
+
+Runs ruff, ty (type checking), biome, and annotation coverage checks without auto-fixing.
+
+## Code Style
+
+- Add `from __future__ import annotations` at the top of Python files
+- Keep imports at the top of the file unless avoiding circular imports
+- Don't include args/returns in docstrings if already type annotated

plainx_sentry-0.11.0/.claude/rules/plain-models.md

@@ -0,0 +1,30 @@
+# Database & Models
+
+## Creating Migrations
+
+```
+uv run plain makemigrations
+```
+
+Only write migrations by hand if they are custom data migrations.
+
+## Running Migrations
+
+```
+uv run plain migrate --backup
+```
+
+The `--backup` flag creates a database backup before applying migrations.
+
+Run `uv run plain docs models --source` for detailed model and migration documentation.
+
+## Querying
+
+Use `Model.query` to build querysets:
+
+- `User.query.all()`
+- `User.query.filter(is_active=True)`
+- `User.query.get(pk=1)`
+- `User.query.exclude(role="admin")`
+
+Run `uv run plain docs models --api` for the full query API.

plainx_sentry-0.11.0/.claude/rules/plain-templates.md

@@ -0,0 +1,27 @@
+---
+paths:
+  - "**/*.html"
+---
+
+# Templates
+
+## Long Lines
+
+When an HTML tag has many attributes or a long class list, break it into multiple lines with each attribute indented. The closing `>` goes on its own line.
+
+**Good:**
+
+```html
+<div
+    class="flex items-center justify-between gap-4 rounded-lg border bg-white p-4 shadow-sm"
+    data-active="{{ is_active }}"
+>
+    ...
+</div>
+```
+
+**Avoid:**
+
+```html
+<div class="flex items-center justify-between gap-4 rounded-lg border bg-white p-4 shadow-sm" data-active="{{ is_active }}">...</div>
+```

plainx_sentry-0.11.0/.claude/rules/plain-test.md

@@ -0,0 +1,13 @@
+# Testing
+
+```
+uv run plain test [pytest options]
+```
+
+- `uv run plain test` - Run all tests
+- `uv run plain test -k test_name` - Filter by test name
+- `uv run plain test --pdb` - Drop into debugger on failure
+- `uv run plain test -x` - Stop on first failure
+- `uv run plain test -v` - Verbose output
+
+Use pytest fixtures and conventions. Place tests in `tests/` directory. Use `plain.test.Client` for HTTP request testing.

plainx_sentry-0.11.0/.claude/rules/plain.md

@@ -0,0 +1,101 @@
+# Plain Framework
+
+Plain is a Python web framework.
+
+- Always use `uv run` to execute commands — never use bare `python` or `plain` directly.
+- Plain is a Django fork but has different APIs — never assume Django patterns will work.
+- When unsure about an API or something doesn't work, run `uv run plain docs <package>` first. Add `--api` if you need the full API surface.
+- Use the `/plain-install` skill to add new Plain packages.
+- Use the `/plain-upgrade` skill to upgrade Plain packages.
+
+## Key Differences from Django
+
+Claude's training data contains a lot of Django code. These are the most common patterns that differ in Plain:
+
+- **Querysets**: Use `Model.query` not `Model.objects` (e.g., `User.query.filter(is_active=True)`)
+- **Field types**: Import from `plain.models.types` not `plain.models.fields`
+- **Templates**: Plain uses Jinja2, not Django's template engine. Most syntax is similar but filters use `|` with function call syntax (e.g., `{{ name|title }}` works, but custom filters differ)
+- **URLs**: Use `Router` with `urls` list, not Django's `urlpatterns`
+- **Tests**: Use `plain.test.Client`, not `django.test.Client`
+- **Settings**: Use `plain.runtime.settings`, not `django.conf.settings`
+
+When in doubt, run `uv run plain docs <package> --api` to check the actual API.
+
+## Documentation
+
+Run `uv run plain docs --list` to see all official packages (installed and uninstalled) with descriptions.
+Run `uv run plain docs <package>` for markdown documentation (installed packages only).
+Run `uv run plain docs <package> --api` for the symbolicated API surface.
+For uninstalled packages, the CLI shows the install command and an online docs URL.
+
+Online docs URL pattern: `https://plainframework.com/docs/<pip-name>/<module/path>/README.md`
+Example: `https://plainframework.com/docs/plain-models/plain/models/README.md`
+
+Examples:
+
+- `uv run plain docs models` - Models and database docs
+- `uv run plain docs models --api` - Models API surface
+- `uv run plain docs templates` - Jinja2 templates
+- `uv run plain docs assets` - Static assets
+
+### All official packages
+
+- **plain** — Web framework core
+- **plain-admin** — Backend admin interface
+- **plain-api** — Class-based API views
+- **plain-auth** — User authentication and authorization
+- **plain-cache** — Database-backed cache with optional expiration
+- **plain-code** — Preconfigured code formatting and linting
+- **plain-dev** — Local development server with auto-reload
+- **plain-elements** — HTML template components
+- **plain-email** — Send email
+- **plain-esbuild** — Build JavaScript with esbuild
+- **plain-flags** — Feature flags via database models
+- **plain-htmx** — HTMX integration for templates and views
+- **plain-jobs** — Background jobs with a database-driven queue
+- **plain-loginlink** — Link-based authentication
+- **plain-models** — Model data and store it in a database
+- **plain-oauth** — OAuth provider login
+- **plain-observer** — On-page telemetry and observability
+- **plain-pages** — Serve static pages, markdown, and assets
+- **plain-pageviews** — Client-side pageview tracking
+- **plain-passwords** — Password authentication
+- **plain-pytest** — Test with pytest
+- **plain-redirection** — URL redirection with admin and logging
+- **plain-scan** — Test for production best practices
+- **plain-sessions** — Database-backed sessions
+- **plain-start** — Bootstrap a new project from templates
+- **plain-support** — Support forms for your application
+- **plain-tailwind** — Tailwind CSS without JavaScript or npm
+- **plain-toolbar** — Debug toolbar
+- **plain-tunnel** — Remote access to local dev server
+- **plain-vendor** — Vendor CDN scripts and styles
+
+## Shell
+
+`uv run plain shell` opens an interactive Python shell with Plain configured and database access.
+
+Run a one-off command:
+
+```
+uv run plain shell -c "from app.users.models import User; print(User.query.count())"
+```
+
+Run a script:
+
+```
+uv run plain run script.py
+```
+
+## HTTP Requests
+
+Use `uv run plain request` to make test HTTP requests against the dev database.
+
+```
+uv run plain request /path
+uv run plain request /path --user 1
+uv run plain request /path --header "Accept: application/json"
+uv run plain request /path --method POST --data '{"key": "value"}'
+uv run plain request /path --no-body    # Headers only
+uv run plain request /path --no-headers # Body only
+```

plainx_sentry-0.11.0/.claude/skills/plain-install/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: plain-install
+description: Installs Plain packages and guides through setup steps. Use when adding new packages to a project.
+---
+
+# Install Plain Packages
+
+## 1. Install the package(s)
+
+```
+uv run plain install <package-name> [additional-packages...]
+```
+
+## 2. Complete setup for each package
+
+1. Run `uv run plain docs <package>` and read the installation instructions
+2. If the docs indicate it's a dev tool, move it: `uv remove <package> && uv add <package> --dev`
+3. Complete any code modifications from the installation instructions
+
+## Guidelines
+
+- DO NOT commit any changes
+- Report back with:
+    - Whether setup completed successfully
+    - Any manual steps the user needs to complete
+    - Any issues or errors encountered

plainx_sentry-0.11.0/.claude/skills/plain-upgrade/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: plain-upgrade
+description: Upgrades Plain packages and applies required migration changes. Use when updating to newer package versions.
+---
+
+# Upgrade Plain Packages
+
+## 1. Run the upgrade
+
+```
+uv run plain upgrade [package-names...]
+```
+
+This will show which packages were upgraded (e.g., `plain-models: 0.1.0 -> 0.2.0`).
+
+## 2. Apply code changes for each upgraded package
+
+For each package that was upgraded:
+
+1. Run `uv run plain changelog <package> --from <old-version> --to <new-version>`
+2. Read the "Upgrade instructions" section
+3. If it says "No changes required", skip to next package
+4. Apply any required code changes
+
+## 3. Validate
+
+1. Run `uv run plain fix` to fix formatting
+2. Run `uv run plain preflight` to validate configuration
+
+## Guidelines
+
+- Process ALL packages before testing
+- DO NOT commit any changes
+- Keep code changes minimal and focused
+- Report any issues or conflicts encountered

plainx_sentry-0.11.0/.github/workflows/release.yml

@@ -0,0 +1,32 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv python install
+
+      # https://docs.pypi.org/trusted-publishers/using-a-publisher/
+      - name: Mint API token
+        id: mint-token
+        run: |
+          resp=$(curl -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
+            "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=pypi")
+          oidc_token=$(jq -r '.value' <<< "${resp}")
+          resp=$(curl -X POST https://pypi.org/_/oidc/mint-token -d "{\"token\": \"${oidc_token}\"}")
+          api_token=$(jq -r '.token' <<< "${resp}")
+          echo "::add-mask::${api_token}"
+          echo "api-token=${api_token}" >> "${GITHUB_OUTPUT}"
+
+      - run: uv build && uv publish
+        env:
+          UV_PUBLISH_TOKEN: ${{ steps.mint-token.outputs.api-token }}

{plainx_sentry-0.10.1 → plainx_sentry-0.11.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: plainx-sentry
-Version: 0.10.1
+Version: 0.11.0
 Author-email: Dave Gaeddert <dave.gaeddert@gmail.com>
-Requires-Python: >=3.11
+Requires-Python: >=3.13
 Requires-Dist: plain-auth>=0.16.0
 Requires-Dist: plain-sessions>=0.27.0
 Requires-Dist: sentry-sdk[opentelemetry]>=2.24.0
@@ -47,6 +47,27 @@ In Heroku, for example:
 heroku config:set SENTRY_DSN=<your-DSN>
 ```
 
+## User and request context
+
+To attach user and request context to errors, add the middleware:
+
+```python
+# settings.py
+MIDDLEWARE = [
+    ...
+    "plain.sessions.middleware.SessionMiddleware",
+    "plainx.sentry.middleware.SentryMiddleware",  # After SessionMiddleware
+    ...
+]
+```
+
+This attaches to errors:
+
+- **User context**: ID, email, username
+- **Request context**: URL, method, query string, headers, cookies
+
+Email, username, headers, and cookies require `SENTRY_PII_ENABLED=True` (the default).
+
 ## Configuration
 
 [Look at the `default_settings.py` for all available settings.](./plainx/sentry/default_settings.py)

{plainx_sentry-0.10.1 → plainx_sentry-0.11.0}/README.md

@@ -37,6 +37,27 @@ In Heroku, for example:
 heroku config:set SENTRY_DSN=<your-DSN>
 ```
 
+## User and request context
+
+To attach user and request context to errors, add the middleware:
+
+```python
+# settings.py
+MIDDLEWARE = [
+    ...
+    "plain.sessions.middleware.SessionMiddleware",
+    "plainx.sentry.middleware.SentryMiddleware",  # After SessionMiddleware
+    ...
+]
+```
+
+This attaches to errors:
+
+- **User context**: ID, email, username
+- **Request context**: URL, method, query string, headers, cookies
+
+Email, username, headers, and cookies require `SENTRY_PII_ENABLED=True` (the default).
+
 ## Configuration
 
 [Look at the `default_settings.py` for all available settings.](./plainx/sentry/default_settings.py)

plainx_sentry-0.11.0/plainx/sentry/CHANGELOG.md

@@ -0,0 +1,24 @@
+# plainx-sentry changelog
+
+## [0.11.0](https://github.com/davegaeddert/plainx-sentry/releases/v0.11.0) (2026-02-05)
+
+### What's changed
+
+- Added `SentryMiddleware` for automatic request and user context on Sentry events ([950df07](https://github.com/davegaeddert/plainx-sentry/commit/950df07))
+- Now requires Python 3.13+ ([dbfb0d7](https://github.com/davegaeddert/plainx-sentry/commit/dbfb0d7))
+- Added type annotations throughout the codebase ([dbfb0d7](https://github.com/davegaeddert/plainx-sentry/commit/dbfb0d7))
+
+### Upgrade instructions
+
+- Ensure you are running Python 3.13 or higher
+- Add `SentryMiddleware` to your middleware stack after `SessionMiddleware` for automatic request/user context
+
+## [0.7.0](https://github.com/davegaeddert/plainx-sentry/releases/plainx-sentry@0.7.0) (2025-07-19)
+
+### What's changed
+
+- Middleware was removed in favor of using the OpenTelemetry integration and new otel instrumentation in Plain.
+
+### Upgrade instructions
+
+- Remove `SentryMiddleware` and `SentryWorkerMiddleware` from your `app/settings.py`.

{plainx_sentry-0.10.1 → plainx_sentry-0.11.0}/plainx/sentry/config.py

@@ -11,7 +11,7 @@ from sentry_sdk.integrations.opentelemetry import SentryPropagator, SentrySpanPr
 class PlainxSentryConfig(PackageConfig):
     label = "plainxsentry"
 
-    def ready(self):
+    def ready(self) -> None:
         if settings.SENTRY_DSN and settings.SENTRY_AUTO_INIT:
             sentry_sdk.init(
                 settings.SENTRY_DSN,

plainx_sentry-0.11.0/plainx/sentry/middleware.py

@@ -0,0 +1,73 @@
+from typing import Any
+
+import sentry_sdk
+from plain.auth import get_request_user
+from plain.http import HttpMiddleware
+from plain.http.request import Request
+from plain.http.response import Response
+from sentry_sdk.scope import should_send_default_pii
+
+
+def _build_request_info(request: Request) -> dict[str, Any]:
+    """Build request context dictionary for Sentry events."""
+    try:
+        url = request.build_absolute_uri()
+    except Exception:
+        url = request.path
+
+    request_info = {
+        "method": request.method,
+        "url": url,
+        "query_string": request.query_string,
+    }
+
+    if should_send_default_pii():
+        request_info["headers"] = dict(request.headers)
+        request_info["cookies"] = dict(request.cookies)
+
+    return request_info
+
+
+def _build_user_info(user: Any) -> dict[str, Any]:
+    """Build user context dictionary for Sentry events."""
+    user_info = {"id": str(user.id)}
+
+    if should_send_default_pii():
+        if email := getattr(user, "email", None):
+            user_info["email"] = email
+        if username := getattr(user, "username", None):
+            user_info["username"] = username
+
+    return user_info
+
+
+class SentryMiddleware(HttpMiddleware):
+    """
+    Middleware that registers a Sentry event processor for request/user context.
+
+    Add this to your MIDDLEWARE setting after SessionMiddleware:
+
+        MIDDLEWARE = [
+            ...
+            "plain.sessions.middleware.SessionMiddleware",
+            "plainx.sentry.middleware.SentryMiddleware",
+            ...
+        ]
+    """
+
+    def process_request(self, request: Request) -> Response:
+        def event_processor(
+            event: dict[str, Any], hint: dict[str, Any]
+        ) -> dict[str, Any]:
+            if "request" not in event:
+                event["request"] = _build_request_info(request)
+
+            if "user" not in event:
+                user = get_request_user(request)
+                if user:
+                    event["user"] = _build_user_info(user)
+
+            return event
+
+        sentry_sdk.get_current_scope().add_event_processor(event_processor)
+        return self.get_response(request)

{plainx_sentry-0.10.1 → plainx_sentry-0.11.0}/plainx/sentry/templates.py

@@ -1,4 +1,7 @@
+from typing import Any
+
 import sentry_sdk
+from jinja2.runtime import Context
 from plain.auth import get_request_user
 from plain.runtime import settings
 from plain.templates import register_template_extension
@@ -10,7 +13,9 @@ class SentryJSExtension(InclusionTagExtension):
     tags = {"sentry_js"}
     template_name = "sentry/js.html"
 
-    def get_context(self, context, *args, **kwargs):
+    def get_context(
+        self, context: Context, *args: Any, **kwargs: Any
+    ) -> Context | dict[str, Any]:
         if not settings.SENTRY_DSN:
             return {}
 
@@ -45,7 +50,10 @@ class SentryJSExtension(InclusionTagExtension):
 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
+    def get_context(
+        self, context: Context, *args: Any, **kwargs: Any
+    ) -> dict[str, Any]:
+        parent_result = super().get_context(context, *args, **kwargs)
+        result: dict[str, Any] = dict(parent_result)
+        result["sentry_dialog_event_id"] = sentry_sdk.last_event_id()
+        return result

{plainx_sentry-0.10.1 → plainx_sentry-0.11.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "plainx-sentry"
-version = "0.10.1"
+version = "0.11.0"
 description = ""
 readme = "README.md"
 authors = [
     { name = "Dave Gaeddert", email = "dave.gaeddert@gmail.com" }
 ]
-requires-python = ">=3.11"
+requires-python = ">=3.13"
 dependencies = [
     "plain-auth>=0.16.0",
     "plain-sessions>=0.27.0",
@@ -26,7 +26,7 @@ packages = ["plainx"]
 
 
 [tool.plain.code.biome]
-version = "2.1.2"
+enabled = false
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

{plainx_sentry-0.10.1 → plainx_sentry-0.11.0}/tests/test_sentry.py

@@ -1,9 +1,13 @@
+from typing import cast
+
 import sentry_sdk
+from jinja2 import Environment
+from jinja2.runtime import Context
 from plain.auth import get_user_model
 from plain.auth.requests import set_request_user
 from plain.views import TemplateView
 
-from plainx.sentry.templatetags.sentry import sentry_js
+from plainx.sentry.templates import SentryJSExtension
 
 SENTRY_TEST_DSN = "https://publickey@1.ingest.sentry.io/1"
 
@@ -38,14 +42,21 @@ def test_sentry_tag(settings, rf):
 def test_sentry_pii_enabled(settings, rf):
     settings.SENTRY_DSN = SENTRY_TEST_DSN
     settings.SENTRY_PII_ENABLED = True
+    settings.SENTRY_RELEASE = None
+    settings.SENTRY_ENVIRONMENT = "production"
 
     request = rf.get("/")
-    set_request_user(request, get_user_model()(id=1, email="test@example.com", username="test"))
+    request.csp_nonce = "test-nonce"
+    set_request_user(
+        request, get_user_model()(id=1, email="test@example.com", username="test")
+    )
 
-    assert sentry_js({"request": request}) == {
-        "sentry_js_enabled": True,
+    extension = SentryJSExtension(cast(Environment, None))
+    result = extension.get_context(cast(Context, {"request": request}))
+
+    assert result == {
         "sentry_public_key": "publickey",
-        "sentry_dialog_event_id": None,
+        "csp_nonce": "test-nonce",
         "sentry_init": {
             "release": None,
             "environment": "production",
@@ -64,13 +75,18 @@ def test_sentry_pii_enabled(settings, rf):
 def test_sentry_pii_enabled_without_user(settings, rf):
     settings.SENTRY_DSN = SENTRY_TEST_DSN
     settings.SENTRY_PII_ENABLED = True
+    settings.SENTRY_RELEASE = None
+    settings.SENTRY_ENVIRONMENT = "production"
 
     request = rf.get("/")
+    request.csp_nonce = "test-nonce"
+
+    extension = SentryJSExtension(cast(Environment, None))
+    result = extension.get_context(cast(Context, {"request": request}))
 
-    assert sentry_js({"request": request}) == {
-        "sentry_js_enabled": True,
+    assert result == {
         "sentry_public_key": "publickey",
-        "sentry_dialog_event_id": None,
+        "csp_nonce": "test-nonce",
         "sentry_init": {
             "release": None,
             "environment": "production",
@@ -82,18 +98,30 @@ def test_sentry_pii_enabled_without_user(settings, rf):
 def test_sentry_pii_disabled(settings, rf):
     settings.SENTRY_DSN = SENTRY_TEST_DSN
     settings.SENTRY_PII_ENABLED = False
+    settings.SENTRY_RELEASE = None
+    settings.SENTRY_ENVIRONMENT = "production"
 
     request = rf.get("/")
-    set_request_user(request, get_user_model()(id=1, email="test@example.com", username="test"))
+    request.csp_nonce = "test-nonce"
+    set_request_user(
+        request, get_user_model()(id=1, email="test@example.com", username="test")
+    )
+
+    extension = SentryJSExtension(cast(Environment, None))
+    result = extension.get_context(cast(Context, {"request": request}))
 
-    assert sentry_js({"request": request}) == {
-        "sentry_js_enabled": True,
+    assert result == {
         "sentry_public_key": "publickey",
-        "sentry_dialog_event_id": None,
+        "csp_nonce": "test-nonce",
         "sentry_init": {
             "release": None,
             "environment": "production",
             "sendDefaultPii": False,
+            "initialScope": {
+                "user": {
+                    "id": 1,
+                }
+            },
         },
     }
 
@@ -105,16 +133,26 @@ def test_sentry_release_env(settings, rf):
     settings.SENTRY_ENVIRONMENT = "production"
 
     request = rf.get("/")
-    set_request_user(request, get_user_model()(id=1, email="test@example.com", username="test"))
+    request.csp_nonce = "test-nonce"
+    set_request_user(
+        request, get_user_model()(id=1, email="test@example.com", username="test")
+    )
 
-    assert sentry_js({"request": request}) == {
-        "sentry_js_enabled": True,
+    extension = SentryJSExtension(cast(Environment, None))
+    result = extension.get_context(cast(Context, {"request": request}))
+
+    assert result == {
         "sentry_public_key": "publickey",
-        "sentry_dialog_event_id": None,
+        "csp_nonce": "test-nonce",
         "sentry_init": {
             "release": "v1",
             "environment": "production",
             "sendDefaultPii": False,
+            "initialScope": {
+                "user": {
+                    "id": 1,
+                }
+            },
         },
     }
 
@@ -128,11 +166,3 @@ def test_sentry_feedback_middleware(settings, client):
 
     assert response.status_code == 500
     assert b"Sentry.onLoad" in response.content
-
-    # # # Have to test the middleware directly
-    # middleware = SentryFeedbackMiddleware(get_response=lambda request: response)
-    # response = middleware(response.request)
-
-    # assert response.status_code == 500
-    # assert b"Sentry.onLoad" in response.content
-    # assert b"Sentry.showReportDialog" in response.content