Rate limiting

import { auth, spaces } from '@qlik/api';

// Configuration for authentication
const hostConfig = {
    authType: 'apikey',
    host: 'https://<TENANT_HOSTNAME>.<REGION>.qlikcloud.com', // Replace with values for your Qlik Cloud tenant
    apiKey: '<API_KEY>', // Replace with your API key
  };

// Set the default host configuration for all API requests
auth.setDefaultHostConfig(hostConfig);

async function getSpacesWithRetry(maxRetries = 5) {
    // Retry logic for handling rate limits
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
        try {
            console.log(`Attempting to retrieve spaces (attempt ${attempt})`);

            // Get spaces using the high-level spaces.getSpaces function
            const { status, headers, data: mySpaces } = await spaces.getSpaces();

            // Check if HTTP 429 Too Many Requests error occurs
            if (status === 429) {
                if (attempt === maxRetries) {
                    throw new Error(`Max retries reached after ${attempt} attempts due to rate limiting`);
                }

                // Get the number of seconds included in the retry-after header
                const retryAfter = headers['retry-after'];
                const waitTime = retryAfter ? parseInt(retryAfter, 10) * 1000 : 1000; // Default to 1 second if no retry-after header

                console.log(`Rate limit hit. Waiting ${waitTime / 1000} seconds before retrying.`);

                // Wait for the retry-after time before retrying
                await new Promise(resolve => setTimeout(resolve, waitTime));

            } else if (status < 300) {
                // Successful response, return spaces
                return mySpaces;
            } else {
                throw new Error(`Request failed with status: ${status}`);
            }
        } catch (error) {
            if (attempt === maxRetries) throw error; // Throw error if max retries are reached
            console.error(`Error occurred: ${error.message}. Retrying request (attempt ${attempt})...`);
        }
    }
}

// Example usage
async function fetchData() {
    try {
        const mySpaces = await getSpacesWithRetry();
        console.log('Spaces retrieved:', mySpaces);
    } catch (error) {
        console.error('Failed to retrieve spaces:', error.message);
    }
}

fetchData();

import fetch from 'node-fetch';

// Fetch with retry logic for handling rate limits.

async function fetchWithRetry(url, options = {}, maxRetries = 5) {
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
        try {
            console.log(`Attempting request to ${url} (attempt ${attempt})`);

            const response = await fetch(url, options);

            // Check if HTTP 429 Too Many Requests error occurs
            if (response.status === 429) {
                if (attempt === maxRetries) {
                    throw new Error(`Max retries reached after ${attempt} attempts due to rate limiting.`);
                }

                // Get the number of seconds included in the retry-after header
                const retryAfter = response.headers.get('retry-after');
                const waitTime = retryAfter ? parseInt(retryAfter, 10) * 1000 : 1000; // Default to 1 second if no retry-after header

                console.log(`Rate limit hit. Waiting ${waitTime / 1000} seconds before retrying.`);

                // Wait for the retry-after time before retrying
                await new Promise(resolve => setTimeout(resolve, waitTime));

            } else if (response.ok) {
                return await response.json();  // Return successful response
            } else {
                throw new Error(`Request failed with status: ${response.status}`);
            }
        } catch (error) {
            if (attempt === maxRetries) throw error;  // Throw error if the max number of retries is reached
            console.error(`Error occurred: ${error.message}. Retrying request (attempt ${attempt})...`);
        }
    }
}

// Example usage
async function fetchData() {
    const url = 'https://<TENANT_HOSTNAME>.<REGION>.qlikcloud.com/api/v1/<RESOURCE>';  // Replace with the API endpoint URL
    const options = { method: 'GET', headers: { 'Authorization': 'Bearer <YOUR_ACCESS_TOKEN>' } };  // Replace with your access token

    try {
        const data = await fetchWithRetry(url, options);
        console.log('Data retrieved:', data);
    } catch (error) {
        console.error('Failed to retrieve data:', error.message);
    }
}

fetchData();

# Fetch with retry logic for handling rate limits.

function Invoke-FetchWithRetry {
    param (
        [string]$Url,                # The API endpoint URL
        [string]$Method = 'GET',     # HTTP method (default: GET)
        [hashtable]$Headers = @{},   # Headers for the request
        [object]$Body = $null,       # Request body (optional)
        [int]$MaxRetries = 5         # Maximum number of retries
    )

    $attempt = 1     # Track the retry attempt

    while ($attempt -le $MaxRetries) {
        try {
            Write-Host "Attempting request to $Url (attempt $attempt)"

            # Make the HTTP request
            $response = Invoke-RestMethod -Uri $Url -Method $Method -Headers $Headers -Body $Body -ErrorAction Stop -PreserveAuthorizationOnRedirect

            return $response  # Return successful response
        } catch {
            $errorResponse = $_.Exception.Response

            # Check if HTTP 429 Too Many Requests error occurs
            if ($errorResponse.StatusCode -eq 429) {
                if ($attempt -eq $MaxRetries) {
                    throw "Max retries reached after $attempt attempts due to rate limiting."
                }  # Throw error if the max number of retries is reached

                # Get the number of seconds included in the retry-after header
                $retryAfter = $errorResponse.Headers['retry-after']
                $waitTime = if ($retryAfter) { [int]$retryAfter } else { 1 }  # Default to 1 second if no retry-after header
                Write-Host "Rate limit hit. Waiting $waitTime seconds before retrying."

                # Wait for the specified time before retrying
                Start-Sleep -Seconds $waitTime

            } else {
                Write-Host "Error occurred: $_. Retrying request (attempt {$attempt})..."
                throw $_
            }
        }
        $attempt++
    }
}

# Example usage
$Url = "https://<TENANT_HOSTNAME>.<REGION>.qlikcloud.com/api/v1/<RESOURCE>"  # Replace with the API endpoint URL
$Headers = @{
    "Authorization" = "Bearer <YOUR_ACCESS_TOKEN>"  # Replace with your access token
}

try {
    $data = Invoke-FetchWithRetry -Url $Url -Method 'GET' -Headers $Headers
    Write-Host "Data retrieved successfully:" $data
} catch {
    Write-Host "Failed to retrieve data: $_"
}

import requests
import time

def fetch_with_retry(url, method='GET', headers=None, data=None, max_retries=5):
    # Fetch with retry logic for handling rate limits.
    for attempt in range(1, max_retries + 1):
        try:
            print(f"Attempting request to {url} (attempt {attempt})")
            response = requests.request(method, url, headers=headers, json=data)

            # Check if HTTP 429 Too Many Requests error occurs
            if response.status_code == 429:
                if attempt == max_retries:
                    raise Exception(f'Max retries reached after {attempt} attempts due to rate limiting.')

                # Get the number of seconds included in the retry-after header
                retry_after = response.headers.get('retry-after')
                wait_time = int(retry_after) if retry_after else 1  # Default to 1 second if no retry-after header
                print(f"Rate limit hit. Waiting {wait_time} seconds before retrying.")

                # Wait for the specified time before retrying
                time.sleep(wait_time)

            elif response.ok:
                return response.json()  # Return successful response
            else:
                response.raise_for_status()
        except requests.RequestException as e:
            if attempt == max_retries:
                raise e  # Throw error if the max number of retries is reached
            print(f"Error occurred: {e}. Retrying request (attempt {attempt})...")

# Example usage
def fetch_data():
    url = 'https://<TENANT_HOSTNAME>.<REGION>.qlikcloud.com/api/v1/<RESOURCE>'  # Replace with the API endpoint URL
    headers = { 'Authorization': 'Bearer <YOUR_ACCESS_TOKEN>' }  # Replace with your access token

    try:
        data = fetch_with_retry(url, headers=headers)
        print("Data retrieved:", data)
    except Exception as e:
        print(f"Failed to retrieve data: {e}")

fetch_data()