Update app.py

app.py

@@ -4,42 +4,74 @@ import instaloader
 import requests
 import os
 import time
+import logging
 from functools import wraps
+from typing import Optional
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
 app = FastAPI(title="Instagram Stories API", docs_url=None, redoc_url=None)
 
-# Load Instagram credentials from environment variables
+# Environment variables
 INSTAGRAM_USERNAME = os.getenv('INSTAGRAM_USERNAME')
 INSTAGRAM_PASSWORD = os.getenv('INSTAGRAM_PASSWORD')
 
-# Configure Instaloader with session persistence
-def get_instaloader():
-    L = instaloader.Instaloader()
+# Session file path
+SESSION_FILE = f"/tmp/session-{INSTAGRAM_USERNAME}" if INSTAGRAM_USERNAME else None
+
+def get_instaloader() -> instaloader.Instaloader:
+    """Create and configure Instaloader instance with session management"""
+    L = instaloader.Instaloader(
+        sleep=True,
+        request_timeout=300,
+        max_connection_attempts=3,
+        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    )
     
-    # Try to load existing session
+    if not INSTAGRAM_USERNAME or not INSTAGRAM_PASSWORD:
+        logger.error("Instagram credentials not configured in environment variables")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Server configuration error"
+        )
+
     try:
-        L.load_session_from_file(INSTAGRAM_USERNAME)
-    except FileNotFoundError:
-        # If session doesn't exist, perform login
-        try:
+        if SESSION_FILE and os.path.exists(SESSION_FILE):
+            logger.info(f"Loading session from file: {SESSION_FILE}")
+            L.load_session_from_file(INSTAGRAM_USERNAME, SESSION_FILE)
+        else:
+            logger.info("No session file found, performing fresh login")
             L.login(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD)
-            L.save_session_to_file()
-        except instaloader.exceptions.BadCredentialsException:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid Instagram credentials"
-            )
-        except instaloader.exceptions.TwoFactorAuthRequiredException:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Two-factor authentication required"
-            )
-    
-    # Set request delay to avoid rate limits
-    L.request_timeout = 300
-    L.sleep = True
-    L.delay_seconds = 5  # Minimum 5 seconds between requests
-    
+            if SESSION_FILE:
+                L.save_session_to_file(SESSION_FILE)
+                logger.info(f"Saved new session to: {SESSION_FILE}")
+                
+    except instaloader.exceptions.BadCredentialsException as e:
+        logger.error("Invalid Instagram credentials: %s", str(e))
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid Instagram credentials"
+        )
+    except instaloader.exceptions.ConnectionException as e:
+        logger.error("Instagram connection failed: %s", str(e))
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Instagram service unavailable"
+        )
+    except Exception as e:
+        logger.error("Unexpected error during session creation: %s", str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Internal server error"
+        )
+
+    # Configure rate limiting
+    L.delay_seconds = 10  # Increased delay between requests
     return L
 
 def handle_instagram_errors(func):
@@ -47,81 +79,104 @@ def handle_instagram_errors(func):
     async def wrapper(*args, **kwargs):
         try:
             return await func(*args, **kwargs)
-        except instaloader.exceptions.QueryReturnedBadRequestException:
+        except instaloader.exceptions.QueryReturnedBadRequestException as e:
+            logger.error("Instagram API error (400): %s", str(e))
             raise HTTPException(
                 status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-                detail="Instagram rate limit exceeded - try again later"
+                detail="Too many requests to Instagram - try again later"
             )
-        except instaloader.exceptions.ConnectionException:
+        except instaloader.exceptions.ConnectionException as e:
+            logger.error("Connection error: %s", str(e))
             raise HTTPException(
                 status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Instagram connection failed - try again later"
+                detail="Instagram connection failed"
+            )
+        except instaloader.exceptions.ProfileNotExistsException as e:
+            logger.warning("Profile not found: %s", str(e))
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Profile not found"
             )
-        except instaloader.exceptions.PrivateProfileNotFollowedException:
+        except Exception as e:
+            logger.error("Unexpected error: %s", str(e))
             raise HTTPException(
-                status_code=status.HTTP_403_FORBIDDEN,
-                detail="Cannot access private profile"
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Internal server error"
             )
     return wrapper
 
 @app.get("/stories/{username}")
 @handle_instagram_errors
 async def get_stories(username: str):
-    """Retrieve metadata for Instagram stories (public or private if followed)"""
-    L = get_instaloader()
+    """Retrieve Instagram stories with enhanced logging"""
+    logger.info(f"Received request for stories from @{username}")
     
     try:
+        L = get_instaloader()
+        logger.debug("Instaloader instance created")
+        
+        logger.info(f"Attempting to fetch profile for @{username}")
         profile = instaloader.Profile.from_username(L.context, username)
-    except instaloader.exceptions.ProfileNotExistsException:
-        raise HTTPException(status.HTTP_404_NOT_FOUND, "Profile not found")
-    
-    # Check if we can access stories
-    if not profile.has_public_story and not profile.is_followed_by_viewer:
-        raise HTTPException(
-            status.HTTP_403_FORBIDDEN,
-            "No accessible stories for this profile"
-        )
+        logger.info(f"Successfully retrieved profile: {profile.userid}")
 
-    stories = []
-    try:
-        for story in L.get_stories(userids=[profile.userid]):
-            for item in story.get_items():
-                stories.append({
-                    "id": str(item.mediaid),
-                    "url": item.url,
-                    "type": "video" if item.is_video else "image",
-                    "timestamp": item.date_utc.isoformat(),
-                    "views": item.view_count if item.is_video else None,
-                })
-    except instaloader.exceptions.QueryReturnedNotFoundException:
-        raise HTTPException(
-            status.HTTP_404_NOT_FOUND,
-            "Stories not found or expired"
-        )
+        if not profile.has_public_story and not profile.is_followed_by_viewer:
+            logger.warning(f"No accessible stories for @{username}")
+            raise HTTPException(
+                status.HTTP_403_FORBIDDEN,
+                "No accessible stories for this profile"
+            )
 
-    if not stories:
-        raise HTTPException(
-            status.HTTP_404_NOT_FOUND,
-            "No active stories available"
-        )
+        logger.info(f"Fetching stories for user ID: {profile.userid}")
+        stories = []
+        try:
+            for story in L.get_stories(userids=[profile.userid]):
+                for item in story.get_items():
+                    stories.append({
+                        "id": str(item.mediaid),
+                        "url": item.url,
+                        "type": "video" if item.is_video else "image",
+                        "timestamp": item.date_utc.isoformat(),
+                        "views": item.view_count if item.is_video else None,
+                    })
+                    logger.debug(f"Found story item: {item.mediaid}")
+        except instaloader.exceptions.QueryReturnedNotFoundException as e:
+            logger.error(f"Story query failed: {str(e)}")
+            raise HTTPException(
+                status.HTTP_404_NOT_FOUND,
+                "Stories not found or expired"
+            )
+
+        if not stories:
+            logger.info(f"No active stories found for @{username}")
+            raise HTTPException(
+                status.HTTP_404_NOT_FOUND,
+                "No active stories available"
+            )
 
-    return {"data": stories}
+        logger.info(f"Returning {len(stories)} stories for @{username}")
+        return {"data": stories}
+
+    except Exception as e:
+        logger.error(f"Critical error in get_stories: {str(e)}")
+        raise
 
 @app.get("/download/{media_id}")
 @handle_instagram_errors
 async def download_story(media_id: str, username: str):
-    """Download specific story media by ID"""
-    L = get_instaloader()
+    """Download story media with retry logic"""
+    logger.info(f"Download request for media {media_id} from @{username}")
     
+    L = get_instaloader()
     try:
         profile = instaloader.Profile.from_username(L.context, username)
-    except instaloader.exceptions.ProfileNotExistsException:
-        raise HTTPException(status.HTTP_404_NOT_FOUND, "Profile not found")
+    except Exception as e:
+        logger.error(f"Profile fetch failed for @{username}: {str(e)}")
+        raise
 
-    # Find the story item with retry logic
     story_item = None
-    for _ in range(3):  # Retry up to 3 times
+    for attempt in range(3):
         try:
+            logger.info(f"Searching for media {media_id} (attempt {attempt+1}/3)")
             story_item = next(
                 (item for story in L.get_stories(userids=[profile.userid])
                 for item in story.get_items()
@@ -130,16 +185,20 @@ async def download_story(media_id: str, username: str):
             if story_item:
                 break
         except instaloader.exceptions.QueryReturnedBadRequestException:
-            time.sleep(10)  # Wait 10 seconds before retrying
-    
+            wait_time = (2 ** attempt) * 10  # Exponential backoff
+            logger.warning(f"Rate limited, waiting {wait_time}s before retry")
+            time.sleep(wait_time)
+
     if not story_item:
+        logger.error(f"Media {media_id} not found for @{username}")
         raise HTTPException(status.HTTP_404_NOT_FOUND, "Story not found")
 
     try:
-        # Use Instaloader's context to maintain session cookies
+        logger.info(f"Downloading media from {story_item.url}")
         response = L.context.get(story_item.url, stream=True)
         response.raise_for_status()
-    except requests.exceptions.RequestException:
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Media download failed: {str(e)}")
         raise HTTPException(
             status.HTTP_500_INTERNAL_SERVER_ERROR,
             "Failed to fetch media content"