​

Connection Optimization for API Calls

​

HTTP Connection Pooling

• How it Works: Instead of closing a connection after a request-response cycle, the connection is kept open and returned to a pool. Subsequent requests to the same host can reuse a connection from this pool, bypassing the handshake overhead.
• Benefits:
  • Reduced latency for API calls.
  • Lower CPU usage on both your server and Mubarokah ID’s servers.
• Implementation: Most modern HTTP client libraries in various languages support connection pooling by default or through configuration.
  • Node.js: The built-in http.Agent and https.Agent use connection pooling. Libraries like axios use these agents. You can configure maxSockets on the agent.
  • Python: Libraries like requests (with Session objects) and httpx manage connection pools automatically. You can often configure pool size and other parameters.
  • Java: Apache HttpClient, OkHttp, and Java’s built-in HttpClient (Java 11+) all support robust connection pooling.
  • PHP: Guzzle (when using cURL handlers) can leverage cURL’s connection caching features. Ensure your PHP environment and cURL are configured to allow persistent connections if appropriate for your execution model (e.g., long-running workers vs. short PHP-FPM requests).

import http from 'http';
import https from 'https';

// Configure global HTTP/HTTPS agents for connection pooling
const httpAgent = new http.Agent({
  keepAlive: true,
  maxSockets: 100, // Max sockets per host
  maxFreeSockets: 10,
  timeout: 60000, // Active socket timeout
  freeSocketTimeout: 30000 // Free socket timeout before closing
});

const httpsAgent = new https.Agent({
  keepAlive: true,
  maxSockets: 100,
  maxFreeSockets: 10,
  timeout: 60000,
  freeSocketTimeout: 30000
});

// If using axios, you can pass these agents during instance creation
import axios from 'axios';
const apiClient = axios.create({
  baseURL: 'https://accounts.mubarokah.com',
  httpAgent: httpAgent, // For http requests
  httpsAgent: httpsAgent // For https requests
});

​

HTTP Keep-Alive

• How it’s Enabled: Typically controlled by the Connection: Keep-Alive header (for HTTP/1.0) or by default in HTTP/1.1 and HTTP/2.
• Benefits: Similar to pooling – reduces latency and overhead.
• Client Responsibility: Your HTTP client needs to support and enable keep-alive. Most modern clients do this by default for HTTP/1.1.

​

Request Deduplication & Short-Circuiting

• Problem: In some application flows, your code might inadvertently trigger multiple identical API requests in rapid succession (e.g., fetching user profile multiple times during a single page load).
• Solution (Client-Side or Server-Side Logic):
  • Implement a mechanism to detect if an identical request is already in flight.
  • If so, instead of issuing a new network call, subscribe to the result of the ongoing request.
  • This can be managed with promises or similar async patterns.

class OptimizedOAuthClient {
  private ongoingRequests: Map<string, Promise<any>> = new Map();

  private generateRequestKey(method: string, url: string, params?: any): string {
    return `${method}:${url}:${JSON.stringify(params || {})}`;
  }

  async makeRequest(method: string, url: string, params?: any, data?: any): Promise<any> {
    const requestKey = this.generateRequestKey(method, url, params);

    if (this.ongoingRequests.has(requestKey)) {
      console.log(`Deduplicating request: ${requestKey}`);
      return this.ongoingRequests.get(requestKey);
    }

    const requestPromise = this.executeActualRequest(method, url, params, data)
      .finally(() => {
        this.ongoingRequests.delete(requestKey); // Clean up after request completes
      });

    this.ongoingRequests.set(requestKey, requestPromise);
    return requestPromise;
  }

  private async executeActualRequest(method: string, url: string, params?: any, data?: any): Promise<any> {
    // Actual HTTP client call (e.g., using axios or fetch)
    const response = await this.httpClient.request({ method, url, params, data });
    return response.data;
    console.log(`Executing actual request: ${method} ${url}`);
    return Promise.resolve({ mockData: "data for " + url }); // Placeholder
  }
}

const client = new OptimizedOAuthClient();
client.makeRequest('GET', 'https://accounts.mubarokah.com/api/user', { id: 123 });
client.makeRequest('GET', 'https://accounts.mubarokah.com/api/user', { id: 123 }); // This one would be deduplicated

​

Timeouts and Retries

• Connection Timeouts: Set a reasonable timeout for establishing a connection to Mubarokah ID’s servers.
• Request/Response Timeouts: Set a timeout for the entire request-response cycle.
• Retry Mechanisms:
  • Implement retries for idempotent requests (like GET requests for user info) that fail due to transient network errors or specific HTTP status codes (e.g., 502 Bad Gateway, 503 Service Unavailable, 504 Gateway Timeout).
  • Use an exponential backoff strategy for retries (e.g., wait 1s, then 2s, then 4s) to avoid overwhelming the server.
  • Limit the number of retries.
  • Do not retry non-idempotent requests (like POST to /oauth/token with an authorization code) automatically unless you are certain it's safe and the failure was due to a network blip before the request was processed. Replaying a token exchange with the same auth code might lead to errors if the code was already consumed.

async function exchangeCodeForTokensWithRetry(code, redirectUri, attempt = 1) {
  const MAX_RETRIES = 3;
  const INITIAL_BACKOFF_MS = 1000;

  try {
    // const response = await httpClient.post('https://accounts.mubarokah.com/oauth/token', { ... });
    // return response.data;
    throw new Error("Simulated network error"); // For example
  } catch (error) {
    // Check if error is retryable (e.g., network error, specific 5xx status codes)
    const isRetryable = error.isNetworkError || (error.response && error.response.status >= 500);

    if (isRetryable && attempt <= MAX_RETRIES) {
      const backoffTime = INITIAL_BACKOFF_MS * Math.pow(2, attempt - 1);
      console.log(`Attempt \${attempt} failed. Retrying in \${backoffTime}ms...`);
      await new Promise(resolve => setTimeout(resolve, backoffTime));
      return exchangeCodeForTokensWithRetry(code, redirectUri, attempt + 1);
    } else {
      console.error(`Request failed after \${attempt} attempts or error not retryable.`);
      throw error; // Re-throw the last error
    }
  }
}

​

Other Considerations

• HTTP/2 or HTTP/3: If Mubarokah ID’s servers support HTTP/2 or HTTP/3, and your client library does as well, these newer protocols offer multiplexing and other features that can improve connection efficiency over HTTP/1.1.
• DNS Caching: Ensure your server or application environment correctly caches DNS lookups to avoid repeated DNS resolution overhead for accounts.mubarokah.com. This is usually handled by the OS or your runtime environment.
• Payload Size: While not strictly connection optimization, sending smaller request payloads (e.g., only necessary JSON fields) and preferring concise response formats can reduce transfer time. Mubarokah ID APIs should be designed with this in mind.