djlogq 1.0.4__tar.gz → 1.0.6__tar.gz

{djlogq-1.0.4/src/djlogq.egg-info → djlogq-1.0.6}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: djlogq
-Version: 1.0.4
+Version: 1.0.6
 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
+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"

{djlogq-1.0.4 → djlogq-1.0.6}/pyproject.toml

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

{djlogq-1.0.4 → djlogq-1.0.6/src/djlogq.egg-info}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: djlogq
-Version: 1.0.4
+Version: 1.0.6
 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
+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"

{djlogq-1.0.4 → djlogq-1.0.6}/src/djlogq.egg-info/requires.txt

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

{djlogq-1.0.4 → djlogq-1.0.6}/src/logq/async_logger.py

@@ -26,6 +26,9 @@ class AsyncLogger:
         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()  # 
         
     def start(self):
         """Start the logging thread."""
@@ -80,6 +83,36 @@ class AsyncLogger:
         try:
             with transaction.atomic():
                 LogEntry.objects.bulk_create(batch, ignore_conflicts=True)
+
+                # 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}")
     
@@ -110,7 +143,23 @@ class AsyncLogger:
             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}")
+            # 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)

{djlogq-1.0.4 → djlogq-1.0.6}/src/logq/tests.py

@@ -8,7 +8,8 @@ import time
 import threading
 from .models import LogEntry, LogLevel
 from .async_logger import AsyncLogger, get_async_logger, stop_async_logger
-
+from .utils import log_performance, log_function_call
+import requests
 
 class AsyncLoggerTestCase(TransactionTestCase):
     def setUp(self):
@@ -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,60 @@ 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):
-    def setUp(self):
-        super().setUp()
-        # Clear all existing logs
-        with connection.cursor() as cursor:
-            cursor.execute("DELETE FROM logq_logentry")
-    
-    def tearDown(self):
-        # 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)
 
 
-class MiddlewareTestCase(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_middleware_request_logging(self):
-        """Test that middleware logs requests."""
-        # Verify we start with no logs
-        self.assertEqual(LogEntry.objects.count(), 0)
+    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)
         
-        response = self.client.get('/admin/')
+        @log_performance(threshold_seconds=0.1, always_log=True)
+        def slow_function():
+            time.sleep(0.2)
+            return "Result"
         
-        time.sleep(0.5)
+        slow_function()
+        
+        time.sleep(0.5)  # Wait longer for flush
         
         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")
-        
-        self.assertGreater(start_logs.count(), 0)
-        self.assertGreater(complete_logs.count(), 0)
+        

{djlogq-1.0.4 → djlogq-1.0.6}/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(