matrice-analytics 0.1.3__py3-none-any.whl → 0.1.31__py3-none-any.whl

matrice_analytics/post_processing/face_reg/face_recognition_client.py

@@ -10,6 +10,8 @@ import os
 import base64
 import logging
 import httpx
+import urllib
+import urllib.request
 from typing import List, Dict, Any, Optional
 from datetime import datetime, timezone
 
@@ -38,6 +40,10 @@ class FacialRecognitionClient:
         if not self.server_id:
             raise ValueError("Server ID is required for Face Recognition Client")
 
+        self.server_info = None
+        self.server_base_url = None
+        self.public_ip = self._get_public_ip()
+
         # Use existing session if provided, otherwise create new one
         if session is not None:
             self.session = session
@@ -70,6 +76,60 @@ class FacialRecognitionClient:
                 self.logger.error(f"Failed to initialize Matrice session: {e}", exc_info=True)
                 raise
 
+        # Fetch server connection info if server_id is provided
+        if self.server_id:
+            try:
+                self.server_info = self.get_server_connection_info()
+                if self.server_info:
+                    self.logger.info(f"Successfully fetched facial recognition server info: {self.server_info.get('name', 'Unknown')}")
+                    # Compare server host with public IP to determine if it's localhost
+                    server_host = self.server_info.get('host', 'localhost')
+                    server_port = self.server_info.get('port', 8081)
+                    
+                    if server_host == self.public_ip:
+                        self.server_base_url = f"http://localhost:{server_port}"
+                        self.logger.warning(f"Server host matches public IP, using localhost: {self.server_base_url}")
+                    else:
+                        self.server_base_url = f"https://{server_host}:{server_port}"
+                        self.logger.warning(f"Facial recognition server base URL: {self.server_base_url}")
+                    
+                    self.session.update(self.server_info.get('projectID', ''))
+                    self.logger.info(f"Updated Matrice session with project ID: {self.server_info.get('projectID', '')}")
+                else:
+                    self.logger.warning("Failed to fetch facial recognition server connection info")
+            except Exception as e:
+                self.logger.error(f"Error fetching facial recognition server connection info: {e}", exc_info=True)
+    
+    def _get_public_ip(self) -> str:
+        """Get the public IP address of this machine."""
+        try:
+            public_ip = urllib.request.urlopen("https://v4.ident.me", timeout=120).read().decode("utf8").strip()
+            self.logger.warning(f"Successfully fetched external IP: {public_ip}")
+            return public_ip
+        except Exception as e:
+            self.logger.error(f"Error fetching external IP: {e}", exc_info=True)
+            return "localhost"
+
+    def get_server_connection_info(self) -> Optional[Dict[str, Any]]:
+        """Fetch server connection info from RPC."""
+        if not self.server_id:
+            return None
+        
+        try:
+            response = self.session.rpc.get(f"/v1/actions/get_facial_recognition_server/{self.server_id}")
+            if response.get("success", False) and response.get("code") == 200:
+                # Response format:
+                # {'success': True, 'code': 200, 'message': 'Success', 'serverTime': '2025-10-21T09:56:14Z',
+                #  'data': {'id': '68f28be1f74ae116727448c4', 'name': 'Local Server', 'host': '68.36.82.163', 'port': 8081, 'status': 'active', 'accountNumber': '3823255831182978487149732',
+                #           'projectID': '68aff0bbce98491879437909', 'region': 'United States', 'isShared': False}}
+                return response.get("data", {})
+            else:
+                self.logger.warning(f"Failed to fetch server info: {response.get('message', 'Unknown error')}")
+                return None
+        except Exception as e:
+            self.logger.error(f"Exception while fetching server connection info: {e}", exc_info=True)
+            return None
+
     async def enroll_staff(self, staff_data: Dict[str, Any], image_paths: List[str]) -> Dict[str, Any]:
         """
         Enroll a new staff member with face images
@@ -95,21 +155,40 @@ class FacialRecognitionClient:
         return await self.enroll_staff_base64(staff_data, base64_images)
 
     async def enroll_staff_base64(self, staff_data: Dict[str, Any], base64_images: List[str]) -> Dict[str, Any]:
-        """Enroll staff with base64 encoded images"""
+        """Enroll staff with base64 encoded images
+        
+        API: POST /v1/facial_recognition/staff/enroll?projectId={projectId}&serverID={serverID}
+        """
 
-        # Prepare enrollment request
+        # Prepare enrollment request matching API spec
         enrollment_request = {
-            "staff_info": staff_data,
+            "staffId": staff_data.get("staffId", ""),
+            "firstName": staff_data.get("firstName", ""),
+            "lastName": staff_data.get("lastName", ""),
+            "email": staff_data.get("email", ""),
+            "position": staff_data.get("position", ""),
+            "department": staff_data.get("department", ""),
             "images": base64_images
         }
 
+        self.logger.info(f"API REQUEST: Enrolling staff with {len(base64_images)} images - Staff ID: {staff_data.get('staffId', 'N/A')}")
+        self.logger.debug(f"Enrollment request payload: {list(enrollment_request.keys())}, num_images={len(base64_images)}")
+
         # Use Matrice session for async RPC call
-        response = await self.session.rpc.async_send_request(
-            method="POST",
-            path=f"/v1/actions/facial_recognition/staff/enroll?serverID={self.server_id}",
-            payload=enrollment_request
-        )
-        return self._handle_response(response)
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="POST",
+                path=f"/v1/facial_recognition/staff/enroll?projectId={self.project_id}&serverID={self.server_id}",
+                payload=enrollment_request,
+                base_url=self.server_base_url
+            )
+            self.logger.info(f"API RESPONSE: Staff enrollment completed - Success: {response.get('success', False)}")
+            if not response.get('success', False):
+                self.logger.warning(f"Staff enrollment failed: {response.get('error', 'Unknown error')}")
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Staff enrollment request failed - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
 
     async def search_similar_faces(self, face_embedding: List[float], 
                            threshold: float = 0.3, limit: int = 10, 
@@ -119,6 +198,8 @@ class FacialRecognitionClient:
         """
         Search for staff members by face embedding vector
         
+        API: POST /v1/facial_recognition/search/similar?projectId={projectId}&serverID={serverID}
+        
         Args:
             face_embedding: Face embedding vector
             collection: Vector collection name
@@ -134,29 +215,67 @@ class FacialRecognitionClient:
             "embedding": face_embedding,
             "collection": collection,
             "threshold": threshold,
-            "limit": limit,
-            "location": location,
-            "timestamp": timestamp
+            "limit": limit
         }
+        
+        # Add optional fields only if provided
+        if location:
+            search_request["location"] = location
+        if timestamp:
+            search_request["timestamp"] = timestamp
+
+        self.logger.debug(f"API REQUEST: Searching similar faces - threshold={threshold}, limit={limit}, collection={collection}, location={location}")
 
         # Use Matrice session for async RPC call
-        response = await self.session.rpc.async_send_request(
-            method="POST",
-            path=f"/v1/actions/facial_recognition/search/similar?serverID={self.server_id}",
-            payload=search_request
-        )
-        return self._handle_response(response)
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="POST",
+                path=f"/v1/facial_recognition/search/similar?projectId={self.project_id}&serverID={self.server_id}",
+                payload=search_request,
+                base_url=self.server_base_url
+            )
+            
+            results_count = 0
+            if response.get('success', False):
+                data = response.get('data', [])
+                results_count = len(data) if isinstance(data, list) else 0
+                self.logger.info(f"API RESPONSE: Face search completed - Found {results_count} matches")
+                if results_count > 0:
+                    self.logger.debug(f"Top match: staff_id={data[0].get('staffId', 'N/A')}, score={data[0].get('score', 0):.3f}")
+            else:
+                self.logger.warning(f"Face search failed: {response.get('error', 'Unknown error')}")
+            
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Face search request failed - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
 
     async def get_staff_details(self, staff_id: str) -> Dict[str, Any]:
-        """Get full staff details by staff ID"""
+        """Get full staff details by staff ID
+        
+        API: GET /v1/facial_recognition/staff/:staffId?projectId={projectId}&serverID={serverID}
+        """
+
+        self.logger.debug(f"API REQUEST: Getting staff details - staff_id={staff_id}")
 
         # Use Matrice session for async RPC call
-        response = await self.session.rpc.async_send_request(
-            method="GET",
-            path=f"/v1/actions/facial_recognition/staff/{staff_id}?serverID={self.server_id}",
-            payload={}
-        )
-        return self._handle_response(response)
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="GET",
+                path=f"/v1/facial_recognition/staff/{staff_id}?projectId={self.project_id}&serverID={self.server_id}",
+                payload={},
+                base_url=self.server_base_url
+            )
+            
+            if response.get('success', False):
+                self.logger.info(f"API RESPONSE: Staff details retrieved successfully - staff_id={staff_id}")
+            else:
+                self.logger.warning(f"Failed to get staff details for staff_id={staff_id}: {response.get('error', 'Unknown error')}")
+            
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Get staff details request failed for staff_id={staff_id} - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
 
     async def store_people_activity(self, 
                                   staff_id: str,
@@ -169,6 +288,8 @@ class FacialRecognitionClient:
         """
         Store people activity data and return response with potential upload URLs
         
+        API: POST /v1/facial_recognition/store_people_activity?projectId={projectId}&serverID={serverID}
+        
         Args:
             staff_id: Staff identifier (empty for unknown faces)
             detection_type: Type of detection (known, unknown, empty)
@@ -189,97 +310,201 @@ class FacialRecognitionClient:
             "location": location,
         }
 
-        # Add optional fields if provided
-        if detection_type == "unknown":
-            if employee_id:
-                activity_request["anonymous_id"] = employee_id
+        # Add optional fields if provided based on API spec
+        if detection_type == "unknown" and employee_id:
+            activity_request["anonymous_id"] = employee_id
         elif detection_type == "known" and employee_id:
             activity_request["employee_id"] = employee_id
-        response = await self.session.rpc.async_send_request(
-            method="POST",
-            path=f"/v1/actions/facial_recognition/store_people_activity?serverID={self.server_id}",
-            payload=activity_request
-        )
-        handled_response = self._handle_response(response)
-        if handled_response.get("success", False):
-            data = handled_response.get("data", {})
-            self.logger.debug(f"Successfully stored {detection_type} activity")
-            if not data:
-                self.logger.warning("No data returned form store people activity")
+        
+        self.logger.info(f"API REQUEST: Storing people activity - type={detection_type}, staff_id={staff_id}, location={location}")
+        self.logger.debug(f"Activity request payload: bbox={bbox}, employee_id={employee_id}")
+        
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="POST",
+                path=f"/v1/facial_recognition/store_people_activity?projectId={self.project_id}&serverID={self.server_id}",
+                payload=activity_request,
+                base_url=self.server_base_url
+            )
+            handled_response = self._handle_response(response)
+            
+            if handled_response.get("success", False):
+                data = handled_response.get("data", {})
+                self.logger.info(f"API RESPONSE: Successfully stored {detection_type} activity for staff_id={staff_id}")
+                if not data:
+                    self.logger.warning(f"No data returned from store people activity for staff_id={staff_id}")
+                    return None
+                return data
+            else:
+                self.logger.warning(f"Failed to store {detection_type} activity: {handled_response.get('error', 'Unknown error')}")
                 return None
-            return data
-        else:
-            self.logger.error(f"Failed to store {detection_type} activity: {handled_response.get('error', 'Unknown error')}")
+        except Exception as e:
+            self.logger.error(f"API ERROR: Store people activity request failed - type={detection_type}, staff_id={staff_id} - {e}", exc_info=True)
             return None
 
     async def update_staff_images(self, image_url: str, employee_id: str) -> Dict[str, Any]:
-        """Update staff images with uploaded image URL"""
+        """Update staff images with uploaded image URL
+        
+        API: PUT /v1/facial_recognition/staff/update_images?projectId={projectId}&serverID={serverID}
+        """
 
         update_request = {
             "imageUrl": image_url,
             "employeeId": employee_id
         }
 
+        self.logger.info(f"API REQUEST: Updating staff images - employee_id={employee_id}")
+        self.logger.debug(f"Update request: image_url={image_url[:50]}...")
+
         # Use Matrice session for async RPC call
-        response = await self.session.rpc.async_send_request(
-            method="PUT",
-            path=f"/v1/actions/facial_recognition/update_staff_images?serverID={self.server_id}",
-            payload=update_request
-        )
-        return self._handle_response(response)
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="PUT",
+                path=f"/v1/facial_recognition/staff/update_images?projectId={self.project_id}&serverID={self.server_id}",
+                payload=update_request,
+                base_url=self.server_base_url
+            )
+            
+            if response.get('success', False):
+                self.logger.info(f"API RESPONSE: Staff images updated successfully - employee_id={employee_id}")
+            else:
+                self.logger.warning(f"Failed to update staff images for employee_id={employee_id}: {response.get('error', 'Unknown error')}")
+            
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Update staff images request failed - employee_id={employee_id} - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
 
     async def upload_image_to_url(self, image_bytes: bytes, upload_url: str) -> bool:
         """Upload image bytes to the provided URL"""
         try:
+            self.logger.info(f"API REQUEST: Uploading image to URL - size={len(image_bytes)} bytes")
+            self.logger.debug(f"Upload URL: {upload_url[:100]}...")
+            
             # Upload the image to the signed URL using async httpx
             headers = {'Content-Type': 'image/jpeg'}
             async with httpx.AsyncClient() as client:
                 response = await client.put(upload_url, content=image_bytes, headers=headers)
 
             if response.status_code in [200, 201]:
-                self.logger.debug(f"Successfully uploaded image to URL")
+                self.logger.info(f"API RESPONSE: Successfully uploaded image - status={response.status_code}")
                 return True
             else:
-                self.logger.error(f"Failed to upload image: {response.status_code} - {response.text}")
+                self.logger.error(f"API ERROR: Failed to upload image - status={response.status_code}, response={response.text[:200]}")
                 return False
 
         except Exception as e:
-            self.logger.error(f"Error uploading image to URL: {e}", exc_info=True)
+            self.logger.error(f"API ERROR: Exception during image upload - {e}", exc_info=True)
             return False
 
     async def shutdown_service(self, action_record_id: Optional[str] = None) -> Dict[str, Any]:
-        """Gracefully shutdown the service"""
+        """Gracefully shutdown the service
+        
+        API: DELETE /v1/facial_recognition/shutdown?projectId={projectId}&serverID={serverID}
+        """
 
         payload = {} if not action_record_id else {"actionRecordId": action_record_id}
 
+        self.logger.info(f"API REQUEST: Shutting down service - action_record_id={action_record_id}")
+
         # Use Matrice session for async RPC call
-        response = await self.session.rpc.async_send_request(
-            method="DELETE",
-            path=f"/v1/actions/facial_recognition/shutdown?serverID={self.server_id}",
-            payload=payload
-        )
-        return self._handle_response(response)
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="DELETE",
+                path=f"/v1/facial_recognition/shutdown?projectId={self.project_id}&serverID={self.server_id}",
+                payload=payload,
+                base_url=self.server_base_url
+            )
+            
+            if response.get('success', False):
+                self.logger.info(f"API RESPONSE: Service shutdown successful")
+            else:
+                self.logger.warning(f"Service shutdown failed: {response.get('error', 'Unknown error')}")
+            
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Shutdown service request failed - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
 
     async def get_all_staff_embeddings(self) -> Dict[str, Any]:
-        """Get all staff embeddings"""
+        """Get all staff embeddings
+        
+        API: GET /v1/facial_recognition/get_all_staff_embeddings?projectId={projectId}&serverID={serverID}
+        """
 
         payload = {}
 
+        self.logger.info(f"API REQUEST: Getting all staff embeddings")
+
         # Use Matrice session for async RPC call
-        response = await self.session.rpc.async_send_request(
-            method="GET",
-            path=f"/v1/actions/facial_recognition/get_all_staff_embeddings?serverID={self.server_id}",
-            payload=payload,
-        )
-        return self._handle_response(response)
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="GET",
+                path=f"/v1/facial_recognition/get_all_staff_embeddings?projectId={self.project_id}&serverID={self.server_id}",
+                payload=payload,
+                base_url=self.server_base_url
+            )
+            
+            embeddings_count = 0
+            if response.get('success', False):
+                data = response.get('data', [])
+                embeddings_count = len(data) if isinstance(data, list) else 0
+                self.logger.info(f"API RESPONSE: Retrieved {embeddings_count} staff embeddings")
+            else:
+                self.logger.warning(f"Failed to get staff embeddings: {response.get('error', 'Unknown error')}")
+            
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Get all staff embeddings request failed - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def update_deployment(self, deployment_id: str) -> Dict[str, Any]:
+        """Update deployment to notify facial recognition server
+        
+        API: PUT /v1/facial_recognition/update_deployment/:deployment_id
+        
+        Args:
+            deployment_id: The deployment ID to update
+            
+        Returns:
+            Dict containing response data
+        """
+        if not deployment_id:
+            self.logger.warning("No deployment_id provided for update_deployment")
+            return {"success": False, "error": "deployment_id is required"}
+
+        self.logger.info(f"API REQUEST: Updating deployment - deployment_id={deployment_id}")
+
+        # Use Matrice session for async RPC call
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="PUT",
+                path=f"/v1/facial_recognition/update_deployment/{deployment_id}",
+                payload={},
+                base_url=self.server_base_url
+            )
+            
+            if response.get('success', False):
+                self.logger.info(f"API RESPONSE: Deployment updated successfully - deployment_id={deployment_id}")
+            else:
+                self.logger.warning(f"Failed to update deployment for deployment_id={deployment_id}: {response.get('error', 'Unknown error')}")
+            
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Update deployment request failed - deployment_id={deployment_id} - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
     
     async def enroll_unknown_person(self, embedding: List[float], image_source: str = None, timestamp: str = None, location: str = None, employee_id: str = None) -> Dict[str, Any]:
-        """Enroll an unknown person"""
+        """Enroll an unknown person
+        
+        API: POST /v1/facial_recognition/enroll_unknown_person?projectId={projectId}&serverID={serverID}
+        """
 
         payload = {
             "embedding": embedding
         }
         
+        # Add optional fields based on API spec
         if image_source:
             payload["imageSource"] = image_source
         if timestamp:
@@ -288,27 +513,52 @@ class FacialRecognitionClient:
             payload["timestamp"] = datetime.now(timezone.utc).isoformat()
         if location:
             payload["location"] = location
-        if employee_id:
-            payload["employeeId"] = employee_id
+
+        self.logger.info(f"API REQUEST: Enrolling unknown person - location={location}")
+        self.logger.debug(f"Unknown enrollment payload: has_embedding={bool(embedding)}, has_image_source={bool(image_source)}")
 
         # Use Matrice session for async RPC call
-        response = await self.session.rpc.async_send_request(
-            method="POST",
-            path=f"/v1/actions/facial_recognition/enroll_unknown_person?serverID={self.server_id}",
-            payload=payload,
-        )
-        return self._handle_response(response)
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="POST",
+                path=f"/v1/facial_recognition/enroll_unknown_person?projectId={self.project_id}&serverID={self.server_id}",
+                payload=payload,
+                base_url=self.server_base_url
+            )
+            
+            if response.get('success', False):
+                self.logger.info(f"API RESPONSE: Unknown person enrolled successfully")
+            else:
+                self.logger.warning(f"Failed to enroll unknown person: {response.get('error', 'Unknown error')}")
+            
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Enroll unknown person request failed - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
 
     async def health_check(self) -> Dict[str, Any]:
         """Check if the facial recognition service is healthy"""
 
+        self.logger.debug(f"API REQUEST: Health check")
+
         # Use Matrice session for async RPC call
-        response = await self.session.rpc.async_send_request(
-            method="GET",
-            path=f"/v1/actions/facial_recognition/health?serverID={self.server_id}",
-            payload={}
-        )
-        return self._handle_response(response)
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="GET",
+                path=f"/v1/facial_recognition/health?serverID={self.server_id}",
+                payload={},
+                base_url=self.server_base_url
+            )
+            
+            if response.get('success', False):
+                self.logger.info(f"API RESPONSE: Service is healthy")
+            else:
+                self.logger.warning(f"Health check failed: {response.get('error', 'Unknown error')}")
+            
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Health check request failed - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
 
     def _handle_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
         """Handle RPC response and errors"""

matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -2,6 +2,7 @@ import asyncio
 import logging
 import time
 import threading
+import queue
 from typing import Dict, Optional, Set
 import numpy as np
 import cv2
@@ -16,8 +17,8 @@ class PeopleActivityLogging:
         self.face_client = face_client
         self.logger = logging.getLogger(__name__)
 
-        # Queue for processing detections in background
-        self.activity_queue = asyncio.Queue()
+        # Use thread-safe queue for cross-thread communication (Python 3.8 compatibility)
+        self.activity_queue = queue.Queue()
 
         # Thread for background processing
         self.processing_thread = None
@@ -75,14 +76,12 @@ class PeopleActivityLogging:
         """Process activity queue continuously"""
         while self.is_running:
             try:
-                # Process queued detections with timeout
+                # Process queued detections with timeout using thread-safe queue
                 try:
-                    activity_data = await asyncio.wait_for(
-                        self.activity_queue.get(), timeout=20
-                    )
+                    activity_data = self.activity_queue.get(timeout=20)
                     await self._process_activity(activity_data)
                     self.activity_queue.task_done()
-                except asyncio.TimeoutError:
+                except queue.Empty:
                     # Continue loop to check for empty detections
                     continue
 
@@ -135,7 +134,8 @@ class PeopleActivityLogging:
             self.last_detection_time = time.time()
             self.empty_detection_logged = False
 
-            await self.activity_queue.put(activity_data)
+            # Use thread-safe put (no await needed for queue.Queue)
+            self.activity_queue.put(activity_data)
         except Exception as e:
             self.logger.error(f"Error enqueueing detection: {e}", exc_info=True)
 
@@ -180,14 +180,16 @@ class PeopleActivityLogging:
         
         try:
             if not self.face_client:
+                self.logger.warning("Face client not available for activity logging")
                 return
 
             # Check if we should log this detection (avoid duplicates within time window)
             if not self._should_log_detection(employee_id):
+                self.logger.debug(f"Skipping activity log for employee_id={employee_id} (within cooldown period)")
                 return None
 
             # Store activity data
-            self.logger.info(f"Storing activity data for employee {employee_id}")
+            self.logger.info(f"Processing activity log - type={detection_type}, employee_id={employee_id}, staff_id={staff_id}, location={location}")
             upload_url = await self.face_client.store_people_activity(
                 staff_id=staff_id,
                 detection_type=detection_type,
@@ -198,28 +200,33 @@ class PeopleActivityLogging:
             )
 
             if upload_url:
-                self.logger.debug("Successfully stored activity log and fetched upload URL")
+                self.logger.info(f"Activity log stored successfully, upload URL received for employee_id={employee_id}")
                 await self._upload_frame(current_frame, upload_url, employee_id)
             else:
-                self.logger.warning("Failed to store activity log")
+                self.logger.warning(f"Failed to store activity log for employee_id={employee_id} - no upload URL returned")
 
             return upload_url
         except Exception as e:
-            self.logger.error(f"Error storing activity log: {e}", exc_info=True)
+            self.logger.error(f"Error processing activity log for employee_id={employee_id}: {e}", exc_info=True)
 
 
     async def _upload_frame(self, current_frame: np.ndarray, upload_url: str, employee_id: str):
-        _, buffer = cv2.imencode(".jpg", current_frame)
-        frame_bytes = buffer.tobytes()
-
-        upload_success = await self.face_client.upload_image_to_url(
-            frame_bytes, upload_url
-        )
+        try:
+            self.logger.debug(f"Encoding frame for upload - employee_id={employee_id}")
+            _, buffer = cv2.imencode(".jpg", current_frame)
+            frame_bytes = buffer.tobytes()
+            
+            self.logger.info(f"Uploading frame to storage - employee_id={employee_id}, size={len(frame_bytes)} bytes")
+            upload_success = await self.face_client.upload_image_to_url(
+                frame_bytes, upload_url
+            )
 
-        if upload_success:
-            self.logger.info(f"Successfully uploaded whole frame for employee {employee_id}")
-        else:
-            self.logger.warning("Failed to upload whole frame")
+            if upload_success:
+                self.logger.info(f"Frame uploaded successfully for employee_id={employee_id}")
+            else:
+                self.logger.warning(f"Failed to upload frame for employee_id={employee_id}")
+        except Exception as e:
+            self.logger.error(f"Error uploading frame for employee_id={employee_id}: {e}", exc_info=True)
 
     async def _should_log_activity(self, activity_data: Dict) -> bool:
         """Check if activity should be logged"""