How to fix CursorNotFound: cursor id not found in MongoDB

// Node.js MongoDB driver
const cursor = db.collection("largeCollection")
  .find(query)
  .noCursorTimeout(true);

try {
  await cursor.forEach(doc => {
    // Process each document (can take > 10 minutes total)
    processDocument(doc);
  });
} finally {
  // CRITICAL: Always close cursor manually when using noCursorTimeout
  await cursor.close();
}

// Mongoose with noCursorTimeout
const cursor = Model.find(query)
  .cursor({ noCursorTimeout: true });

for await (const doc of cursor) {
  await processDocument(doc);
}
await cursor.close();

// Default batch size is 101 for initial batch, then 16MB limit
// Set explicit batch size
const cursor = db.collection("data")
  .find(query)
  .batchSize(1000); // Fetch 1000 documents per batch

await cursor.forEach(doc => {
  processDocument(doc);
});

// Aggregation with batch size
const cursor = db.collection("data").aggregate(
  [
    { $match: { status: "pending" } },
    { $sort: { createdAt: -1 } }
  ],
  { batchSize: 500 }
);

// Python pymongo
cursor = collection.find(query).batch_size(1000)
for doc in cursor:
    process_document(doc)

// BAD: Slow processing that may exceed timeout
const cursor = db.collection("data").find(query);
for await (const doc of cursor) {
  await heavyExternalApiCall(doc); // Could take minutes per document
  await complexCalculation(doc);
}

// GOOD: Fast processing with proper batch handling
const cursor = db.collection("data")
  .find(query)
  .batchSize(100);

const batchPromises = [];
for await (const doc of cursor) {
  // Collect documents for parallel processing
  batchPromises.push(processDocumentFast(doc));
  
  // Process in parallel batches of 10
  if (batchPromises.length >= 10) {
    await Promise.all(batchPromises);
    batchPromises.length = 0; // Clear array
  }
}

// Process remaining documents
if (batchPromises.length > 0) {
  await Promise.all(batchPromises);
}

// Process data in pages to avoid cursor timeout
const pageSize = 1000;
let page = 0;
let hasMore = true;

while (hasMore) {
  const documents = await db.collection("data")
    .find(query)
    .sort({ _id: 1 }) // Consistent ordering required
    .skip(page * pageSize)
    .limit(pageSize)
    .toArray();
  
  if (documents.length === 0) {
    hasMore = false;
    break;
  }
  
  // Process this page
  for (const doc of documents) {
    await processDocument(doc);
  }
  
  page++;
  
  // Optional: Add small delay between pages
  await new Promise(resolve => setTimeout(resolve, 100));
}

// BETTER: Use range-based pagination for better performance
let lastId = null;
while (true) {
  const query = lastId ? { _id: { $gt: lastId } } : {};
  const documents = await db.collection("data")
    .find(query)
    .sort({ _id: 1 })
    .limit(pageSize)
    .toArray();
  
  if (documents.length === 0) break;
  
  for (const doc of documents) {
    await processDocument(doc);
  }
  
  lastId = documents[documents.length - 1]._id;
}

// Connection string with readPreference and session options
const client = new MongoClient(uri, {
  readPreference: "primary",
  // Use consistent mongos routing
});

// Use explicit sessions for cursor operations
const session = client.startSession();
try {
  const cursor = db.collection("data")
    .find(query, { session })
    .batchSize(500);
  
  for await (const doc of cursor) {
    processDocument(doc);
  }
} finally {
  await session.endSession();
}

// Connect to MongoDB admin database
use admin

// Check current cursor timeout (milliseconds)
db.adminCommand({ getParameter: 1, cursorTimeoutMillis: 1 })
// Returns: { cursorTimeoutMillis: 600000, ok: 1 } (10 minutes)

// Increase timeout to 30 minutes
db.adminCommand({ 
  setParameter: 1, 
  cursorTimeoutMillis: 1800000 
})

setParameter:
  cursorTimeoutMillis: 1800000

sudo systemctl restart mongod