djlogq 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

{djlogq-1.0.6.dist-info → djlogq-1.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djlogq
-Version: 1.0.6
+Version: 1.0.8
 Summary: A reusable Django app for asynchronous, thread-safe logging with rich metadata, admin interface, and API support.
 Author-email: mess <mesnavunawa@gmail.com>
 License: MIT
@@ -29,6 +29,16 @@ A reusable Django app that provides asynchronous logging functionality using a s
 - **Decorators**: Utility decorators for function logging and performance monitoring
 - **Context Managers**: Easy-to-use context managers for operation logging
 - **Configurable**: Customizable queue size, flush intervals, and cleanup policies
+- **Extendible**: Easily add your own custom handlers to process logs in different ways.
+
+  **Useful built-in and example handlers include:**
+  - **File Handler**: Write logs to a file.
+  - **Email Handler**: Send error logs via email.
+  - **Webhook Handler**: Forward logs to external services (e.g., Slack, Discord, custom endpoints).
+  - **Database Handler**: Store logs in custom database tables.
+  - **Console Handler**: Output logs to the console for development.
+  - **Third-Party Integrations**: Integrate with services like Sentry or Logstash.
+  - You can implement your own handler by subclassing the provided base handler class.
 
 ## Installation
 
@@ -62,6 +72,7 @@ ASYNC_LOGGING_CONFIG = {
     'AUTO_CLEANUP_DAYS': 30,
     'ENABLE_REQUEST_LOGGING': True,
     'IGNORE_PATHS': ['/admin/'],  # paths to ignore for request logging
+    'DEFAULT_HANDLERS': [],  # list of handler class paths, e.g. ['logq.handlers.FileHandler']
 }
 ```
 
@@ -146,6 +157,11 @@ response = requests.get('http://your-domain/logq/api/logs/?limit=10')
 logs = response.json()['logs']
 ```
 
+### CUSTOM HANDLERS
+You can define custom log handlers by subclassing `LogHandler` and passing them to `AsyncLogger` or define them in the `DEFAULT_HANDLERS` section of the config. This allows you to process or forward log entries in any way you need (e.g., send to an external service, write to a file, etc).
+
+
+
 ### Admin Interface
 
 Access the admin interface at `/admin/` to view and manage logs. Features include:
@@ -177,7 +193,6 @@ python manage.py clean_logs --dry-run
 |---------|---------|-------------|
 | `MAX_QUEUE_SIZE` | 1000 | Maximum number of log entries in the queue |
 | `FLUSH_INTERVAL` | 1.0 | How often to flush logs to database (seconds) |
-| `AUTO_CLEANUP_DAYS` | 30 | Days to keep logs before auto-cleanup |
 | `ENABLE_REQUEST_LOGGING` | True | Whether to log all HTTP requests |
 
 ## Model Fields

{djlogq-1.0.6.dist-info → djlogq-1.0.8.dist-info}/RECORD

@@ -1,10 +1,10 @@
 logq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 logq/admin.py,sha256=nC8TVXc64G41Mh05ijUSCJmvIDo-kgZHKyyOlmqH-AE,320
 logq/apps.py,sha256=LNBTCEKiwAU2wT3CTjQ-EfXumbBF6Izez5J7mTK3i-U,330
-logq/async_logger.py,sha256=fdMqtkAXFVAHt1yYPpxC5CK8Nzryebj4PFXsijcsG-I,7495
+logq/async_logger.py,sha256=6eQxoUmWHr7nbgwA_Txnp9d91kFZfj_JZUrlIJwl97M,10481
 logq/middleware.py,sha256=Y9EAnxrmavyDgVklEW893Wh0eeQPKdCvizcxGzPDLBo,3642
 logq/models.py,sha256=Gu8KLNMn7I4XtEUHQPavSSlcESQ-2Pu5JLKsL97t9Gg,1616
-logq/tests.py,sha256=ILuZHtFDi_ushbGEwFDrch_EBwR1BkKhcjpGVFHVSwY,8584
+logq/tests.py,sha256=180_XHLQ3I1am5qlaaf-36n8E-CaRI4ZT3uGZ-OyYJU,10704
 logq/urls.py,sha256=oGwVM9HXsVY_P86sVPuz5xnFofYfmkL8ZSZDhExhJQk,216
 logq/utils.py,sha256=lNm2TfbpWdKbAeoy4ny8-TFaNFyQGsBL_Wxq0VoxkO4,5235
 logq/views.py,sha256=WJpwiPyfItBbceM1862NcXp_ui4U6WyNBhw2P27mlJ4,3695
@@ -14,7 +14,7 @@ logq/management/commands/clean_logs.py,sha256=Cc33EEqGGwsNcvQjwnLbM6kIb0lBJsyDQl
 logq/migrations/0001_initial.py,sha256=l4f-lUcO7OsABGYiSBp7fdWDt2rLHaIhR78pCKIAAdQ,2007
 logq/migrations/0002_alter_logentry_function_alter_logentry_line_number_and_more.py,sha256=SNBngZmhk9BgcOe8eAojX47V5JKC2V7oW9QtLHWIkFc,750
 logq/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-djlogq-1.0.6.dist-info/METADATA,sha256=IEboB0sstO5gMVslUUId9LgfH--Aj66MTZuqiIso27I,6447
-djlogq-1.0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-djlogq-1.0.6.dist-info/top_level.txt,sha256=VWj_EO93x0ix2Y2qm6obWT22L7VPFiZ7lQf0yIaI8do,5
-djlogq-1.0.6.dist-info/RECORD,,
+djlogq-1.0.8.dist-info/METADATA,sha256=FpJJheb91bTyn2ML2zDaRduvmS6iclcnedomCmPMjL0,7426
+djlogq-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+djlogq-1.0.8.dist-info/top_level.txt,sha256=VWj_EO93x0ix2Y2qm6obWT22L7VPFiZ7lQf0yIaI8do,5
+djlogq-1.0.8.dist-info/RECORD,,

logq/async_logger.py

@@ -9,6 +9,19 @@ from django.utils import timezone
 from django.db import transaction
 from django.conf import settings
 from .models import LogEntry, LogLevel
+from typing import List
+
+
+class LogHandler:
+    """Base class for custom log handlers"""
+
+    def handle(self, log_entry:LogEntry) -> None:
+        """Handle a log entry. Overide this method to implement custom logging behavior."""
+        pass
+
+    def flush(self) -> None:
+        """Flush any buffered log entries. Override this method to implement custom flushing behavior."""
+        pass
 
 
 class AsyncLogger:
@@ -16,7 +29,7 @@ class AsyncLogger:
     Asynchronous logger that runs in a separate thread to avoid blocking the main application.
     """
     
-    def __init__(self, max_queue_size: int = None, flush_interval: float = None):
+    def __init__(self, max_queue_size: int = None, flush_interval: float = None, handlers: List[LogHandler] = None):
         # Get configuration from settings
         config = getattr(settings, 'ASYNC_LOGGING_CONFIG', {})
         self.max_queue_size = max_queue_size or config.get('MAX_QUEUE_SIZE', 1000)
@@ -28,7 +41,41 @@ class AsyncLogger:
         self._lock = threading.Lock()
         self.dropped_count = 0
         self.dropped_levels = {}  # track most serious dropped level
-        self._dropped_lock = threading.Lock()  # 
+        self._dropped_lock = threading.Lock()
+
+        # initialize custom handlers
+        self.handlers = handlers or []
+        self._add_default_handlers()  # add default handlers to the logger
+
+    def _add_default_handlers(self):
+        """Add default handlers from settings if configured."""
+        config = getattr(settings, 'ASYNC_LOGGING_CONFIG', {})
+        default_handlers = config.get('DEFAULT_HANDLERS', [])
+        for handler_class in default_handlers:
+            try:
+                if isinstance(handler_class, str):
+                    # import handler class from string
+                    module_path, class_name = handler_class.rsplit('.', 1)
+                    module = __import__(module_path, fromlist=[class_name])  # import the module
+                    handler_class = getattr(module, class_name)
+                handler = handler_class()
+                self.handlers.append(handler)
+            except Exception as e:
+                print(f"Error initializing default handler {handler_class}: {e}")
+    
+    def add_handler(self, handler: LogHandler):
+        """Add a custom handler to the logger."""
+        if not isinstance(handler, LogHandler):
+            raise ValueError("Handler must be an instance of LogHandler")
+        self.handlers.append(handler)
+
+    def remove_handler(self, handler: LogHandler):
+        """Remove a custom handler from the logger."""
+        if handler in self.handlers:
+            self.handlers.remove(handler)
+
+    def clear_handlers(self):
+        """Remove all custom handlers from the logger."""
         
     def start(self):
         """Start the logging thread."""
@@ -84,6 +131,10 @@ class AsyncLogger:
             with transaction.atomic():
                 LogEntry.objects.bulk_create(batch, ignore_conflicts=True)
 
+                # send log entries to custom handlers
+                self._send_to_handlers(batch)
+                # flush custom handlers
+                self._flush_handlers()
                 # Log dropped messages if any
                 with self._dropped_lock:
                     if self.dropped_count > 0:
@@ -115,6 +166,28 @@ class AsyncLogger:
 
         except Exception as e:
             print(f"Error flushing log batch: {e}")
+
+    def _send_to_handlers(self, batch: List[LogEntry]):
+        """Send log entries to all registered handlers.
+        Args:
+            batch: List[LogEntry] - The batch of log entries to send to handlers
+        """
+        for handler in self.handlers:
+            try:
+                for entry in batch:
+                    handler.handle(entry)
+                
+            except Exception as e:
+                # Dont let an error in a handler crash the logger
+                print(f"Error sending log entries to handler {handler.__class__.__name__}: {e}")
+
+    def _flush_handlers(self):
+        """Flush all registered handlers."""
+        for handler in self.handlers:
+            try:
+                handler.flush()
+            except Exception as e:
+                print(f"Error flushing handler {handler.__class__.__name__}: {e}")
     
     def log(self, level: str, message: str, **kwargs):
         """Add a log entry to the queue."""
@@ -207,3 +280,4 @@ def stop_async_logger():
         _async_logger.stop()
         _async_logger = None
 
+    

logq/tests.py

@@ -7,9 +7,9 @@ import json
 import time
 import threading
 from .models import LogEntry, LogLevel
-from .async_logger import AsyncLogger, get_async_logger, stop_async_logger
+from .async_logger import AsyncLogger, get_async_logger, stop_async_logger, LogHandler
 from .utils import log_performance, log_function_call
-import requests
+
 
 class AsyncLoggerTestCase(TransactionTestCase):
     def setUp(self):
@@ -240,4 +240,70 @@ class UtilsTestCase(TransactionTestCase):
         entries = LogEntry.objects.all()
 
         self.assertGreater(entries.count(), 0)
+        
+
+class LogHandlerTestCase(TransactionTestCase):
+    def setUp(self):
+        super().setUp()
+        # Stop the global logger to avoid interference
+        stop_async_logger()
+        
+        # Clear all existing logs
+        with connection.cursor() as cursor:
+            cursor.execute("DELETE FROM logq_logentry")
+        
+        # Create a properly configured global logger
+        from .async_logger import _async_logger
+        from . import async_logger as async_logger_module
+        
+        # Create a test logger with fast flush interval
+        test_logger = AsyncLogger(max_queue_size=100, flush_interval=0.1)
+        test_logger.start()
+        
+        # Replace the global logger
+        async_logger_module._async_logger = test_logger
+        
+        time.sleep(0.2)  # Wait for thre
+    
+    def tearDown(self):
+        # Stop the global logger
+        stop_async_logger()
+        time.sleep(0.2)  # Wait for thread to stop
+        
+        # Clear logs after test
+        with connection.cursor() as cursor:
+            cursor.execute("DELETE FROM logq_logentry")
+        super().tearDown()
+    
+    def test_log_handler(self):
+        """Test log handler functionality."""
+        # Verify we start with no logs
+        self.assertEqual(LogEntry.objects.count(), 0)
+        
+        # Create a test handler
+        class TestHandler(LogHandler):
+            def handle(self, log_entry:LogEntry) -> None:
+                pass
+
+            def flush(self) -> None:
+                pass
+        
+        # Create a logger with the test handler
+        logger = get_async_logger()
+        logger.add_handler(TestHandler())
+        logger.start()
+        
+        logger.info("Test message")
+        time.sleep(0.5)
+
+        # Verify we have exactly one log entry
+        self.assertEqual(LogEntry.objects.count(), 1)
+        
+        # Verify the log entry was sent to the handler
+        log_entry = LogEntry.objects.first()
+        self.assertEqual(log_entry.message, "Test message")
+        
+        # Stop the logger
+        logger.stop()
+        time.sleep(0.2)  # Wait for thread to stop