varanus 0.1.0.dev4__tar.gz → 0.1.0.dev6__tar.gz

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/PKG-INFO

@@ -1,15 +1,14 @@
 Metadata-Version: 2.3
 Name: varanus
-Version: 0.1.0.dev4
+Version: 0.1.0.dev6
 Summary: Django application monitoring.
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: msgspec>=0.19.0
 Requires-Dist: cconf>=1.0.0 ; extra == 'server'
-Requires-Dist: django~=5.2.0 ; extra == 'server'
+Requires-Dist: django>=6.0 ; python_full_version >= '3.12' and extra == 'server'
 Requires-Dist: django-passkey-auth>=0.2.0 ; extra == 'server'
-Requires-Dist: granian>=2.4.2 ; extra == 'server'
+Requires-Dist: granian[reload]>=2.4.2 ; extra == 'server'
 Requires-Dist: psycopg[binary]>=3.2.1 ; extra == 'server'
-Requires-Dist: websockets>=13.0 ; extra == 'server'
 Requires-Dist: whitenoise>=6.7.0 ; extra == 'server'
 Requires-Python: >=3.11
 Provides-Extra: server

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "varanus"
-version = "0.1.0.dev4"
+version = "0.1.0.dev6"
 description = "Django application monitoring."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -12,11 +12,10 @@ dependencies = [
 [project.optional-dependencies]
 server = [
     "cconf>=1.0.0",
-    "django~=5.2.0",
+    "django>=6.0; python_version>='3.12'",
     "django-passkey-auth>=0.2.0",
-    "granian>=2.4.2",
+    "granian[reload]>=2.4.2",
     "psycopg[binary]>=3.2.1",
-    "websockets>=13.0",
     "whitenoise>=6.7.0",
 ]
 

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/src/varanus/client/client.py

@@ -40,8 +40,9 @@ def resolve_include_exclude(
 
 
 class VaranusClient:
+    # Things we don't want to send, at least by default.
     sensitive_headers = set(["authorization", "cookie", "proxy-authorization"])
-    sensitive_settings = set(["DATABASES"])
+    sensitive_settings = set(["SECRET_KEY"])
     sensitive_env = set(["PGPASSWORD"])
 
     scheme_transports = {
@@ -63,9 +64,10 @@ class VaranusClient:
         tags: dict | None = None,
         include_headers: Iterable[str] | bool = False,
         exclude_headers: Iterable[str] | None = None,
-        include_settings: Iterable[str] | bool = False,
+        include_settings: Iterable[str] | bool = True,
         exclude_settings: Iterable[str] | None = None,
         include_default_settings: bool = False,
+        filter_settings: bool = True,
         include_env: Iterable[str] | bool = False,
         exclude_env: Iterable[str] | None = None,
         log_queries: bool | int = False,
@@ -106,6 +108,7 @@ class VaranusClient:
             else set(exclude_settings)
         )
         self.include_default_settings = include_default_settings
+        self.filter_settings = filter_settings
         self.include_env = include_env
         self.exclude_env = (
             self.sensitive_env if exclude_env is None else set(exclude_env)
@@ -152,8 +155,20 @@ class VaranusClient:
         from django import get_version
         from django.conf import settings
 
+        if self.filter_settings:
+            from django.views.debug import SafeExceptionReporterFilter
+
+            settings_dict = {
+                k: repr(v)
+                for k, v in SafeExceptionReporterFilter().get_safe_settings().items()
+            }
+        else:
+            settings_dict = {
+                s: repr(getattr(settings, s)) for s in dir(settings) if s.isupper()
+            }
+
         include_settings = resolve_include_exclude(
-            [s for s in dir(settings) if s == s.upper()],
+            settings_dict.keys(),
             self.include_settings,
             self.exclude_settings,
         )
@@ -173,7 +188,7 @@ class VaranusClient:
                 framework_version=get_version(),
                 packages={d.name: d.version for d in distributions()},
                 settings={
-                    s: repr(getattr(settings, s))
+                    s: settings_dict[s]
                     for s in include_settings
                     if self.include_default_settings or settings.is_overridden(s)
                 },

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/src/varanus/client/loggers.py

@@ -42,20 +42,19 @@ class QueryLogger:
                 elapsed_ms = (now() - start) // ONE_MS
                 if self.metrics_name:
                     ctx.metric(self.metrics_name, elapsed_ms)
-                if elapsed_ms < self.threshold:
-                    return
-                ctx.queries.append(
-                    Query(
-                        timestamp=start,
-                        sql=sql,
-                        params=(
-                            [repr(p) for p in params]
-                            if params and self.log_params
-                            else []
-                        ),
-                        db=context["connection"].alias,
-                        elapsed_ms=elapsed_ms,
-                        success=success,
-                        stack=capture_stack(1) if self.log_stack else [],
+                if elapsed_ms >= self.threshold:
+                    ctx.queries.append(
+                        Query(
+                            timestamp=start,
+                            sql=sql,
+                            params=(
+                                [repr(p) for p in params]
+                                if params and self.log_params
+                                else []
+                            ),
+                            db=context["connection"].alias,
+                            elapsed_ms=elapsed_ms,
+                            success=success,
+                            stack=capture_stack(1) if self.log_stack else [],
+                        )
                     )
-                )

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/src/varanus/client/middleware.py

@@ -2,6 +2,7 @@ import ipaddress
 
 from django.core.exceptions import MiddlewareNotUsed
 from django.http import HttpRequest, HttpResponse
+from django.utils import timezone
 
 from ..events import Request
 from .client import client, resolve_include_exclude
@@ -40,7 +41,7 @@ class VaranusMiddleware:
             # TODO: warning
             print("VaranusClient is not configured -- disabling middleware.")
             raise MiddlewareNotUsed()
-        client.ping()
+        self.last_ping = None
         self.get_response = get_response
 
     def process_exception(self, request, exception):
@@ -48,6 +49,13 @@ class VaranusMiddleware:
         client.raw_exception(exception)
 
     def __call__(self, request: HttpRequest):
+        if self.last_ping is None:
+            self.last_ping = timezone.now()
+            try:
+                client.ping()
+            except Exception:
+                pass
+
         with client.context(request.path) as varanus:
             setattr(request, client.request_attr, varanus)
             response = self.get_response(request)

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/src/varanus/client/transport/database.py

@@ -1,7 +1,8 @@
 import typing
-import uuid
 from urllib.parse import SplitResult
 
+import msgspec
+
 from varanus import events
 
 from .base import BaseTransport
@@ -17,6 +18,7 @@ class ModelTransport(BaseTransport):
     def __init__(self, url: SplitResult, environment: str, node: str):
         self.slug = url.netloc
         self.environment = environment
+        self.node_name = node
 
     def ensure_site(self):
         if hasattr(self, "site"):
@@ -43,13 +45,11 @@ class ModelTransport(BaseTransport):
             )
 
     def send(self, event: events.Context):
-        from varanus.server.models import Context
+        from varanus.server.tasks import ingest
 
-        with self.site.activated():
-            Context.from_event(
-                event,
-                event_id=uuid.uuid4(),
-                site=self.site,
-                environment=self.environment,
-                node=self.node,
-            )
+        ingest.enqueue(
+            self.site.pk,
+            self.node_name,
+            self.environment,
+            msgspec.json.encode(event).decode(),
+        )

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/src/varanus/events.py

@@ -4,6 +4,8 @@ from datetime import datetime, timezone
 
 from msgspec import Struct, field
 
+from .utils import safe_repr
+
 
 def now():
     return datetime.now(tz=timezone.utc)
@@ -46,7 +48,7 @@ def capture_stack(skip: int = 0, include_locals: bool = False) -> list[StackLine
                 function=frame.function,
                 module=frame.frame.f_globals.get("__name__", ""),
                 locals=(
-                    {name: repr(val) for name, val in frame.frame.f_locals.items()}
+                    {name: safe_repr(val) for name, val in frame.frame.f_locals.items()}
                     if include_locals
                     else {}
                 ),
@@ -94,7 +96,7 @@ class Error(Event):
                     function=function,
                     module=module,
                     linesrc=linesrc,
-                    locals={name: repr(val) for name, val in f_locals.items()},
+                    locals={name: safe_repr(val) for name, val in f_locals.items()},
                 )
             )
             tb = tb.tb_next

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/src/varanus/server/admin.py

@@ -4,6 +4,7 @@ from django.contrib import admin
 
 from .models import (
     Context,
+    ContextIntegration,
     Error,
     Log,
     Metric,
@@ -13,6 +14,7 @@ from .models import (
     Query,
     Request,
     Site,
+    SiteIntegration,
     SiteKey,
     SiteMember,
 )
@@ -34,9 +36,14 @@ class SiteKeyInline(admin.TabularInline):
     extra = 0
 
 
+class SiteIntegrationInline(admin.StackedInline):
+    model = SiteIntegration
+    extra = 0
+
+
 class SiteAdmin(admin.ModelAdmin):
     list_display = ["name", "slug", "schema_name"]
-    inlines = [SiteMemberInline, SiteKeyInline]
+    inlines = [SiteMemberInline, SiteKeyInline, SiteIntegrationInline]
     prepopulated_fields = {"slug": ["name"], "schema_name": ["name"]}
     fieldsets = [
         (
@@ -160,15 +167,22 @@ class NodeUpdateAdmin(admin.ModelAdmin):
     list_filter = ["node", "node__site", "node__environment"]
 
 
+class ContextIntegrationAdmin(admin.ModelAdmin):
+    list_display = ["context", "context__site", "integration", "run_date"]
+    list_filter = ["context__site", "integration"]
+    raw_id_fields = ["context"]
+
+
 admin.site.register(Site, SiteAdmin)
+admin.site.register(Node, NodeAdmin)
+admin.site.register(NodePackage, NodePackageAdmin)
+admin.site.register(NodeUpdate, NodeUpdateAdmin)
 
 if not settings.VARANUS_USE_SCHEMAS:
-    admin.site.register(Node, NodeAdmin)
-    admin.site.register(NodePackage, NodePackageAdmin)
-    admin.site.register(NodeUpdate, NodeUpdateAdmin)
     admin.site.register(Request, RequestAdmin)
     admin.site.register(Log, LogAdmin)
     admin.site.register(Error, ErrorAdmin)
     admin.site.register(Context, ContextAdmin)
     admin.site.register(Metric, MetricAdmin)
     admin.site.register(Query, QueryAdmin)
+    admin.site.register(ContextIntegration, ContextIntegrationAdmin)

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/src/varanus/server/apps.py

@@ -5,3 +5,6 @@ class VaranusServer(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "varanus.server"
     label = "varanus"
+
+    def ready(self):
+        pass

varanus-0.1.0.dev6/src/varanus/server/integrations/__init__.py

@@ -0,0 +1,3 @@
+from .base import DuplicateIntegration, Integration, IntegrationError
+
+__all__ = ["DuplicateIntegration", "Integration", "IntegrationError"]

varanus-0.1.0.dev6/src/varanus/server/integrations/base.py

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING, Any
+
+from varanus import events
+
+if TYPE_CHECKING:
+    from ..models import Context
+
+
+class IntegrationError(Exception):
+    pass
+
+
+class DuplicateIntegration(IntegrationError):
+    pass
+
+
+class Integration:
+    def __init__(self, settings: dict[str, Any]):
+        self.settings = settings
+
+    def is_valid(self, context: events.Context) -> bool:
+        """
+        Returns whether the integration should be scheduled to run for the given
+        Context event (not the Context model).
+        """
+        return True
+
+    def fingerprint(self, context: "Context") -> str | None:
+        """
+        Given a Context model, returns a fingerprint for debouncing integration calls.
+        """
+        return None
+
+    def execute(self, context: "Context") -> Any:
+        """
+        Runs the integration for the given Context model.
+        """
+        raise NotImplementedError()

varanus-0.1.0.dev6/src/varanus/server/integrations/squish.py

@@ -0,0 +1,74 @@
+import itertools
+import logging
+
+import httpx
+
+from varanus import events
+from varanus.utils import make_fingerprint
+
+from ..models import Context
+from .base import Integration
+
+logger = logging.getLogger(__name__)
+
+
+class SquishIntegration(Integration):
+    def is_valid(self, context: events.Context) -> bool:
+        return (
+            (len(context.errors) > 0)
+            and bool(self.settings.get("endpoint"))
+            and bool(self.settings.get("api_key"))
+            and bool(self.settings.get("user_key"))
+        )
+
+    def fingerprint(self, context: "Context") -> str | None:
+        return make_fingerprint(
+            itertools.chain.from_iterable(
+                err.fingerprint_parts() for err in context.errors.all()
+            )
+        )
+
+    def execute(self, context: Context):
+        lines = []
+
+        for err in context.errors.all():
+            lines.append(f"### {err.kind} in {err.module}")
+            lines.append(f"> {err.message}")
+            lines.append("```")
+            for line in err.stack:
+                lines.append(
+                    "{module}.{func} - {file}:{lineno}".format(
+                        module=line["module"],
+                        func=line["function"],
+                        file=line["file"],
+                        lineno=line["lineno"],
+                    )
+                )
+                lines.append("    " + line["linesrc"])
+            lines.append("```")
+
+        for idx, log in enumerate(context.logs.all()):
+            if idx == 0:
+                lines.append("### Request Logs")
+            lines.append(
+                "* `{level} - {name}:{lineno}`: *{msg}*".format(
+                    level=log.get_level_display(),  # type: ignore
+                    name=log.name,
+                    lineno=log.lineno,
+                    msg=log.message,
+                )
+            )
+
+        subject = f"{context.site.name} ({context.environment}) - {context.name}"
+        return httpx.post(
+            self.settings["endpoint"],
+            json={
+                "issue_type": self.settings.get("issue_type", "bug"),
+                "subject": subject,
+                "description": {"comment": "\n".join(lines), "format": "markdown"},
+            },
+            headers={
+                "X-Squish-API-Key": self.settings["api_key"],
+                "X-Squish-User-Key": self.settings["user_key"],
+            },
+        ).json()

varanus-0.1.0.dev6/src/varanus/server/management/commands/serve.py

@@ -0,0 +1,64 @@
+import os
+import threading
+
+from django.conf import settings
+from django.core.management import BaseCommand
+from granian import Granian
+from granian.constants import Interfaces
+
+
+def cpus() -> int:
+    return os.cpu_count() or 4
+
+
+class Command(BaseCommand):
+    help = "Web server and task runner."
+
+    def add_arguments(self, parser):
+        parser.add_argument("-r", "--reload", action="store_true", default=False)
+        parser.add_argument("-w", "--workers", type=int, default=1)
+        parser.add_argument("-t", "--threads", type=int, default=cpus())
+        parser.add_argument(
+            "-k",
+            "--tasks",
+            nargs="?",
+            type=int,
+            const=cpus() // 2,
+            default=0,
+        )
+
+    def on_startup(self):
+        if self.runner:
+            threading.Thread(target=self.runner.run).start()
+
+    def on_reload(self):
+        if self.runner:
+            self.runner.reload()
+
+    def on_shutdown(self):
+        if self.runner:
+            self.runner.stop()
+
+    def handle(self, *args, **options):
+        self.runner = None
+        if workers := options["tasks"]:
+            from varanus.tasks.runner import Runner
+
+            self.runner = Runner(workers=workers)
+
+        server = Granian(
+            ":".join(settings.WSGI_APPLICATION.rsplit(".", 1)),
+            address="0.0.0.0",
+            port=9000,
+            interface=Interfaces.WSGI,
+            workers=options["workers"],
+            blocking_threads=options["threads"],
+            log_access=True,
+            reload=options["reload"],
+            reload_paths=[settings.BASE_DIR / "src"],
+            websockets=False,
+        )
+        server.on_startup(self.on_startup)
+        server.on_reload(self.on_reload)
+        server.on_shutdown(self.on_shutdown)
+        server.serve()

{varanus-0.1.0.dev4 → varanus-0.1.0.dev6}/src/varanus/server/migrations/0001_initial.py

@@ -1,4 +1,4 @@
-# Generated by Django 5.2.8 on 2025-11-25 01:37
+# Generated by Django 6.0 on 2025-12-11 00:00
 
 import secrets
 
@@ -491,6 +491,81 @@ class Migration(migrations.Migration):
                 to="varanus.site",
             ),
         ),
+        migrations.CreateModel(
+            name="SiteIntegration",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.CharField(max_length=100)),
+                ("integration_path", models.CharField(max_length=250)),
+                ("settings", models.JSONField(blank=True, default=dict)),
+                ("event_filter", models.JSONField(blank=True, default=dict)),
+                ("debounce", models.CharField(default="30d", max_length=20)),
+                (
+                    "site",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="integrations",
+                        to="varanus.site",
+                    ),
+                ),
+            ],
+            options={
+                "db_table": "site_integration",
+            },
+        ),
+        migrations.CreateModel(
+            name="ContextIntegration",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "identifier",
+                    models.CharField(
+                        blank=True,
+                        db_index=True,
+                        default=None,
+                        max_length=200,
+                        null=True,
+                    ),
+                ),
+                ("result", models.JSONField(blank=True, default=dict)),
+                ("run_date", models.DateTimeField(auto_now_add=True)),
+                (
+                    "context",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="integrations",
+                        to="varanus.context",
+                    ),
+                ),
+                (
+                    "integration",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="contexts",
+                        to="varanus.siteintegration",
+                    ),
+                ),
+            ],
+            options={
+                "db_table": "context_integration",
+            },
+        ),
         migrations.CreateModel(
             name="SiteKey",
             fields=[
@@ -604,6 +679,20 @@ class Migration(migrations.Migration):
                 name="unique_site_node",
             ),
         ),
+        migrations.AddConstraint(
+            model_name="context",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("parent__isnull", True)),
+                fields=("event_id",),
+                name="unique_context_event_id",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="contextintegration",
+            constraint=models.UniqueConstraint(
+                fields=("context", "integration"), name="uniq_context_integration"
+            ),
+        ),
         migrations.AddConstraint(
             model_name="sitemember",
             constraint=models.UniqueConstraint(