velocity-python 0.0.128__py3-none-any.whl → 0.0.131__py3-none-any.whl

velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.128"
+__version__ = version = "0.0.131"
 
 from . import aws
 from . import db

velocity/aws/handlers/lambda_handler.py

@@ -68,7 +68,7 @@ class LambdaHandler(BaseHandler):
             postdata=postdata,
             response=response,
             session=self.session,
-            log=lambda message, function=None: self.log(tx, message, function),
+            log=lambda message, function=None: self.log(message, function),
         )
 
         # Determine action from postdata or query parameters

velocity/aws/handlers/mixins/__init__.py

@@ -0,0 +1,16 @@
+"""
+Mixins for AWS Lambda handlers.
+
+This package provides reusable mixins for common Lambda handler functionality:
+- ActivityTracker: Standardized activity logging and tracking
+- ErrorHandler: Standardized error handling and notifications
+- StandardMixin: Combined mixin for most common use cases
+- LegacyMixin: Backward-compatible enhanced tracking for existing handlers
+"""
+
+from .activity_tracker import ActivityTracker
+from .error_handler import ErrorHandler
+from .standard_mixin import StandardMixin
+from .legacy_mixin import LegacyMixin
+
+__all__ = ['ActivityTracker', 'ErrorHandler', 'StandardMixin', 'LegacyMixin']

velocity/aws/handlers/mixins/activity_tracker.py

@@ -0,0 +1,142 @@
+"""
+Activity Tracker Mixin for Lambda Handlers.
+
+Provides standardized activity tracking and logging functionality
+for Lambda handlers using the aws_api_activity table.
+"""
+
+import copy
+import json
+import os
+import time
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+
+class ActivityTracker(ABC):
+    """
+    Mixin class providing standardized activity tracking for Lambda handlers.
+    
+    Tracks API calls to the aws_api_activity table with consistent data structure
+    and automatic duration calculation.
+    """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.activity_log_key = None
+        self.start_time = None
+        self.end_time = None
+        self.activity_data = {}
+    
+    def track_activity_start(self, tx, context):
+        """Start tracking activity for the current request"""
+        self.start_time = time.time()
+        
+        # Gather common activity data
+        postdata = context.postdata()
+        payload = context.payload()
+        
+        self.activity_data = {
+            "action": context.action(),
+            "args": json.dumps(context.args()),
+            "postdata": self._sanitize_postdata(postdata),
+            "handler_name": self.__class__.__name__,
+            "function_name": os.environ.get("AWS_LAMBDA_FUNCTION_NAME", "Unknown"),
+            "user_branch": os.environ.get("USER_BRANCH", "Unknown"),
+            "start_timestamp": self.start_time,
+        }
+        
+        # Add user information if available
+        user_info = self._extract_user_info(payload)
+        if user_info:
+            self.activity_data.update(user_info)
+            
+        # Add session information
+        session_data = context.session()
+        if session_data:
+            self.activity_data.update({k: v for k, v in session_data.items() 
+                                     if k not in ['cognito_user']})
+        
+        # Create the activity record
+        self.activity_log_key = tx.table("aws_api_activity").new(self.activity_data).pk
+        
+        return self.activity_log_key
+    
+    def track_activity_success(self, tx, context):
+        """Update activity record with success information"""
+        if not self.activity_log_key:
+            return
+            
+        self.end_time = time.time()
+        update_data = {
+            "end_timestamp": self.end_time,
+            "duration": self.end_time - self.start_time,
+            "status": "success"
+        }
+        
+        tx.table("aws_api_activity").update(update_data, self.activity_log_key)
+    
+    def track_activity_error(self, tx, context, exception, tb_string):
+        """Update activity record with error information"""
+        if not self.activity_log_key:
+            return
+            
+        self.end_time = time.time()
+        update_data = {
+            "end_timestamp": self.end_time,
+            "duration": self.end_time - self.start_time if self.start_time else 0,
+            "status": "error",
+            "exception_type": exception.__class__.__name__,
+            "exception_message": str(exception),
+            "traceback": tb_string,
+        }
+        
+        # Handle legacy field names for backward compatibility
+        update_data["exception"] = exception.__class__.__name__
+        
+        tx.table("aws_api_activity").update(update_data, self.activity_log_key)
+    
+    def _sanitize_postdata(self, postdata: Dict) -> str:
+        """Remove sensitive information from postdata before logging"""
+        if not postdata:
+            return "{}"
+            
+        sanitized = copy.deepcopy(postdata)
+        
+        # Remove cognito user data from payload if present
+        if "payload" in sanitized and isinstance(sanitized["payload"], dict):
+            sanitized["payload"].pop("cognito_user", None)
+            
+        # Remove other sensitive fields as needed
+        sensitive_fields = ["password", "token", "secret", "key", "auth", "cognito_user"]
+        self._recursive_sanitize(sanitized, sensitive_fields)
+        
+        return json.dumps(sanitized)
+    
+    def _recursive_sanitize(self, data: Any, sensitive_fields: list):
+        """Recursively remove sensitive fields from nested data structures"""
+        if isinstance(data, dict):
+            for key in list(data.keys()):
+                if any(field in key.lower() for field in sensitive_fields):
+                    data[key] = "[REDACTED]"
+                else:
+                    self._recursive_sanitize(data[key], sensitive_fields)
+        elif isinstance(data, list):
+            for item in data:
+                self._recursive_sanitize(item, sensitive_fields)
+    
+    def _extract_user_info(self, payload: Dict) -> Dict:
+        """Extract user information from payload"""
+        user_info = {}
+        
+        if payload and "cognito_user" in payload:
+            try:
+                attrs = payload["cognito_user"]["attributes"]
+                if "email" in attrs:
+                    user_info["email_address"] = attrs["email"].lower()
+                if "sub" in attrs:
+                    user_info["user_id"] = attrs["sub"]
+            except (KeyError, TypeError):
+                pass
+                
+        return user_info

velocity/aws/handlers/mixins/error_handler.py

@@ -0,0 +1,192 @@
+"""
+Error Handler Mixin for Lambda Handlers.
+
+Provides standardized error handling, logging, and notification functionality
+for Lambda handlers.
+"""
+
+import copy
+import os
+import pprint
+import time
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+
+class ErrorHandler(ABC):
+    """
+    Mixin class providing standardized error handling for Lambda handlers.
+    
+    Handles error logging to sys_log table, email notifications to administrators,
+    and error metrics collection.
+    """
+    
+    def handle_standard_error(self, tx, context, exception: Exception, tb_string: str):
+        """Handle errors with consistent logging and notification patterns"""
+        
+        # Log to sys_log for centralized logging
+        self.log_error_to_system(tx, context, exception, tb_string)
+        
+        # Determine if this error requires notification
+        if self._should_notify_error(exception):
+            self.send_error_notification(tx, context, exception, tb_string)
+        
+        # Log error metrics for monitoring
+        self.log_error_metrics(tx, context, exception)
+    
+    def log_error_to_system(self, tx, context, exception: Exception, tb_string: str):
+        """Log error to sys_log table"""
+        error_data = {
+            "level": "ERROR",
+            "message": str(exception),
+            "function": f"{self.__class__.__name__}.{context.action()}",
+            "traceback": tb_string,
+            "exception_type": exception.__class__.__name__,
+            "handler_name": self.__class__.__name__,
+            "action": context.action(),
+            "user_branch": os.environ.get("USER_BRANCH", "Unknown"),
+            "function_name": os.environ.get("AWS_LAMBDA_FUNCTION_NAME", "Unknown"),
+            "app_name": os.environ.get("ProjectName", "Unknown"),
+            "user_agent": "AWS Lambda",
+            "device_type": "Lambda",
+            "sys_modified_by": "Lambda",
+        }
+        
+        # Add user context if available
+        try:
+            if hasattr(self, 'current_user') and self.current_user:
+                error_data["user_email"] = self.current_user.get("email_address")
+        except:
+            pass
+            
+        tx.table("sys_log").insert(error_data)
+    
+    def send_error_notification(self, tx, context, exception: Exception, tb_string: str):
+        """Send error notification email to administrators"""
+        try:
+            # Import here to avoid circular dependency
+            from support.app import helpers
+            
+            environment = os.environ.get('USER_BRANCH', 'Unknown').title()
+            function_name = os.environ.get('AWS_LAMBDA_FUNCTION_NAME', 'Unknown')
+            
+            subject = f"{environment} Lambda Error - {function_name}"
+            
+            body = f"""
+Error Details:
+- Handler: {self.__class__.__name__}
+- Action: {context.action()}
+- Exception: {exception.__class__.__name__}
+- Message: {str(exception)}
+- Environment: {environment}
+- Function: {function_name}
+
+Full Traceback:
+{tb_string}
+
+Request Details:
+{self._get_error_context(context)}
+            """
+            
+            sender = self._get_error_notification_sender()
+            recipients = self._get_error_notification_recipients()
+            
+            helpers.sendmail(
+                tx,
+                subject=subject,
+                body=body,
+                html=None,
+                sender=sender,
+                recipient=recipients[0],
+                cc=recipients[1:] if len(recipients) > 1 else None,
+                bcc=None,
+                email_settings_id=1001,
+            )
+        except Exception as email_error:
+            print(f"Failed to send error notification email: {email_error}")
+    
+    def _should_notify_error(self, exception: Exception) -> bool:
+        """Determine if an error should trigger email notifications"""
+        # Don't notify for user authentication errors or validation errors
+        non_notification_types = [
+            "AuthenticationError", 
+            "ValidationError", 
+            "ValueError",
+            "AlertError"
+        ]
+        
+        exception_name = exception.__class__.__name__
+        
+        # Check for authentication-related exceptions
+        if "Authentication" in exception_name or "Auth" in exception_name:
+            return False
+            
+        return exception_name not in non_notification_types
+    
+    @abstractmethod
+    def _get_error_notification_recipients(self) -> list:
+        """
+        Get list of email recipients for error notifications.
+        
+        Must be implemented by the handler class.
+        
+        Returns:
+            List of email addresses to notify when errors occur
+            
+        Example:
+            return ["admin@company.com", "devops@company.com"]
+        """
+        pass
+    
+    @abstractmethod
+    def _get_error_notification_sender(self) -> str:
+        """
+        Get email sender for error notifications.
+        
+        Must be implemented by the handler class.
+        
+        Returns:
+            Email address to use as sender for error notifications
+            
+        Example:
+            return "no-reply@company.com"
+        """
+        pass
+    
+    def _get_error_context(self, context) -> str:
+        """Get sanitized request context for error reporting"""
+        try:
+            postdata = context.postdata()
+            sanitized = copy.deepcopy(postdata)
+            
+            # Remove sensitive data
+            if "payload" in sanitized and isinstance(sanitized["payload"], dict):
+                sanitized["payload"].pop("cognito_user", None)
+                
+            return pprint.pformat(sanitized)
+        except:
+            return "Unable to retrieve request context"
+    
+    def log_error_metrics(self, tx, context, exception: Exception):
+        """Log error metrics for monitoring and alerting"""
+        try:
+            metrics_data = {
+                "metric_type": "error_count",
+                "handler_name": self.__class__.__name__,
+                "action": context.action(),
+                "exception_type": exception.__class__.__name__,
+                "environment": os.environ.get("USER_BRANCH", "Unknown"),
+                "function_name": os.environ.get("AWS_LAMBDA_FUNCTION_NAME", "Unknown"),
+                "timestamp": time.time(),
+                "sys_modified_by": "Lambda"
+            }
+            
+            # Try to insert into metrics table if it exists
+            try:
+                tx.table("lambda_metrics").insert(metrics_data)
+            except:
+                # Metrics table might not exist yet, don't fail error handler
+                pass
+        except:
+            # Don't fail the error handler if metrics logging fails
+            pass

velocity/aws/handlers/mixins/legacy_mixin.py

@@ -0,0 +1,53 @@
+"""
+Legacy Mixin for backward compatibility.
+
+Provides enhanced activity tracking while maintaining existing 
+beforeAction/afterAction/onError implementations in handlers.
+"""
+
+import os
+from .activity_tracker import ActivityTracker
+from .error_handler import ErrorHandler
+
+
+class LegacyMixin(ActivityTracker, ErrorHandler):
+    """
+    Legacy-compatible mixin that enhances existing handlers without breaking them.
+    
+    This mixin adds standardized activity tracking and error handling
+    while preserving existing beforeAction/afterAction/onError implementations.
+    
+    Use this when migrating existing handlers that have complex custom logic
+    in their action methods.
+    """
+    
+    def _enhanced_before_action(self, tx, context):
+        """Enhanced beforeAction that adds activity tracking"""
+        # Start activity tracking
+        self.track_activity_start(tx, context)
+    
+    def _enhanced_after_action(self, tx, context):
+        """Enhanced afterAction that adds activity tracking"""
+        # Update activity tracking with success
+        self.track_activity_success(tx, context)
+    
+    def _enhanced_error_handler(self, tx, context, exc, tb):
+        """Enhanced onError that adds standardized error handling"""
+        # Convert exc to exception object if it's a string
+        if isinstance(exc, str):
+            exception = Exception(exc)
+        else:
+            exception = exc
+            
+        # Update activity tracking with error
+        self.track_activity_error(tx, context, exception, tb)
+        
+        # Handle error with standard patterns (but don't send duplicate emails)
+        self.log_error_to_system(tx, context, exception, tb)
+        self.log_error_metrics(tx, context, exception)
+        
+        # Only send notification if handler doesn't already handle it
+        # Check for a flag that handlers can set to indicate they handle their own notifications
+        if not getattr(self, '_handles_own_error_notifications', False):
+            if self._should_notify_error(exception):
+                self.send_error_notification(tx, context, exception, tb)

velocity/aws/handlers/mixins/standard_mixin.py

@@ -0,0 +1,73 @@
+"""
+Standard Mixin combining ActivityTracker and ErrorHandler.
+
+Provides a single mixin that includes both activity tracking and error handling
+with standardized beforeAction, afterAction, and onError implementations.
+"""
+
+import copy
+import pprint
+from abc import ABC, abstractmethod
+
+from .activity_tracker import ActivityTracker
+from .error_handler import ErrorHandler
+
+
+class StandardMixin(ActivityTracker, ErrorHandler):
+    """
+    Combined mixin providing both activity tracking and error handling.
+    Use this as the primary mixin for Lambda handlers.
+    
+    Provides standard implementations of:
+    - beforeAction: Starts activity tracking + custom logic
+    - afterAction: Records success + custom logic  
+    - onError: Records error + handles notifications + custom logic
+    """
+    
+    def beforeAction(self, tx, context):
+        """Standard beforeAction implementation"""
+        # Start activity tracking
+        self.track_activity_start(tx, context)
+        
+        # Call any custom beforeAction logic
+        self._custom_before_action(tx, context)
+    
+    def afterAction(self, tx, context):
+        """Standard afterAction implementation"""
+        # Update activity tracking with success
+        self.track_activity_success(tx, context)
+        
+        # Call any custom afterAction logic
+        self._custom_after_action(tx, context)
+    
+    def onError(self, tx, context, exc, tb):
+        """Standard onError implementation"""
+        # Convert exc to exception object if it's a string
+        if isinstance(exc, str):
+            exception = Exception(exc)
+        else:
+            exception = exc
+            
+        # Update activity tracking with error
+        self.track_activity_error(tx, context, exception, tb)
+        
+        # Handle error with standard patterns
+        self.handle_standard_error(tx, context, exception, tb)
+        
+        # Call any custom error handling
+        self._custom_error_handler(tx, context, exception, tb)
+    
+    @abstractmethod
+    def _custom_before_action(self, tx, context):
+        """Override this method for handler-specific beforeAction logic"""
+        pass
+    
+    @abstractmethod  
+    def _custom_after_action(self, tx, context):
+        """Override this method for handler-specific afterAction logic"""
+        pass
+    
+    @abstractmethod
+    def _custom_error_handler(self, tx, context, exception, tb):
+        """Override this method for handler-specific error handling"""
+        pass

{velocity_python-0.0.128.dist-info → velocity_python-0.0.131.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.128
+Version: 0.0.131
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.128.dist-info → velocity_python-0.0.131.dist-info}/RECORD

@@ -1,4 +1,4 @@
-velocity/__init__.py,sha256=zQ0Q2qkU3osjFiKRk7HW8XMynDw8zQNSmnERDVkQaDI,147
+velocity/__init__.py,sha256=BLvCt7oG0pOKOxVPemY9WH6NtsP7cw04_KsA56xXCwk,147
 velocity/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/invoices.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/orders.py,sha256=fr1oTBjSFfyeMBUXRG06LV4jgwrlwYNL5mbEBleFwf0,6328
@@ -10,9 +10,14 @@ velocity/aws/handlers/__init__.py,sha256=4-NKj8dBzjYEdIlNdfm_Ip5mI0oOGcpjjBcMwU4
 velocity/aws/handlers/base_handler.py,sha256=bapdzWss5lXesoLPsVwJo9hQMZLdz7XOubo3sK70xC8,7960
 velocity/aws/handlers/context.py,sha256=0kPZ8y-XjmBZY5NcexynR5htnWYfF0nwM1n5UH-6c5w,8413
 velocity/aws/handlers/exceptions.py,sha256=i4wcB8ZSWUHglX2xnesDlWLsU9AMYU72cHCWRBDmjQ8,361
-velocity/aws/handlers/lambda_handler.py,sha256=Njqu7Xap2t8Z9l89DApFnlhLSohv5oGTKHz2UMoDALA,4431
+velocity/aws/handlers/lambda_handler.py,sha256=0wa_CHyJOaI5RsHqB0Ae83-B-SwlKR0qkGUlc7jitQI,4427
 velocity/aws/handlers/response.py,sha256=s2Kw7yv5zAir1mEmfv6yBVIvRcRQ__xyryf1SrvtiRc,9317
 velocity/aws/handlers/sqs_handler.py,sha256=azuV8DrFOh0hM13EnPzyYVBS-3fLe2fn9OPc4ho7sGc,3375
+velocity/aws/handlers/mixins/__init__.py,sha256=_zyEpsnKikF7D7X-F0GA4cyIrQ6wBq7k5j6Vhp17vaQ,623
+velocity/aws/handlers/mixins/activity_tracker.py,sha256=b2Cu46FM0fLS2-FkWXXAPw6yvMV_Viu5-IlpGkVAlmk,5254
+velocity/aws/handlers/mixins/error_handler.py,sha256=uN2YF9v-3LzS3o_HdVpO-XMcPy3sS7SHjUg_LfbsG7Q,6803
+velocity/aws/handlers/mixins/legacy_mixin.py,sha256=_YhiPU-zzXQjGNSAKhoUwfTFlnczmU-3BkwNFqr0hYE,2117
+velocity/aws/handlers/mixins/standard_mixin.py,sha256=-wBX0PFlZAnxQsaMDEWr-xmU8TcRbQ4BZD3wmAKR2d0,2489
 velocity/db/__init__.py,sha256=7XRUHY2af0HL1jvL0SAMpxSe5a2Phbkm-YLJCvC1C_0,739
 velocity/db/exceptions.py,sha256=XHREJvzNctrtYE-ScBRLnbk7thxTswkfWojKhMmBmd8,2185
 velocity/db/utils.py,sha256=IoXeAL_0wZE15gbxlb2TtNdHzUSV9bIvw8jNkqjz38o,7020
@@ -50,8 +55,8 @@ velocity/misc/tools.py,sha256=4TWa-ja2gMZJr1EhqTKsJNirvDclCruyRGMttPhCIGw,1487
 velocity/misc/conv/__init__.py,sha256=qhHFl_UqW5tjPm--6shO171IysWIdH3mmp3uwiQVyqY,70
 velocity/misc/conv/iconv.py,sha256=16aPWtreHCxmpl5ufku0KWWZj8PIUFI5J1dP0aXyM3o,10794
 velocity/misc/conv/oconv.py,sha256=h5Lo05DqOQnxoD3y6Px_MQP_V-pBbWf8Hkgkb9Xp1jk,6032
-velocity_python-0.0.128.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.0.128.dist-info/METADATA,sha256=z-ONVxVF8G6qGO8rZszDMmWLCrWnuFRZYHaKCjpopsg,34262
-velocity_python-0.0.128.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-velocity_python-0.0.128.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.0.128.dist-info/RECORD,,
+velocity_python-0.0.131.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.0.131.dist-info/METADATA,sha256=hrp_x5Sgp7kautE2OXlW0UbonLT7lTVKvQDgHKXqkqI,34262
+velocity_python-0.0.131.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+velocity_python-0.0.131.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.0.131.dist-info/RECORD,,