fix start_time -> update_time

api/controllers/service_api/wraps.py

@@ -397,19 +397,19 @@ def _async_update_token_last_used_at(auth_token: str, scope: str | None):
     Asynchronously update the last_used_at timestamp for a token.
 
     This schedules a Celery task to update the database without blocking
-    the current request. The start time is passed to ensure only older
+    the current request. The update time is passed to ensure only older
     records are updated, providing natural concurrency control.
     """
     try:
         from tasks.update_api_token_last_used_task import update_api_token_last_used_task
-
-        # Record the request start time for concurrency control
-        start_time = naive_utc_now()
-        start_time_iso = start_time.isoformat()
-
+        
+        # Record the update time for concurrency control
+        update_time = naive_utc_now()
+        update_time_iso = update_time.isoformat()
+        
         # Fire and forget - don't wait for result
-        update_api_token_last_used_task.delay(auth_token, scope, start_time_iso)
-        logger.debug("Scheduled async update for last_used_at (scope: %s, start_time: %s)", scope, start_time_iso)
+        update_api_token_last_used_task.delay(auth_token, scope, update_time_iso)
+        logger.debug("Scheduled async update for last_used_at (scope: %s, update_time: %s)", scope, update_time_iso)
     except Exception as e:
         # Don't fail the request if task scheduling fails
         logger.warning("Failed to schedule last_used_at update task: %s", e)

api/libs/api_token_updater.py

@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 
 
 def update_token_last_used_at(
-    token: str, scope: str | None, start_time: datetime, session: Session | None = None
+    token: str, scope: str | None, update_time: datetime, session: Session | None = None
 ) -> dict:
     """
     Unified method to update API token last_used_at timestamp.
@@ -31,7 +31,7 @@ def update_token_last_used_at(
     Args:
         token: The API token string
         scope: The token type/scope (e.g., 'app', 'dataset')
-        start_time: The request start time (for concurrency control)
+        update_time: The time to use for the update (for concurrency control)
         session: Optional existing session to use (if None, creates new one)
 
     Returns:
@@ -46,8 +46,8 @@ def update_token_last_used_at(
             .where(
                 ApiToken.token == token,
                 ApiToken.type == scope,
-                # Only update if last_used_at is older than start_time
-                (ApiToken.last_used_at.is_(None) | (ApiToken.last_used_at < start_time)),
+                # Only update if last_used_at is older than update_time
+                (ApiToken.last_used_at.is_(None) | (ApiToken.last_used_at < update_time)),
             )
             .values(last_used_at=current_time)
         )
@@ -60,7 +60,7 @@ def update_token_last_used_at(
             return {"status": "updated", "rowcount": rowcount}
         else:
             logger.debug("No update needed for token: %s... (already up-to-date)", token[:10])
-            return {"status": "no_update_needed", "reason": "last_used_at >= start_time"}
+            return {"status": "no_update_needed", "reason": "last_used_at >= update_time"}
 
     try:
         if session:

api/tasks/update_api_token_last_used_task.py

@@ -13,35 +13,35 @@ logger = logging.getLogger(__name__)
 
 
 @shared_task(queue="api_token_update", bind=True)
-def update_api_token_last_used_task(self, token: str, scope: str | None, start_time_iso: str):
+def update_api_token_last_used_task(self, token: str, scope: str | None, update_time_iso: str):
     """
     Asynchronously update the last_used_at timestamp for an API token.
 
     Uses the unified update_token_last_used_at() method to avoid code duplication.
-
+    
     Queue: api_token_update (dedicated queue to isolate from other tasks and
            prevent accumulation in production environment)
 
     Args:
         token: The API token string
         scope: The token type/scope (e.g., 'app', 'dataset')
-        start_time_iso: ISO format timestamp of when the request started
-
+        update_time_iso: ISO format timestamp for the update operation
+    
     Returns:
         Dict with status and metadata
     """
     try:
-        # Parse start_time from ISO format
-        start_time = datetime.fromisoformat(start_time_iso)
-
+        # Parse update_time from ISO format
+        update_time = datetime.fromisoformat(update_time_iso)
+        
         # Use unified update method
-        result = update_token_last_used_at(token, scope, start_time, session=None)
-
+        result = update_token_last_used_at(token, scope, update_time, session=None)
+        
         if result["status"] == "updated":
             logger.info("Updated last_used_at for token (async): %s... (scope: %s)", token[:10], scope)
-
+        
         return result
-
+    
     except Exception as e:
         logger.warning("Failed to update last_used_at for token (async): %s", e)
         return {"status": "failed", "error": str(e)}