logsetu-django

Ship Django / DRF, Flask and FastAPI logs and unhandled errors to your self-hosted LogSetu server. Zero runtime dependencies, non-blocking (background thread + batching), and it never crashes your app if the log server is down.

pip install logsetu-django

Despite the name, the Django part is optional — the same package (import name logsetu) ships integrations for Flask and FastAPI / any ASGI app. The core client and logging handler work in any Python program.

Setup (2 minutes)

# settings.py
INSTALLED_APPS = [..., "logsetu"]  # optional, but nice for discoverability

LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "handlers": {
        "logsetu": {
            "class": "logsetu.handler.LogSetuHandler",
            "api_key": env("LOGSETU_API_KEY"),        # from the LogSetu dashboard → Projects
            "endpoint": env("LOGSETU_ENDPOINT"),      # e.g. https://logs.example.com
            "environment": env("ENVIRONMENT", default="production"),
            "source": "django-backend",
            "level": "WARNING",
        },
    },
    "root": {"handlers": ["logsetu"], "level": "INFO"},
}

MIDDLEWARE = [
    ...,
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "logsetu.middleware.LogSetuMiddleware",   # after auth middleware so user ids are captured
]

That's it. Every logging call at or above the handler's level is sent to LogSetu, and the middleware reports unhandled exceptions (and 5xx responses) with the request path, method, view, user, redacted headers and full traceback.

import logging
log = logging.getLogger(__name__)

log.warning("Checkout is slow", extra={"duration_ms": 1830, "cart_items": 12})
try:
    charge(card)
except PaymentError:
    log.exception("Payment failed")          # traceback is attached automatically

Multi-tenant apps

Tag every log with the current tenant by pointing the SDK at a callable (request) -> str | None:

# settings.py
LOGGING["handlers"]["logsetu"]["get_tenant_id"] = "myapp.tenants.get_tenant_id"

# myapp/tenants.py
def get_tenant_id(request):
    return getattr(request, "tenant", None) and request.tenant.slug

Or, from anywhere inside a request (e.g. after you resolve the tenant in your own middleware):

from logsetu import update_request_context
update_request_context(tenant_id=tenant.slug, plan=tenant.plan)

Handler options

Middleware options (settings.LOGSETU)

The middleware reuses the client and options of a configured LogSetuHandler. Without a handler it can run standalone:

LOGSETU = {
    "API_KEY": env("LOGSETU_API_KEY"),
    "ENDPOINT": env("LOGSETU_ENDPOINT"),
    "ENVIRONMENT": "production",
    "SOURCE": "django-backend",
    "GET_TENANT_ID": "myapp.tenants.get_tenant_id",
    "REDACT_HEADERS": ["authorization", "cookie", "x-api-key"],  # defaults already cover these
    "CAPTURE_5XX": True,   # also report 5xx responses that didn't raise
}

Every request gets a request_id (taken from X-Request-ID if present, otherwise generated) which is attached to all logs emitted during that request and exposed as request.logsetu_request_id.

Guarantees

• Never blocks the request cycle: emit() only appends to an in-memory queue.
• Never raises into your app: transport errors are printed once to stderr, then suppressed.
• Never leaks secrets: Authorization, Cookie, X-Api-Key, X-CSRFToken and Proxy-Authorization are redacted.
• Never loses the last logs on shutdown: the queue is flushed via atexit.

Celery / management commands

Nothing special — the handler works anywhere Python's logging does. Set extra={"source": "celery"} to distinguish workers, or configure a second handler with a different source.

Flask

import os
from flask import Flask
from logsetu.flask import LogSetu

app = Flask(__name__)
LogSetu(app, api_key=os.environ["LOGSETU_API_KEY"], endpoint=os.environ["LOGSETU_ENDPOINT"], source="flask-api")

App factory? Create logsetu = LogSetu() at module level and call logsetu.init_app(app); options you don't pass are read from app.config (LOGSETU_API_KEY, LOGSETU_ENDPOINT, LOGSETU_ENVIRONMENT, LOGSETU_SOURCE).

The extension reports unhandled exceptions and 5xx responses (route, endpoint, redacted headers, traceback), and attaches a LogSetuHandler to the root logger so logging.warning(...) and above is shipped with the request id, method and path of the current request. Flask's own "Exception on /path" log line is de-duplicated.

FastAPI / Starlette / ASGI

import os
from fastapi import FastAPI
from logsetu.fastapi import LogSetuMiddleware   # alias of logsetu.asgi — works with any ASGI app

app = FastAPI()
app.add_middleware(
    LogSetuMiddleware,
    api_key=os.environ["LOGSETU_API_KEY"],
    endpoint=os.environ["LOGSETU_ENDPOINT"],
    source="fastapi",
    ignore_paths=["/healthz"],
)

A pure ASGI middleware (streaming responses aren't buffered). Same options as Flask plus ignore_paths; get_tenant_id receives the ASGI scope, and api_key / endpoint / environment / source fall back to the LOGSETU_* environment variables. Request context reaches logs from both async def endpoints and sync endpoints running in the threadpool. HTTPExceptions with 4xx status codes aren't reported as errors. The request id is available as request.state.logsetu_request_id.

License

MIT