varanus 0.1.0__tar.gz → 0.1.0.dev1__tar.gz

varanus-0.1.0.dev1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.3
+Name: varanus
+Version: 0.1.0.dev1
+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-passkey-auth>=0.2.0 ; extra == 'server'
+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
+Provides-Extra: server
+Description-Content-Type: text/markdown
+
+* Single database mode
+* Multiple schema mode
+* Local mode

varanus-0.1.0.dev1/README.md

@@ -0,0 +1,3 @@
+* Single database mode
+* Multiple schema mode
+* Local mode

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

@@ -1,35 +1,31 @@
 [project]
 name = "varanus"
-version = "0.1.0"
+version = "0.1.0.dev1"
 description = "Django application monitoring."
-authors = [
-    { name = "Dan Watson", email = "watsond@imsweb.com" }
-]
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.13"
 dependencies = [
     "httpx>=0.27.0",
     "msgspec>=0.19.0",
 ]
-classifiers = [
-    "Intended Audience :: Developers",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3",
-]
 
 [project.optional-dependencies]
 server = [
     "cconf>=1.0.0",
-    "django>=6.0; python_version>='3.12'",
-    "django-dbtasks[serve]>=0.3.2; python_version>='3.12'",
+    "django~=5.2.0",
     "django-passkey-auth>=0.2.0",
+    "granian>=2.4.2",
     "psycopg[binary]>=3.2.1",
+    "websockets>=13.0",
     "whitenoise>=6.7.0",
 ]
 
 [dependency-groups]
 dev = []
 
+[project.scripts]
+manage = "varanus.server.__main__:manage"
+
 [build-system]
 requires = ["uv_build>=0.9.2,<0.10.0"]
 build-backend = "uv_build"
@@ -37,3 +33,7 @@ build-backend = "uv_build"
 [tool.ruff.lint]
 extend-select = ["I"]
 isort.known-first-party = ["varanus"]
+
+[tool.pytest.ini_options]
+addopts = "--tb=short -s"
+DJANGO_SETTINGS_MODULE = "varanus.server.settings"

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

@@ -4,4 +4,3 @@ setup = client.setup
 context = client.context
 log = client.log
 metric = client.metric
-timer = client.timer

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

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

varanus-0.1.0.dev1/src/varanus/client/client.py

@@ -0,0 +1,151 @@
+import platform
+from importlib.metadata import distributions
+from typing import Union
+from urllib.parse import urlsplit
+
+from varanus.events import Context, NodeInfo
+
+from ..utils import import_string
+from .context import VaranusContext, current_context
+from .loggers import QueryLogger
+from .transport.base import BaseTransport
+
+
+def install_query_logger(logger):
+    def handler(sender, **kwargs):
+        if logger not in kwargs["connection"].execute_wrappers:
+            kwargs["connection"].execute_wrappers.append(logger)
+
+    return handler
+
+
+class VaranusClient:
+    environment: str | None
+    transport: BaseTransport
+
+    request_attr: str
+    logger_name: str
+    tags: dict
+
+    include_headers: Union[list, bool, None]
+    exclude_headers: list | None
+    sensitive_headers = set(
+        [
+            "authorization",
+            "cookie",
+            "proxy-authorization",
+        ]
+    )
+
+    scheme_transports = {
+        "test": "varanus.client.transport.test.TestTransport",
+        "http": "varanus.client.transport.http.HttpTransport",
+        "https": "varanus.client.transport.http.HttpTransport",
+        "db": "varanus.client.transport.database.ModelTransport",
+    }
+
+    send_all: bool
+    configured = False
+
+    def setup(
+        self,
+        dsn,
+        request_attr="varanus",
+        environment=None,
+        transport_class=None,
+        logger_name="varanus.request",
+        tags=None,
+        include_headers=None,
+        exclude_headers=None,
+        log_queries: bool | int = False,
+        log_query_params=False,
+        query_metrics=False,
+        send_all=False,
+        install=None,
+    ):
+        url = urlsplit(dsn)
+        self.environment = environment
+        if transport_class is None:
+            transport_class = self.scheme_transports.get(url.scheme)
+            if transport_class is None:
+                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)
+        self.request_attr = request_attr
+        self.logger_name = logger_name
+        self.tags = tags or {}
+        self.include_headers = include_headers
+        self.exclude_headers = exclude_headers
+        if log_queries or query_metrics:
+            try:
+                # The logger is installed as early as possible, and for all connections.
+                from django.db.backends.signals import connection_created
+
+                # Create a single QueryLogger to be used by all connections.
+                self.query_logger = QueryLogger(
+                    log_queries,
+                    log_query_params,
+                    query_metrics,
+                )
+                # Install it in each new connection (if it's not already installed).
+                connection_created.connect(
+                    install_query_logger(self.query_logger),
+                    weak=False,
+                )
+            except ImportError:
+                pass
+        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"
+                )
+                install.insert(idx + 1, "varanus.client.middleware.VaranusMiddleware")
+            elif "django.middleware.common.CommonMiddleware" in install:
+                idx = install.index("django.middleware.common.CommonMiddleware")
+                install.insert(idx + 1, "varanus.client.middleware.VaranusMiddleware")
+            else:
+                install.append("varanus.client.middleware.VaranusMiddleware")
+        return self
+
+    def send(self, *events: Context):
+        for e in events:
+            self.transport.send(e)
+
+    def ping(self):
+        self.transport.ping(
+            NodeInfo(
+                name=platform.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):
+        if ctx := current_context.get():
+            kwargs.setdefault("stacklevel", 2)
+            ctx.log(level, message, *args, **kwargs)
+
+    def raw_exception(self, exception, tags: dict | None = None):
+        if ctx := current_context.get():
+            ctx.raw_exception(exception, tags=tags)
+
+    def metric(self, name, value: float = 0.0, tags: dict | None = None):
+        if ctx := current_context.get():
+            ctx.metric(name, value, tags=tags)
+
+    def context(self, name: str, tags: dict | None = None):
+        if ctx := current_context.get():
+            return ctx.context(name, tags)
+        else:
+            return VaranusContext(self, name, tags or self.tags)
+
+
+client = VaranusClient()

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

@@ -1,8 +1,6 @@
-import contextlib
 import inspect
 import logging
 import sys
-import time
 from contextvars import ContextVar, Token
 from datetime import timedelta
 from typing import TYPE_CHECKING
@@ -80,11 +78,11 @@ class VaranusContext:
 
     def log(
         self,
-        level: int,
-        message: str,
+        level,
+        message,
         *args,
         exc_info=None,
-        stacklevel: int = 1,
+        stacklevel=1,
         tags: dict | None = None,
         **kwargs,
     ):
@@ -101,27 +99,27 @@ class VaranusContext:
             )
         )
 
-    def debug(self, message: str, *args, **kwargs):
+    def debug(self, message, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.DEBUG, message, *args, **kwargs)
 
-    def info(self, message: str, *args, **kwargs):
+    def info(self, message, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.INFO, message, *args, **kwargs)
 
-    def warning(self, message: str, *args, **kwargs):
+    def warning(self, message, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.WARNING, message, *args, **kwargs)
 
-    def error(self, message: str, *args, **kwargs):
+    def error(self, message, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.ERROR, message, *args, **kwargs)
 
-    def critical(self, message: str, *args, **kwargs):
+    def critical(self, message, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         self.log(logging.CRITICAL, message, *args, **kwargs)
 
-    def exception(self, message: str, *args, **kwargs):
+    def exception(self, message, *args, **kwargs):
         kwargs.setdefault("stacklevel", 2)
         kwargs.setdefault("exc_info", sys.exc_info())
         self.log(logging.ERROR, message, *args, **kwargs)
@@ -130,25 +128,16 @@ class VaranusContext:
         if err := Error.from_exception(exception, tags=tags):
             self.errors.append(err)
 
-    def context(self, name: str = "", tags: dict | None = None):
+    def context(self, name="", tags: dict | None = None):
         ctx = VaranusContext(self.client, name, tags)
         self.subcontexts.append(ctx)
         return ctx
 
-    def metric(self, name: str, value: float = 0.0, tags: dict | None = None):
+    def metric(self, name, 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)
 
-    @contextlib.contextmanager
-    def timer(self, name: str, tags: dict | None = None):
-        start = time.monotonic()
-        try:
-            yield self
-        finally:
-            elapsed = time.monotonic() - start
-            self.metric(name, elapsed, tags=tags)
-
 
 current_context: ContextVar[VaranusContext | None] = ContextVar(
     "current_context",

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

@@ -1,7 +1,7 @@
 import logging
 import sys
 
-from ..events import Log, Query, capture_stack, now
+from ..events import Log, Query, now
 from .context import ONE_MS, current_context
 
 
@@ -12,7 +12,7 @@ class VaranusHandler(logging.Handler):
 
 
 class QueryLogger:
-    def __init__(self, threshold, log_params, log_stack, metrics):
+    def __init__(self, threshold, log_params, metrics):
         # TODO: add callback for tagging?
         if threshold is True:
             self.threshold = 0
@@ -21,7 +21,6 @@ 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:
@@ -42,19 +41,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:
-                    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:
+                    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,
                     )
+                )

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

@@ -1,11 +1,12 @@
-import ipaddress
+import re
 
 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
+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):
@@ -14,21 +15,24 @@ 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()
-    try:
-        # Validate and normalize the IP address.
-        return str(ipaddress.ip_address(ip_address))
-    except ValueError:
-        return ""
+    if not IP_REGEX.match(ip_address):
+        ip_address = None
+    return ip_address
 
 
 def request_headers(request: HttpRequest):
     headers = {}
-    include_headers = resolve_include_exclude(
-        [name.lower() for name in request.headers],
-        client.include_headers,
-        client.exclude_headers,
-    )
-    for name in include_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):
         value = request.headers.get(name)
         if value is not None:
             headers[name] = value
@@ -41,7 +45,7 @@ class VaranusMiddleware:
             # TODO: warning
             print("VaranusClient is not configured -- disabling middleware.")
             raise MiddlewareNotUsed()
-        self.last_ping = None
+        client.ping()
         self.get_response = get_response
 
     def process_exception(self, request, exception):
@@ -49,22 +53,14 @@ 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(),
-                method=request.method or "",
                 path=request.path,
-                query=request.META.get("QUERY_STRING", ""),
+                method=request.method or "",
                 status=response.status_code,
                 headers=request_headers(request),
                 size=(

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

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

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

@@ -0,0 +1,28 @@
+import uuid
+from urllib.parse import SplitResult
+
+from django.db import transaction
+
+from varanus import events
+from varanus.server import models
+
+from .base import BaseTransport
+
+
+class ModelTransport(BaseTransport):
+    def __init__(self, url: SplitResult, environment: str):
+        self.environment = environment
+
+    def ping(self, info: events.NodeInfo):
+        site = models.Site.objects.get()
+        models.Node.update(info, site=site, environment=self.environment)
+
+    @transaction.atomic
+    def send(self, event: events.Context):
+        site = models.Site.objects.get()
+        models.Context.from_event(
+            event,
+            event_id=uuid.uuid4(),
+            site=site,
+            environment=self.environment,
+        )

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

@@ -0,0 +1,37 @@
+import platform
+from typing import Any
+from urllib.parse import SplitResult
+
+import httpx
+import msgspec
+
+from varanus import events
+
+from .base import BaseTransport
+
+
+class HttpTransport(BaseTransport):
+    def __init__(self, url: SplitResult, environment: 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.client = httpx.Client(
+            headers={
+                "X-Varanus-Key": url.username or "",
+                "X-Varanus-Environment": environment or "",
+                "X-Varanus-Node": platform.node(),
+            },
+            timeout=1.0,
+        )
+
+    def request(self, url: str, obj: Any):
+        try:
+            self.client.post(url, content=msgspec.json.encode(obj))
+        except Exception as ex:
+            print(f"error sending to {url}: {ex}")
+
+    def ping(self, info: events.NodeInfo):
+        self.request(self.ping_url, info)
+
+    def send(self, event: events.Context):
+        self.request(self.event_url, event)

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

@@ -1,11 +1,8 @@
-import inspect
 import logging
 from datetime import datetime, timezone
 
 from msgspec import Struct, field
 
-from .utils import safe_repr
-
 
 def now():
     return datetime.now(tz=timezone.utc)
@@ -19,50 +16,23 @@ class Event(Struct, kw_only=True, omit_defaults=True):
 class NodeInfo(Struct):
     name: str
     platform: str
-    language: str
-    language_version: str
-    framework: str
-    framework_version: str
+    python_version: str
     packages: dict[str, str]
-    settings: dict[str, str]
-    environment: dict[str, str]
-    version: str = ""
 
 
-class StackLine(Struct):
+class ErrorLine(Struct):
     file: str | None
     lineno: int | None
     function: str | None
     module: str | None
-    linesrc: str | None
     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: safe_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
-    stack: list[StackLine] = []
+    lines: list[ErrorLine] = []
 
     @classmethod
     def from_exception(cls, exc_info, tags=None):
@@ -82,22 +52,14 @@ 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(
-                StackLine(
+                ErrorLine(
                     file=abs_path,
                     lineno=lineno,
                     function=function,
                     module=module,
-                    linesrc=linesrc,
-                    locals={name: safe_repr(val) for name, val in f_locals.items()},
+                    locals={name: repr(val) for name, val in f_locals.items()},
                 )
             )
             tb = tb.tb_next
@@ -106,7 +68,7 @@ class Error(Event):
             kind=kind,
             module=module,
             message=message,
-            stack=lines,
+            lines=lines,
         )
 
 
@@ -154,8 +116,8 @@ class Metric(Event):
     agg_count: int = 0
     agg_sum: float = 0.0
     agg_avg: float = 0.0
-    agg_min: float = float("inf")
-    agg_max: float = float("-inf")
+    agg_min: float = 0.0
+    agg_max: float = 0.0
 
     def update(self, value: float):
         self.agg_count += 1
@@ -172,14 +134,12 @@ class Query(Event):
     db: str
     elapsed_ms: int
     success: bool
-    stack: list[StackLine] = []
 
 
 class Request(Event):
     host: str
-    method: str
     path: str
-    query: str
+    method: str
     status: int
     headers: dict = {}
     size: int | None = None