feat(gooddata-pipelines): Add rate militer and use it on workspace backup

Author: benkeanna

gooddata-pipelines/gooddata_pipelines/backup_and_restore/backup_manager.py

@@ -37,6 +37,7 @@
     S3Storage,
 )
 from gooddata_pipelines.logger import LogObserver
+from gooddata_pipelines.utils.rate_limiter import RateLimiter
 
 
 @dataclass
@@ -58,6 +59,11 @@ def __init__(self, host: str, token: str, config: BackupRestoreConfig):
 
         self.loader = BackupInputProcessor(self._api, self.config.api_page_size)
 
+        self._api_rate_limiter = RateLimiter(
+            calls_per_second=self.config.api_calls_per_second,
+            name="GoodData_API_RateLimiter",
+        )
+
     @classmethod
     def create(
         cls: Type["BackupManager"],
@@ -93,11 +99,12 @@ def _get_storage(conf: BackupRestoreConfig) -> BackupStorage:
 
     def get_user_data_filters(self, ws_id: str) -> dict:
         """Returns the user data filters for the specified workspace."""
-        response: requests.Response = self._api.get_user_data_filters(ws_id)
-        if response.ok:
-            return response.json()
-        else:
-            raise RuntimeError(f"{response.status_code}: {response.text}")
+        with self._api_rate_limiter:
+            response: requests.Response = self._api.get_user_data_filters(ws_id)
+            if response.ok:
+                return response.json()
+            else:
+                raise RuntimeError(f"{response.status_code}: {response.text}")
 
     def _store_user_data_filters(
         self,
@@ -142,14 +149,17 @@ def _write_to_yaml(path: str, source: Any) -> None:
 
     def _get_automations_from_api(self, workspace_id: str) -> Any:
         """Returns automations for the workspace as JSON."""
-        response: requests.Response = self._api.get_automations(workspace_id)
-        if response.ok:
-            return response.json()
-        else:
-            raise RuntimeError(
-                f"Failed to get automations for {workspace_id}. "
-                + f"{response.status_code}: {response.text}"
+        with self._api_rate_limiter:
+            response: requests.Response = self._api.get_automations(
+                workspace_id
             )
+            if response.ok:
+                return response.json()
+            else:
+                raise RuntimeError(
+                    f"Failed to get automations for {workspace_id}. "
+                    + f"{response.status_code}: {response.text}"
+                )
 
     def _store_automations(self, export_path: Path, workspace_id: str) -> None:
         """Stores the automations in the specified export path."""
@@ -181,7 +191,8 @@ def store_declarative_filter_views(
     ) -> None:
         """Stores the filter views in the specified export path."""
         # Get the filter views YAML files from the API
-        self._api.store_declarative_filter_views(workspace_id, export_path)
+        with self._api_rate_limiter:
+            self._api.store_declarative_filter_views(workspace_id, export_path)
 
         # Move filter views to the subfolder containing the analytics model
         self._move_folder(
@@ -229,7 +240,10 @@ def _get_workspace_export(
                 # the SDK. That way we could save and package all the declarations
                 # directly instead of reorganizing the folder structures. That should
                 # be more transparent/readable and possibly safer for threading
-                self._api.store_declarative_workspace(workspace_id, export_path)
+                with self._api_rate_limiter:
+                    self._api.store_declarative_workspace(
+                        workspace_id, export_path
+                    )
                 self.store_declarative_filter_views(export_path, workspace_id)
                 self._store_automations(export_path, workspace_id)
 

gooddata-pipelines/gooddata_pipelines/backup_and_restore/constants.py

@@ -25,6 +25,7 @@ class DirNames:
 class ApiDefaults:
     DEFAULT_PAGE_SIZE = 100
     DEFAULT_BATCH_SIZE = 100
+    DEFAULT_API_CALLS_PER_SECOND = 1.0
 
 
 @dataclass(frozen=True)

gooddata-pipelines/gooddata_pipelines/backup_and_restore/models/storage.py

@@ -83,6 +83,13 @@ class BackupRestoreConfig(BaseModel):
             description="Batch size must be greater than 0",
         ),
     ] = Field(default=BackupSettings.DEFAULT_BATCH_SIZE)
+    api_calls_per_second: Annotated[
+        float,
+        Field(
+            gt=0,
+            description="Maximum API calls per second (rate limiting)",
+        ),
+    ] = Field(default=BackupSettings.DEFAULT_API_CALLS_PER_SECOND)
 
     @classmethod
     def from_yaml(cls, conf_path: str) -> "BackupRestoreConfig":

gooddata-pipelines/gooddata_pipelines/utils/__init__.py

@@ -0,0 +1,9 @@
+# (C) 2025 GoodData Corporation
+
+"""
+Utility modules for gooddata-pipelines package.
+"""
+
+from .rate_limiter import RateLimiter
+
+__all__ = ["RateLimiter"]

gooddata-pipelines/gooddata_pipelines/utils/rate_limiter.py

@@ -0,0 +1,93 @@
+# (C) 2025 GoodData Corporation
+
+import time
+import threading
+from typing import Any, Optional
+
+
+class RateLimiter:
+    """
+    A rate limiter that ensures a minimum interval between operations.
+
+    This class can be used to limit the rate of API calls, file operations, or any
+    other operations that need to be throttled to avoid overwhelming external systems.
+    """
+
+    def __init__(
+        self,
+        calls_per_second: float = 1.0,
+        name: Optional[str] = None,
+        logger: Optional[Any] = None,
+    ) -> None:
+        """
+        Initialize the rate limiter.
+
+        Args:
+            calls_per_second: Maximum number of calls allowed per second
+            name: Optional name for logging purposes
+            logger: Optional logger instance for rate limiting messages
+        """
+        if calls_per_second <= 0:
+            raise ValueError("calls_per_second must be greater than 0")
+
+        self.calls_per_second = calls_per_second
+        self.min_interval = 1.0 / calls_per_second
+        self.name = name or "RateLimiter"
+        self.logger = logger
+
+        # Thread-safe tracking of last call time
+        self._lock = threading.Lock()
+        self._last_call_time = 0.0
+
+    def wait_if_needed(self) -> float:
+        """
+        Wait if necessary to maintain the rate limit.
+
+        Returns:
+            The actual time waited (0 if no wait was needed)
+        """
+        with self._lock:
+            current_time = time.time()
+            time_since_last_call = current_time - self._last_call_time
+
+            if time_since_last_call < self.min_interval:
+                sleep_time = self.min_interval - time_since_last_call
+
+                if self.logger:
+                    self.logger.info(
+                        f"{self.name}: Rate limiting active, waiting {sleep_time:.2f} seconds "
+                        f"(limit: {self.calls_per_second} calls/sec)"
+                    )
+
+                time.sleep(sleep_time)
+                self._last_call_time = time.time()
+                return sleep_time
+            else:
+                self._last_call_time = current_time
+                return 0.0
+
+    def __enter__(self) -> "RateLimiter":
+        self.wait_if_needed()
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        pass
+
+    def reset(self) -> None:
+        """Reset the rate limiter state (useful for testing)."""
+        with self._lock:
+            self._last_call_time = 0.0
+
+    @property
+    def time_until_next_call(self) -> float:
+        """
+        Get the time (in seconds) until the next call can be made without waiting.
+        """
+        with self._lock:
+            current_time = time.time()
+            time_since_last_call = current_time - self._last_call_time
+
+            if time_since_last_call < self.min_interval:
+                return self.min_interval - time_since_last_call
+            else:
+                return 0.0

gooddata-pipelines/tests/backup_and_restore/test_backup.py

@@ -3,7 +3,6 @@
 import os
 import shutil
 import tempfile
-import threading
 from pathlib import Path
 from unittest import mock
 
@@ -325,7 +324,6 @@ def test_process_batch_success(
 
     backup_manager._process_batch(
         batch=batch,
-        stop_event=threading.Event(),
         retry_count=0,
     )
 
@@ -362,7 +360,6 @@ def fail_once(*args, **kwargs):
 
     backup_manager._process_batch(
         batch=batch,
-        stop_event=threading.Event(),
     )
 
     assert get_workspace_export_mock.call_count == 2
@@ -392,7 +389,6 @@ def test_process_batch_raises_after_max_retries(
     with pytest.raises(Exception) as exc_info:
         backup_manager._process_batch(
             batch=batch,
-            stop_event=threading.Event(),
             retry_count=BackupSettings.MAX_RETRIES,
         )
     assert str(exc_info.value) == "fail"