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

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

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

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

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

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

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

@@ -5,13 +5,15 @@ 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 time
 import traceback
 from typing import Any, Dict, List, Optional
 
 from velocity.aws.handlers import context as VelocityContext
-from velocity.logging import get_logger
+logger = logging.getLogger(__name__)
 
 
 class BaseHandler:
@@ -22,8 +24,6 @@ class BaseHandler:
     and error handling hooks that can be shared across different handler types.
     """
 
-    logger = get_logger("velocity.aws.handlers.base")
-
     def __init__(
         self,
         aws_event: Dict[str, Any],
@@ -131,9 +131,18 @@ class BaseHandler:
         Returns:
             True if an action was executed, False otherwise
         """
+        total_start = time.perf_counter()
+
         # Execute beforeAction hook if available
         if hasattr(self, "beforeAction"):
+            before_start = time.perf_counter()
             self.beforeAction(tx, local_context)
+            before_elapsed = (time.perf_counter() - before_start) * 1000
+            logger.info(
+                "Timing: beforeAction %.2f ms",
+                before_elapsed,
+                extra={"action": getattr(local_context, "action", lambda: None)()},
+            )
 
         action_executed = False
 
@@ -143,7 +152,15 @@ class BaseHandler:
                 break
 
             if hasattr(self, action):
+                action_start = time.perf_counter()
                 result = getattr(self, action)(tx, local_context)
+                action_elapsed = (time.perf_counter() - action_start) * 1000
+                logger.info(
+                    "Timing: %s %.2f ms",
+                    action,
+                    action_elapsed,
+                    extra={"action": getattr(local_context, "action", lambda: None)()},
+                )
                 if result is not None:
                     # Gather diagnostic information
                     diagnostic_info = {
@@ -162,8 +179,9 @@ class BaseHandler:
                             diagnostic_info["dataset"] = local_context.dataset()
                     except Exception as e:
                         diagnostic_info["diagnostic_error"] = str(e)
-                    
-                    self.logger.warning(
+                        """
+                        Get the list of actions to execute.
+                    logger.warning(
                         "Action %s returned an unexpected non-None result (%r).",
                         action,
                         result,
@@ -174,7 +192,21 @@ class BaseHandler:
 
         # Execute afterAction hook if available
         if hasattr(self, "afterAction"):
+            after_start = time.perf_counter()
             self.afterAction(tx, local_context)
+            after_elapsed = (time.perf_counter() - after_start) * 1000
+            logger.info(
+                "Timing: afterAction %.2f ms",
+                after_elapsed,
+                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,
+            extra={"action": getattr(local_context, "action", lambda: None)()},
+        )
 
         return action_executed
 
@@ -210,7 +242,7 @@ class BaseHandler:
         }
         self._extend_log_data(log_data)
 
-        log_method = getattr(self.logger, level, self.logger.info)
+        log_method = getattr(logger, level, logger.info)
         log_method(
             "%s %s",
             function,
@@ -249,7 +281,7 @@ class BaseHandler:
             f"  - action: {action}\n"
             f"  - handler: {self.__class__.__name__}"
         )
-        self.logger.warning(warning_message)
+        logger.warning(warning_message)
         local_context.response().set_body(
             {"event": self.aws_event, "postdata": local_context.postdata()}
         )

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

@@ -1,6 +1,7 @@
 import json
 import os
 import re
+import time
 import boto3
 import uuid
 from velocity.misc.format import to_json
@@ -477,6 +478,7 @@ class Context:
         return None
 
     def get_cognito_user(self, aws_event):
+        overall_start = time.perf_counter()
         provider = (
             aws_event.get("requestContext", {})
             .get("identity", {})
@@ -502,18 +504,24 @@ class Context:
             raise AlertError("Incomplete Cognito identity provider data") from None
 
         try:
+            admin_start = time.perf_counter()
             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)
             resolved_username = response.get("Username")
         except cognito_client.exceptions.UserNotFoundException:
             try:
+                list_start = time.perf_counter()
                 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)
             except ClientError as exc:
                 message = exc.response.get("Error", {}).get("Message", "Unknown error")
                 raise AlertError(
@@ -552,6 +560,9 @@ 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)
+
         return user
 
     def get_cognito_user_optional(self, aws_event):

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

@@ -1,5 +1,6 @@
 import copy
 import json
+import logging
 import os
 import pprint
 import time
@@ -7,11 +8,11 @@ from typing import Optional, Type
 
 from velocity.aws.handlers.base_handler import BaseHandler
 from velocity.aws.handlers.response import Response
-from velocity.logging import configure_logging, get_logger
+from velocity.logging import configure_logging
 from . import context
 
 configure_logging()
-logger = get_logger("velocity.aws.handlers.lambda")
+logger = logging.getLogger(__name__)
 
 
 class LambdaHandler(BaseHandler):
@@ -68,7 +69,10 @@ class LambdaHandler(BaseHandler):
         logger.debug("starting LamdaHandler.beforeAction")
 
         
+        cognito_start = time.perf_counter()
         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)
         self.current_user = {}
 
         logger.debug("DEBUG: !!! cognito_user %s", self.cognito_user)
@@ -76,9 +80,9 @@ class LambdaHandler(BaseHandler):
             email_address = self.cognito_user["attributes"]["email"]
             self.session["email_address"] = email_address
         except Exception:
-            self.logger.warning("Unable to read email from Cognito user", exc_info=True)
+            logger.warning("Unable to read email from Cognito user", exc_info=True)
 
-        self.logger.info(
+        logger.info(
             "Starting action",
             extra={
                 "action": context.action(),
@@ -89,16 +93,19 @@ class LambdaHandler(BaseHandler):
         )
 
         if not self.user_table:
-            self.logger.warning(
+            logger.warning(
                 "user_table not configured; skipping DB lookup for %s",
                 self.session.get("email_address"),
             )
             raise Exception(
                 "User table not configured; cannot validate user [Config]"
             )
+        lookup_start = time.perf_counter()
         row = tx.table(self.user_table).find(
             {"email_address": self.session.get("email_address")}
         )
+        lookup_elapsed = (time.perf_counter() - lookup_start) * 1000
+        logger.info("Timing: user lookup %.2f ms", lookup_elapsed)
         if not row:
             raise Exception(
                 "A valid user with permission is required to access this function [DB]"
@@ -107,7 +114,7 @@ class LambdaHandler(BaseHandler):
          
         temp = copy.deepcopy(context.postdata())
         temp["payload"].pop("cognito_user", None)
-        self.logger.debug(
+        logger.debug(
             "Events.OnAction %s",
             temp.get("action"),
             extra={"payload": pprint.pformat(temp)},
@@ -121,7 +128,7 @@ class LambdaHandler(BaseHandler):
         logger.debug("starting LamdaHandler.afterAction")
 
         self.end = time.time()
-        self.logger.info(
+        logger.info(
             "Completed action",
             extra={
                 "action": context.action(),
@@ -135,7 +142,7 @@ class LambdaHandler(BaseHandler):
             return
         logger.debug("starting LamdaHandler.aws_api_activity")
         request_id = getattr(self.aws_context, "aws_request_id", None)
-        self.logger.error(
+        logger.error(
             "Unhandled exception for action %s",
             context.action(),
             exc_info=exc,
@@ -147,7 +154,7 @@ class LambdaHandler(BaseHandler):
         temp = copy.deepcopy(context.postdata())
         logger.debug("starting BackOfficeEvents.log")
         temp["payload"].pop("cognito_user", None)
-        self.logger.error(
+        logger.error(
             "Events.OnError %s",
             temp.get("action"),
             extra={"payload": pprint.pformat(temp), "traceback": tb},

{velocity_python-0.0.193 → velocity_python-0.0.195}/src/velocity/aws/handlers/mixins/web_handler.py

@@ -36,6 +36,8 @@ class WebHandler(ABC):
         self.end_time = None
         self.activity_log_key = None
         self.activity_data = {}
+        self._perf_timing_enabled = False
+        self._perf_timing_start = None
 
     # ------------------------------------------------------------------
     # Activity helpers
@@ -43,6 +45,7 @@ class WebHandler(ABC):
 
     def track_activity_start(self, tx, context):
         """Start tracking activity for the current request"""
+        perf_start = time.perf_counter()
         self.start_time = time.time()
 
         postdata = context.postdata()
@@ -73,7 +76,14 @@ class WebHandler(ABC):
         }
 
         try:
+            insert_start = time.perf_counter()
             self.activity_log_key = tx.table("aws_api_activity").new(self.activity_data).pk
+            insert_elapsed = (time.perf_counter() - insert_start) * 1000
+            logger.info(
+                "Timing: aws_api_activity insert %.2f ms",
+                insert_elapsed,
+                extra={"action": context.action(), "handler": self.__class__.__name__},
+            )
         except Exception as exc:
             logger.error(
                 "WebHandler.track_activity_start failed",
@@ -84,6 +94,13 @@ class WebHandler(ABC):
             )
             raise
 
+        total_elapsed = (time.perf_counter() - perf_start) * 1000
+        logger.info(
+            "Timing: track_activity_start total %.2f ms",
+            total_elapsed,
+            extra={"action": context.action(), "handler": self.__class__.__name__},
+        )
+
         return self.activity_log_key
 
     def track_activity_success(self, tx, context):
@@ -132,6 +149,29 @@ class WebHandler(ABC):
 
         return json.dumps(sanitized)
 
+    def _is_performance_timing_enabled(self, context) -> bool:
+        """Check postdata/payload for log_performance_timing=true"""
+        try:
+            postdata = context.postdata() or {}
+        except Exception:
+            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(postdata, dict) else None
+        if isinstance(payload, dict) and normalize(payload.get("log_performance_timing")):
+            return True
+
+        return False
+
     def _recursive_sanitize(self, data: Any, sensitive_fields: List[str]):
         """Recursively remove sensitive fields from nested data structures"""
         if isinstance(data, dict):
@@ -372,15 +412,38 @@ Request Details:
 
     def _enhanced_before_action(self, tx, context):
         """Enhanced beforeAction that adds activity tracking"""
+        self._perf_timing_enabled = self._is_performance_timing_enabled(context)
+        if self._perf_timing_enabled:
+            self._perf_timing_start = time.perf_counter()
+            logger.info(
+                "Performance timing enabled: start action=%s handler=%s",
+                context.action(),
+                self.__class__.__name__,
+            )
         self.track_activity_start(tx, context)
 
     def _enhanced_after_action(self, tx, context):
         """Enhanced afterAction that adds activity tracking"""
         self.track_activity_success(tx, context)
+        if self._perf_timing_enabled and self._perf_timing_start is not None:
+            elapsed_ms = (time.perf_counter() - self._perf_timing_start) * 1000
+            logger.info(
+                "Performance timing end: action=%s handler=%s duration=%.2f ms",
+                context.action(),
+                self.__class__.__name__,
+                elapsed_ms,
+            )
 
     def _enhanced_error_handler(self, tx, context, exc, tb):
         """Enhanced onError that adds standardized error handling"""
-      
+        if self._perf_timing_enabled and self._perf_timing_start is not None:
+            elapsed_ms = (time.perf_counter() - self._perf_timing_start) * 1000
+            logger.info(
+                "Performance timing error: action=%s handler=%s duration=%.2f ms",
+                context.action(),
+                self.__class__.__name__,
+                elapsed_ms,
+            )
 
         self.track_activity_error(tx, context, exc, tb)
         self.log_error_to_system(tx, context, exc, tb)

{velocity_python-0.0.193 → velocity_python-0.0.195}/src/velocity_python.egg-info/PKG-INFO

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