velocity-python 0.0.169__tar.gz → 0.0.171__tar.gz

{velocity_python-0.0.169 → velocity_python-0.0.171}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.169
+Version: 0.0.171
 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.169 → velocity_python-0.0.171}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.169"
+version = "0.0.171"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.0.169 → velocity_python-0.0.171}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.169"
+__version__ = version = "0.0.171"
 
 from . import aws
 from . import db

{velocity_python-0.0.169 → velocity_python-0.0.171}/src/velocity/aws/handlers/base_handler.py

@@ -5,7 +5,6 @@ This module provides a base class for handling AWS Lambda events.
 It includes common functionality shared between LambdaHandler and SqsHandler.
 """
 
-import logging
 import os
 import sys
 import traceback
@@ -146,10 +145,14 @@ class BaseHandler:
             if hasattr(self, action):
                 result = getattr(self, action)(tx, local_context)
                 if result is not None:
-                    logging.warning(
-                        f"Action {action} returned an unexpected non-None result ({result!r})."
-                        " Handlers should return None so results are not ignored."
-                        " Please refactor the action to avoid returning a value that will be discarded."
+                    self.logger.warning(
+                        "Action %s returned an unexpected non-None result (%r).",
+                        action,
+                        result,
+                        extra={
+                            "note": "Handlers should return None so results are not ignored.",
+                            "action": action,
+                        },
                     )
                 action_executed = True
                 break
@@ -180,31 +183,25 @@ class BaseHandler:
             # Re-raise if no error handler is defined
             raise exception
 
-    def log(self, tx, message: str, function: Optional[str] = None):
-        """
-        Log a message to the system log table.
-        This is a base implementation that should be overridden by subclasses
-        to provide handler-specific logging details.
-
-        Args:
-            tx: Database transaction object
-            message: The message to log
-            function: Optional function name, auto-detected if not provided
-        """
+    def log(self, tx, message: str, function: Optional[str] = None, level: str = "info"):
+        """Emit structured log output through the shared logger."""
         if not function:
             function = self.get_calling_function()
 
-        # Base log data - subclasses should extend this
-        data = {
+        log_data = {
             "app_name": os.environ.get("ProjectName", "Unknown"),
             "function": function,
             "message": message,
         }
-
-        # Let subclasses add their specific fields
-        self._extend_log_data(data)
-
-        tx.table("sys_log").insert(data)
+        self._extend_log_data(log_data)
+
+        log_method = getattr(self.logger, level, self.logger.info)
+        log_method(
+            "%s %s",
+            function,
+            message,
+            extra={"log_data": log_data, "tx_present": tx is not None},
+        )
 
     def _extend_log_data(self, data: Dict[str, Any]):
         """

{velocity_python-0.0.169 → velocity_python-0.0.171}/src/velocity/aws/handlers/context.py

@@ -1,5 +1,4 @@
 import json
-import logging
 import os
 import re
 import boto3
@@ -12,12 +11,13 @@ from botocore.exceptions import ClientError
 import hashlib
 import velocity
 import velocity.db
+from velocity.logging import get_logger
 
 engine = velocity.db.postgres.initialize()
 
 
 cognito_client = boto3.client("cognito-idp")
-logger = logging.getLogger(__name__)
+logger = get_logger("velocity.aws.handlers.context")
 
 
 @engine.transaction
@@ -83,11 +83,10 @@ class Context:
     def log(self, message, function=None):
         if self.__log:
             return self.__log(message, function)
+        if function:
+            logger.info("%s: %s", function, message)
         else:
-            if function:
-                print(f"{function}: {message}")
-            else:
-                print(f"{message}")
+            logger.info("%s", message)
 
     def update_job(self, tx, data=None):
         """Update job status and message in aws_job_activity table.

{velocity_python-0.0.169 → velocity_python-0.0.171}/src/velocity/aws/handlers/lambda_handler.py

@@ -14,11 +14,6 @@ configure_logging()
 logger = get_logger("velocity.aws.handlers.lambda")
 
 
-def log_debug(*args) -> None:
-    if args:
-        logger.debug(" ".join(str(arg) for arg in args))
-
-
 class LambdaHandler(BaseHandler):
     def __init__(
         self, 
@@ -59,143 +54,91 @@ class LambdaHandler(BaseHandler):
         else:
             self.session["device_type"] = "unknown"
 
-    def get_pass_through_vars(self, tx, context):
-        """Get pass-through variables: environment vars, layers, and user data"""
-        temp = context.get_pass_through_vars(tx, self.current_user)
-
-        log_debug(
-            "LAYER_DEBUG: vars object contains:",
-            list(temp.get("controls", {}).get("vars", {}).keys()),
-        )
-        if "layers" in temp.get("controls", {}).get("vars", {}):
-            log_debug("LAYER_DEBUG: layers value:", temp["controls"]["vars"]["layers"])
-
-        # Merge with user data from database
-        temp = context.merge_user_data(tx, temp, self.session["email_address"])
-
-        return temp
-
-    def _summarize_postdata(self, postdata):
-        """Extract key fields from postdata for logging without storing entire payload"""
-        if not postdata:
-            return {}
-
-        summary = {
-            "action": postdata.get("action"),
-            "payload_keys": (
-                list(postdata.get("payload", {}).keys())
-                if isinstance(postdata.get("payload"), dict)
-                else None
-            ),
-        }
-
-        # Add size info
-        try:
-            summary["payload_size_bytes"] = len(json.dumps(postdata.get("payload", {})))
-        except:
-            summary["payload_size_bytes"] = 0
-
-        return summary
 
     def beforeAction(self, tx, context):
         # Enhanced activity tracking
-        result = self._enhanced_before_action(tx, context)
-        # You can prevent further processing by returning True
-        # All other return values are ignored
-        if result is True:
+        stop_processing = self._enhanced_before_action(tx, context)
+        if stop_processing is True:
             return 
-        log_debug("starting BackOfficeEvents.beforeAction")
+        logger.debug("starting LamdaHandler.beforeAction")
 
-        postdata = context.postdata()
-        payload = context.payload()
-        args = context.args()
         self.start = time.time()
         self.cognito_user = context.get_cognito_user(self.aws_event)
-        self.current_user = {}  # user data from database
-
-        log_debug("DEBUG: !!! cognito_user", self.cognito_user)
-        # Legacy activity tracking (keep for compatibility) - store summary not full postdata
-        data = {}
-        data["action"] = context.action()
-        data["args"] = json.dumps(args)
-        # Store postdata summary instead of full payload to avoid bloat
-        data["postdata"] = json.dumps(self._summarize_postdata(postdata))
+        self.current_user = {}
+
+        logger.debug("DEBUG: !!! cognito_user %s", self.cognito_user)
         try:
             email_address = self.cognito_user["attributes"]["email"]
             self.session["email_address"] = email_address
-            data["email_address"] = email_address
-        except:
-            pass
-        data.update(self.session)
-        self.logkey = tx.table("aws_api_activity").new(data).pk
+        except Exception:
+            self.logger.warning("Unable to read email from Cognito user", exc_info=True)
+
+        self.logger.info(
+            "Starting action",
+            extra={
+                "action": context.action(),
+                "context_args": context.args(),
+                "summary": self._summarize_postdata(context.postdata()),
+                "session_email": self.session.get("email_address"),
+            },
+        )
 
         row = tx.table(user_table).find(
-            {"email_address": self.session["email_address"]}
+            {"email_address": self.session.get("email_address")}
         )
         if not row:
             raise Exception(
                 "A valid user with permission is required to access this function [DB]"
             )
         self.current_user = row.to_dict()
-        temp = copy.deepcopy(postdata)
+        temp = copy.deepcopy(context.postdata())
         temp["payload"].pop("cognito_user", None)
-        self.log(tx, pprint.pformat(temp), f"Events.OnAction {temp['action']}")
+        self.logger.debug(
+            "Events.OnAction %s",
+            temp.get("action"),
+            extra={"payload": pprint.pformat(temp)},
+        )
 
     def afterAction(self, tx, context):
-        # Enhanced activity tracking
-        
-
-        result = self._enhanced_after_action(tx, context)
-        # You can prevent further processing by returning True
-        # All other return values are ignored
-        if result is True:
+        stop_processing = self._enhanced_after_action(tx, context)
+        if stop_processing is True:
             return
-        
-        log_debug("starting BackOfficeEvents.afterAction")
 
-        # Legacy tracking (keep for compatibility)
+        logger.debug("starting LamdaHandler.afterAction")
+
         self.end = time.time()
-        if hasattr(self, "logkey") and self.logkey:
-            tx.table("aws_api_activity").update(
-                {"duration": self.end - self.start}, self.logkey
-            )
+        self.logger.info(
+            "Completed action",
+            extra={
+                "action": context.action(),
+                "duration": self.end - self.start,
+            },
+        )
 
     def onError(self, tx, context, exc, tb):
-        
-        result = self._enhanced_error_handler(error_tx, context, exc, tb)
-        # You can prevent further processing by returning True
-        # All other return values are ignored
-        if result is True:
+        stop_processing = self._enhanced_error_handler(tx, context, exc, tb)
+        if stop_processing is True:
             return
-        log_debug("starting BackOfficeEvents.aws_api_activity")
-        with engine.transaction() as error_tx:
-            is_production = os.environ.get("USER_BRANCH", "").lower() == "production"
-            request_id = getattr(self.aws_context, "aws_request_id", None)
-            message = f"Unhandled exception for action {context.action()} (request_id={request_id}): {exc}"
-            if is_production:
-                logger.error(message)
-            else:
-                logger.error("%s\n%s", message, tb)
-
-            # Enhanced error handling
-            log_debug("starting BackOfficeEvents.onError")
-
-           
-            # Legacy error handling (keep for compatibility)
-            if hasattr(self, "logkey") and self.logkey:
-                error_tx.table("aws_api_activity").update(
-                    {"exception": exc.__class__.__name__, "traceback": tb}, self.logkey
-                )
-            log_debug("starting BackOfficeEvents.copypayload")
-            temp = copy.deepcopy(context.postdata())
-            log_debug("starting BackOfficeEvents.log")
-            temp["payload"].pop("cognito_user", None)
-            self.log(
-                error_tx,
-                f"{pprint.pformat(temp)}\n\n{tb}\n\n{exc}",
-                f"Events.OnError {temp['action']}",
-            )
-            log_debug("Ending BackOfficeEvents.OnError Done")
+        logger.debug("starting LamdaHandler.aws_api_activity")
+        request_id = getattr(self.aws_context, "aws_request_id", None)
+        self.logger.error(
+            "Unhandled exception for action %s",
+            context.action(),
+            exc_info=exc,
+            extra={"request_id": request_id},
+        )
+
+        logger.debug("starting BackOfficeEvents.onError")
+
+        temp = copy.deepcopy(context.postdata())
+        logger.debug("starting BackOfficeEvents.log")
+        temp["payload"].pop("cognito_user", None)
+        self.logger.error(
+            "Events.OnError %s",
+            temp.get("action"),
+            extra={"payload": pprint.pformat(temp), "traceback": tb},
+        )
+        logger.debug("Ending BackOfficeEvents.OnError Done")
             
     def serve(self, tx):
         response = Response()
@@ -223,7 +166,7 @@ class LambdaHandler(BaseHandler):
             postdata=postdata,
             response=response,
             session=self.session,
-            log=lambda message, function=None: self.log(message, function),
+            log=lambda message, function=None: self.log(tx, message, function),
         )
 
         # Determine action from postdata or query parameters
@@ -268,11 +211,69 @@ class LambdaHandler(BaseHandler):
         except Exception as exc:  # pragma: no cover - best effort logging
             self.log(tx, f"Failed to write tracking record: {exc}", "track")
 
+    def validate(self, user_required=True):
+        if user_required:
+            try:
+                attrs = self.cognito_user["attributes"]
+                assert attrs
+                assert attrs["email"]
+                assert attrs["sub"]
+                assert self.session["sub"]
+                assert self.session["sub"] == attrs["sub"]
+            except:
+                raise Exception("User Authentication Error [Cognito]")
+        else:
+            try:
+                if not self.session["sub"]:
+                    # User is not signed in. If user_required
+                    # is false, then simply return
+                    return
+                attrs = self.cognito_user["attributes"]
+                assert attrs
+                assert attrs["email"]
+                assert attrs["sub"]
+                assert self.session["sub"]
+                assert self.session["sub"] == attrs["sub"]
+            except:
+                raise Exception("User Authentication Error [Cognito]")
+
+    def get_pass_through_vars(self, tx, context):
+        """Get pass-through variables: environment vars, layers, and user data"""
+        temp = context.get_pass_through_vars(tx, self.current_user)
 
-    def OnActionTracking(self, tx, context):
-        self.track(
-            tx,
-            context.payload().get("data", {}),
-            user=context.session(),
-            context_obj=context,
+        logger.debug(
+            "LAYER_DEBUG: vars object contains: %s",
+            list(temp.get("controls", {}).get("vars", {}).keys()),
         )
+        if "layers" in temp.get("controls", {}).get("vars", {}):
+            logger.debug(
+                "LAYER_DEBUG: layers value: %s",
+                temp["controls"]["vars"]["layers"],
+            )
+
+        # Merge with user data from database
+        temp = context.merge_user_data(tx, temp, self.session["email_address"])
+
+        return temp
+
+    def _summarize_postdata(self, postdata):
+        """Extract key fields from postdata for logging without storing entire payload"""
+        if not postdata:
+            return {}
+
+        summary = {
+            "action": postdata.get("action"),
+            "payload_keys": (
+                list(postdata.get("payload", {}).keys())
+                if isinstance(postdata.get("payload"), dict)
+                else None
+            ),
+        }
+
+        # Add size info
+        try:
+            summary["payload_size_bytes"] = len(json.dumps(postdata.get("payload", {})))
+        except:
+            summary["payload_size_bytes"] = 0
+
+        return summary

velocity_python-0.0.171/src/velocity/aws/handlers/mixins/__init__.py

@@ -0,0 +1,10 @@
+"""
+Mixins for AWS Lambda handlers.
+
+This package exposes a single WebHandler mixin that unifies activity tracking,
+logging, and error handling helpers for Lambda handlers.
+"""
+
+from .web_handler import WebHandler
+
+__all__ = ['WebHandler']