django-activity-audit 1.3.0.dev19__tar.gz → 1.3.0.dev20__tar.gz

{django_activity_audit-1.3.0.dev19 → django_activity_audit-1.3.0.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-activity-audit
-Version: 1.3.0.dev19
+Version: 1.3.0.dev20
 Summary: A Django package for easy CRUD operation logging and container logs
 Project-URL: Homepage, https://github.com/shree256/django-activity-audit
 Project-URL: Repository, https://github.com/shree256/django-activity-audit
@@ -26,19 +26,18 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Requires-Dist: django<6.0,>=4.2
+Requires-Dist: orjson>=3.0
+Requires-Dist: structlog>=24.0
 Provides-Extra: dev
 Requires-Dist: pre-commit>=3.5; (python_version >= '3.9') and extra == 'dev'
 Requires-Dist: pre-commit~=3.5; (python_version < '3.9') and extra == 'dev'
 Requires-Dist: ruff>=0.1.11; extra == 'dev'
-Provides-Extra: structlog
-Requires-Dist: structlog>=24.0; extra == 'structlog'
 Provides-Extra: test
 Requires-Dist: djangorestframework>=3.14.0; extra == 'test'
 Requires-Dist: factory-boy>=3.2.0; extra == 'test'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
 Requires-Dist: pytest-django>=4.0.0; extra == 'test'
 Requires-Dist: pytest>=6.0.0; extra == 'test'
-Requires-Dist: structlog>=24.0; extra == 'test'
 Description-Content-Type: text/markdown
 
 # Django Activity Audit
@@ -62,6 +61,8 @@ A Django package that extends the default logging mechanism to track CRUD operat
 pip install django-activity-audit
 ```
 
+This also installs [`structlog`](https://www.structlog.org/) and [`orjson`](https://github.com/ijl/orjson) as required dependencies.
+
 2. Add 'activity_audit' to your INSTALLED_APPS in settings.py:
 ```python
 INSTALLED_APPS = [
@@ -79,47 +80,101 @@ MIDDLEWARE = [
 ```
 
 4. Configure logging in settings.py:
+
+Import the formatter helpers from `activity_audit.config`:
+
 ```python
-from activity_audit import *
+from activity_audit.config import get_plain_formatter, get_stdlib_formatter
+```
+
+- `get_stdlib_formatter()` — structlog JSON renderer. Use in staging/production where logs are ingested by a pipeline (Vector, CloudWatch, etc.).
+- `get_plain_formatter()` — structlog plain-text renderer. Use locally for human-readable console output.
+
+**Local development** (plain text output):
+
+```python
+from activity_audit.config import get_plain_formatter, get_stdlib_formatter
 
 LOGGING = {
     "version": 1,
     "disable_existing_loggers": False,
     "formatters": {
-        "json": get_json_formatter(),
-        "verbose": get_console_formatter(),
+        "structlog": get_stdlib_formatter(),
+        "default":   get_plain_formatter(),
     },
     "handlers": {
-        "console": {
-            "level": "DEBUG",
-            "class": "logging.StreamHandler",
-            "formatter": "verbose",
-        },
-        "file": get_json_handler(level="DEBUG", formatter="json"),
-        "api_file": get_api_file_handler(),
-        "audit_file": get_audit_handler(),
+        "console":        {"class": "logging.StreamHandler", "formatter": "default"},
+        "console_struct": {"class": "logging.StreamHandler", "formatter": "structlog"},
+    },
+    "root": {
+        "level": "INFO",
+        "handlers": ["console"],   # plain text fallback for all loggers
     },
-    "root": {"level": "DEBUG", "handlers": ["console", "file"]},
     "loggers": {
-        "audit.request": {
-            "handlers": ["api_file"],
-            "level": "API",
-            "propagate": False,
-        },
-        "audit.model": {
-            "handlers": ["audit_file"],
-            "level": "AUDIT",
-            "propagate": False,
-        },
-        "django": {
-            "handlers": ["console", "file"],
-            "level": "INFO",
-            "propagate": False,
-        },
-    }
+        # Structlog owns these — explicit handler, no propagation to avoid double output
+        "audit.model":   {"handlers": ["console_struct"], "propagate": False},
+        "audit.request": {"handlers": ["console_struct"], "propagate": False},
+        "audit.login":   {"handlers": ["console_struct"], "propagate": False},
+
+        # Celery — structlog formats log_type correctly
+        "celery":        {"level": "INFO", "handlers": ["console_struct"], "propagate": False},
+        "celery.task":   {"level": "INFO", "handlers": ["console_struct"], "propagate": False},
+        "celery.beat":   {"level": "INFO", "handlers": ["console_struct"], "propagate": False},
+
+        # Third-party noise control — WARNING only, routed to root
+        "django.db.backends": {"level": "WARNING", "handlers": [], "propagate": True},
+        "boto3":              {"level": "WARNING", "handlers": [], "propagate": True},
+        "botocore":           {"level": "WARNING", "handlers": [], "propagate": True},
+
+        # Framework loggers
+        "django":        {"level": "INFO", "handlers": [], "propagate": True},
+        "uvicorn":       {"level": "INFO", "handlers": [], "propagate": True},
+        "uvicorn.error": {"level": "INFO", "handlers": [], "propagate": True},
+        "uvicorn.access":{"level": "INFO", "handlers": [], "propagate": True},
+    },
 }
 ```
 
+**Staging / production** (structured JSON output): identical structure, but the `root` handler also uses `console_struct` (or keep `console` for mixed output — both handlers use the same `StreamHandler` class):
+
+```python
+"root": {
+    "level": "INFO",
+    "handlers": ["console"],
+}
+```
+
+---
+
+### When to add a logger entry
+
+Add an explicit logger entry when you need **any** of the following:
+
+| Situation | What to set |
+|-----------|-------------|
+| Route to structured JSON (`console_struct`) | `handlers: ["console_struct"], propagate: False` |
+| Suppress a noisy third-party library | `level: "WARNING", handlers: [], propagate: True` |
+| Prevent double output for a structlog-owned logger | `handlers: ["console_struct"], propagate: False` |
+| Change the log level for a specific namespace | Set `level` explicitly |
+
+**Do not** add a logger entry if the default behaviour is acceptable — a logger with no entry propagates to `root` and is emitted in plain text at INFO level. That is the correct behaviour for most application loggers.
+
+### Silencing audit loggers (route to root instead of structlog)
+
+By default `audit.model`, `audit.request`, and `audit.login` are pointed at `console_struct` with `propagate: False` so only the structlog-formatted JSON line is emitted.
+
+To stop structlog from handling them and fall back to the plain-text root logger instead, set `handlers: []` and `propagate: True`:
+
+```python
+"loggers": {
+    "audit.model":   {"handlers": [], "propagate": True},
+    "audit.request": {"handlers": [], "propagate": True},
+    "audit.login":   {"handlers": [], "propagate": True},
+}
+```
+
+This routes all three through the `root` logger (`console` handler, `default` / plain-text formatter). Use this when you want to completely disable structured audit output — for example, in a minimal local environment or during debugging.
+
 5. Configure the service name in `settings.py` (optional, defaults to `"default"`):
 ```python
 AUDIT_SERVICE_NAME = "my_service"

{django_activity_audit-1.3.0.dev19 → django_activity_audit-1.3.0.dev20}/README.md

@@ -19,6 +19,8 @@ A Django package that extends the default logging mechanism to track CRUD operat
 pip install django-activity-audit
 ```
 
+This also installs [`structlog`](https://www.structlog.org/) and [`orjson`](https://github.com/ijl/orjson) as required dependencies.
+
 2. Add 'activity_audit' to your INSTALLED_APPS in settings.py:
 ```python
 INSTALLED_APPS = [
@@ -36,47 +38,101 @@ MIDDLEWARE = [
 ```
 
 4. Configure logging in settings.py:
+
+Import the formatter helpers from `activity_audit.config`:
+
 ```python
-from activity_audit import *
+from activity_audit.config import get_plain_formatter, get_stdlib_formatter
+```
+
+- `get_stdlib_formatter()` — structlog JSON renderer. Use in staging/production where logs are ingested by a pipeline (Vector, CloudWatch, etc.).
+- `get_plain_formatter()` — structlog plain-text renderer. Use locally for human-readable console output.
+
+**Local development** (plain text output):
+
+```python
+from activity_audit.config import get_plain_formatter, get_stdlib_formatter
 
 LOGGING = {
     "version": 1,
     "disable_existing_loggers": False,
     "formatters": {
-        "json": get_json_formatter(),
-        "verbose": get_console_formatter(),
+        "structlog": get_stdlib_formatter(),
+        "default":   get_plain_formatter(),
     },
     "handlers": {
-        "console": {
-            "level": "DEBUG",
-            "class": "logging.StreamHandler",
-            "formatter": "verbose",
-        },
-        "file": get_json_handler(level="DEBUG", formatter="json"),
-        "api_file": get_api_file_handler(),
-        "audit_file": get_audit_handler(),
+        "console":        {"class": "logging.StreamHandler", "formatter": "default"},
+        "console_struct": {"class": "logging.StreamHandler", "formatter": "structlog"},
+    },
+    "root": {
+        "level": "INFO",
+        "handlers": ["console"],   # plain text fallback for all loggers
     },
-    "root": {"level": "DEBUG", "handlers": ["console", "file"]},
     "loggers": {
-        "audit.request": {
-            "handlers": ["api_file"],
-            "level": "API",
-            "propagate": False,
-        },
-        "audit.model": {
-            "handlers": ["audit_file"],
-            "level": "AUDIT",
-            "propagate": False,
-        },
-        "django": {
-            "handlers": ["console", "file"],
-            "level": "INFO",
-            "propagate": False,
-        },
-    }
+        # Structlog owns these — explicit handler, no propagation to avoid double output
+        "audit.model":   {"handlers": ["console_struct"], "propagate": False},
+        "audit.request": {"handlers": ["console_struct"], "propagate": False},
+        "audit.login":   {"handlers": ["console_struct"], "propagate": False},
+
+        # Celery — structlog formats log_type correctly
+        "celery":        {"level": "INFO", "handlers": ["console_struct"], "propagate": False},
+        "celery.task":   {"level": "INFO", "handlers": ["console_struct"], "propagate": False},
+        "celery.beat":   {"level": "INFO", "handlers": ["console_struct"], "propagate": False},
+
+        # Third-party noise control — WARNING only, routed to root
+        "django.db.backends": {"level": "WARNING", "handlers": [], "propagate": True},
+        "boto3":              {"level": "WARNING", "handlers": [], "propagate": True},
+        "botocore":           {"level": "WARNING", "handlers": [], "propagate": True},
+
+        # Framework loggers
+        "django":        {"level": "INFO", "handlers": [], "propagate": True},
+        "uvicorn":       {"level": "INFO", "handlers": [], "propagate": True},
+        "uvicorn.error": {"level": "INFO", "handlers": [], "propagate": True},
+        "uvicorn.access":{"level": "INFO", "handlers": [], "propagate": True},
+    },
 }
 ```
 
+**Staging / production** (structured JSON output): identical structure, but the `root` handler also uses `console_struct` (or keep `console` for mixed output — both handlers use the same `StreamHandler` class):
+
+```python
+"root": {
+    "level": "INFO",
+    "handlers": ["console"],
+}
+```
+
+---
+
+### When to add a logger entry
+
+Add an explicit logger entry when you need **any** of the following:
+
+| Situation | What to set |
+|-----------|-------------|
+| Route to structured JSON (`console_struct`) | `handlers: ["console_struct"], propagate: False` |
+| Suppress a noisy third-party library | `level: "WARNING", handlers: [], propagate: True` |
+| Prevent double output for a structlog-owned logger | `handlers: ["console_struct"], propagate: False` |
+| Change the log level for a specific namespace | Set `level` explicitly |
+
+**Do not** add a logger entry if the default behaviour is acceptable — a logger with no entry propagates to `root` and is emitted in plain text at INFO level. That is the correct behaviour for most application loggers.
+
+### Silencing audit loggers (route to root instead of structlog)
+
+By default `audit.model`, `audit.request`, and `audit.login` are pointed at `console_struct` with `propagate: False` so only the structlog-formatted JSON line is emitted.
+
+To stop structlog from handling them and fall back to the plain-text root logger instead, set `handlers: []` and `propagate: True`:
+
+```python
+"loggers": {
+    "audit.model":   {"handlers": [], "propagate": True},
+    "audit.request": {"handlers": [], "propagate": True},
+    "audit.login":   {"handlers": [], "propagate": True},
+}
+```
+
+This routes all three through the `root` logger (`console` handler, `default` / plain-text formatter). Use this when you want to completely disable structured audit output — for example, in a minimal local environment or during debugging.
+
 5. Configure the service name in `settings.py` (optional, defaults to `"default"`):
 ```python
 AUDIT_SERVICE_NAME = "my_service"

{django_activity_audit-1.3.0.dev19 → django_activity_audit-1.3.0.dev20}/activity_audit/config.py

@@ -20,6 +20,22 @@ class AuditBoundLogger(structlog.stdlib.BoundLogger):
         return self._proxy_to_logger("login", event, *args, **kw)
 
 
+def get_plain_formatter() -> dict:
+    """
+    LOGGING formatter dict that routes stdlib loggers through the structlog
+    processor chain but renders as plain text instead of JSON. Use for local
+    development when human-readable output is preferred over structured JSON.
+    """
+    return {
+        "()": structlog.stdlib.ProcessorFormatter,
+        "processors": [
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            structlog.dev.ConsoleRenderer(colors=False),
+        ],
+        "foreign_pre_chain": shared_processors,
+    }
+
+
 def get_stdlib_formatter() -> dict:
     """
     LOGGING formatter dict that routes stdlib loggers through the structlog

{django_activity_audit-1.3.0.dev19 → django_activity_audit-1.3.0.dev20}/activity_audit/middleware.py

@@ -1,16 +1,15 @@
-import contextlib
 import json
 import re
 import time
 import uuid
 
+from contextvars import ContextVar
+
 import structlog.contextvars as ctx
 
-from asgiref.local import Local
 from asgiref.sync import (
     iscoroutinefunction,
     markcoroutinefunction,
-    sync_to_async,
 )
 from django.http import HttpResponse
 from django.utils.deprecation import MiddlewareMixin
@@ -21,7 +20,7 @@ from .settings import REGISTERED_URLS, SERVICE_NAME, UNREGISTERED_URLS
 
 _log = get_logger("audit.request")
 
-_thread_locals = Local()
+_request_var: ContextVar = ContextVar("current_request", default=None)
 
 
 class MockRequest:
@@ -32,11 +31,11 @@ class MockRequest:
 
 
 def get_current_request():
-    return getattr(_thread_locals, "request", None)
+    return _request_var.get()
 
 
 def set_current_request(request):
-    _thread_locals.request = request
+    _request_var.set(request)
 
 
 def get_current_user():
@@ -47,11 +46,11 @@ def get_current_user():
 
 
 def set_current_user(user):
-    try:
-        _thread_locals.request.user = user
-    except AttributeError:
-        request = MockRequest(user=user)
-        _thread_locals.request = request
+    request = _request_var.get()
+    if request is not None:
+        request.user = user
+    else:
+        _request_var.set(MockRequest(user=user))
 
 
 def get_user_details():
@@ -73,8 +72,7 @@ def get_user_details():
 
 
 def clear_request():
-    with contextlib.suppress(AttributeError):
-        del _thread_locals.request
+    _request_var.set(None)
 
 
 def should_log_url(url):
@@ -242,9 +240,7 @@ class AuditLoggingMiddleware(MiddlewareMixin):
         end_time = time.time()
 
         # Capture user details AFTER authentication has happened
-        user_id, user_info = await sync_to_async(
-            get_user_details, thread_sensitive=True
-        )()
+        user_id, user_info = get_user_details()
         ctx.bind_contextvars(user_id=user_id, user_info=user_info)
 
         # TODO: Find way to add status code to response_data

{django_activity_audit-1.3.0.dev19 → django_activity_audit-1.3.0.dev20}/activity_audit/shared_processors.py

@@ -96,6 +96,26 @@ _STANDARD_KEYS = frozenset(
         "request_id",
         "_record",
         "_from_structlog",
+        # audit.model fields
+        "model",
+        "event_type",
+        "instance_id",
+        "instance_repr",
+        "user_id",
+        "user_info",
+        "extra",
+        # audit.request fields
+        "service_name",
+        "request_type",
+        "protocol",
+        "request_repr",
+        "response_repr",
+        "error_message",
+        "execution_time",
+        # audit.login fields
+        "event",
+        "success",
+        "error",
     }
 )
 

{django_activity_audit-1.3.0.dev19 → django_activity_audit-1.3.0.dev20}/activity_audit/utils.py

@@ -145,7 +145,7 @@ def push_usage_log(
     """
     import logging
 
-    from .signals import get_user_details
+    from .middleware import get_user_details
 
     logger = logging.getLogger("audit.login")
     user_id, user_info = get_user_details()

{django_activity_audit-1.3.0.dev19 → django_activity_audit-1.3.0.dev20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "django-activity-audit"
-version = "1.3.0.dev19"
+version = "1.3.0.dev20"
 description = "A Django package for easy CRUD operation logging and container logs"
 authors = [
     { name = "Shreeshan", email = "shreeshan256@gmail.com" }
@@ -31,6 +31,8 @@ classifiers = [
 requires-python = ">=3.8"
 dependencies = [
   "django>=4.2,<6.0",
+  "structlog>=24.0",
+  "orjson>=3.0",
 ]
 
 [project.urls]
@@ -50,9 +52,7 @@ test = [
   "pytest-django>=4.0.0",
   "pytest-cov>=4.0.0",
   "djangorestframework>=3.14.0",
-  "structlog>=24.0",
 ]
-structlog = ["structlog>=24.0"]
 
 [build-system]
 requires = ["hatchling"]