How to fix MongoServerError: TransientTransactionError in MongoDB

async function executeTransactionWithRetry(session, transactionFn, maxRetries = 3) {
  let lastError;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      await transactionFn(session);
      return; // Success
    } catch (error) {
      lastError = error;

      // Check if it's a transient error that can be retried
      if (error.errorLabels && error.errorLabels.includes('TransientTransactionError')) {
        console.log(`TransientTransactionError on attempt ${attempt}, retrying...`);

        // Exponential backoff with jitter
        const delay = Math.min(1000 * Math.pow(2, attempt - 1) + Math.random() * 100, 10000);
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }

      // Not a transient error, rethrow
      throw error;
    }
  }

  // All retries failed
  throw lastError;
}

// Usage
const session = client.startSession();
try {
  await executeTransactionWithRetry(session, async () => {
    await session.withTransaction(async () => {
      // Your transaction operations here
      await collection1.updateOne({ _id: 1 }, { $set: { status: 'updated' } }, { session });
      await collection2.insertOne({ relatedId: 1, data: 'test' }, { session });
    });
  });
} finally {
  await session.endSession();
}

mongodb://host1:27017,host2:27017,host3:27017/dbname?replicaSet=myReplicaSet

const client = new MongoClient(uri, {
     serverSelectionTimeoutMS: 30000,
     socketTimeoutMS: 45000,
     connectTimeoutMS: 30000,
     retryWrites: true,
     retryReads: true
   });

# Connect to any member and run
   rs.status()

# Check MongoDB logs for election activity
   grep -i "election" /var/log/mongodb/mongod.log

const sessionOptions = {
     readConcern: { level: 'local' },
     writeConcern: { w: 'majority' },
     readPreference: 'primary'
   };
   const session = client.startSession(sessionOptions);

# Check current transaction statistics
   db.serverStatus().transactions

   # Monitor in-progress transactions
   db.currentOp({ "active": true, "secs_running": { "$gt": 5 } })

const client = new MongoClient(uri, {
     // Transaction-specific timeouts
     maxPoolSize: 50,
     minPoolSize: 10,
     maxIdleTimeMS: 30000,
     waitQueueTimeoutMS: 10000,

     // Read/Write concern for transactions
     readConcernLevel: 'local',
     writeConcern: 'majority',

     // Retry settings
     retryWrites: true,
     retryReads: true,
     maxStalenessSeconds: 90
   });

# In mongod configuration
   setParameter:
     transactionLifetimeLimitSeconds: 60
     maxTransactionLockRequestTimeoutMillis: 5

const sessionOptions = {
     causalConsistency: false, // Disable for better performance
     defaultTransactionOptions: {
       readConcern: { level: 'local' },
       writeConcern: { w: 'majority', wtimeout: 5000 },
       readPreference: 'primary',
       maxCommitTimeMS: 10000
     }
   };

class TransactionCircuitBreaker {
  constructor(failureThreshold = 5, resetTimeout = 60000) {
    this.failureThreshold = failureThreshold;
    this.resetTimeout = resetTimeout;
    this.failureCount = 0;
    this.lastFailureTime = null;
    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
  }

  async execute(transactionFn) {
    if (this.state === 'OPEN') {
      const timeSinceFailure = Date.now() - this.lastFailureTime;
      if (timeSinceFailure > this.resetTimeout) {
        this.state = 'HALF_OPEN';
      } else {
        throw new Error('Circuit breaker is OPEN - transactions temporarily disabled');
      }
    }

    try {
      const result = await transactionFn();

      // Success - reset circuit breaker if it was HALF_OPEN
      if (this.state === 'HALF_OPEN') {
        this.reset();
      }

      return result;
    } catch (error) {
      this.recordFailure();

      if (this.state === 'HALF_OPEN') {
        this.state = 'OPEN';
        this.lastFailureTime = Date.now();
      }

      throw error;
    }
  }

  recordFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();

    if (this.failureCount >= this.failureThreshold) {
      this.state = 'OPEN';
    }
  }

  reset() {
    this.failureCount = 0;
    this.lastFailureTime = null;
    this.state = 'CLOSED';
  }
}

// Usage
const circuitBreaker = new TransactionCircuitBreaker();

try {
  await circuitBreaker.execute(async () => {
    const session = client.startSession();
    try {
      return await session.withTransaction(async () => {
        // Transaction operations
      });
    } finally {
      await session.endSession();
    }
  });
} catch (error) {
  console.error('Transaction failed:', error.message);
  // Implement fallback logic or alerting
}