varanus 0.1.0.dev3__tar.gz → 0.1.0.dev5__tar.gz

{varanus-0.1.0.dev3 → varanus-0.1.0.dev5}/PKG-INFO

@@ -1,15 +1,14 @@
 Metadata-Version: 2.3
 Name: varanus
-Version: 0.1.0.dev3
+Version: 0.1.0.dev5
 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.dev3 → varanus-0.1.0.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "varanus"
-version = "0.1.0.dev3"
+version = "0.1.0.dev5"
 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.dev3 → varanus-0.1.0.dev5}/src/varanus/client/client.py

@@ -1,5 +1,7 @@
+import os
 import platform
 from importlib.metadata import distributions
+from typing import Iterable
 from urllib.parse import urlsplit
 
 from varanus.events import Context, NodeInfo
@@ -18,23 +20,30 @@ def install_query_logger(logger):
     return handler
 
 
+def resolve_include_exclude(
+    items: Iterable[str],
+    include: Iterable[str] | bool,
+    exclude: Iterable[str] | None,
+) -> set[str]:
+    if not include:
+        return set()
+
+    if include is True:
+        resolved = set(items)
+    else:
+        resolved = set(items).intersection(include)
+
+    if exclude is not None:
+        resolved.difference_update(exclude)
+
+    return resolved
+
+
 class VaranusClient:
-    environment: str
-    transport: BaseTransport
-
-    request_attr: str
-    logger_name: str
-    tags: dict
-
-    include_headers: list | bool | None
-    exclude_headers: list | None
-    sensitive_headers = set(
-        [
-            "authorization",
-            "cookie",
-            "proxy-authorization",
-        ]
-    )
+    # Things we don't want to send, at least by default.
+    sensitive_headers = set(["authorization", "cookie", "proxy-authorization"])
+    sensitive_settings = set(["SECRET_KEY"])
+    sensitive_env = set(["PGPASSWORD"])
 
     scheme_transports = {
         "http": "varanus.client.transport.http.ThreadedHttpTransport",
@@ -42,22 +51,28 @@ class VaranusClient:
         "db": "varanus.client.transport.database.ModelTransport",
     }
 
-    send_all: bool
     configured = False
 
     def setup(
         self,
         dsn: str,
+        environment: str,
         node: str | None = None,
-        environment: str = "",
         transport_class: str | type[BaseTransport] | None = None,
         request_attr: str = "varanus",
         logger_name: str = "varanus.request",
         tags: dict | None = None,
-        include_headers: list | bool | None = None,
-        exclude_headers: list | None = None,
+        include_headers: Iterable[str] | bool = False,
+        exclude_headers: Iterable[str] | None = None,
+        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,
         log_query_params: bool = False,
+        log_query_stack: bool = False,
         query_metrics: bool | str = False,
         send_all: bool = False,
         install: list | None = None,
@@ -83,7 +98,21 @@ class VaranusClient:
         self.logger_name = logger_name
         self.tags = tags or {}
         self.include_headers = include_headers
-        self.exclude_headers = exclude_headers
+        self.exclude_headers = (
+            self.sensitive_headers if exclude_headers is None else set(exclude_headers)
+        )
+        self.include_settings = include_settings
+        self.exclude_settings = (
+            self.sensitive_settings
+            if exclude_settings is None
+            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)
+        )
         if log_queries or query_metrics:
             try:
                 # The logger is installed as early as possible, and for all connections.
@@ -93,6 +122,7 @@ class VaranusClient:
                 self.query_logger = QueryLogger(
                     log_queries,
                     log_query_params,
+                    log_query_stack,
                     query_metrics,
                 )
                 # Install it in each new connection (if it's not already installed).
@@ -122,12 +152,47 @@ class VaranusClient:
             self.transport.send(e)
 
     def ping(self):
+        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(
+            settings_dict.keys(),
+            self.include_settings,
+            self.exclude_settings,
+        )
+        include_env = resolve_include_exclude(
+            os.environ.keys(),
+            self.include_env,
+            self.exclude_env,
+        )
+
         self.transport.ping(
             NodeInfo(
                 name=self.node,
                 platform=platform.platform(),
-                python_version=platform.python_version(),
+                language=platform.python_implementation(),
+                language_version=platform.python_version(),
+                framework="Django",
+                framework_version=get_version(),
                 packages={d.name: d.version for d in distributions()},
+                settings={
+                    s: settings_dict[s]
+                    for s in include_settings
+                    if self.include_default_settings or settings.is_overridden(s)
+                },
+                environment={e: os.environ[e] for e in include_env},
             )
         )
 

{varanus-0.1.0.dev3 → varanus-0.1.0.dev5}/src/varanus/client/loggers.py

@@ -1,7 +1,7 @@
 import logging
 import sys
 
-from ..events import Log, Query, now
+from ..events import Log, Query, capture_stack, now
 from .context import ONE_MS, current_context
 
 
@@ -12,7 +12,7 @@ class VaranusHandler(logging.Handler):
 
 
 class QueryLogger:
-    def __init__(self, threshold, log_params, metrics):
+    def __init__(self, threshold, log_params, log_stack, metrics):
         # TODO: add callback for tagging?
         if threshold is True:
             self.threshold = 0
@@ -21,6 +21,7 @@ class QueryLogger:
         else:
             self.threshold = int(threshold)
         self.log_params = log_params
+        self.log_stack = log_stack
         if isinstance(metrics, str):
             self.metrics_name = metrics
         else:
@@ -41,19 +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,
+                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.dev3 → varanus-0.1.0.dev5}/src/varanus/client/middleware.py

@@ -2,9 +2,10 @@ 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
+from .client import client, resolve_include_exclude
 
 
 def get_ip(request: HttpRequest):
@@ -22,17 +23,12 @@ def get_ip(request: HttpRequest):
 
 def request_headers(request: HttpRequest):
     headers = {}
-    if not client.include_headers:
-        return headers
-    if client.include_headers is True:
-        include = set(name.lower() for name in request.headers)
-    else:
-        include = set(name.lower() for name in client.include_headers)
-    if client.exclude_headers is None:
-        exclude = client.sensitive_headers
-    else:
-        exclude = set(name.lower() for name in client.exclude_headers)
-    for name in sorted(include - exclude):
+    include_headers = resolve_include_exclude(
+        [name.lower() for name in request.headers],
+        client.include_headers,
+        client.exclude_headers,
+    )
+    for name in include_headers:
         value = request.headers.get(name)
         if value is not None:
             headers[name] = value
@@ -45,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):
@@ -53,14 +49,22 @@ 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)
             # TODO: any need for request tags separate from context tags?
             varanus.request = Request(
                 host=request.get_host(),
-                path=request.path,
                 method=request.method or "",
+                path=request.path,
+                query=request.META.get("QUERY_STRING", ""),
                 status=response.status_code,
                 headers=request_headers(request),
                 size=(

varanus-0.1.0.dev5/src/varanus/client/transport/database.py

@@ -0,0 +1,55 @@
+import typing
+from urllib.parse import SplitResult
+
+import msgspec
+
+from varanus import events
+
+from .base import BaseTransport
+
+if typing.TYPE_CHECKING:
+    from varanus.server.models import Node, Site
+
+
+class ModelTransport(BaseTransport):
+    site: "Site"
+    node: "Node"
+
+    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"):
+            return
+
+        from varanus.server.models import Site
+
+        self.site, created = Site.objects.get_or_create(
+            slug=self.slug,
+            defaults={
+                "name": self.slug,
+                "schema_name": self.slug,
+            },
+        )
+
+    def ping(self, info: events.NodeInfo):
+        from varanus.server.models import Node
+
+        self.ensure_site()
+
+        with self.site.activated():
+            self.node, created, updates = Node.update(
+                info, site=self.site, environment=self.environment
+            )
+
+    def send(self, event: events.Context):
+        from varanus.server.tasks import ingest
+
+        ingest.enqueue(
+            self.site.pk,
+            self.node_name,
+            self.environment,
+            msgspec.json.encode(event).decode(),
+        )

{varanus-0.1.0.dev3 → varanus-0.1.0.dev5}/src/varanus/events.py

@@ -17,11 +17,16 @@ class Event(Struct, kw_only=True, omit_defaults=True):
 class NodeInfo(Struct):
     name: str
     platform: str
-    python_version: str
+    language: str
+    language_version: str
+    framework: str
+    framework_version: str
     packages: dict[str, str]
+    settings: dict[str, str]
+    environment: dict[str, str]
 
 
-class ErrorLine(Struct):
+class StackLine(Struct):
     file: str | None
     lineno: int | None
     function: str | None
@@ -30,11 +35,31 @@ class ErrorLine(Struct):
     locals: dict[str, str]
 
 
+def capture_stack(skip: int = 0, include_locals: bool = False) -> list[StackLine]:
+    lines = []
+    for frame in inspect.stack()[skip + 1 :]:
+        lines.append(
+            StackLine(
+                file=frame.filename,
+                lineno=frame.lineno,
+                linesrc=frame.code_context[0].strip() if frame.code_context else "",
+                function=frame.function,
+                module=frame.frame.f_globals.get("__name__", ""),
+                locals=(
+                    {name: repr(val) for name, val in frame.frame.f_locals.items()}
+                    if include_locals
+                    else {}
+                ),
+            )
+        )
+    return lines
+
+
 class Error(Event):
     kind: str
     module: str
     message: str
-    lines: list[ErrorLine] = []
+    stack: list[StackLine] = []
 
     @classmethod
     def from_exception(cls, exc_info, tags=None):
@@ -63,7 +88,7 @@ class Error(Event):
                     pass
             module = f_globals.get("__name__", "")
             lines.append(
-                ErrorLine(
+                StackLine(
                     file=abs_path,
                     lineno=lineno,
                     function=function,
@@ -78,7 +103,7 @@ class Error(Event):
             kind=kind,
             module=module,
             message=message,
-            lines=lines,
+            stack=lines,
         )
 
 
@@ -144,12 +169,14 @@ class Query(Event):
     db: str
     elapsed_ms: int
     success: bool
+    stack: list[StackLine] = []
 
 
 class Request(Event):
     host: str
-    path: str
     method: str
+    path: str
+    query: str
     status: int
     headers: dict = {}
     size: int | None = None

{varanus-0.1.0.dev3/src/varanus/server → varanus-0.1.0.dev5/src/varanus}/search/__init__.py

@@ -1,9 +1,10 @@
 from .base import Search
-from .date import DateRange
-from .facet import MultiFacet
+from .fields import DateRange, Filter, Hidden, MultiFacet
 
 __all__ = [
     "Search",
     "DateRange",
+    "Filter",
+    "Hidden",
     "MultiFacet",
 ]

varanus-0.1.0.dev5/src/varanus/search/base.py

@@ -0,0 +1,159 @@
+from typing import Callable, ClassVar, Iterable, Literal, Self
+
+from django.db.models import QuerySet
+from django.http import HttpRequest
+from django.template import loader
+from django.utils.datastructures import MultiValueDict
+from django.utils.functional import Promise
+from django.utils.safestring import SafeString
+
+from .utils import Namer, StringValues, string_data
+
+
+class SkipRender(Exception):
+    pass
+
+
+class SearchField:
+    template_name: str
+    prefixed = False
+    default = False
+
+    def __init__(
+        self,
+        label=None,
+        field_name: str | Iterable[str] | None = None,
+        empty_label="NULL",
+        # These belong on Facet
+        choice_label: Callable[..., str | Promise] | None = None,
+        order: Literal["value", "count"] = "value",
+        default: bool = False,
+    ):
+        self.name = ""
+        self.label = label or ""
+        self.field_name = field_name or ""
+        self.prefix = ""
+        self.id = ""
+        self.empty_label = empty_label
+        self.choice_label = choice_label
+        self.order = order
+        self.default = default
+
+    def __set_name__(self, owner, name: str):
+        assert issubclass(owner, Search)
+        self.name = name
+        self.prefix = f"{name}_" if self.prefixed else ""
+        self.id = f"id_{name}"
+        if not self.label:
+            self.label = name.capitalize().replace("__", " ")
+        if not self.field_name:
+            self.field_name = name
+        if not hasattr(owner, "_fields"):
+            owner._fields = []
+        owner._fields.append(self)
+
+    def __get__(self, instance: "Search", owner=None) -> StringValues | Self:
+        if owner is None:
+            return self
+        if self.prefixed:
+            return {
+                key[len(self.prefix) :]: values
+                for key, values in instance._data.items()
+                if key.startswith(self.prefix)
+            }
+        else:
+            return (
+                {self.name: instance._data[self.name]}
+                if self.name in instance._data
+                else {}
+            )
+
+    def __set__(self, instance, value):
+        raise AttributeError(f"`{self.name}` is read-only")
+
+    @property
+    def named(self):
+        """
+        Allows for {{ field.named.something }} in templates.
+        """
+        return Namer(self.prefix)
+
+    def apply(
+        self,
+        queryset: QuerySet,
+        field_data: StringValues,
+        request: HttpRequest | None = None,
+    ) -> QuerySet:
+        raise NotImplementedError()
+
+    def has_value(
+        self,
+        queryset: QuerySet,
+        field_data: StringValues,
+        request: HttpRequest | None = None,
+    ) -> bool:
+        return any(any(v) for v in field_data.values())
+
+    def get_context(
+        self,
+        queryset: QuerySet,
+        field_data: StringValues,
+        request: HttpRequest | None = None,
+    ) -> dict:
+        return {
+            "field": self,
+        }
+
+    def render(
+        self,
+        queryset: QuerySet,
+        field_data: StringValues,
+        request: HttpRequest | None = None,
+    ) -> SafeString:
+        return loader.render_to_string(
+            self.template_name,
+            self.get_context(queryset, field_data, request=request),
+            request,
+        )
+
+
+class Search:
+    _fields: ClassVar[list[SearchField]]
+    template_name = "search/search.html"
+
+    def __init__(
+        self,
+        queryset: QuerySet,
+        data: dict | MultiValueDict | None = None,
+        request: HttpRequest | None = None,
+    ):
+        self._queryset = queryset
+        self._data = string_data(data)
+        self._request = request
+
+    def queryset(self, for_field=None):
+        qs = self._queryset
+        for field in self._fields:
+            if field == for_field:
+                continue
+            field_data = getattr(self, field.name)
+            qs = field.apply(qs, field_data, request=self._request)
+        return qs
+
+    def render(self) -> SafeString:
+        context = {"fields": []}
+        initial = not bool(self._data)
+        for field in self._fields:
+            qs = self.queryset(for_field=field)
+            field_data = getattr(self, field.name)
+            try:
+                rendered = field.render(qs, field_data, request=self._request)
+                default = (initial and field.default) or field.has_value(
+                    qs,
+                    field_data,
+                    request=self._request,
+                )
+                context["fields"].append((field, default, rendered))
+            except SkipRender:
+                continue
+        return loader.render_to_string(self.template_name, context, self._request)