djlogq 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

{djlogq-1.0.5.dist-info → djlogq-1.0.7.dist-info}/METADATA

@@ -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.dist-info → djlogq-1.0.7.dist-info}/RECORD

@@ -1,12 +1,12 @@
 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=I8za2lfEhiGrKDq76oZ4DZvvAlXeiRr17bmXT5tXSY4,5216
+logq/async_logger.py,sha256=kNAmyVV7GWzsd_aZ4baSfNz5H7AwZV5YC4oV-Xy_k5M,10382
 logq/middleware.py,sha256=Y9EAnxrmavyDgVklEW893Wh0eeQPKdCvizcxGzPDLBo,3642
 logq/models.py,sha256=Gu8KLNMn7I4XtEUHQPavSSlcESQ-2Pu5JLKsL97t9Gg,1616
-logq/tests.py,sha256=iimhG7nvH5SbFn1og6soBMvCWhxCsuvgwkfaPOr5PC4,11102
+logq/tests.py,sha256=180_XHLQ3I1am5qlaaf-36n8E-CaRI4ZT3uGZ-OyYJU,10704
 logq/urls.py,sha256=oGwVM9HXsVY_P86sVPuz5xnFofYfmkL8ZSZDhExhJQk,216
-logq/utils.py,sha256=Bg973EhnvQXvFSk1mtf8pcpQqnHiOnQRdaCLM9ibJPw,4204
+logq/utils.py,sha256=lNm2TfbpWdKbAeoy4ny8-TFaNFyQGsBL_Wxq0VoxkO4,5235
 logq/views.py,sha256=WJpwiPyfItBbceM1862NcXp_ui4U6WyNBhw2P27mlJ4,3695
 logq/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 logq/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -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.5.dist-info/METADATA,sha256=ETmekY9yeJ4CUXuu-esuL2UZx77BaNj0h3z5XKCX6zk,6423
-djlogq-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-djlogq-1.0.5.dist-info/top_level.txt,sha256=VWj_EO93x0ix2Y2qm6obWT22L7VPFiZ7lQf0yIaI8do,5
-djlogq-1.0.5.dist-info/RECORD,,
+djlogq-1.0.7.dist-info/METADATA,sha256=3EhYc2CraOPQMB61EeB-Q_kA5yyETvN1_WfEggsjqqE,7426
+djlogq-1.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+djlogq-1.0.7.dist-info/top_level.txt,sha256=VWj_EO93x0ix2Y2qm6obWT22L7VPFiZ7lQf0yIaI8do,5
+djlogq-1.0.7.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)
@@ -26,6 +39,43 @@ 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()
+
+        # 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."""
@@ -80,8 +130,62 @@ class AsyncLogger:
         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."""
@@ -110,7 +214,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)

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
+        

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(