django-activity-audit 1.3.0.dev7__tar.gz → 1.3.0.dev9__tar.gz

{django_activity_audit-1.3.0.dev7 → django_activity_audit-1.3.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-activity-audit
-Version: 1.3.0.dev7
+Version: 1.3.0.dev9
 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

django_activity_audit-1.3.0.dev9/activity_audit/handlers.py

@@ -0,0 +1,166 @@
+import logging
+import queue
+
+from logging.handlers import QueueHandler, QueueListener, RotatingFileHandler
+
+from .formatters import APIFormatter, AuditFormatter, JsonFormatter, LoginFormatter
+
+
+class BaseAuditHandler(RotatingFileHandler):
+    """Base handler for all audit logs with common emit logic."""
+
+    def emit(self, record):
+        """
+        Emit a record with additional values for audit-specific fields.
+        """
+        try:
+            # Handle extra if present
+            if hasattr(record, "extra"):
+                for key, value in record.extra.items():
+                    setattr(record, key, value)
+
+            super().emit(record)
+
+        except Exception as e:
+            self.handleError(record)
+            # Log the error to the root logger
+            logging.getLogger().error(f"Error in AuditLogHandler: {str(e)}")
+
+
+class APILogHandler(BaseAuditHandler):
+    """Handler for API audit logs with default APIFormatter."""
+
+    def __init__(
+        self,
+        filename,
+        mode="a",
+        maxBytes=0,
+        backupCount=0,
+        encoding=None,
+        delay=False,
+    ):
+        super().__init__(filename, mode, maxBytes, backupCount, encoding, delay)
+        self.setFormatter(APIFormatter())
+
+
+class AuditLogHandler(BaseAuditHandler):
+    """Handler for model audit logs with default AuditFormatter."""
+
+    def __init__(
+        self,
+        filename,
+        mode="a",
+        maxBytes=0,
+        backupCount=0,
+        encoding=None,
+        delay=False,
+    ):
+        super().__init__(filename, mode, maxBytes, backupCount, encoding, delay)
+        self.setFormatter(AuditFormatter())
+
+
+class LoginLogHandler(BaseAuditHandler):
+    """Handler for login audit logs with default LoginFormatter."""
+
+    def __init__(
+        self,
+        filename,
+        mode="a",
+        maxBytes=0,
+        backupCount=0,
+        encoding=None,
+        delay=False,
+    ):
+        super().__init__(filename, mode, maxBytes, backupCount, encoding, delay)
+        self.setFormatter(LoginFormatter())
+
+
+# ASYNC ------------------------------------------------------
+class AsyncBaseAuditHandler(QueueHandler):
+    """
+    Base async handler. Enqueues records on the calling thread; a background
+    QueueListener thread does the actual file write via the wrapped sync handler.
+
+    Subclasses pass the concrete sync handler class and formatter via
+    _sync_handler_class and _formatter_class.
+    """
+
+    _sync_handler_class = None
+    _formatter_class = None
+
+    def __init__(
+        self,
+        filename,
+        mode="a",
+        maxBytes=0,
+        backupCount=0,
+        encoding=None,
+        delay=False,
+    ):
+        log_queue = queue.Queue(-1)
+        super().__init__(log_queue)
+
+        sync_handler = self._sync_handler_class(
+            filename, mode, maxBytes, backupCount, encoding, delay
+        )
+        self._listener = QueueListener(
+            log_queue, sync_handler, respect_handler_level=True
+        )
+        self._listener.start()
+
+    def close(self):
+        self._listener.stop()
+        super().close()
+
+
+class AsyncAPILogHandler(AsyncBaseAuditHandler):
+    """Non-blocking handler for API audit logs."""
+
+    _sync_handler_class = APILogHandler
+    _formatter_class = APIFormatter
+
+
+class AsyncAuditLogHandler(AsyncBaseAuditHandler):
+    """Non-blocking handler for model audit logs."""
+
+    _sync_handler_class = AuditLogHandler
+    _formatter_class = AuditFormatter
+
+
+class AsyncLoginLogHandler(AsyncBaseAuditHandler):
+    """Non-blocking handler for login audit logs."""
+
+    _sync_handler_class = LoginLogHandler
+    _formatter_class = LoginFormatter
+
+
+class AsyncJsonHandler(QueueHandler):
+    """
+    Non-blocking handler for general JSON logs. Wraps a RotatingFileHandler
+    with JsonFormatter on the background thread.
+    """
+
+    def __init__(
+        self,
+        filename,
+        mode="a",
+        maxBytes=0,
+        backupCount=0,
+        encoding=None,
+        delay=False,
+    ):
+        log_queue = queue.Queue(-1)
+        super().__init__(log_queue)
+
+        sync_handler = RotatingFileHandler(
+            filename, mode, maxBytes, backupCount, encoding, delay
+        )
+        sync_handler.setFormatter(JsonFormatter())
+        self._listener = QueueListener(
+            log_queue, sync_handler, respect_handler_level=True
+        )
+        self._listener.start()
+
+    def close(self):
+        self._listener.stop()
+        super().close()

{django_activity_audit-1.3.0.dev7 → django_activity_audit-1.3.0.dev9}/activity_audit/signals.py

@@ -79,25 +79,7 @@ def get_calling_model() -> Optional[str]:
     return None
 
 
-class ModelSignalMixin:
-    """Mixin to add signal handling capabilities to models."""
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self._original_m2m = self._get_m2m_state()
-
-    def _get_m2m_state(self) -> dict:
-        try:
-            """Get the current state of M2M fields."""
-            return {
-                field.name: set(
-                    getattr(self, field.name).all().values_list("id", flat=True)
-                )
-                for field in self._meta.many_to_many
-            }
-        except Exception as e:
-            logger.error(f"Error getting M2M state: {e}")
-            return {}
+_patched_models: set = set()
 
 
 def push_log(
@@ -131,12 +113,15 @@ def push_log(
         logger.error(f"Failed to prepare audit log: {e}")
 
 
+def instance_to_dict(instance: models.Model) -> dict:
+    return model_to_dict(instance, fields=[f.name for f in instance._meta.fields])
+
+
 def patch_model_event(model_class: type[models.Model]) -> None:
     """Monkey patch a model to add signal handling capabilities."""
 
-    if not issubclass(model_class, ModelSignalMixin):
-        # Add the mixin to the model's base classes
-        model_class.__bases__ = (ModelSignalMixin,) + model_class.__bases__
+    if model_class not in _patched_models:
+        _patched_models.add(model_class)
 
         # Store the original methods
         original_save = model_class.save
@@ -154,7 +139,7 @@ def patch_model_event(model_class: type[models.Model]) -> None:
             # Log the event
             event_type = EVENT_TYPES[0] if is_new else EVENT_TYPES[1]
 
-            instance_repr = model_to_dict(self)
+            instance_repr = instance_to_dict(self)
 
             push_log(
                 f"{event_type} event by {model_class.__name__} (id: {self.pk})",
@@ -179,7 +164,7 @@ def patch_model_event(model_class: type[models.Model]) -> None:
 
             # For new instances, we might not have a pk yet, so use a placeholder
             instance_id = str(instance.pk) if instance.pk else "pending"
-            instance_repr = model_to_dict(instance)
+            instance_repr = instance_to_dict(instance)
 
             push_log(
                 f"{event_type} event by {model_class.__name__} (id: {instance_id})",
@@ -208,7 +193,7 @@ def patch_model_event(model_class: type[models.Model]) -> None:
             # Log only if this is the calling model
             if calling_model == model_class.__name__:
                 first_obj = created_objs[0]
-                instance_repr = model_to_dict(first_obj)
+                instance_repr = instance_to_dict(first_obj)
 
                 push_log(
                     f"{EVENT_TYPES[3]} event by {model_class.__name__} (id: {first_obj.pk})",
@@ -231,17 +216,17 @@ def patch_model_event(model_class: type[models.Model]) -> None:
                 return original_bulk_update(self, objs, fields, batch_size)
 
             # Call the original bulk_update method
-            original_bulk_update(self, objs, fields, batch_size)
+            bulk_update = original_bulk_update(self, objs, fields, batch_size)
 
             # Get the calling model
             calling_model = get_calling_model()
             if not calling_model:
-                return original_bulk_update(self, objs, fields, batch_size)
+                return bulk_update
 
             # Log only if this is the calling model
             if calling_model == model_class.__name__:
                 first_obj = objs[0]
-                instance_repr = model_to_dict(first_obj)
+                instance_repr = instance_to_dict(first_obj)
 
                 push_log(
                     f"{EVENT_TYPES[4]} event by {model_class.__name__}",
@@ -268,7 +253,7 @@ def patch_model_event(model_class: type[models.Model]) -> None:
             if not should_audit(instance):
                 return
 
-            instance_repr = model_to_dict(instance)
+            instance_repr = instance_to_dict(instance)
 
             push_log(
                 f"{EVENT_TYPES[8]} event by {model_class.__name__} (id: {instance.pk})",
@@ -283,7 +268,7 @@ def patch_model_event(model_class: type[models.Model]) -> None:
         def handle_delete(
             sender: type[models.Model], instance: models.Model, **kwargs: Any
         ) -> None:
-            instance_repr = model_to_dict(instance)
+            instance_repr = instance_to_dict(instance)
 
             push_log(
                 f"{EVENT_TYPES[2]} event by {model_class.__name__} (id: {instance.pk})",
@@ -308,7 +293,7 @@ def patch_model_event(model_class: type[models.Model]) -> None:
                     return
 
                 field_name = kwargs.get("model", sender).__name__.lower()
-                instance_repr = model_to_dict(instance)
+                instance_repr = instance_to_dict(instance)
 
                 push_log(
                     f"M2M {action} event by {model_class.__name__} (id: {instance.pk})",
@@ -330,7 +315,7 @@ def setup_model_signals() -> None:
             if not should_audit(model):
                 continue
 
-            if not issubclass(model, ModelSignalMixin):
+            if model not in _patched_models:
                 patch_model_event(model)
 
 

{django_activity_audit-1.3.0.dev7 → django_activity_audit-1.3.0.dev9}/activity_audit/utils.py

@@ -63,6 +63,58 @@ def get_login_handler(
     }
 
 
+# ASYNC ------------------------------------------------------
+def get_async_json_handler(
+    level: str = "DEBUG",
+    filename: str = "audit_logs/app.log",
+    max_bytes: int = 1024 * 1024 * 10,
+    backup_count: int = 5,
+) -> dict:
+    return {
+        "level": level,
+        "class": "activity_audit.handlers.AsyncJsonHandler",
+        "filename": filename,
+        "maxBytes": max_bytes,
+        "backupCount": backup_count,
+    }
+
+
+def get_async_api_handler(
+    filename: str = "audit_logs/api.log",
+) -> dict:
+    return {
+        "class": "activity_audit.handlers.AsyncAPILogHandler",
+        "filename": filename,
+        "maxBytes": 1024 * 1024 * 10,  # 10MB
+        "backupCount": 5,
+    }
+
+
+def get_async_audit_handler(
+    filename: str = "audit_logs/audit.log",
+) -> dict:
+    return {
+        "class": "activity_audit.handlers.AsyncAuditLogHandler",
+        "filename": filename,
+        "maxBytes": 1024 * 1024 * 10,  # 10MB
+        "backupCount": 5,
+    }
+
+
+def get_async_login_handler(
+    filename: str = "audit_logs/login.log",
+) -> dict:
+    return {
+        "class": "activity_audit.handlers.AsyncLoginLogHandler",
+        "filename": filename,
+        "maxBytes": 1024 * 1024 * 5,  # 5MB
+        "backupCount": 5,
+    }
+
+
+# ----------------------------------------------------------------
+
+
 def push_usage_log(
     message: str,
     event: str,