Implement retry logic for fetching active Paddle subscriptions and enhance subscription checking in the App component

Author: Bharani0012

src/backend/base/langflow/api/v1/billing.py

@@ -1,5 +1,3 @@
-import asyncio
-
 from fastapi import APIRouter, HTTPException
 from langflow.services.auth.clerk_metadata_constants import PADDLE_SUBSCRIPTION_ID_KEY
 from lfx.log.logger import logger
@@ -18,9 +16,11 @@
 from langflow.services.paddle.provisioning import get_paddle_prices
 from langflow.services.paddle.subscriptions import (
     ensure_paddle_customer_for_user,
+    fetch_active_subscription,
     get_subscriptions_by_customer_id,
     has_active_subscription,
     pick_active_subscription,
+    retry_with_backoff,
 )
 
 router = APIRouter(tags=["Billing"], prefix="/billing")
@@ -127,54 +127,34 @@ async def list_paddle_prices():
 async def get_subscriptions_by_customer(
     current_user: CurrentActiveUser,
 ) -> dict:
+
     if not get_settings_service().auth_settings.CLERK_AUTH_ENABLED:
         raise HTTPException(status_code=400, detail="Clerk auth not enabled")
 
     customer_id = await get_paddle_customer_id_from_clerk_payload()
     org_id = get_org_id_from_clerk_payload()
-    organisation_created_by = await get_organisation_created_by_from_clerk_payload()
 
     if not customer_id:
         raise HTTPException(status_code=400, detail="Missing paddle_customer_id")
-
-    # 1️⃣ Fetch subscriptions
-    subscriptions = await get_subscriptions_by_customer_id(
-        customer_id=customer_id
-    )
-
-    if not subscriptions:
-        return {
-            "updated": False,
-            "reason": "no_subscriptions_found",
-        }
-
-    # 2️⃣ Pick active subscription
+    
+    subscriptions = await get_subscriptions_by_customer_id(customer_id)
     active_sub_id = pick_active_subscription(subscriptions, org_id=org_id)
-    retry_attempts = 3
-    retry_delay_seconds = 3
-
     if not active_sub_id:
-        for attempt in range(retry_attempts):
-            logger.info(
-                "No active subscription found on initial lookup, retrying %s/%s after %ss",
-                attempt + 1,
-                retry_attempts,
-                retry_delay_seconds,
+        try:
+            active_sub_id, subscriptions = await retry_with_backoff(
+                lambda: fetch_active_subscription(customer_id, org_id),
+                retries=3,
+                base_delay=2,
+                max_delay=5,
+                retry_exceptions=(ValueError,),  # retry only for this
             )
-            await asyncio.sleep(retry_delay_seconds)
-            subscriptions = await get_subscriptions_by_customer_id(customer_id=customer_id)
-            active_sub_id = pick_active_subscription(subscriptions, org_id=org_id)
-            if active_sub_id:
-                break
-
-    logger.info(f"Active subscription id: {active_sub_id}")
 
-    if not active_sub_id:
-        return {
-            "updated": False,
-            "reason": "no_active_subscription",
-            "subscriptions": subscriptions,
-        }
+        except ValueError:
+            return {
+                "updated": False,
+                "reason": "no_active_subscription",
+                "subscriptions": subscriptions,
+            }
 
     # 3️⃣ Update Clerk org metadata
     await update_clerk_organization(

src/backend/base/langflow/services/paddle/subscriptions.py

@@ -4,7 +4,8 @@
 
 import asyncio
 import re
-from typing import Any
+from typing import Callable, Any, Awaitable
+import random
 
 from lfx.log.logger import logger
 from paddle_billing import Client  #noqa: TCH002
@@ -375,4 +376,45 @@ def pick_active_subscription(
             status = str(sub.get("status", "")).lower()
             if status in ACTIVE_SUBSCRIPTION_STATUSES and str(sub.get("org_id", "")).strip() == org_id:
                 return sub["id"]
-    return None
+    return None
+
+async def fetch_active_subscription(customer_id, org_id):
+    subs = await get_subscriptions_by_customer_id(customer_id=customer_id)
+    active_id = pick_active_subscription(subs, org_id=org_id)
+
+    if not active_id:
+        raise ValueError("No active subscription yet")
+
+    return active_id, subs
+
+async def retry_with_backoff(
+    func: Callable[[], Awaitable[Any]],
+    retries: int = 3,
+    base_delay: float = 2,
+    max_delay: float = 10,
+    jitter: bool = True,
+    retry_exceptions: tuple = (Exception,),
+) -> Any:
+    last_exception = None
+
+    for attempt in range(retries):
+        try:
+            return await func()
+
+        except retry_exceptions as e:
+            last_exception = e
+
+            delay = min(base_delay * (2 ** attempt), max_delay)
+
+            if jitter:
+                delay += random.uniform(0, 0.5)
+
+            logger.info(
+                "Retry %s/%s failed. Retrying in %.2fs",
+                attempt + 1,
+                retries,
+                delay
+            )
+            await asyncio.sleep(delay)
+
+    raise last_exception

src/frontend/src/App.tsx

@@ -1,6 +1,6 @@
 import { useAuth, useOrganization } from "@clerk/clerk-react";
 import { initializePaddle } from "@paddle/paddle-js";
-import { Suspense, useCallback, useEffect } from "react";
+import { Suspense, useCallback, useEffect, useState } from "react";
 import { RouterProvider } from "react-router-dom";
 import { IS_CLERK_AUTH } from "@/clerk/auth";
 import { api } from "@/controllers/API/api";
@@ -24,6 +24,8 @@ export default function App() {
     ? useAuth()
     : { getToken: async () => null };
 
+  const [isCheckingSubscription, setIsCheckingSubscription] = useState(false);
+
   const fetchPaddleSubscription = useCallback(async () => {
     if (!IS_CLERK_AUTH) {
       console.warn(
@@ -32,6 +34,8 @@ export default function App() {
       return;
     }
 
+    setIsCheckingSubscription(true);
+
     try {
       const clerkToken = await getToken();
 
@@ -92,6 +96,8 @@ export default function App() {
       }
     } catch (error) {
       console.error("Failed to fetch Paddle subscription from backend", error);
+    }finally {
+      setIsCheckingSubscription(false);
     }
   }, [getToken, organization?.id]);
 
@@ -136,8 +142,11 @@ export default function App() {
   }, [fetchPaddleSubscription]);
 
   return (
-    <Suspense fallback={<LoadingPage />}>
-      <RouterProvider router={router} />
-    </Suspense>
+    <>
+      <Suspense fallback={<LoadingPage />}>
+        <RouterProvider router={router} />
+      </Suspense>
+      {isCheckingSubscription && <LoadingPage overlay />}
+    </>
   );
 }