Step 1

Browser snippet

Paste this before </head> in the base template used by the site. It records browser errors and lightweight pageviews.

base.html

Step 2

Django settings.py snippet

Paste this at the bottom of settings.py. It captures server exceptions, 404s, request duration, and database query counts.

settings.py

Paste this block at the bottom of the file.

# FetchNode — paste everything in this block at the bottom of settings.py.

# No pip install, no downloaded file, no dependency: only the Python standard library + Django.

FETCHNODE = {
    'DSN': 'https://fetch-node.com/api/events/ingest/',
    'KEY': 'PUBLIC_PROJECT_KEY',
    'ENVIRONMENT': 'production',
    'RELEASE': '1.0.0',
    'TIMEOUT': 5,
}

# FetchNodeMiddleware is defined below in this same settings.py snippet.
# Keep it first so it sees every request, exception, 404, and slow query.
if f'{__name__}.FetchNodeMiddleware' not in MIDDLEWARE:
    MIDDLEWARE = [f'{__name__}.FetchNodeMiddleware', *MIDDLEWARE]

"""
FetchNode Django Snippet
========================================
Paste this snippet at the very bottom of your Django settings.py file.
It automatically captures 500s and 404s and sends them to your FetchNode dashboard.
"""

import hashlib
import json
import logging
import socket
import threading
import urllib.request
from datetime import datetime, timezone

from django.conf import settings
from django.http import HttpRequest

logger = logging.getLogger("fetchnode.middleware")

def _cfg(key: str, default=""):
    """Read a value from settings.FETCHNODE with a default."""
    return getattr(settings, "FETCHNODE", {}).get(key, default)

def _send(payload: dict) -> None:
    """POST an event payload to FetchNode in a background thread."""
    dsn, key = _cfg("DSN"), _cfg("KEY")
    if not dsn or not key:
        return

def _post():
        try:
            data = json.dumps(payload).encode("utf-8")
            req = urllib.request.Request(
                dsn, data=data, headers={
                    "Content-Type": "application/json",
                    "Authorization": f"Bearer {key}",
                    "X-Forwarded-Proto": "https",
                }, method="POST",
            )
            urllib.request.urlopen(req, timeout=_cfg("TIMEOUT", 5))
        except Exception:
            pass  # never crash the Django process

threading.Thread(target=_post, daemon=True).start()

def _req(request: HttpRequest) -> dict:
    """Extract request info from a Django HttpRequest."""
    xff = request.META.get("HTTP_X_FORWARDED_FOR", "")
    ip = xff.split(",")[0].strip() if xff else request.META.get("REMOTE_ADDR", "")
    return {
        "method": request.method,
        "path": request.path,
        "query_string": request.META.get("QUERY_STRING", ""),
        "ip_address": ip,
    }

def _user(request: HttpRequest) -> dict:
    """Extract user info if authenticated."""
    if hasattr(request, "user") and request.user and getattr(request.user, "is_authenticated", False):
        return {"id": str(request.user.pk), "email": getattr(request.user, "email", ""), "username": getattr(request.user, "username", "")}
    return {}

def _frames(tb):
    """Extract minimal stack frames from a traceback."""
    frames = []
    while tb is not None:
        f = tb.tb_frame
        filename = f.f_code.co_filename
        frames.append({
            "filename": filename,
            "module": filename,
            "function": f.f_code.co_name,
            "line_number": tb.tb_lineno,
            "in_app": "/site-packages/" not in filename,
        })
        tb = tb.tb_next
    return frames

class FetchNodeMiddleware:
    """Captures unhandled exceptions and 404s and sends them to FetchNode.

Add as the FIRST middleware in MIDDLEWARE for best coverage.
    """

def __init__(self, get_response):
        self.get_response = get_response

def __call__(self, request: HttpRequest):
        queries = []
        import time
        from django.db import connection

def _query_log(execute, sql, params, many, context):
            start_time = time.time()
            try:
                return execute(sql, params, many, context)
            finally:
                duration = time.time() - start_time
                queries.append({
                    "sql": sql,
                    "duration_ms": round(duration * 1000, 2),
                })

start_time_req = time.time()
        try:
            with connection.execute_wrapper(_query_log):
                response = self.get_response(request)
        except Exception as exc:
            if _cfg("DSN") and _cfg("KEY"):
                etype = type(exc).__name__
                msg = str(exc)[:2000]
                _send({
                    "timestamp": datetime.now(timezone.utc).isoformat(),
                    "level": "error",
                    "environment": _cfg("ENVIRONMENT") or getattr(settings, "DJANGO_ENV", "production"),
                    "release": _cfg("RELEASE") or getattr(settings, "GIT_COMMIT", ""),
                    "logger": "fetchnode.django",
                    "server_name": socket.gethostname(),
                    "exception": {"type": etype, "message": msg, "frames": _frames(exc.__traceback__)},
                    "request": _req(request),
                    "user": _user(request),
                    "queries": queries,
                    "fingerprint": hashlib.sha256(f"{etype}:{msg[:200]}".encode()).hexdigest()[:64],
                })
            
            # Send transaction for failed request
            duration_ms = (time.time() - start_time_req) * 1000
            if _cfg("DSN") and _cfg("KEY"):
                _send({
                    "type": "transaction",
                    "timestamp": datetime.now(timezone.utc).isoformat(),
                    "method": request.method,
                    "path": request.path,
                    "status_code": 500,
                    "duration_ms": duration_ms,
                    "db_queries_count": len(queries),
                    "db_time_ms": sum(q["duration_ms"] for q in queries),
                    "environment": _cfg("ENVIRONMENT") or getattr(settings, "DJANGO_ENV", "production"),
                })
            raise

duration_ms = (time.time() - start_time_req) * 1000

if _cfg("DSN") and _cfg("KEY"):
            # Send transaction
            _send({
                "type": "transaction",
                "timestamp": datetime.now(timezone.utc).isoformat(),
                "method": request.method,
                "path": request.path,
                "status_code": response.status_code,
                "duration_ms": duration_ms,
                "db_queries_count": len(queries),
                "db_time_ms": sum(q["duration_ms"] for q in queries),
                "environment": _cfg("ENVIRONMENT") or getattr(settings, "DJANGO_ENV", "production"),
            })

# Capture 404s
            if response.status_code == 404:
                path = request.path
                if not any(path.startswith(p) for p in ("/static/", "/media/", "/favicon.ico", "/robots.txt", "/sitemap")):
                    _send({
                        "timestamp": datetime.now(timezone.utc).isoformat(),
                        "level": "warning",
                        "environment": _cfg("ENVIRONMENT") or getattr(settings, "DJANGO_ENV", "production"),
                        "release": _cfg("RELEASE") or getattr(settings, "GIT_COMMIT", ""),
                        "logger": "fetchnode.django.404",
                        "server_name": socket.gethostname(),
                        "exception": {"type": "Http404", "message": f"Not Found: {request.path}", "frames": []},
                        "request": _req(request),
                        "user": _user(request),
                        "queries": queries,
                        "tags": {"source": "server", "type": "404"},
                        "fingerprint": hashlib.sha256(f"404:{request.path}".encode()).hexdigest()[:64],
                    })

return response

class FetchNodeHandler(logging.Handler):
    """Optional logging handler — sends ERROR+ records to FetchNode.

Add to your LOGGING settings:

LOGGING = {
            'handlers': {
                'fetchnode': {
                    'level': 'ERROR',
                    'class': 'fetchnode_middleware.FetchNodeHandler',
                },
            },
            'loggers': {
                'django': {'handlers': ['fetchnode'], 'level': 'ERROR'},
            },
        }
    """

def emit(self, record: logging.LogRecord) -> None:
        try:
            if not _cfg("DSN") or not _cfg("KEY"):
                return
            exc_info = record.exc_info
            etype = exc_info[0].__name__ if exc_info and exc_info[0] else "Error"
            msg = str(exc_info[1])[:2000] if exc_info and exc_info[1] else record.getMessage()
            _send({
                "timestamp": datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(),
                "level": record.levelname.lower(),
                "environment": _cfg("ENVIRONMENT") or getattr(settings, "DJANGO_ENV", "production"),
                "release": _cfg("RELEASE") or getattr(settings, "GIT_COMMIT", ""),
                "logger": record.name or "fetchnode.django.logging",
                "server_name": socket.gethostname(),
                "exception": {"type": etype, "message": msg, "frames": _frames(exc_info[2]) if exc_info and exc_info[2] else []},
                "request": {"method": "", "path": "", "query_string": "", "ip_address": ""},
                "user": {},
                "tags": {"source": "server", "type": "log"},
                "fingerprint": hashlib.sha256(f"{etype}:{msg[:200]}".encode()).hexdigest()[:64],
            })
        except Exception:
            self.handleError(record)

def fetchnode_track(event_name: str, payload: dict = None, user_identifier: str = ""):
    """Send a custom event to FetchNode. Usage: settings.fetchnode_track('signup', {'plan': 'pro'})"""
    if not _cfg("DSN") or not _cfg("KEY"):
        return
    _send({
        "type": "custom",
        "name": event_name,
        "payload": payload or {},
        "user_identifier": user_identifier,
        "timestamp": datetime.now(timezone.utc).isoformat(),
        "environment": _cfg("ENVIRONMENT") or getattr(settings, "DJANGO_ENV", "production"),
    })

FetchNode filters scanner noise on the server, so you do not need extra 404 rules in this snippet.

Step 3

Verify it works

Browser error

Open your website console and run:

throw new Error("FetchNode test — browser")

Server error

Add a temporary URL, visit it once, then remove it:

path("test-fetchnode/", lambda r: (_ for _ in ()).throw(Exception("FetchNode test — server")))

Then open the project dashboard. Within a few seconds you should see the test issues, pageviews, users, sessions, and top pages.

Assistant prompt

If you prefer to let your coding assistant make the change, copy this prompt into the project you want to connect.

Prompt

Use this in the codebase you want to connect.

Set up FetchNode in this Django project: error tracking plus lightweight analytics.

Goals:
1. Capture browser JavaScript errors and pageviews with the FetchNode browser snippet.
2. Capture Django server exceptions, 404s, request duration, and database query counts by pasting the FetchNode settings.py snippet.
3. Verify one browser error, one server error, and pageviews appear in the FetchNode dashboard.

Use this project key:
PUBLIC_PROJECT_KEY

Step 1 — add the browser snippet before </head> in the base template used by all pages:
```html
<script>
  window.FetchNodeQueue = window.FetchNodeQueue || [];
  window.FetchNode = window.FetchNode || function () {
    window.FetchNodeQueue.push(arguments);
  };

FetchNode("init", {
    projectKey: "PUBLIC_PROJECT_KEY",
    endpoint: "https://fetch-node.com/api/events/ingest/",
    environment: "production",
    release: "2026.04.29",
    trackPageviews: true
  });
</script>
<script async src="https://fetch-node.com/widget/v1/widget.min.js" crossorigin="anonymous"></script>
```

Step 2 — paste this self-contained Django snippet at the very bottom of settings.py:
```python
# FetchNode — paste everything in this block at the bottom of settings.py.