secploy 0.2.6__tar.gz → 0.2.7__tar.gz

{secploy-0.2.6/secploy.egg-info → secploy-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: secploy
-Version: 0.2.6
+Version: 0.2.7
 Summary: Event tracking and monitoring SDK for Python applications
 Home-page: https://github.com/agastronics/secploy-python-sdk
 Author: Agastronics

{secploy-0.2.6 → secploy-0.2.7}/secploy/__init__.py

@@ -23,7 +23,7 @@ def cli():
     
     parser = argparse.ArgumentParser(description=__description__)
     parser.add_argument('--version', action='version', version=f'Secploy SDK v{__version__}')
-    parser.add_argument('--test-config', help='Test a configuration file', metavar='CONFIG_FILE')
+    parser.add_argument('--test-config', help='Test a configuration file: To verify if it is well configured', metavar='CONFIG_FILE')
     
     args = parser.parse_args()
     

{secploy-0.2.6 → secploy-0.2.7}/secploy/client.py

@@ -104,6 +104,8 @@ class SecployClient:
         
         # Initialize log capturer
         self._log_capturer = SecployLogCapturer(self, levels=log_levels)
+        
+        self.start()
     
     def capture_logs(self, loggers: Union[str, List[str], None] = None):
         """

{secploy-0.2.6 → secploy-0.2.7}/secploy/log_capture.py

@@ -4,7 +4,10 @@ Secploy Log Capture Module
 This module provides functionality for capturing and forwarding logs to Secploy's ingest endpoint.
 """
 
+import asyncio
+import json
 import logging
+import sys
 import threading
 import traceback
 from typing import Any, Dict, Optional, List, Union
@@ -17,7 +20,7 @@ from .schemas import LogEntry, Context, Tags
 
 class SecployLogCapturer:
     """
-    Manages log capture and forwarding to Secploy ingest endpoint.
+    Manages log capture and exception forwarding to Secploy ingest endpoint.
     """
     
     def __init__(self, client, levels: Optional[List[Union[str, int]]] = None):
@@ -30,58 +33,105 @@ class SecployLogCapturer:
         self.client = client
         self.levels = levels
         self._handler = self._create_handler()
+        self._installed = False
         
     def _create_handler(self) -> logging.Handler:
         """Create the custom logging handler."""
         return SecployLogHandler(self.client, levels=self.levels)
 
     def start_capture(self, loggers: Union[str, List[str], None] = None):
-        """
-        Start capturing logs from specified loggers.
-        
-        Args:
-            loggers: Logger name(s) to capture. Can be:
-                    - None to capture the root logger
-                    - A string for a single logger
-                    - A list of logger names
-        """
+        """Start capturing logs and exceptions."""
+        if self._installed:
+            return
+        self._installed = True
         
         if isinstance(loggers, str):
             loggers = [loggers]
         elif loggers is None:
-            loggers = ['']  # Root logger
-            
+            loggers = ['']
+
         for logger_name in loggers:
             logger = logging.getLogger(logger_name)
             logger.addHandler(self._handler)
+
+        sys.excepthook = self._capture_uncaught_exceptions
+
+        if hasattr(threading, "excepthook"):
+            threading.excepthook = self._thread_exception_handler
+
+        try:
+            loop = asyncio.get_event_loop()
+            loop.set_exception_handler(self._async_exception_handler)
+        except RuntimeError:
+            pass
             
     def stop_capture(self, loggers: Union[str, List[str], None] = None):
-        """
-        Stop capturing logs from specified loggers.
-        
-        Args:
-            loggers: Logger name(s) to stop capturing. Same format as start_capture()
-        """
         if isinstance(loggers, str):
             loggers = [loggers]
         elif loggers is None:
-            loggers = ['']  # Root logger
-            
+            loggers = ['']
+
         for logger_name in loggers:
             logger = logging.getLogger(logger_name)
             if self._handler in logger.handlers:
                 logger.removeHandler(self._handler)
                 
     def stop_all(self):
-        """Stop all log capturing."""
-        # Find all loggers that have our handler
+        """Stop all log capturing and exception hooks."""
         for logger in [logging.getLogger(name) for name in logging.root.manager.loggerDict]:
             if self._handler in logger.handlers:
                 logger.removeHandler(self._handler)
-        # Check root logger too
         if self._handler in logging.root.handlers:
             logging.root.removeHandler(self._handler)
 
+        sys.excepthook = sys.__excepthook__
+        if hasattr(threading, "excepthook"):
+            threading.excepthook = threading.__excepthook__
+        try:
+            loop = asyncio.get_event_loop()
+            loop.set_exception_handler(None)
+        except RuntimeError:
+            pass
+
+        self._installed = False
+        
+    def _capture_uncaught_exceptions(self, exc_type, exc_value, exc_tb):
+        self._send_exception(exc_type, exc_value, exc_tb, source="sys")
+
+    def _thread_exception_handler(self, args):
+        self._send_exception(args.exc_type, args.exc_value, args.exc_traceback, source="thread")
+
+    def _async_exception_handler(self, loop, context):
+        exc = context.get("exception")
+        if exc:
+            self._send_exception(type(exc), exc, exc.__traceback__, source="asyncio")
+        else:
+            self._send_exception(RuntimeError, RuntimeError(context["message"]), None, source="asyncio")
+
+    def _send_exception(self, exc_type, exc_value, exc_tb, source="system"):
+        stacktrace = traceback.format_exception(exc_type, exc_value, exc_tb)
+
+        log_entry = LogEntry(
+            timestamp=datetime.now().timestamp(),
+            type="error",
+            message=str(exc_value),
+            context=Context(
+                user_id="unknown",
+                session_id="global",
+                http_method="NONE",
+                http_url="",
+                http_status=500,
+                stacktrace=stacktrace,
+                tags=Tags(
+                    environment=self.client.environment,
+                    service=f"exception.{source}",
+                    region="unknown"
+                )
+            )
+        )
+        payload = log_entry.model_dump(mode="json")
+        self.client._event_queue.put(("log", payload))
+
 
 class SecployLogHandler(logging.Handler):
     """
@@ -94,45 +144,34 @@ class SecployLogHandler(logging.Handler):
         self._local = threading.local()
         self._event_handler = EventHandler(self.client._event_queue)
         
-        if levels:
-            self.levels = {
-                lvl if isinstance(lvl, int) else logging._nameToLevel[lvl.upper()]
-                for lvl in levels
-            }
-        else:
-            self.levels = None  # None = capture all levels
+        # if levels:
+        #     self.levels = {
+        #         lvl if isinstance(lvl, int) else logging._nameToLevel[lvl.upper()]
+        #         for lvl in levels
+        #     }
+        # else:
+        #     self.levels = None  # None = capture all levels
             
-    def filter(self, record: logging.LogRecord) -> bool:
-        """Return True if this record should be handled."""
-        if self.levels is None:
-            return True
-        return record.levelno in self.levels
+    # def filter(self, record: logging.LogRecord) -> bool:
+    #     """Return True if this record should be handled."""
+    #     if self.levels is None:
+    #         return True
+    #     return record.levelno in self.levels
         
     def get_thread_id(self) -> str:
         """Get the current thread identifier."""
         return str(threading.get_ident())
         
-    def format_exc_info(self, exc_info) -> Optional[Dict[str, Any]]:
-        """Format exception information if available."""
-        if not exc_info:
-            return None
-            
-        exc_type, exc_value, exc_tb = exc_info
-        return {
-            'type': exc_type.__name__ if exc_type else None,
-            'message': str(exc_value) if exc_value else None,
-            'stacktrace': traceback.format_tb(exc_tb) if exc_tb else None
-        }
-        
     def emit(self, record: logging.LogRecord):
         """Send the log record to Secploy ingest."""
+        print(f'\n\nLEVEL NAME: {record.levelname} -  LEVEL NO: {record.levelno}\n\n')
         try:
             # Get stacktrace if exception exists
             stacktrace = []
             if record.exc_info:
-                exc_info = self.format_exc_info(record.exc_info)
-                if exc_info['stacktrace']:
-                    stacktrace = exc_info['stacktrace']
+                stacktrace = traceback.format_exception(*record.exc_info)
+            elif record.stack_info:
+                stacktrace = [record.stack_info]
 
             # Build tags with log metadata
             tags = Tags(
@@ -144,23 +183,22 @@ class SecployLogHandler(logging.Handler):
             # Build context
             context = Context(
                 user_id=getattr(record, 'user_id', 'unknown'),
-                session_id=self.get_thread_id(),  # Using thread_id as session_id for logging
+                session_id=self.get_thread_id(), 
                 http_method=getattr(record, 'http_method', 'NONE'),
-                http_url=getattr(record, 'path', ''),
                 http_status=getattr(record, 'status_code', 0),
-                stacktrace=stacktrace,
-                tags=tags
+                tags=tags,
+                http_url=getattr(record, "http_url", getattr(record, "path", "")),
+                stacktrace=stacktrace
             )
 
             # Create LogEntry using our schema
             log_entry = LogEntry(
                 timestamp=datetime.fromtimestamp(record.created).timestamp(),
-                type=record.levelname.lower(),  # convert DEBUG -> debug, ERROR -> error etc
+                type=record.levelname.lower(),
                 message=self.format(record),
                 context=context
             )
             payload = log_entry.model_dump(mode="json") 
-            # Validate and send the log entry
             self._event_handler.send_event('log', payload)
 
         except Exception as e:

{secploy-0.2.6 → secploy-0.2.7}/secploy/schemas.py

@@ -1,6 +1,6 @@
 from typing import TypedDict, Optional, Union, List
 from datetime import datetime
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, ConfigDict
 from .enums import LogLevel
 
 
@@ -28,8 +28,7 @@ class Tags(BaseModel):
     service: str
     region: str
 
-    class Config:
-        extra = Extra.allow  # Allow additional fields in tags
+    model_config = ConfigDict(extra="allow")
 
 
 class Context(BaseModel):
@@ -40,6 +39,7 @@ class Context(BaseModel):
     http_status: int
     stacktrace: List[str]
     tags: Tags
+    
 
 
 class LogEntry(BaseModel):

{secploy-0.2.6 → secploy-0.2.7/secploy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: secploy
-Version: 0.2.6
+Version: 0.2.7
 Summary: Event tracking and monitoring SDK for Python applications
 Home-page: https://github.com/agastronics/secploy-python-sdk
 Author: Agastronics

{secploy-0.2.6 → secploy-0.2.7}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="secploy",
-    version="0.2.6",
+    version="0.2.7",
     packages=find_packages(),
     install_requires=[
         "requests>=2.25.0",