How to fix TransactionInProgressException: The transaction with the given request token is already in progress in DynamoDB

// AWS SDK v3 (JavaScript/TypeScript)
import { DynamoDBClient, TransactWriteItemsCommand } from "@aws-sdk/client-dynamodb";
import { randomUUID } from "crypto";

const client = new DynamoDBClient({});

async function submitTransaction(items) {
  // Generate a UNIQUE token for each attempt, don't reuse
  const requestToken = randomUUID();

  const command = new TransactWriteItemsCommand({
    TransactItems: items,
    ClientRequestToken: requestToken // Each attempt gets a new token
  });

  try {
    const response = await client.send(command);
    console.log("Transaction succeeded:", response);
    return response;
  } catch (error) {
    if (error.name === "TransactionInProgressException") {
      // DO NOT retry with the same token
      // Instead, either wait and retry with a new token, or fail
      console.error("Transaction still in progress, please retry later with a new token");
      throw error;
    }
    throw error;
  }
}

# AWS SDK (Python/boto3)
import uuid
import boto3
from botocore.exceptions import ClientError

dynamodb = boto3.client('dynamodb')

def submit_transaction(transact_items):
    # Generate a unique token for each attempt
    request_token = str(uuid.uuid4())

    try:
        response = dynamodb.transact_write_items(
            TransactItems=transact_items,
            ClientRequestToken=request_token
        )
        print("Transaction succeeded")
        return response
    except ClientError as e:
        if e.response['Error']['Code'] == 'TransactionInProgressException':
            # Do not retry with the same token
            print("Transaction in progress, retry with a new token later")
            raise
        raise

// AWS SDK v3 configuration with proper timeouts
const client = new DynamoDBClient({
  maxAttempts: 3,
  retryStrategy: new DefaultRetryStrategy(
    3, // max attempts
    (attempt) => {
      // Exponential backoff: 100ms, 200ms, 400ms
      return Math.min(Math.pow(2, attempt) * 100, 1000);
    }
  )
});

// For individual transactions, ensure socket timeout is set appropriately
const command = new TransactWriteItemsCommand({
  TransactItems: items,
  ClientRequestToken: randomUUID()
});

const response = await Promise.race([
  client.send(command),
  new Promise((_, reject) =>
    setTimeout(() => reject(new Error("Transaction timeout")), 30000) // 30 second timeout
  )
]);

# AWS SDK v3 configuration (Python/boto3)
import boto3
from botocore.config import Config

# Configure proper retry settings
config = Config(
    max_pool_connections=50,
    retries={
        'max_attempts': 3,
        'mode': 'adaptive'
    },
    connect_timeout=5,
    read_timeout=60  # 60 second read timeout for transactions
)

dynamodb = boto3.client('dynamodb', config=config)

def submit_transaction_with_timeout(transact_items):
    import time
    start_time = time.time()
    timeout_seconds = 30

    while time.time() - start_time < timeout_seconds:
        try:
            response = dynamodb.transact_write_items(
                TransactItems=transact_items,
                ClientRequestToken=str(uuid.uuid4())
            )
            return response
        except ClientError as e:
            if e.response['Error']['Code'] == 'TransactionInProgressException':
                time.sleep(1)  # Wait before retrying with new token
                continue
            raise

    raise TimeoutError("Transaction did not complete within timeout")

// BAD: Multiple instances using the same hardcoded token
const GLOBAL_TOKEN = "my-fixed-token"; // Don't do this!

// GOOD: Each instance generates unique tokens
import { randomUUID } from "crypto";

class TransactionManager {
  constructor() {
    this.instanceId = randomUUID(); // Unique per instance
  }

  async executeTransaction(items) {
    // Combine instance ID with timestamp for uniqueness
    const requestToken = `${this.instanceId}-${Date.now()}-${Math.random()}`;

    const command = new TransactWriteItemsCommand({
      TransactItems: items,
      ClientRequestToken: requestToken
    });

    return this.client.send(command);
  }
}

const manager = new TransactionManager();

# Better token strategy for distributed systems
import uuid
from datetime import datetime

class TransactionManager:
    def __init__(self, instance_id=None):
        self.instance_id = instance_id or str(uuid.uuid4())

    def generate_request_token(self):
        """Generate a globally unique request token"""
        timestamp = datetime.utcnow().isoformat()
        random_part = str(uuid.uuid4())
        return f"{self.instance_id}-{timestamp}-{random_part}"

    def submit_transaction(self, transact_items):
        request_token = self.generate_request_token()

        response = dynamodb.transact_write_items(
            TransactItems=transact_items,
            ClientRequestToken=request_token
        )
        return response

// AWS SDK v3 with proper DynamoDB transaction settings
const client = new DynamoDBClient({
  requestHandler: new NodeHttpHandler({
    connectionTimeout: 5000,       // 5 seconds to establish connection
    socketTimeout: 30000,          // 30 seconds for socket operations
    requestTimeout: 60000,         // 60 seconds total request timeout
    abortSignal: AbortSignal.timeout(60000)
  }),
  maxAttempts: 3,
  retryStrategy: new AdaptiveRetryStrategy(3)
});

// For JavaScript SDK v2 (if still in use)
const dynamodb = new AWS.DynamoDB({
  maxRetries: 3,
  httpOptions: {
    timeout: 60000,
    connectTimeout: 5000
  }
});

# Proper configuration for boto3
from botocore.config import Config

config = Config(
    connect_timeout=5,
    read_timeout=60,
    retries={
        'max_attempts': 3,
        'mode': 'adaptive'
    }
)

dynamodb = boto3.client('dynamodb', config=config)

# AWS recommends:
# clientExecutionTimeout >= 5 seconds (allow one retry to complete)
# socketTimeout < requestTimeout (detect stalled sockets)
# For transactions, set these to at least 30-60 seconds

// Example: Token cache with expiration
class TokenCache {
  constructor(ttlMs = 10 * 60 * 1000) { // 10 minutes
    this.cache = new Map();
    this.ttlMs = ttlMs;
  }

  canReuse(token) {
    const entry = this.cache.get(token);
    if (!entry) return false;

    const age = Date.now() - entry.createdAt;
    return age < this.ttlMs;
  }

  recordToken(token) {
    this.cache.set(token, { createdAt: Date.now() });
  }

  cleanExpired() {
    const now = Date.now();
    for (const [token, entry] of this.cache.entries()) {
      if (now - entry.createdAt > this.ttlMs) {
        this.cache.delete(token);
      }
    }
  }
}

const tokenCache = new TokenCache();

// When retrying:
// - Within 10 minutes: can reuse same token for exact same request
// - After 10 minutes: must use new token
// - Different request: must use new token even within 10 minutes

// Instrumentation for token tracking
class InstrumentedTransactionManager {
  constructor() {
    this.tokenLog = new Map();
  }

  async executeTransaction(items, options = {}) {
    const requestToken = randomUUID();
    const timestamp = Date.now();

    // Log token usage
    if (this.tokenLog.has(requestToken)) {
      console.warn(`WARNING: Token ${requestToken} reused at ${new Date(timestamp).toISOString()}`);
    }
    this.tokenLog.set(requestToken, {
      timestamp,
      itemCount: items.length,
      status: 'PENDING'
    });

    try {
      const result = await client.send(
        new TransactWriteItemsCommand({
          TransactItems: items,
          ClientRequestToken: requestToken
        })
      );

      this.tokenLog.set(requestToken, {
        ...this.tokenLog.get(requestToken),
        status: 'SUCCESS',
        completedAt: Date.now()
      });

      return result;
    } catch (error) {
      this.tokenLog.set(requestToken, {
        ...this.tokenLog.get(requestToken),
        status: 'FAILED',
        error: error.name,
        completedAt: Date.now()
      });

      // Send to monitoring (CloudWatch, DataDog, etc.)
      if (error.name === 'TransactionInProgressException') {
        console.error(`Token ${requestToken} caused TransactionInProgressException`);
        // This indicates incorrect retry logic
      }

      throw error;
    }
  }

  getTokenStats() {
    // Analyze patterns: token reuse, failure rates, timing
    return Array.from(this.tokenLog.entries()).map(([token, data]) => ({
      token,
      ...data
    }));
  }
}