Debug issue

controllers/log_controller.py

@@ -355,7 +355,7 @@ def classify_log_activities(current_user):
     Extract and classify activities from a log file without creating incidents
     Returns classified activities for the frontend to handle
     """
-    logger.info(f"classify_log_activities called. Files in request: {request.files.keys()}")
+    logger.info(f"Entering classify_log_activities for user {current_user.email}")
     
     if 'file' not in request.files:
         logger.error("No file part in the request")
@@ -372,50 +372,42 @@ def classify_log_activities(current_user):
         return jsonify({'message': 'Only PDF files are allowed'}), 400
     
     try:
-        # Check if OpenAI API key is set
+        logger.info("Checking for OpenAI API key...")
         api_key = os.environ.get('OPENAI_API_KEY')
         if not api_key:
             logger.error("OPENAI_API_KEY environment variable is not set")
             return jsonify({'message': 'OpenAI API key not configured'}), 500
             
-        # Create OpenAI client - removed any proxies parameter
-        client = openai.OpenAI(api_key=api_key)
-        
-        # Read file content
+        logger.info("Reading file content...")
         file_content = file.read()
         logger.info(f"Read {len(file_content)} bytes from file {file.filename}")
         
-        # Extract text from PDF using OCR
-        logger.info(f"Starting OCR for uploaded log")
+        logger.info(f"Starting OCR...")
         extracted_text = pdf_to_text(file_content, is_bytes=True)
-        logger.info(f"Extracted {len(extracted_text)} characters of text")
+        logger.info(f"OCR finished. Extracted {len(extracted_text)} characters.")
         
-        # Extract activities using LLM
-        logger.info(f"Extracting activities from log")
+        logger.info(f"Extracting activities with LLM...")
         activities_json = extract_activities(extracted_text)
+        logger.info(f"Activity extraction finished. Received JSON string of length {len(activities_json)}.")
         
-        # Parse the activities JSON
+        logger.info("Parsing activities JSON...")
         activities_data = json.loads(activities_json)
         activities = activities_data.get('activities', [])
-        logger.info(f"Extracted {len(activities)} activities")
+        logger.info(f"Parsed activities JSON. Found {len(activities)} activities.")
         
-        # Classify each activity against workflows
-        logger.info(f"Classifying activities")
-        
-        # Get all workflows for this department
+        logger.info(f"Fetching workflows for department {current_user.department_id}...")
         workflows = Workflow.find_by_department(current_user.department_id)
+        logger.info(f"Fetched {len(workflows)} workflows.")
         
-        # Skip if no workflows defined
         if not workflows:
-            logger.warning(f"No workflows defined for department {current_user.department_id}")
+            logger.warning(f"No workflows defined for department {current_user.department_id}. Returning early.")
             return jsonify({
                 'message': 'No workflows to classify against',
                 'activities': activities,
                 'classified_activities': [],
-                'extracted_text': extracted_text  # Include the extracted text in the response
+                'extracted_text': extracted_text
             }), 200
         
-        # Prepare workflow information for classification
         workflow_info = []
         for workflow in workflows:
             workflow_info.append({
@@ -423,43 +415,54 @@ def classify_log_activities(current_user):
                 "title": workflow.title,
                 "description": workflow.description
             })
+        logger.info(f"Prepared workflow info for classification: {workflow_info}")
         
-        # Classify each activity
-        classified_activities = []
+        classified_activities_output = []
+        logger.info(f"Starting classification loop for {len(activities)} activities...")
         
-        for activity in activities:
-            # Classify activity against workflows
+        for index, activity in enumerate(activities):
+            logger.info(f"Classifying activity {index + 1}/{len(activities)}: '{activity.get('activity', 'N/A')}'")
+            # classify_activity function now handles its own detailed logging
             workflow_id = classify_activity(activity, workflow_info)
             
-            # Add classification result
+            activity_result = {
+                "activity": activity,
+                "classified": False, # Default to false
+                "workflow_id": None,
+                "workflow_title": None
+            }
+            
             if workflow_id:
                 workflow = next((w for w in workflow_info if w["id"] == workflow_id), None)
-                workflow_title = workflow["title"] if workflow else "Unknown workflow"
-                
-                classified_activities.append({
-                    "activity": activity,
-                    "workflow_id": workflow_id,
-                    "workflow_title": workflow_title,
-                    "classified": True
-                })
+                if workflow:
+                    activity_result["classified"] = True
+                    activity_result["workflow_id"] = workflow_id
+                    activity_result["workflow_title"] = workflow["title"]
+                    logger.info(f"Activity {index + 1} classified as Workflow: {workflow['title']} ({workflow_id})")
+                else:
+                     # This case should be rare now due to checks in classify_activity
+                    logger.warning(f"Activity {index + 1} returned workflow ID {workflow_id} but no matching workflow found in info list.")
             else:
-                classified_activities.append({
-                    "activity": activity,
-                    "classified": False
-                })
+                logger.info(f"Activity {index + 1} classified as mundane.")
+                
+            classified_activities_output.append(activity_result)
         
-        logger.info(f"Classification complete. {len(classified_activities)} activities classified.")
+        logger.info(f"Classification loop finished. Successfully processed {len(classified_activities_output)} activities.")
         
+        # If we reached here, the try block succeeded.
+        logger.info("Successfully processed classification request. Returning 200 OK.")
         return jsonify({
             'message': 'Log activities extracted and classified',
-            'activities': activities,
-            'classified_activities': classified_activities,
+            'activities': activities, # Original activities
+            'classified_activities': classified_activities_output, # Activities with classification results
             'workflows': workflow_info,
-            'extracted_text': extracted_text  # Include the extracted text in the response
+            'extracted_text': extracted_text
         }), 200
         
     except Exception as e:
-        logger.error(f"Error classifying log activities: {str(e)}")
+        # Log the exception *before* returning the 500 response
+        logger.error(f"!!! Unhandled exception in classify_log_activities: {str(e)}")
         import traceback
-        logger.error(traceback.format_exc())
-        return jsonify({'message': f'Error classifying log activities: {str(e)}'}), 500 
+        logger.error(traceback.format_exc()) # Log the full traceback
+        # Return a generic error message, the detailed error is in the logs
+        return jsonify({'message': 'An internal server error occurred during log classification.'}), 500