djlogq 1.0.5__tar.gz → 1.0.7__tar.gz

{djlogq-1.0.5/src/djlogq.egg-info → djlogq-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djlogq
-Version: 1.0.5
+Version: 1.0.7
 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
@@ -8,6 +8,7 @@ Project-URL: Homepage, https://github.com/Mesake94/djlogq
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: Django
+Requires-Dist: requests
 Provides-Extra: dev
 Requires-Dist: build==1.2.1; extra == "dev"
 Requires-Dist: nox==2024.4.15; extra == "dev"
@@ -28,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
 
@@ -61,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']
 }
 ```
 
@@ -145,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:
@@ -176,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.5 → djlogq-1.0.7}/README.md

@@ -13,6 +13,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
 
@@ -46,6 +56,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']
 }
 ```
 
@@ -130,6 +141,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:
@@ -161,7 +177,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.5 → djlogq-1.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "djlogq"
-version = "1.0.5"
+version = "1.0.7"
 description = "A reusable Django app for asynchronous, thread-safe logging with rich metadata, admin interface, and API support."
 readme = "README.md"
 authors = [
@@ -13,7 +13,8 @@ authors = [
 license = {text = "MIT"}
 requires-python = ">=3.8"
 dependencies = [
-    "Django"
+    "Django",
+    "requests",
 ]
 urls = {Homepage = "https://github.com/Mesake94/djlogq"}
 [project.optional-dependencies]

{djlogq-1.0.5 → djlogq-1.0.7/src/djlogq.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djlogq
-Version: 1.0.5
+Version: 1.0.7
 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
@@ -8,6 +8,7 @@ Project-URL: Homepage, https://github.com/Mesake94/djlogq
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: Django
+Requires-Dist: requests
 Provides-Extra: dev
 Requires-Dist: build==1.2.1; extra == "dev"
 Requires-Dist: nox==2024.4.15; extra == "dev"
@@ -28,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
 
@@ -61,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']
 }
 ```
 
@@ -145,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:
@@ -176,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.5 → djlogq-1.0.7}/src/djlogq.egg-info/requires.txt

@@ -1,4 +1,5 @@
 Django
+requests
 
 [dev]
 build==1.2.1

djlogq-1.0.7/src/logq/async_logger.py

@@ -0,0 +1,280 @@
+import threading
+import queue
+import time
+import logging
+import traceback
+import inspect
+from typing import Optional, Dict, Any
+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:
+    """
+    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, 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)
+        self.flush_interval = flush_interval or config.get('FLUSH_INTERVAL', 1.0)
+        
+        self.queue = queue.Queue(maxsize=self.max_queue_size)
+        self.running = False
+        self.thread = None
+        self._lock = threading.Lock()
+        self.dropped_count = 0
+        self.dropped_levels = {}  # track most serious dropped level
+        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."""
+        with self._lock:
+            if not self.running:
+                self.running = True
+                self.thread = threading.Thread(target=self._worker, daemon=True)
+                self.thread.start()
+    
+    def stop(self):
+        """Stop the logging thread."""
+        with self._lock:
+            if self.running:
+                self.running = False
+                if self.thread:
+                    self.thread.join(timeout=5.0)
+    
+    def _worker(self):
+        """Worker thread that processes log entries from the queue."""
+        batch = []
+        last_flush = time.time()
+        
+        while self.running:
+            try:
+                # Try to get a log entry with timeout
+                try:
+                    entry = self.queue.get(timeout=0.1)
+                    batch.append(entry)
+                except queue.Empty:
+                    pass
+                
+                # Flush batch if it's time or batch is getting large
+                current_time = time.time()
+                if (current_time - last_flush >= self.flush_interval or 
+                    len(batch) >= 50):
+                    if batch:
+                        self._flush_batch(batch)
+                        batch = []
+                        last_flush = current_time
+                        
+            except Exception as e:
+                # Log the error to prevent infinite loops
+                print(f"Error in async logger worker: {e}")
+                time.sleep(1)
+        
+        # Flush remaining entries
+        if batch:
+            self._flush_batch(batch)
+    
+    def _flush_batch(self, batch):
+        """Flush a batch of log entries to the database."""
+        try:
+            with transaction.atomic():
+                LogEntry.objects.bulk_create(batch, ignore_conflicts=True)
+
+                # send log entries to custom handlers
+                self._send_to_handlers(batch)
+
+                # Log dropped messages if any
+                with self._dropped_lock:
+                    if self.dropped_count > 0:
+                        # Find the most serious dropped level
+                        level_priority = {
+                            'DEBUG': 0,
+                            'INFO': 1,
+                            'WARNING': 2,
+                            'ERROR': 3,
+                            'CRITICAL': 4
+                        }
+                        most_serious_level = max(self.dropped_levels.keys(), 
+                                               key=lambda x: level_priority.get(x, 0)) if self.dropped_levels else 'INFO'
+                        
+                        dropped_entry = LogEntry(
+                            level='WARNING',
+                            message=f"{self.dropped_count} log messages were dropped due to queue overflow",
+                            module='logq.async_logger',
+                            function='_flush_batch',
+                            extra_data={
+                                'dropped_count': self.dropped_count,
+                                'most_serious_level': most_serious_level
+                            }
+                        )
+                        dropped_entry.save()
+                        
+                        self.dropped_count = 0
+                        self.dropped_levels = {}
+
+        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."""
+        if not self.running:
+            return
+        
+        # Get caller information
+        frame = inspect.currentframe().f_back
+        module = frame.f_globals.get('__name__', 'unknown')
+        function = frame.f_code.co_name
+        line_number = frame.f_lineno
+        
+        # Create log entry
+        entry = LogEntry(
+            level=level,
+            message=message,
+            module=module,
+            function=function,
+            line_number=line_number,
+            user_id=kwargs.get('user_id'),
+            request_id=kwargs.get('request_id'),
+            extra_data=kwargs.get('extra_data', {})
+        )
+        
+        try:
+            self.queue.put_nowait(entry)
+        except queue.Full:
+            # If queue is full, log to console as fallback
+            # print(f"Log queue full, dropping entry: [{level}] {message}")
+            # Track dropped messages with counter
+            with self._dropped_lock:
+                self.dropped_count += 1
+                # Track the most serious level dropped
+                level_priority = {
+                    'DEBUG': 0,
+                    'INFO': 1,
+                    'WARNING': 2,
+                    'ERROR': 3,
+                    'CRITICAL': 4
+                }
+                current_priority = level_priority.get(level, 0)
+                if level not in self.dropped_levels or current_priority > level_priority.get(self.dropped_levels[level], 0):
+                    self.dropped_levels[level] = level
+                self.dropped_levels[level] = level
+                    
+    
+    def debug(self, message: str, **kwargs):
+        self.log(LogLevel.DEBUG, message, **kwargs)
+    
+    def info(self, message: str, **kwargs):
+        self.log(LogLevel.INFO, message, **kwargs)
+    
+    def warning(self, message: str, **kwargs):
+        self.log(LogLevel.WARNING, message, **kwargs)
+    
+    def error(self, message: str, **kwargs):
+        self.log(LogLevel.ERROR, message, **kwargs)
+    
+    def critical(self, message: str, **kwargs):
+        self.log(LogLevel.CRITICAL, message, **kwargs)
+    
+    def exception(self, message: str, exc_info=None, **kwargs):
+        """Log an exception with traceback."""
+        if exc_info is None:
+            exc_info = traceback.format_exc()
+        
+        extra_data = kwargs.get('extra_data', {})
+        extra_data['traceback'] = exc_info
+        
+        self.log(LogLevel.ERROR, message, extra_data=extra_data, **kwargs)
+
+
+# Global logger instance
+_async_logger = None
+
+
+def get_async_logger() -> AsyncLogger:
+    """Get the global async logger instance."""
+    global _async_logger
+    if _async_logger is None:
+        _async_logger = AsyncLogger()
+        _async_logger.start()
+    return _async_logger
+
+
+def stop_async_logger():
+    """Stop the global async logger."""
+    global _async_logger
+    if _async_logger:
+        _async_logger.stop()
+        _async_logger = None
+

{djlogq-1.0.5 → djlogq-1.0.7}/src/logq/tests.py

@@ -7,7 +7,8 @@ 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
 
 
 class AsyncLoggerTestCase(TransactionTestCase):
@@ -97,7 +98,13 @@ class AsyncLoggerTestCase(TransactionTestCase):
         # Should have some entries but not all due to queue being full
         entries = LogEntry.objects.count()
         self.assertGreater(entries, 0)
-        self.assertLessEqual(entries, 100)  # max_queue_size
+        self.assertLessEqual(entries, 101)  # max_queue_size + 1 (allowing for edge case)
+
+        # Check if the dropped log entry is present
+        dropped_entry = LogEntry.objects.filter(message__contains="dropped due to queue overflow").first()
+        self.assertIsNotNone(dropped_entry)
+        self.assertEqual(dropped_entry.level, LogLevel.WARNING)
+        
 
 
 class LogEntryModelTestCase(TransactionTestCase):
@@ -148,10 +155,23 @@ class LogEntryModelTestCase(TransactionTestCase):
         self.assertIn("This is a very long message that should be truncated", str_repr[:100])
 
 
-class LoggingAPITestCase(TransactionTestCase):
+
+@override_settings(
+    ASYNC_LOGGING_CONFIG={'MAX_QUEUE_SIZE': 500, 'FLUSH_INTERVAL': 0.5},
+    MIDDLEWARE=[
+        "django.middleware.security.SecurityMiddleware",
+        "django.contrib.sessions.middleware.SessionMiddleware",
+        "django.middleware.common.CommonMiddleware",
+        "django.middleware.csrf.CsrfViewMiddleware",
+        "django.contrib.auth.middleware.AuthenticationMiddleware",
+        "django.contrib.messages.middleware.MessageMiddleware",
+        "django.middleware.clickjacking.XFrameOptionsMiddleware",
+        "logq.middleware.AsyncLoggingMiddleware",  # Fixed: Added middleware
+    ]
+)
+class MiddlewareTestCase(TransactionTestCase):
     def setUp(self):
         super().setUp()
-        self.user = User.objects.create_user(username='testuser', password='testpass')
         # Stop the global logger to avoid interference
         stop_async_logger()
         # Clear all existing logs
@@ -164,154 +184,126 @@ class LoggingAPITestCase(TransactionTestCase):
             cursor.execute("DELETE FROM logq_logentry")
         super().tearDown()
     
-    def test_log_endpoint(self):
-        """Test the log API endpoint."""
-        # Verify we start with no logs
-        self.assertEqual(LogEntry.objects.count(), 0)
-        
-        data = {
-            'level': 'INFO',
-            'message': 'Test API log',
-            'extra_data': {'source': 'api'}
-        }
-        
-        response = self.client.post(
-            reverse('logq:log_endpoint'),
-            data=json.dumps(data),
-            content_type='application/json'
-        )
-        
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.json()['status'], 'success')
-        
-        # Wait for async processing
-        time.sleep(0.5)
-        
-        # Verify we have exactly one log entry
-        self.assertEqual(LogEntry.objects.count(), 1)
-        
-        entry = LogEntry.objects.first()
-        self.assertEqual(entry.message, 'Test API log')
-        self.assertEqual(entry.extra_data, {'source': 'api'})
-    
-    def test_log_api_view(self):
-        """Test the class-based log API view."""
-        # Verify we start with no logs
-        self.assertEqual(LogEntry.objects.count(), 0)
-        
-        data = {
-            'level': 'WARNING',
-            'message': 'Test warning',
-            'user_id': self.user.id,
-            'request_id': 'test-123'
-        }
-        
-        response = self.client.post(
-            reverse('logq:log_api'),
-            data=json.dumps(data),
-            content_type='application/json'
-        )
-        
-        self.assertEqual(response.status_code, 200)
-        
-        time.sleep(0.5)
-        
-        # Verify we have exactly one log entry
-        self.assertEqual(LogEntry.objects.count(), 1)
-        
-        entry = LogEntry.objects.first()
-        self.assertEqual(entry.level, LogLevel.WARNING)
-        self.assertEqual(entry.user_id, self.user.id)
-        self.assertEqual(entry.request_id, 'test-123')
-    
-    def test_get_logs_api(self):
-        """Test retrieving logs via API."""
-        # Verify we start with no logs
-        self.assertEqual(LogEntry.objects.count(), 0)
-        
-        # Create some test logs directly
-        LogEntry.objects.create(level=LogLevel.INFO, message="Test 1")
-        LogEntry.objects.create(level=LogLevel.ERROR, message="Test 2")
-        LogEntry.objects.create(level=LogLevel.DEBUG, message="Test 3")
-        
-        # Verify we have exactly 3 logs
-        self.assertEqual(LogEntry.objects.count(), 3)
-        
-        response = self.client.get(reverse('logq:log_api'))
-        self.assertEqual(response.status_code, 200)
-        
-        data = response.json()
-        self.assertEqual(len(data['logs']), 3)
-        self.assertEqual(data['logs'][0]['message'], "Test 1")
-    
-    def test_invalid_log_level(self):
-        """Test API with invalid log level."""
-        data = {
-            'level': 'INVALID',
-            'message': 'Test message'
-        }
-        
-        response = self.client.post(
-            reverse('logq:log_endpoint'),
-            data=json.dumps(data),
-            content_type='application/json'
-        )
-        
-        self.assertEqual(response.status_code, 400)
-        self.assertIn('Invalid log level', response.json()['error'])
 
 
-@override_settings(ASYNC_LOGGING_CONFIG={'MAX_QUEUE_SIZE': 500, 'FLUSH_INTERVAL': 0.5})
-class ConfigurationTestCase(TransactionTestCase):
+class UtilsTestCase(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 thread to start
     
     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_custom_configuration(self):
-        """Test that custom configuration is respected."""
-        logger = AsyncLogger()
-        self.assertEqual(logger.queue.maxsize, 500)
-        self.assertEqual(logger.flush_interval, 0.5)
+    def test_log_performance(self):
+        """Test log_performance decorator."""
+        # Debug: Check if the logger is running
+        logger = get_async_logger()
 
+        # Test direct logging first
+        logger.info("Direct test message")
+        time.sleep(0.3)
+        
+        @log_performance(threshold_seconds=0.1, always_log=True)
+        def slow_function():
+            time.sleep(0.2)
+            return "Result"
+        
+        slow_function()
+        
+        time.sleep(0.5)  # Wait longer for flush
+        
+        entries = LogEntry.objects.all()
 
-class MiddlewareTestCase(TransactionTestCase):
+        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_middleware_request_logging(self):
-        """Test that middleware logs requests."""
+    def test_log_handler(self):
+        """Test log handler functionality."""
         # Verify we start with no logs
         self.assertEqual(LogEntry.objects.count(), 0)
         
-        response = self.client.get('/admin/')
+        # 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)
         
-        entries = LogEntry.objects.all()
-        self.assertGreater(entries.count(), 0)
-        
-        # Should have request start and completion logs
-        start_logs = entries.filter(message__contains="Request started")
-        complete_logs = entries.filter(message__contains="Request completed")
+        # Verify the log entry was sent to the handler
+        log_entry = LogEntry.objects.first()
+        self.assertEqual(log_entry.message, "Test message")
         
-        self.assertGreater(start_logs.count(), 0)
-        self.assertGreater(complete_logs.count(), 0)
+        # Stop the logger
+        logger.stop()
+        time.sleep(0.2)  # Wait for thread to stop
+        

{djlogq-1.0.5 → djlogq-1.0.7}/src/logq/utils.py

@@ -32,10 +32,10 @@ def log_function_call(func=None, *, level='INFO'):
                 }
             )
             
-            start_time = time.time()
+            start_time = time.perf_counter()
             try:
                 result = func(*args, **kwargs)
-                execution_time = time.time() - start_time
+                execution_time = time.perf_counter() - start_time
                 
                 # Log successful completion
                 logger.log(
@@ -47,7 +47,7 @@ def log_function_call(func=None, *, level='INFO'):
                 return result
             
             except Exception as e:
-                execution_time = time.time() - start_time
+                execution_time = time.perf_counter() - start_time
                 
                 # Log exception
                 logger.exception(
@@ -64,30 +64,54 @@ def log_function_call(func=None, *, level='INFO'):
     return decorator(func)
 
 
-def log_performance(threshold_seconds=1.0):
+def log_performance(threshold_seconds=1.0, always_log=False):
     """
-    Decorator to log slow function calls.
+    Decorator to log function performance metrics.
+    
+    Args:
+        threshold_seconds: Log warning when execution exceeds this threshold
+        always_log: If True, log every function call for analytics (like Sentry spans)
     
     Usage:
         @log_performance(threshold_seconds=0.5)
         def my_slow_function():
             pass
+        
+        @log_performance(always_log=True)
+        def my_analytics_function():
+            pass
     """
     def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
-            start_time = time.time()
+            start_time = time.perf_counter()
             result = func(*args, **kwargs)
-            execution_time = time.time() - start_time
+            execution_time = time.perf_counter() - start_time
+            
+            logger = get_async_logger()
+            
+            # Always log for analytics if requested
+            if always_log:
+                logger.info(
+                    f"Function performance: {func.__name__}",
+                    extra_data={
+                        'execution_time': execution_time,
+                        'function_name': func.__name__,
+                        'module': func.__module__,
+                        'performance_metric': True,  # Tag for easy filtering
+                    }
+                )
             
+            # Log warning if threshold exceeded
             if execution_time > threshold_seconds:
-                logger = get_async_logger()
                 logger.warning(
                     f"Slow function detected: {func.__name__} took {execution_time:.3f}s",
                     extra_data={
                         'execution_time': execution_time,
                         'threshold': threshold_seconds,
                         'module': func.__module__,
+                        'function_name': func.__name__,
+                        'performance_metric': True,
                     }
                 )
             
@@ -114,7 +138,7 @@ class LogContext:
         self.start_time = None
     
     def __enter__(self):
-        self.start_time = time.time()
+        self.start_time = time.perf_counter()
         self.logger.log(
             self.level,
             f"Starting: {self.message}",
@@ -123,7 +147,7 @@ class LogContext:
         return self
     
     def __exit__(self, exc_type, exc_val, exc_tb):
-        execution_time = time.time() - self.start_time
+        execution_time = time.perf_counter() - self.start_time
         
         if exc_type is None:
             self.logger.log(

djlogq-1.0.5/src/logq/async_logger.py

@@ -1,160 +0,0 @@
-import threading
-import queue
-import time
-import logging
-import traceback
-import inspect
-from typing import Optional, Dict, Any
-from django.utils import timezone
-from django.db import transaction
-from django.conf import settings
-from .models import LogEntry, LogLevel
-
-
-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):
-        # Get configuration from settings
-        config = getattr(settings, 'ASYNC_LOGGING_CONFIG', {})
-        self.max_queue_size = max_queue_size or config.get('MAX_QUEUE_SIZE', 1000)
-        self.flush_interval = flush_interval or config.get('FLUSH_INTERVAL', 1.0)
-        
-        self.queue = queue.Queue(maxsize=self.max_queue_size)
-        self.running = False
-        self.thread = None
-        self._lock = threading.Lock()
-        
-    def start(self):
-        """Start the logging thread."""
-        with self._lock:
-            if not self.running:
-                self.running = True
-                self.thread = threading.Thread(target=self._worker, daemon=True)
-                self.thread.start()
-    
-    def stop(self):
-        """Stop the logging thread."""
-        with self._lock:
-            if self.running:
-                self.running = False
-                if self.thread:
-                    self.thread.join(timeout=5.0)
-    
-    def _worker(self):
-        """Worker thread that processes log entries from the queue."""
-        batch = []
-        last_flush = time.time()
-        
-        while self.running:
-            try:
-                # Try to get a log entry with timeout
-                try:
-                    entry = self.queue.get(timeout=0.1)
-                    batch.append(entry)
-                except queue.Empty:
-                    pass
-                
-                # Flush batch if it's time or batch is getting large
-                current_time = time.time()
-                if (current_time - last_flush >= self.flush_interval or 
-                    len(batch) >= 50):
-                    if batch:
-                        self._flush_batch(batch)
-                        batch = []
-                        last_flush = current_time
-                        
-            except Exception as e:
-                # Log the error to prevent infinite loops
-                print(f"Error in async logger worker: {e}")
-                time.sleep(1)
-        
-        # Flush remaining entries
-        if batch:
-            self._flush_batch(batch)
-    
-    def _flush_batch(self, batch):
-        """Flush a batch of log entries to the database."""
-        try:
-            with transaction.atomic():
-                LogEntry.objects.bulk_create(batch, ignore_conflicts=True)
-        except Exception as e:
-            print(f"Error flushing log batch: {e}")
-    
-    def log(self, level: str, message: str, **kwargs):
-        """Add a log entry to the queue."""
-        if not self.running:
-            return
-        
-        # Get caller information
-        frame = inspect.currentframe().f_back
-        module = frame.f_globals.get('__name__', 'unknown')
-        function = frame.f_code.co_name
-        line_number = frame.f_lineno
-        
-        # Create log entry
-        entry = LogEntry(
-            level=level,
-            message=message,
-            module=module,
-            function=function,
-            line_number=line_number,
-            user_id=kwargs.get('user_id'),
-            request_id=kwargs.get('request_id'),
-            extra_data=kwargs.get('extra_data', {})
-        )
-        
-        try:
-            self.queue.put_nowait(entry)
-        except queue.Full:
-            # If queue is full, log to console as fallback
-            print(f"Log queue full, dropping entry: [{level}] {message}")
-    
-    def debug(self, message: str, **kwargs):
-        self.log(LogLevel.DEBUG, message, **kwargs)
-    
-    def info(self, message: str, **kwargs):
-        self.log(LogLevel.INFO, message, **kwargs)
-    
-    def warning(self, message: str, **kwargs):
-        self.log(LogLevel.WARNING, message, **kwargs)
-    
-    def error(self, message: str, **kwargs):
-        self.log(LogLevel.ERROR, message, **kwargs)
-    
-    def critical(self, message: str, **kwargs):
-        self.log(LogLevel.CRITICAL, message, **kwargs)
-    
-    def exception(self, message: str, exc_info=None, **kwargs):
-        """Log an exception with traceback."""
-        if exc_info is None:
-            exc_info = traceback.format_exc()
-        
-        extra_data = kwargs.get('extra_data', {})
-        extra_data['traceback'] = exc_info
-        
-        self.log(LogLevel.ERROR, message, extra_data=extra_data, **kwargs)
-
-
-# Global logger instance
-_async_logger = None
-
-
-def get_async_logger() -> AsyncLogger:
-    """Get the global async logger instance."""
-    global _async_logger
-    if _async_logger is None:
-        _async_logger = AsyncLogger()
-        _async_logger.start()
-    return _async_logger
-
-
-def stop_async_logger():
-    """Stop the global async logger."""
-    global _async_logger
-    if _async_logger:
-        _async_logger.stop()
-        _async_logger = None
-