varanus 0.1.0.dev1__tar.gz → 0.1.0.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: varanus
-Version: 0.1.0.dev1
+Version: 0.1.0.dev3
 Summary: Django application monitoring.
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: msgspec>=0.19.0
@@ -11,7 +11,7 @@ Requires-Dist: granian>=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.13
+Requires-Python: >=3.11
 Provides-Extra: server
 Description-Content-Type: text/markdown
 

{varanus-0.1.0.dev1 → varanus-0.1.0.dev3}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "varanus"
-version = "0.1.0.dev1"
+version = "0.1.0.dev3"
 description = "Django application monitoring."
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.11"
 dependencies = [
     "httpx>=0.27.0",
     "msgspec>=0.19.0",

{varanus-0.1.0.dev1 → varanus-0.1.0.dev3}/src/varanus/client/apps.py

@@ -5,4 +5,4 @@ class VaranusClient(AppConfig):
     name = "varanus.client"
 
     def ready(self):
-        print("VaranusClient.ready")
+        pass

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

@@ -1,6 +1,5 @@
 import platform
 from importlib.metadata import distributions
-from typing import Union
 from urllib.parse import urlsplit
 
 from varanus.events import Context, NodeInfo
@@ -20,14 +19,14 @@ def install_query_logger(logger):
 
 
 class VaranusClient:
-    environment: str | None
+    environment: str
     transport: BaseTransport
 
     request_attr: str
     logger_name: str
     tags: dict
 
-    include_headers: Union[list, bool, None]
+    include_headers: list | bool | None
     exclude_headers: list | None
     sensitive_headers = set(
         [
@@ -38,9 +37,8 @@ class VaranusClient:
     )
 
     scheme_transports = {
-        "test": "varanus.client.transport.test.TestTransport",
-        "http": "varanus.client.transport.http.HttpTransport",
-        "https": "varanus.client.transport.http.HttpTransport",
+        "http": "varanus.client.transport.http.ThreadedHttpTransport",
+        "https": "varanus.client.transport.http.ThreadedHttpTransport",
         "db": "varanus.client.transport.database.ModelTransport",
     }
 
@@ -49,29 +47,38 @@ class VaranusClient:
 
     def setup(
         self,
-        dsn,
-        request_attr="varanus",
-        environment=None,
-        transport_class=None,
-        logger_name="varanus.request",
-        tags=None,
-        include_headers=None,
-        exclude_headers=None,
+        dsn: 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,
         log_queries: bool | int = False,
-        log_query_params=False,
-        query_metrics=False,
-        send_all=False,
-        install=None,
+        log_query_params: bool = False,
+        query_metrics: bool | str = False,
+        send_all: bool = False,
+        install: list | None = None,
     ):
         url = urlsplit(dsn)
         self.environment = environment
+        self.node = node or platform.node()
         if transport_class is None:
-            transport_class = self.scheme_transports.get(url.scheme)
-            if transport_class is None:
+            if url.scheme not in self.scheme_transports:
                 raise ValueError(f"No transport class found for `{url.scheme}`")
-        if isinstance(transport_class, str):
-            transport_class = import_string(transport_class)
-        self.transport = transport_class(url, self.environment)
+            resolved_class = import_string(self.scheme_transports[url.scheme])
+        elif isinstance(transport_class, str):
+            resolved_class = import_string(transport_class)
+        else:
+            resolved_class = transport_class
+        if not issubclass(resolved_class, BaseTransport):
+            raise ValueError(
+                f"Transport class `{transport_class}` must be a subclass of"
+                "BaseTransport."
+            )
+        self.transport = resolved_class(url, self.environment, self.node)
         self.request_attr = request_attr
         self.logger_name = logger_name
         self.tags = tags or {}
@@ -98,10 +105,6 @@ class VaranusClient:
         self.send_all = send_all
         self.configured = True
         if install:
-            if not isinstance(install, list):
-                raise TypeError(
-                    "The varanus middleware can only be automatically installed into a list."
-                )
             if "django.contrib.auth.middleware.AuthenticationMiddleware" in install:
                 idx = install.index(
                     "django.contrib.auth.middleware.AuthenticationMiddleware"
@@ -121,14 +124,14 @@ class VaranusClient:
     def ping(self):
         self.transport.ping(
             NodeInfo(
-                name=platform.node(),
+                name=self.node,
                 platform=platform.platform(),
                 python_version=platform.python_version(),
                 packages={d.name: d.version for d in distributions()},
             )
         )
 
-    def log(self, level, message, *args, **kwargs):
+    def log(self, level: int, message: str, *args, **kwargs):
         if ctx := current_context.get():
             kwargs.setdefault("stacklevel", 2)
             ctx.log(level, message, *args, **kwargs)
@@ -137,7 +140,7 @@ class VaranusClient:
         if ctx := current_context.get():
             ctx.raw_exception(exception, tags=tags)
 
-    def metric(self, name, value: float = 0.0, tags: dict | None = None):
+    def metric(self, name: str, value: float = 0.0, tags: dict | None = None):
         if ctx := current_context.get():
             ctx.metric(name, value, tags=tags)
 

{varanus-0.1.0.dev1 → varanus-0.1.0.dev3}/src/varanus/client/context.py

@@ -78,11 +78,11 @@ class VaranusContext:
 
     def log(
         self,
-        level,
-        message,
+        level: int,
+        message: str,
         *args,
         exc_info=None,
-        stacklevel=1,
+        stacklevel: int = 1,
         tags: dict | None = None,
         **kwargs,
     ):
@@ -99,27 +99,27 @@ class VaranusContext:
             )
         )
 
-    def debug(self, message, *args, **kwargs):
+    def debug(self, message: str, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.DEBUG, message, *args, **kwargs)
 
-    def info(self, message, *args, **kwargs):
+    def info(self, message: str, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.INFO, message, *args, **kwargs)
 
-    def warning(self, message, *args, **kwargs):
+    def warning(self, message: str, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.WARNING, message, *args, **kwargs)
 
-    def error(self, message, *args, **kwargs):
+    def error(self, message: str, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.ERROR, message, *args, **kwargs)
 
-    def critical(self, message, *args, **kwargs):
+    def critical(self, message: str, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.CRITICAL, message, *args, **kwargs)
 
-    def exception(self, message, *args, **kwargs):
+    def exception(self, message: str, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         kwargs.setdefault("exc_info", sys.exc_info())
         self.log(logging.ERROR, message, *args, **kwargs)
@@ -128,12 +128,12 @@ class VaranusContext:
         if err := Error.from_exception(exception, tags=tags):
             self.errors.append(err)
 
-    def context(self, name="", tags: dict | None = None):
+    def context(self, name: str = "", tags: dict | None = None):
         ctx = VaranusContext(self.client, name, tags)
         self.subcontexts.append(ctx)
         return ctx
 
-    def metric(self, name, value: float = 0.0, tags: dict | None = None):
+    def metric(self, name: str, value: float = 0.0, tags: dict | None = None):
         if name not in self.metrics:
             self.metrics[name] = Metric(name=name, tags=tags or {})
         self.metrics[name].update(value)

{varanus-0.1.0.dev1 → varanus-0.1.0.dev3}/src/varanus/client/middleware.py

@@ -1,4 +1,4 @@
-import re
+import ipaddress
 
 from django.core.exceptions import MiddlewareNotUsed
 from django.http import HttpRequest, HttpResponse
@@ -6,8 +6,6 @@ from django.http import HttpRequest, HttpResponse
 from ..events import Request
 from .client import client
 
-IP_REGEX = re.compile(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")
-
 
 def get_ip(request: HttpRequest):
     ip_address = request.META.get("HTTP_X_FORWARDED_FOR", "").strip()
@@ -15,9 +13,11 @@ def get_ip(request: HttpRequest):
         ip_address = ip_address.split(",")[0].strip()
     if not ip_address:
         ip_address = request.META.get("REMOTE_ADDR", "127.0.0.1").strip()
-    if not IP_REGEX.match(ip_address):
-        ip_address = None
-    return ip_address
+    try:
+        # Validate and normalize the IP address.
+        return str(ipaddress.ip_address(ip_address))
+    except ValueError:
+        return ""
 
 
 def request_headers(request: HttpRequest):

{varanus-0.1.0.dev1 → varanus-0.1.0.dev3}/src/varanus/client/transport/base.py

@@ -4,7 +4,7 @@ from varanus import events
 
 
 class BaseTransport:
-    def __init__(self, url: SplitResult, environment: str):
+    def __init__(self, url: SplitResult, environment: str, node: str):
         pass
 
     def ping(self, info: events.NodeInfo):

{varanus-0.1.0.dev1 → varanus-0.1.0.dev3}/src/varanus/client/transport/database.py

@@ -10,8 +10,9 @@ from .base import BaseTransport
 
 
 class ModelTransport(BaseTransport):
-    def __init__(self, url: SplitResult, environment: str):
+    def __init__(self, url: SplitResult, environment: str, node: str):
         self.environment = environment
+        self.node = node
 
     def ping(self, info: events.NodeInfo):
         site = models.Site.objects.get()
@@ -20,9 +21,11 @@ class ModelTransport(BaseTransport):
     @transaction.atomic
     def send(self, event: events.Context):
         site = models.Site.objects.get()
+        node = site.nodes.get(name=self.node, environment=self.environment)
         models.Context.from_event(
             event,
             event_id=uuid.uuid4(),
             site=site,
             environment=self.environment,
+            node=node,
         )

varanus-0.1.0.dev3/src/varanus/client/transport/http.py

@@ -0,0 +1,83 @@
+import logging
+import queue
+import threading
+import time
+from typing import Any
+from urllib.parse import SplitResult, parse_qs
+
+import httpx
+import msgspec
+
+from varanus import events
+
+from .base import BaseTransport
+
+logger = logging.getLogger(__name__)
+
+
+class HttpTransport(BaseTransport):
+    def __init__(self, url: SplitResult, environment: str, node: str):
+        path = url.path.rstrip("/")
+        self.ping_url = f"{url.scheme}://{url.netloc}{path}/api/ping/"
+        self.event_url = f"{url.scheme}://{url.netloc}{path}/api/ingest/"
+        self.options = parse_qs(url.query, keep_blank_values=True)
+        timeout = 1.0
+        if "timeout" in self.options:
+            timeout = float(self.options["timeout"][0])
+        self.client = httpx.Client(
+            headers={
+                "X-Varanus-Key": url.username or "",
+                "X-Varanus-Environment": environment,
+                "X-Varanus-Node": node,
+            },
+            timeout=timeout,
+        )
+
+    def request(self, url: str, obj: Any):
+        try:
+            self.client.post(url, content=msgspec.json.encode(obj))
+        except Exception:
+            logger.exception("error sending to %s", url)
+
+    def ping(self, info: events.NodeInfo):
+        self.request(self.ping_url, info)
+
+    def send(self, event: events.Context):
+        self.request(self.event_url, [event])
+
+
+def sender(pending: queue.SimpleQueue, client: httpx.Client, url: str, rate: float):
+    while True:
+        start = time.time()
+        events = []
+        while True:
+            try:
+                events.append(pending.get_nowait())
+            except queue.Empty:
+                break
+            if len(events) >= 100:
+                break
+        if events:
+            try:
+                client.post(url, content=msgspec.json.encode(events))
+            except Exception:
+                logger.exception("error sending to %s", url)
+        elapsed = time.time() - start
+        time.sleep(max(rate - elapsed, 1.0))
+
+
+class ThreadedHttpTransport(HttpTransport):
+    def __init__(self, url: SplitResult, environment: str, node: str):
+        super().__init__(url, environment, node)
+        self.pending = queue.SimpleQueue()
+        rate = 3.0
+        if "rate" in self.options:
+            rate = float(self.options["rate"][0])
+        threading.Thread(
+            target=sender,
+            args=(self.pending, self.client, self.event_url, rate),
+            daemon=True,
+        ).start()
+
+    def send(self, event: events.Context):
+        self.pending.put(event)

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

@@ -1,3 +1,4 @@
+import inspect
 import logging
 from datetime import datetime, timezone
 
@@ -25,6 +26,7 @@ class ErrorLine(Struct):
     lineno: int | None
     function: str | None
     module: str | None
+    linesrc: str | None
     locals: dict[str, str]
 
 
@@ -52,6 +54,13 @@ class Error(Event):
             abs_path = f_code.co_filename if f_code else None
             function = f_code.co_name if f_code else None
             lineno = getattr(tb, "tb_lineno", None)
+            linesrc = None
+            if f_code and lineno:
+                try:
+                    source, start = inspect.getsourcelines(f_code)
+                    linesrc = source[lineno - start].strip()
+                except (OSError, TypeError):
+                    pass
             module = f_globals.get("__name__", "")
             lines.append(
                 ErrorLine(
@@ -59,6 +68,7 @@ class Error(Event):
                     lineno=lineno,
                     function=function,
                     module=module,
+                    linesrc=linesrc,
                     locals={name: repr(val) for name, val in f_locals.items()},
                 )
             )

varanus-0.1.0.dev3/src/varanus/server/migrations/0003_alter_log_level.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.2.8 on 2025-11-17 19:51
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("varanus", "0002_context_node_error_node_log_node_metric_node_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="log",
+            name="level",
+            field=models.IntegerField(
+                blank=True,
+                choices=[
+                    (50, "CRITICAL"),
+                    (40, "ERROR"),
+                    (30, "WARNING"),
+                    (20, "INFO"),
+                    (10, "DEBUG"),
+                    (0, "NOTSET"),
+                ],
+                null=True,
+            ),
+        ),
+    ]

{varanus-0.1.0.dev1 → varanus-0.1.0.dev3}/src/varanus/server/models.py

@@ -1,6 +1,5 @@
 import hashlib
 import http
-import logging
 import secrets
 from typing import Self
 
@@ -161,7 +160,16 @@ class Node(EnvironmentModel):
         ]
 
     def __str__(self):
-        return self.name
+        return f"{self.environment}@{self.name}"
+
+    def get_absolute_url(self):
+        return reverse(
+            "node-details",
+            kwargs={
+                "slug": self.site.slug,
+                "pk": self.pk,
+            },
+        )
 
     @classmethod
     def update(cls, info: events.NodeInfo, site: Site, environment: str = ""):
@@ -450,9 +458,17 @@ class Error(ContextualModel, FingerprintModel):
 
 
 class Log(ContextualModel, FingerprintModel):
+    class Level(models.IntegerChoices):
+        CRITICAL = 50, "CRITICAL"
+        ERROR = 40, "ERROR"
+        WARNING = 30, "WARNING"
+        INFO = 20, "INFO"
+        DEBUG = 10, "DEBUG"
+        NOTSET = 0, "NOTSET"
+
     message = models.TextField()
     name = models.CharField(max_length=200, blank=True)
-    level = models.IntegerField(null=True, blank=True)
+    level = models.IntegerField(null=True, blank=True, choices=Level)
     file = models.TextField(blank=True)
     lineno = models.IntegerField(null=True, blank=True)
     error = models.ForeignKey(
@@ -481,10 +497,6 @@ class Log(ContextualModel, FingerprintModel):
             **extra,
         )
 
-    @property
-    def level_name(self):
-        return logging.getLevelName(self.level) if self.level is not None else "UNKNOWN"
-
     def fingerprint_parts(self):
         return (self.message, self.name, self.level, self.file, self.lineno)
 

{varanus-0.1.0.dev1 → varanus-0.1.0.dev3}/src/varanus/server/search/base.py

@@ -1,11 +1,12 @@
-from typing import ClassVar, Mapping, Self
+from typing import Callable, ClassVar, Literal, Mapping, Self, TypeAlias
 
 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
 
-type StringValues = dict[str, list[str]]
+StringValues: TypeAlias = dict[str, list[str]]
 
 
 def string_data(data) -> StringValues:
@@ -26,21 +27,31 @@ def string_data(data) -> StringValues:
 class SearchField:
     template_name: str
 
-    def __init__(self, label=None, field_name=None):
+    def __init__(
+        self,
+        label=None,
+        field_name=None,
+        empty_label="NULL",
+        # These belong on Facet
+        choice_label: Callable[..., str | Promise] | None = None,
+        order: Literal["value", "count"] = "value",
+    ):
         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
 
     def __set_name__(self, owner, name: str):
-        # print("__set_name__", owner, name)
         assert issubclass(owner, Search)
         self.name = name
         self.prefix = f"{name}_"
         self.id = f"id_{name}"
         if not self.label:
-            self.label = name.capitalize()
+            self.label = name.capitalize().replace("__", " ")
         if not self.field_name:
             self.field_name = name
         if not hasattr(owner, "_fields"):
@@ -48,7 +59,6 @@ class SearchField:
         owner._fields.append(self)
 
     def __get__(self, instance: "Search", owner=None) -> StringValues | Self:
-        # print("__get__", instance, owner)
         if owner is None:
             return self
         return {
@@ -58,7 +68,7 @@ class SearchField:
         }
 
     def __set__(self, instance, value):
-        print("__set__", instance, value)
+        raise AttributeError(f"`{self.name}` is read-only")
 
     def apply(self, queryset: QuerySet, field_data: StringValues) -> QuerySet:
         raise NotImplementedError()

varanus-0.1.0.dev3/src/varanus/server/search/facet.py

@@ -0,0 +1,63 @@
+import functools
+import operator
+from typing import Any, ClassVar
+
+from django.db.models import Count, Q, QuerySet
+
+from .base import SearchField, StringValues
+
+
+class Choice:
+    id: str
+    value: str
+    label: str
+    count: int
+
+    def __init__(self, field: SearchField, value: Any, count: int):
+        self.value = self.stringify(value)
+        if callable(field.choice_label):
+            self.label = field.choice_label(value)
+        else:
+            self.label = self.value or field.empty_label
+        self.id = field.id + "_" + self.value.replace(" ", "")
+        self.count = count
+
+    @classmethod
+    def stringify(cls, value):
+        return str(value) if value is not None else ""
+
+
+class Facet(SearchField):
+    choice_class: ClassVar[type[Choice]] = Choice
+
+    def get_choices(self, queryset):
+        choice_qs = queryset.values_list(self.field_name).annotate(num=Count("*"))
+        match self.order:
+            case "value":
+                choice_qs = choice_qs.order_by(self.field_name)
+            case "count":
+                choice_qs = choice_qs.order_by("-num")
+        return [self.choice_class(self, c, num) for c, num in choice_qs]
+
+
+class MultiFacet(Facet):
+    template_name = "search/multifacet.html"
+
+    def apply(self, queryset: QuerySet, field_data: StringValues) -> QuerySet:
+        filters = []
+        if selected := set(field_data.get("s", [])):
+            if "" in selected:
+                selected.discard("")
+                filters.append(Q(**{f"{self.field_name}__isnull": True}))
+            if selected:
+                filters.append(Q(**{f"{self.field_name}__in": selected}))
+        if filters:
+            queryset = queryset.filter(functools.reduce(operator.or_, filters))
+        return queryset
+
+    def get_context(self, queryset: QuerySet, field_data: StringValues) -> dict:
+        return {
+            **super().get_context(queryset, field_data),
+            "choices": self.get_choices(queryset),
+            "selected": field_data.get("s", []),
+        }

{varanus-0.1.0.dev1 → varanus-0.1.0.dev3}/src/varanus/server/templates/site/base.html

@@ -32,6 +32,7 @@
                 <form action="" method="get">
                     {{ search.render|safe }}
                     <button class="btn btn-primary">Filter</button>
+                    <a href="{{ request.path }}" class="btn btn-secondary">Clear</a>
                 </form>
             {% endblock search %}
         </div>
@@ -42,11 +43,6 @@
 </div>
 
 <div class="offcanvas offcanvas-end" style="width:33%" tabindex="-1" id="inspector">
-    <div class="offcanvas-header">
-        <button type="button" class="btn-close" data-bs-dismiss="offcanvas" aria-label="Close"></button>
-    </div>
-    <div class="offcanvas-body" id="inspector-content">
-    </div>
 </div>
 {% endblock content %}
 

varanus-0.1.0.dev3/src/varanus/server/templates/site/details/environment_nodes.html

@@ -0,0 +1,6 @@
+<div class="offcanvas-header">
+    <h5 class="offcanvas-title">{{ environment }}</h5>
+    <button type="button" class="btn-close" data-bs-dismiss="offcanvas" aria-label="Close"></button>
+</div>
+<div class="offcanvas-body">
+</div>