velocity-python 0.0.195__tar.gz → 0.0.197__tar.gz

{velocity_python-0.0.195 → velocity_python-0.0.197}/PKG-INFO

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

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

{velocity_python-0.0.195 → velocity_python-0.0.197}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.195"
+__version__ = version = "0.0.197"
 
 from . import aws
 from . import db

{velocity_python-0.0.195 → velocity_python-0.0.197}/src/velocity/aws/handlers/base_handler.py

@@ -8,11 +8,11 @@ It includes common functionality shared between LambdaHandler and SqsHandler.
 import logging
 import os
 import sys
-import time
 import traceback
 from typing import Any, Dict, List, Optional
 
 from velocity.aws.handlers import context as VelocityContext
+from velocity.aws.handlers.context_factory import ContextFactory
 logger = logging.getLogger(__name__)
 
 
@@ -28,6 +28,7 @@ class BaseHandler:
         self,
         aws_event: Dict[str, Any],
         aws_context: Any,
+        context_factory: Optional[ContextFactory] = None,
         context_class=VelocityContext.Context,
     ):
         """
@@ -42,10 +43,21 @@ class BaseHandler:
         self.aws_context = aws_context
         self.serve_action_default = True  # Set to False to disable OnActionDefault
         self.skip_action = False  # Set to True to skip all actions
-        self.ContextClass = context_class
-
-        # Configure SSL certificates for HTTPS requests
-        self._update_lambda_ca_certificates()
+        if context_factory is None:
+            context_factory = ContextFactory(context_class=context_class)
+        self.context_factory = context_factory
+        self.context = None
+
+    def create_context(self, *, args, postdata, response, session):
+        self.context = self.context_factory.create(
+            aws_event=self.aws_event,
+            aws_context=self.aws_context,
+            args=args,
+            postdata=postdata,
+            response=response,
+            session=session,
+        )
+        return self.context
 
     def _update_lambda_ca_certificates(self):
         """Configure SSL certificates for HTTPS requests in Lambda environments."""
@@ -131,16 +143,14 @@ class BaseHandler:
         Returns:
             True if an action was executed, False otherwise
         """
-        total_start = time.perf_counter()
+        local_context.perf.start("execute_actions total")
 
         # Execute beforeAction hook if available
         if hasattr(self, "beforeAction"):
-            before_start = time.perf_counter()
+            local_context.perf.start("beforeAction")
             self.beforeAction(tx, local_context)
-            before_elapsed = (time.perf_counter() - before_start) * 1000
-            logger.info(
-                "Timing: beforeAction %.2f ms",
-                before_elapsed,
+            local_context.perf.log(
+                "beforeAction",
                 extra={"action": getattr(local_context, "action", lambda: None)()},
             )
 
@@ -152,13 +162,10 @@ class BaseHandler:
                 break
 
             if hasattr(self, action):
-                action_start = time.perf_counter()
+                local_context.perf.start(action)
                 result = getattr(self, action)(tx, local_context)
-                action_elapsed = (time.perf_counter() - action_start) * 1000
-                logger.info(
-                    "Timing: %s %.2f ms",
+                local_context.perf.log(
                     action,
-                    action_elapsed,
                     extra={"action": getattr(local_context, "action", lambda: None)()},
                 )
                 if result is not None:
@@ -179,8 +186,6 @@ class BaseHandler:
                             diagnostic_info["dataset"] = local_context.dataset()
                     except Exception as e:
                         diagnostic_info["diagnostic_error"] = str(e)
-                        """
-                        Get the list of actions to execute.
                     logger.warning(
                         "Action %s returned an unexpected non-None result (%r).",
                         action,
@@ -192,19 +197,15 @@ class BaseHandler:
 
         # Execute afterAction hook if available
         if hasattr(self, "afterAction"):
-            after_start = time.perf_counter()
+            local_context.perf.start("afterAction")
             self.afterAction(tx, local_context)
-            after_elapsed = (time.perf_counter() - after_start) * 1000
-            logger.info(
-                "Timing: afterAction %.2f ms",
-                after_elapsed,
+            local_context.perf.log(
+                "afterAction",
                 extra={"action": getattr(local_context, "action", lambda: None)()},
             )
 
-        total_elapsed = (time.perf_counter() - total_start) * 1000
-        logger.info(
-            "Timing: execute_actions total %.2f ms",
-            total_elapsed,
+        local_context.perf.log(
+            "execute_actions total",
             extra={"action": getattr(local_context, "action", lambda: None)()},
         )
 

{velocity_python-0.0.195 → velocity_python-0.0.197}/src/velocity/aws/handlers/context.py

@@ -8,6 +8,7 @@ from velocity.misc.format import to_json
 from velocity.misc.merge import deep_merge
 from datetime import datetime
 from velocity.aws.handlers.exceptions import AlertError
+from velocity.aws.handlers.perf import PerfTimer
 from botocore.exceptions import ClientError
 import hashlib
 import velocity
@@ -24,16 +25,16 @@ logger = get_logger("velocity.aws.handlers.context")
 @engine.transaction
 class Context:
 
-    def __init__(
-        self, aws_event, aws_context, args, postdata, response, session, log=None
-    ):
+    def __init__(self, aws_event, aws_context, args, postdata, response, session):
         self.__args = args
         self.__postdata = postdata
         self.__response = response
+        if session is None:
+            session = self._build_session(aws_event)
         self.__session = {} if session is None else session
         self.__aws_event = aws_event
         self.__aws_context = aws_context
-        self.__log = log
+        self.perf = PerfTimer(False, logger)
         self._job_record_cache = {}
         self._job_cancelled_flag = False
         self._feature_flags_cache = None
@@ -81,13 +82,84 @@ class Context:
     def dataset(self):
         return self.payload().get("dataset", {})
 
-    def log(self, message, function=None):
-        if self.__log:
-            return self.__log(message, function)
-        if function:
-            logger.info("%s: %s", function, message)
+    def update_postdata(self, postdata):
+        self.__postdata = postdata
+
+    def parse_postdata(self):
+        body = self.__aws_event.get("body")
+        postdata = {}
+        if isinstance(body, str) and len(body) > 0:
+            try:
+                postdata = json.loads(body)
+            except (json.JSONDecodeError, TypeError):
+                postdata = {"raw_body": body}
+        elif isinstance(body, dict):
+            postdata = body
+        elif isinstance(body, list) and len(body) > 0:
+            try:
+                new = "\n".join(body)
+                postdata = json.loads(new)
+            except (json.JSONDecodeError, TypeError):
+                postdata = {"raw_body": body}
+        return postdata
+
+    def _is_performance_timing_enabled(self, postdata=None) -> bool:
+        if postdata is None:
+            postdata = self.__postdata
+
+        if not isinstance(postdata, dict):
+            return False
+
+        def normalize(val):
+            if isinstance(val, bool):
+                return val
+            if val is None:
+                return False
+            return str(val).strip().lower() in {"true", "1", "yes", "y"}
+
+        if normalize(postdata.get("log_performance_timing")):
+            return True
+        payload = postdata.get("payload")
+        if isinstance(payload, dict) and normalize(payload.get("log_performance_timing")):
+            return True
+        return False
+
+    def configure_perf(self, postdata=None):
+        enabled = self._is_performance_timing_enabled(postdata=postdata)
+        self.perf.set_enabled(enabled)
+        return enabled
+
+    def _build_session(self, aws_event):
+        request_context = aws_event.get("requestContext") or {}
+        identity = request_context.get("identity") or {}
+        headers = aws_event.get("headers") or {}
+        auth = identity.get("cognitoAuthenticationProvider")
+        session = {
+            "authentication_provider": identity.get("cognitoAuthenticationProvider"),
+            "authentication_type": identity.get("cognitoAuthenticationType"),
+            "cognito_user": identity.get("user"),
+            "is_desktop": headers.get("CloudFront-Is-Desktop-Viewer") == "true",
+            "is_mobile": headers.get("CloudFront-Is-Mobile-Viewer") == "true",
+            "is_smart_tv": headers.get("CloudFront-Is-SmartTV-Viewer") == "true",
+            "is_tablet": headers.get("CloudFront-Is-Tablet-Viewer") == "true",
+            "origin": headers.get("origin"),
+            "path": aws_event.get("path"),
+            "referer": headers.get("Referer"),
+            "source_ip": identity.get("sourceIp"),
+            "user_agent": identity.get("userAgent"),
+            "sub": auth.split(":")[-1] if auth else None,
+        }
+        if session.get("is_mobile"):
+            session["device_type"] = "mobile"
+        elif session.get("is_desktop"):
+            session["device_type"] = "desktop"
+        elif session.get("is_tablet"):
+            session["device_type"] = "tablet"
+        elif session.get("is_smart_tv"):
+            session["device_type"] = "smart_tv"
         else:
-            logger.info("%s", message)
+            session["device_type"] = "unknown"
+        return session
 
     def update_job(self, tx, data=None):
         """Update job status and message in aws_job_activity table.
@@ -478,7 +550,7 @@ class Context:
         return None
 
     def get_cognito_user(self, aws_event):
-        overall_start = time.perf_counter()
+        self.perf.start("get_cognito_user total")
         provider = (
             aws_event.get("requestContext", {})
             .get("identity", {})
@@ -504,24 +576,22 @@ class Context:
             raise AlertError("Incomplete Cognito identity provider data") from None
 
         try:
-            admin_start = time.perf_counter()
+            self.perf.start("cognito admin_get_user")
             response = cognito_client.admin_get_user(
                 UserPoolId=user_pool_id,
                 Username=user_sub,
             )
-            admin_elapsed = (time.perf_counter() - admin_start) * 1000
-            logger.info("Timing: cognito admin_get_user %.2f ms", admin_elapsed)
+            self.perf.log("cognito admin_get_user")
             resolved_username = response.get("Username")
         except cognito_client.exceptions.UserNotFoundException:
             try:
-                list_start = time.perf_counter()
+                self.perf.start("cognito list_users")
                 list_response = cognito_client.list_users(
                     UserPoolId=user_pool_id,
                     Filter=f'sub = "{user_sub}"',
                     Limit=1,
                 )
-                list_elapsed = (time.perf_counter() - list_start) * 1000
-                logger.info("Timing: cognito list_users %.2f ms", list_elapsed)
+                self.perf.log("cognito list_users")
             except ClientError as exc:
                 message = exc.response.get("Error", {}).get("Message", "Unknown error")
                 raise AlertError(
@@ -560,8 +630,7 @@ class Context:
             "sub": attributes.get("sub", user_sub),
         }
 
-        overall_elapsed = (time.perf_counter() - overall_start) * 1000
-        logger.info("Timing: get_cognito_user total %.2f ms", overall_elapsed)
+        self.perf.log("get_cognito_user total")
 
         return user
 

velocity_python-0.0.197/src/velocity/aws/handlers/context_factory.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict, Optional, Type
+
+from velocity.aws.handlers import context as VelocityContext
+
+
+class ContextFactory:
+    def __init__(self, context_class: Optional[Type[VelocityContext.Context]] = None):
+        self.context_class = context_class or VelocityContext.Context
+
+    def create(
+        self,
+        *,
+        aws_event: Dict[str, Any],
+        aws_context: Any,
+        args: Dict[str, Any],
+        postdata: Dict[str, Any],
+        response: Any,
+        session: Optional[Dict[str, Any]],
+    ) -> VelocityContext.Context:
+        return self.context_class(
+            aws_event=aws_event,
+            aws_context=aws_context,
+            args=args,
+            postdata=postdata,
+            response=response,
+            session=session,
+        )

{velocity_python-0.0.195 → velocity_python-0.0.197}/src/velocity/aws/handlers/lambda_handler.py

@@ -4,9 +4,10 @@ import logging
 import os
 import pprint
 import time
-from typing import Optional, Type
+from typing import Optional
 
 from velocity.aws.handlers.base_handler import BaseHandler
+from velocity.aws.handlers.context_factory import ContextFactory
 from velocity.aws.handlers.response import Response
 from velocity.logging import configure_logging
 from . import context
@@ -21,44 +22,16 @@ class LambdaHandler(BaseHandler):
         self, 
         aws_event, 
         aws_context, 
-        context_class: Type[context.Context] = context.Context
+        context_factory: Optional[ContextFactory] = None,
+        context_class: type = context.Context,
     ):
         self.start = time.time()
-        super().__init__(aws_event, aws_context, context_class)
-        self.session = self.create_session(aws_event, aws_context)
-            
-    def create_session(self, aws_event, aws_context):
-           # LambdaHandler-specific initialization
-        requestContext = aws_event.get("requestContext") or {}
-        identity = requestContext.get("identity") or {}
-        headers = aws_event.get("headers") or {}
-        auth = identity.get("cognitoAuthenticationProvider")
-        session = {
-            "authentication_provider": identity.get("cognitoAuthenticationProvider"),
-            "authentication_type": identity.get("cognitoAuthenticationType"),
-            "cognito_user": identity.get("user"),
-            "is_desktop": headers.get("CloudFront-Is-Desktop-Viewer") == "true",
-            "is_mobile": headers.get("CloudFront-Is-Mobile-Viewer") == "true",
-            "is_smart_tv": headers.get("CloudFront-Is-SmartTV-Viewer") == "true",
-            "is_tablet": headers.get("CloudFront-Is-Tablet-Viewer") == "true",
-            "origin": headers.get("origin"),
-            "path": aws_event.get("path"),
-            "referer": headers.get("Referer"),
-            "source_ip": identity.get("sourceIp"),
-            "user_agent": identity.get("userAgent"),
-            "sub": auth.split(":")[-1] if auth else None,
-        }
-        if session.get("is_mobile"):
-            session["device_type"] = "mobile"
-        elif session.get("is_desktop"):
-            session["device_type"] = "desktop"
-        elif session.get("is_tablet"):
-            session["device_type"] = "tablet"
-        elif session.get("is_smart_tv"):
-            session["device_type"] = "smart_tv"
-        else:
-            session["device_type"] = "unknown"
-        return session
+        super().__init__(
+            aws_event,
+            aws_context,
+            context_factory=context_factory,
+            context_class=context_class,
+        )
 
 
     def beforeAction(self, tx, context):
@@ -69,16 +42,16 @@ class LambdaHandler(BaseHandler):
         logger.debug("starting LamdaHandler.beforeAction")
 
         
-        cognito_start = time.perf_counter()
+        context.perf.start("get_cognito_user")
         self.cognito_user = context.get_cognito_user(self.aws_event)
-        cognito_elapsed = (time.perf_counter() - cognito_start) * 1000
-        logger.info("Timing: get_cognito_user %.2f ms", cognito_elapsed)
+        context.perf.log("get_cognito_user")
         self.current_user = {}
 
         logger.debug("DEBUG: !!! cognito_user %s", self.cognito_user)
+        session = context.session() or {}
         try:
             email_address = self.cognito_user["attributes"]["email"]
-            self.session["email_address"] = email_address
+            session["email_address"] = email_address
         except Exception:
             logger.warning("Unable to read email from Cognito user", exc_info=True)
 
@@ -88,24 +61,23 @@ class LambdaHandler(BaseHandler):
                 "action": context.action(),
                 "context_args": context.args(),
                 "summary": self._summarize_postdata(context.postdata()),
-                "session_email": self.session.get("email_address"),
+                "session_email": session.get("email_address"),
             },
         )
 
         if not self.user_table:
             logger.warning(
                 "user_table not configured; skipping DB lookup for %s",
-                self.session.get("email_address"),
+                session.get("email_address"),
             )
             raise Exception(
                 "User table not configured; cannot validate user [Config]"
             )
-        lookup_start = time.perf_counter()
+        context.perf.start("user lookup")
         row = tx.table(self.user_table).find(
-            {"email_address": self.session.get("email_address")}
+            {"email_address": session.get("email_address")}
         )
-        lookup_elapsed = (time.perf_counter() - lookup_start) * 1000
-        logger.info("Timing: user lookup %.2f ms", lookup_elapsed)
+        context.perf.log("user lookup")
         if not row:
             raise Exception(
                 "A valid user with permission is required to access this function [DB]"
@@ -163,32 +135,18 @@ class LambdaHandler(BaseHandler):
             
     def serve(self, tx):
         response = Response()
-        body = self.aws_event.get("body")
-        postdata = {}
-        if isinstance(body, str) and len(body) > 0:
-            try:
-                postdata = json.loads(body)
-            except (json.JSONDecodeError, TypeError):
-                postdata = {"raw_body": body}
-        elif isinstance(body, dict):
-            postdata = body
-        elif isinstance(body, list) and len(body) > 0:
-            try:
-                new = "\n".join(body)
-                postdata = json.loads(new)
-            except (json.JSONDecodeError, TypeError):
-                postdata = {"raw_body": body}
-
         req_params = self.aws_event.get("queryStringParameters") or {}
-        local_context = self.ContextClass(
-            aws_event=self.aws_event,
-            aws_context=self.aws_context,
+        local_context = self.create_context(
             args=req_params,
-            postdata=postdata,
+            postdata={},
             response=response,
-            session=self.session,
-            log=lambda message, function=None: self.log(tx, message, function),
+            session=None,
         )
+        local_context.perf.start("parse body")
+        postdata = local_context.parse_postdata()
+        local_context.update_postdata(postdata)
+        local_context.configure_perf(postdata=postdata)
+        local_context.perf.log("parse body")
 
         # Determine action from postdata or query parameters
         action = postdata.get("action") or req_params.get("action")
@@ -197,21 +155,29 @@ class LambdaHandler(BaseHandler):
         actions = self.get_actions_to_execute(action)
         
         # Use BaseHandler's execute_actions method
+        local_context.perf.start("execute_actions total (serve)")
         try:
             self.execute_actions(tx, local_context, actions)
         except Exception as e:
             self.handle_error(tx, local_context, e)
-            
-        return local_context.response().render()
+        local_context.perf.log("execute_actions total (serve)")
+
+        local_context.perf.start("response.render")
+        rendered = local_context.response().render()
+        local_context.perf.log("response.render")
+
+        return rendered
 
     def track(self, tx, data=None, user=None, context_obj=None):
+        context_obj = context_obj or self.context
+        session = context_obj.session() if context_obj else {}
         sanitized_payload = context.sanitize_tracking_payload(data or {})
         sanitized_payload.update(
             {
-                "source_ip": self.session.get("source_ip"),
-                "referer": self.session.get("referer"),
-                "user_agent": self.session.get("user_agent"),
-                "device_type": self.session.get("device_type"),
+                "source_ip": session.get("source_ip"),
+                "referer": session.get("referer"),
+                "user_agent": session.get("user_agent"),
+                "device_type": session.get("device_type"),
             }
         )
 
@@ -220,7 +186,7 @@ class LambdaHandler(BaseHandler):
         if email:
             sanitized_payload["sys_modified_by"] = email
         elif not sanitized_payload.get("sys_modified_by"):
-            sanitized_payload["sys_modified_by"] = self.session.get("email_address") or "system"
+            sanitized_payload["sys_modified_by"] = session.get("email_address") or "system"
 
         if not email:
             raise Exception(f"Tracking email could not be resolved for tracking.")
@@ -233,19 +199,20 @@ class LambdaHandler(BaseHandler):
             self.log(tx, f"Failed to write tracking record: {exc}", "track")
 
     def validate(self, user_required=True):
+        session = self.context.session() if self.context else {}
         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"]
+                assert session["sub"]
+                assert session["sub"] == attrs["sub"]
             except:
                 raise Exception("User Authentication Error [Cognito]")
         else:
             try:
-                if not self.session["sub"]:
+                if not session["sub"]:
                     # User is not signed in. If user_required
                     # is false, then simply return
                     return
@@ -253,8 +220,8 @@ class LambdaHandler(BaseHandler):
                 assert attrs
                 assert attrs["email"]
                 assert attrs["sub"]
-                assert self.session["sub"]
-                assert self.session["sub"] == attrs["sub"]
+                assert session["sub"]
+                assert session["sub"] == attrs["sub"]
             except:
                 raise Exception("User Authentication Error [Cognito]")