feat(content): enhance logging for Gradio client initialization and API calls

backend/api/posts.py

@@ -118,16 +118,10 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
             'error': None
         }
 
-        # Log that the background task has started
-        current_app.logger.info(f"Starting background post generation task for user_id: {user_id}, job_id: {job_id}")
-
         # Generate content using content service
         # Pass the Hugging Face key directly to the service
         content_service = ContentService(hugging_key=hugging_key)
-        current_app.logger.info(f"ContentService created successfully for user_id: {user_id}")
-
         generated_result = content_service.generate_post_content(user_id)
-        current_app.logger.info(f"Content generation completed successfully for user_id: {user_id}, result type: {type(generated_result)}")
 
         # Handle the case where generated_result might be a tuple, list, or string
         # image_data could be bytes (from base64) or a string (URL)
@@ -151,8 +145,6 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
             'error': None
         }
 
-        current_app.logger.info(f"Background task completed for job_id: {job_id}, status set to completed")
-
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"Generate post background task error: {error_message}")
@@ -162,7 +154,6 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
             'result': None,
             'error': error_message
         }
-        current_app.logger.error(f"Background task failed for job_id: {job_id}, error: {error_message}")
 
 @posts_bp.route('/generate', methods=['POST'])
 @jwt_required()

backend/services/content_service.py

@@ -9,6 +9,7 @@ from flask import current_app
 from gradio_client import Client
 from PIL import Image
 import base64
+import logging
 
 class ContentService:
     """Service for AI content generation using Hugging Face models."""
@@ -32,7 +33,58 @@ class ContentService:
                     raise RuntimeError("Hugging Face API key not provided and not available in app config. "
                                        "Please provide the key when initializing ContentService.")
 
-            self.client = Client("Zelyanoth/Linkedin_poster_dev", token=self.hugging_key)
+            try:
+                current_app.logger.info(f"Initializing Gradio client with Hugging Face Space: Zelyanoth/Linkedin_poster_dev")
+                current_app.logger.info(f"Hugging Face API key presence: {bool(self.hugging_key)}")
+            except RuntimeError:
+                # If outside app context, use basic logging
+                logging.info(f"Initializing Gradio client with Hugging Face Space: Zelyanoth/Linkedin_poster_dev")
+                logging.info(f"Hugging Face API key presence: {bool(self.hugging_key)}")
+
+            try:
+                # Check if the Hugging Face Space exists and is accessible before creating the client
+                self.client = Client("Zelyanoth/Linkedin_poster_dev", hf_token=self.hugging_key)
+
+                # Log success using safe approach
+                try:
+                    current_app.logger.info("Gradio client initialized successfully")
+                except RuntimeError:
+                    logging.info("Gradio client initialized successfully")
+
+                # Test if the API endpoint exists
+                try:
+                    # Get the list of available API endpoints to verify the service is available
+                    api_endpoints = self.client.view_api().named_endpoints
+                    if '/poster_linkedin' not in api_endpoints:
+                        try:
+                            current_app.logger.warning("API endpoint '/poster_linkedin' not found in Hugging Face Space")
+                        except RuntimeError:
+                            logging.warning("API endpoint '/poster_linkedin' not found in Hugging Face Space")
+                        raise Exception("Required API endpoint '/poster_linkedin' not available in Hugging Face Space")
+                except Exception as api_check_error:
+                    try:
+                        current_app.logger.warning(f"Could not verify API endpoints: {str(api_check_error)}")
+                    except RuntimeError:
+                        logging.warning(f"Could not verify API endpoints: {str(api_check_error)}")
+
+            except Exception as e:
+                error_msg = f"Failed to initialize Gradio client: {str(e)}"
+
+                # Log error using safe approach
+                try:
+                    current_app.logger.error(error_msg)
+                except RuntimeError:
+                    logging.error(error_msg)
+
+                # Provide more specific error based on the type of failure
+                if "404" in str(e) or "not found" in str(e).lower():
+                    error_msg += " - The Hugging Face Space 'Zelyanoth/Linkedin_poster_dev' may not exist"
+                elif "401" in str(e) or "unauthorized" in str(e).lower() or "invalid token" in str(e).lower():
+                    error_msg += " - The Hugging Face token may be invalid or missing required permissions"
+                elif "timeout" in str(e).lower() or "connection" in str(e).lower() or "network" in str(e).lower():
+                    error_msg += " - Network connectivity issue or timeout"
+
+                raise Exception(error_msg)
 
     def validate_unicode_content(self, content):
         """Validate Unicode content while preserving original formatting and spaces."""
@@ -139,12 +191,22 @@ class ContentService:
             if self.client is None:
                 self._initialize_client()
 
-            current_app.logger.info(f"Calling Gradio API with user_id: {user_id}")
+            try:
+                current_app.logger.info(f"Calling Gradio API with user_id: {user_id}")
+            except RuntimeError:
+                # If outside app context, use basic logging
+                logging.info(f"Calling Gradio API with user_id: {user_id}")
+
             result = self.client.predict(
                 code=user_id,
                 api_name="/poster_linkedin"
             )
-            current_app.logger.info(f"Gradio API response received: {type(result)}")
+
+            try:
+                current_app.logger.info(f"Gradio API response received: {type(result)}")
+            except RuntimeError:
+                # If outside app context, use basic logging
+                logging.info(f"Gradio API response received: {type(result)}")
 
 
             # Handle the case where result might be a tuple from Gradio