Architecture Basics

# --- Python (boto3) ---
import logging
import time
from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeout
 
logger = logging.getLogger("aws.dynamodb")
_executor = ThreadPoolExecutor(max_workers=4)  # bounded pool per dependency
 
def call_with_timeout(fn, *args, timeout_s=3, **kwargs):
    """Run fn(*args, **kwargs) with a hard timeout and structured logging."""
    start = time.monotonic()
    future = _executor.submit(fn, *args, **kwargs)
    try:
        result = future.result(timeout=timeout_s)
        logger.info("call ok", extra={"elapsed_ms": (time.monotonic() - start) * 1000})
        return result
    except FutureTimeout:
        logger.warning("call timed out", extra={"timeout_s": timeout_s})
        raise
    except Exception:
        logger.exception("call failed")
        raise

// --- TypeScript (AWS SDK v3) ---
type AsyncFn<T> = () => Promise<T>;
 
function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T> {
  return Promise.race([
    promise,
    new Promise<T>((_, reject) =>
      setTimeout(() => reject(new Error("call timed out")), timeoutMs)),
  ]);
}
 
export async function callWithTimeout<T>(fn: AsyncFn<T>, timeoutMs = 3000): Promise<T> {
  const start = Date.now();
  try {
    const result = await withTimeout(fn(), timeoutMs);
    console.log(JSON.stringify({ level: "info", msg: "call ok", elapsedMs: Date.now() - start }));
    return result;
  } catch (err) {
    console.warn(JSON.stringify({ level: "warn", msg: "call failed", error: String(err) }));
    throw err;
  }
}

# --- Python (boto3) ---
import boto3
 
ddb = boto3.client("dynamodb", region_name="us-east-1")
 
def get_order(order_id: str):
    return call_with_timeout(
        ddb.get_item,
        TableName="orders",
        Key={"id": {"S": order_id}},
        timeout_s=2,
    )
 
item = get_order("order-42")

// --- TypeScript (AWS SDK v3) ---
import { DynamoDBClient, GetItemCommand } from "@aws-sdk/client-dynamodb";
 
const ddb = new DynamoDBClient({ region: "us-east-1" });
 
async function getOrder(orderId: string) {
  return callWithTimeout(
    () => ddb.send(new GetItemCommand({
      TableName: "orders",
      Key: { id: { S: orderId } },
    })),
    2000,
  );
}
 
const item = await getOrder("order-42");

# --- Python (boto3) ---
from concurrent.futures import ThreadPoolExecutor
 
# Separate bounded pools per dependency - not one shared pool for everything.
dynamodb_pool = ThreadPoolExecutor(max_workers=4)
s3_pool = ThreadPoolExecutor(max_workers=4)

// --- TypeScript (AWS SDK v3) ---
// Node's event loop is single-threaded, so the "pool" here is a concurrency
// limiter per dependency rather than a thread pool - same isolation goal.
class ConcurrencyLimiter {
  private active = 0;
  private queue: (() => void)[] = [];
  constructor(private readonly max: number) {}
 
  async run<T>(fn: () => Promise<T>): Promise<T> {
    if (this.active >= this.max) {
      await new Promise<void>((resolve) => this.queue.push(resolve));
    }
    this.active++;
    try {
      return await fn();
    } finally {
      this.active--;
      this.queue.shift()?.();
    }
  }
}
 
const dynamoDbLimiter = new ConcurrencyLimiter(4);
const s3Limiter = new ConcurrencyLimiter(4);