New Mongoose error suddenly due to MongooseError: Buffering timeout #14388

Sigmaxii · 2024-02-27T15:57:18Z

Prerequisites

I have written a descriptive issue title

Mongoose version

8.2

Node.js version

18.x

MongoDB version

5.x

Operating system

Windows

Operating system version (i.e. 20.04, 11.3, 10)

11

Issue

Error

MongooseError: Operation `autodeletes.findOne()` buffering timed out after 10000ms at Timeout.<anonymous> (C:\Users\alban\documents\github\autodelete-v14\node_modules\mongoose\lib\drivers\node-mongodb-native\collection.js:186:23) at listOnTimeout (node:internal/timers:573:17) at process.processTimers (node:internal/timers:514:7)

What I've done after research :

Restart my vps :clown:
Give access to my IP separately than just have the 0.0.0.0
Try to connect via compass and check if there is any issues (no issues)
Try to find different ways to connect but nothing seemed to do anything.

Right now, I am using mongoose on node.js , I havent touched the code for a while and this cam up yesterday, as a result my app will not work.

the simple way I use to connect :

    if (mongoose.connection.readyState === 0) {
      try {
        console.log(`${ChalkAdvanced.blue('Database: ')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.yellow('connecting...')}`);
        await mongoose.connect(`${mongoUrl}`, { serverSelectionTimeoutMS: 5000 }); // Increased timeout
        if (mongoose.connection.readyState === 1){
        console.log(`${ChalkAdvanced.blue('Database: ')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.green('Successfully connected')}`);
      } else {
        console.log(`STATE OF THE DB HEREEEEEEEEEEEE : ${mongoose.connection.readyState}`)
      } 
      } catch (err) {
        console.error(err);
      }
    } else {
      console.log('Already connected to database.');
    }
  }```

The text was updated successfully, but these errors were encountered:

FaizBShah · 2024-02-27T18:34:17Z

Other than the error, what are the logs its printing? Like, is it printing any of the above logs mentioned in the code? Also, is it working by just doing await mongoose.connect()?

Sigmaxii · 2024-02-27T18:45:09Z

it does console log that its connected, and it always worked, what else should I do. and this is the only error I am getting

FaizBShah · 2024-02-27T18:54:53Z

It looks like the issue is with the code where you are using the findOne() option. Can you share that code? If possible, try to share a reproducible code

Sigmaxii · 2024-02-27T23:18:19Z

const mongoose = require('mongoose');
const mongoUrl = require('../config.js').mongourl;
const { ChalkAdvanced } = require('chalk-advanced');
const schedule = require('node-schedule');

const dataSchema = new mongoose.Schema({
  key: String,
  value: mongoose.Schema.Types.Mixed
});

const Data = mongoose.model('AutoDelete', dataSchema);

class Database {
  constructor() {
    this.db = mongoose.connection;
    this.db.on('error', console.error.bind(console, 'MongoDB connection error:'));
    this.scheduleCleanup('messagesDeleted', '0 0 * * 0'); // Once a week (Sunday)
    this.scheduleCleanup('messagesDeletedMonth', '0 0 1 * *'); // First day of every month
    this.scheduleCleanup('messagesDeletedYear', '0 0 1 1 *'); // First day of every year
  }
  
  
  async connect() {
    if (mongoose.connection.readyState === 0) {
      try {
        console.log(`${ChalkAdvanced.blue('Database: ')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.yellow('connecting...')}`);
        await mongoose.connect(`${mongoUrl}`, { serverSelectionTimeoutMS: 5000 }); // Increased timeout
        if (mongoose.connection.readyState === 1){
        console.log(`${ChalkAdvanced.blue('Database: ')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.green('Successfully connected')}`);
      } else {
        console.log(`STATE OF THE DB HEREEEEEEEEEEEE : ${mongoose.connection.readyState}`)
      } 
      } catch (err) {
        console.error(err);
        throw err;
      }
    } else {
      console.log('Already connected to database.');
    }
  }

  async disconnect() {
    if (mongoose.connection.readyState !== 0) {
      try {
        await mongoose.disconnect();
        console.log(`${ChalkAdvanced.blue('Database: ')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.red('has been disconnected')}`);
      } catch (err) {
        console.error(err);
      }
    } else {
      console.log('Already disconnected from database.');
    }
  }

  async set(key, value) {
    const existingData = await Data.findOne({ key: key }).exec();
  
    if (existingData) {
      existingData.value = { ...existingData.value, ...value };
      await existingData.save();
    } else {
      const newData = new Data({
        key: key,
        value: value
      });
      await newData.save();
    }
  }

  async autodelete(key, value, forceSetToZero = false) {
    const existingData = await Data.findOne({ key: key }).exec();

    if (existingData) {
      if (forceSetToZero) {
        // If forceSetToZero is true, set the value to zero regardless of the existing value
        existingData.value = 0;
      } else if (typeof existingData.value === 'number') {
        // If the existing value is a number, add the new value to it
        existingData.value += value;
      } else {
        // If the existing value is not a number, set it to the new value
        existingData.value = value;
      }

      await existingData.save();
    } else {
      // If the key doesn't exist, create a new document with the specified value
      const newData = new Data({
        key: key,
        value: value
      });

      await newData.save();
    }
  }


  async get(key) {
    const data = await Data.findOne({ key: key }).exec();
    if (data) {
      return data.value;
    } else {
      return undefined;
    }
  }

  async add(key, value) {
    const data = await Data.findOne({ key: key }).exec();
    if (data) {
      data.value += value;
      await data.save();
    } else {
      const newData = new Data({
        key: key,
        value: value
      });
      await newData.save();
    }
  }

  async delete(key) {
    await Data.findOneAndDelete({ key: key }).exec();
  }

  async push(key, values) {
    const data = await Data.findOne({ key: key }).exec();
  
    if (data) {
      // Ensure that 'value' is an object
      if (typeof data.value === 'object') {
        // Check if the specified properties exist in the object
        for (const property in values) {
          if (values.hasOwnProperty(property)) {
            if (!data.value.hasOwnProperty(property)) {
              // If the property doesn't exist, create it as an array
              data.value[property] = [];
            }
  
            // Use $addToSet to add unique values to the array
            await Data.updateOne({ key: key }, { $addToSet: { [`value.${property}`]: values[property] } });
          }
        }
      } else {
        // If 'value' is not an object, create a new object with the specified values
        const newData = new Data({
          key: key,
          value: values
        });
        await newData.save();
      }
    } else {
      // If the key doesn't exist, create a new document with the specified values
      const newData = new Data({
        key: key,
        value: values
      });
      await newData.save();
    }
  }
  
  
  
  
  
  

  async pull(key, value) {
    await Data.updateOne({ key: key }, { $pull: { value: value } });
  }

 
  async remove(key, values) {
    const data = await Data.findOne({ key: key }).exec();
  
    if (data && typeof data.value === 'object') {
      // Ensure that 'value' is an object
      if (typeof data.value === 'object') {
        // Check if the specified properties exist in the object
        for (const property in values) {
          if (values.hasOwnProperty(property)) {
            // Use $pull to remove the specified values from the array
            await Data.updateOne({ key: key }, { $pull: { [`value.${property}`]: values[property] } });
          }
        }
      }
  
      // Save the updated document
      await data.save();
    }
    // If the key doesn't exist or the property doesn't exist, no action is taken
  }
  
  

  async has(key) {
    const data = await Data.findOne({ key: key }).exec();
    if (data) {
      return true;
    } else {
      return false;
    }
  }

  async hasIn(key, value) {
    const hasIn = await this.get(key);
    if (hasIn && hasIn.includes(value)) {
      return true;
    } else {
      return false;
    }
  }
  

  async scheduleCleanup(collectionName, cronExpression) {
    schedule.scheduleJob(cronExpression, async () => {
      await this.delete(collectionName);
      console.log(`${ChalkAdvanced.blue('Database Cleanup:')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.green(`${collectionName} deleted`)}`);
    });
  }
}

module.exports = Database;

Sigmaxii · 2024-02-27T23:18:45Z

const mongoose = require('mongoose');
const mongoUrl = require('../config.js').mongourl;
const { ChalkAdvanced } = require('chalk-advanced');
const schedule = require('node-schedule');

const dataSchema = new mongoose.Schema({
  key: String,
  value: mongoose.Schema.Types.Mixed
});

const Data = mongoose.model('AutoDelete', dataSchema);

class Database {
  constructor() {
    this.db = mongoose.connection;
    this.db.on('error', console.error.bind(console, 'MongoDB connection error:'));
    this.scheduleCleanup('messagesDeleted', '0 0 * * 0'); // Once a week (Sunday)
    this.scheduleCleanup('messagesDeletedMonth', '0 0 1 * *'); // First day of every month
    this.scheduleCleanup('messagesDeletedYear', '0 0 1 1 *'); // First day of every year
  }
  
  
  async connect() {
    if (mongoose.connection.readyState === 0) {
      try {
        console.log(`${ChalkAdvanced.blue('Database: ')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.yellow('connecting...')}`);
        await mongoose.connect(`${mongoUrl}`, { serverSelectionTimeoutMS: 5000 }); // Increased timeout
        if (mongoose.connection.readyState === 1){
        console.log(`${ChalkAdvanced.blue('Database: ')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.green('Successfully connected')}`);
      } else {
        console.log(`STATE OF THE DB HEREEEEEEEEEEEE : ${mongoose.connection.readyState}`)
      } 
      } catch (err) {
        console.error(err);
        throw err;
      }
    } else {
      console.log('Already connected to database.');
    }
  }

  async disconnect() {
    if (mongoose.connection.readyState !== 0) {
      try {
        await mongoose.disconnect();
        console.log(`${ChalkAdvanced.blue('Database: ')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.red('has been disconnected')}`);
      } catch (err) {
        console.error(err);
      }
    } else {
      console.log('Already disconnected from database.');
    }
  }

  async set(key, value) {
    const existingData = await Data.findOne({ key: key }).exec();
  
    if (existingData) {
      existingData.value = { ...existingData.value, ...value };
      await existingData.save();
    } else {
      const newData = new Data({
        key: key,
        value: value
      });
      await newData.save();
    }
  }

  async autodelete(key, value, forceSetToZero = false) {
    const existingData = await Data.findOne({ key: key }).exec();

    if (existingData) {
      if (forceSetToZero) {
        // If forceSetToZero is true, set the value to zero regardless of the existing value
        existingData.value = 0;
      } else if (typeof existingData.value === 'number') {
        // If the existing value is a number, add the new value to it
        existingData.value += value;
      } else {
        // If the existing value is not a number, set it to the new value
        existingData.value = value;
      }

      await existingData.save();
    } else {
      // If the key doesn't exist, create a new document with the specified value
      const newData = new Data({
        key: key,
        value: value
      });

      await newData.save();
    }
  }


  async get(key) {
    const data = await Data.findOne({ key: key }).exec();
    if (data) {
      return data.value;
    } else {
      return undefined;
    }
  }

  async add(key, value) {
    const data = await Data.findOne({ key: key }).exec();
    if (data) {
      data.value += value;
      await data.save();
    } else {
      const newData = new Data({
        key: key,
        value: value
      });
      await newData.save();
    }
  }

  async delete(key) {
    await Data.findOneAndDelete({ key: key }).exec();
  }

  async push(key, values) {
    const data = await Data.findOne({ key: key }).exec();
  
    if (data) {
      // Ensure that 'value' is an object
      if (typeof data.value === 'object') {
        // Check if the specified properties exist in the object
        for (const property in values) {
          if (values.hasOwnProperty(property)) {
            if (!data.value.hasOwnProperty(property)) {
              // If the property doesn't exist, create it as an array
              data.value[property] = [];
            }
  
            // Use $addToSet to add unique values to the array
            await Data.updateOne({ key: key }, { $addToSet: { [`value.${property}`]: values[property] } });
          }
        }
      } else {
        // If 'value' is not an object, create a new object with the specified values
        const newData = new Data({
          key: key,
          value: values
        });
        await newData.save();
      }
    } else {
      // If the key doesn't exist, create a new document with the specified values
      const newData = new Data({
        key: key,
        value: values
      });
      await newData.save();
    }
  }
  
  
  
  
  
  

  async pull(key, value) {
    await Data.updateOne({ key: key }, { $pull: { value: value } });
  }

 
  async remove(key, values) {
    const data = await Data.findOne({ key: key }).exec();
  
    if (data && typeof data.value === 'object') {
      // Ensure that 'value' is an object
      if (typeof data.value === 'object') {
        // Check if the specified properties exist in the object
        for (const property in values) {
          if (values.hasOwnProperty(property)) {
            // Use $pull to remove the specified values from the array
            await Data.updateOne({ key: key }, { $pull: { [`value.${property}`]: values[property] } });
          }
        }
      }
  
      // Save the updated document
      await data.save();
    }
    // If the key doesn't exist or the property doesn't exist, no action is taken
  }
  
  

  async has(key) {
    const data = await Data.findOne({ key: key }).exec();
    if (data) {
      return true;
    } else {
      return false;
    }
  }

  async hasIn(key, value) {
    const hasIn = await this.get(key);
    if (hasIn && hasIn.includes(value)) {
      return true;
    } else {
      return false;
    }
  }
  

  async scheduleCleanup(collectionName, cronExpression) {
    schedule.scheduleJob(cronExpression, async () => {
      await this.delete(collectionName);
      console.log(`${ChalkAdvanced.blue('Database Cleanup:')} ${ChalkAdvanced.gray('>')} ${ChalkAdvanced.green(`${collectionName} deleted`)}`);
    });
  }
}

module.exports = Database;

Sigmaxii · 2024-02-27T23:19:20Z

That is it , and I use the connect here :

const { ShardingManager } = require('discord.js');
const fs = require('fs');
const config = require('./src/config.js');
const { ChalkAdvanced } = require('chalk-advanced');
const manager = new ShardingManager('./main.js', { token: config.token, respawn: true });
const on = require("./website/server.js");
const { Auto } = require('./src/structures/bot.js');
const abot = new Auto();
const Database = require("./src/utils/Database.js");
const db = new Database();
db.connect();
on(abot);
//...

donoftime2018 · 2024-02-28T01:20:41Z

Why not use then() or await/async for where the mongoose connection statement?

Sigmaxii · 2024-02-28T13:38:32Z

Other than the error, what are the logs its printing? Like, is it printing any of the above logs mentioned in the code? Also, is it working by just doing await mongoose.connect()?

the console.logs are printing that its connecting succesfully, and then the error pops, after a few seconds

ghost-dev-gr · 2024-02-28T13:48:03Z

Does the connection appear on the dashboard of mongoose??

Sigmaxii · 2024-02-28T14:22:09Z

Does the connection appear on the dashboard of mongoose??

yes !? (if u mean the metrics on mongodb cloud)

Sigmaxii · 2024-02-28T14:46:45Z

After some testing, indeed findOne gets timed out. but I dont know why tho. findOne is still a function, and I assume that the code is correctly written (which obviously is not since I have this bugs)

FaizBShah · 2024-02-28T15:00:51Z

@Sigmaxii Maybe this stack overflow answer might help you - https://stackoverflow.com/questions/65408618/mongooseerror-operation-users-findone-buffering-timed-out-after-10000ms.

Also, before that, can you allow access from everywhere (0.0.0.0) instead of just your IP address to check whether its not an issue due to your IP or VPS

donoftime2018 · 2024-02-28T15:03:03Z

Are you connecting using 127.0.0.1 or localhost?

vkarpov15 · 2024-02-28T21:35:48Z

Is there any indication that your code called disconnect()?

Also, can you please paste the output of npm list mongoose?

Sigmaxii · 2024-03-01T14:24:43Z

Is there any indication that your code called disconnect()?

Also, can you please paste the output of npm list mongoose?

Currently no, disconnect is not called anywhere, and as mentioned in the description, mongoose version is 8.2

Sigmaxii · 2024-03-02T14:56:00Z

@Sigmaxii Maybe this stack overflow answer might help you - https://stackoverflow.com/questions/65408618/mongooseerror-operation-users-findone-buffering-timed-out-after-10000ms.

Also, before that, can you allow access from everywhere (0.0.0.0) instead of just your IP address to check whether its not an issue due to your IP or VPS

About the stack overflow:
This is not helping since its all about mongoose 5.x
About the IP access:
Yes I do allow access from everywhere thats not the issue

vkarpov15 · 2024-03-05T15:46:34Z

"mentioned in the description, mongoose version is 8.2" <-- I understand, I'm asking for the output of npm list mongoose to rule out multiple versions of Mongoose.

Also, are you connecting to localhost or a remote server?

github-actions · 2024-03-20T00:17:30Z

This issue is stale because it has been open 14 days with no activity. Remove stale label or comment or this will be closed in 5 days

github-actions · 2024-03-25T00:18:56Z

This issue was closed because it has been inactive for 19 days and has been marked as stale.

Sigmaxii added help This issue can likely be resolved in GitHub issues. No bug fixes, features, or docs necessary help wanted labels Feb 27, 2024

vkarpov15 added the needs clarification This issue doesn't have enough information to be actionable. Close after 14 days of inactivity label Feb 28, 2024

github-actions bot added the Stale label Mar 20, 2024

github-actions bot closed this as not planned Won't fix, can't repro, duplicate, stale Mar 25, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

New Mongoose error suddenly due to MongooseError: Buffering timeout #14388

New Mongoose error suddenly due to MongooseError: Buffering timeout #14388

Sigmaxii commented Feb 27, 2024

FaizBShah commented Feb 27, 2024

Sigmaxii commented Feb 27, 2024

FaizBShah commented Feb 27, 2024 •

edited

Loading

Sigmaxii commented Feb 27, 2024

Sigmaxii commented Feb 27, 2024

Sigmaxii commented Feb 27, 2024

donoftime2018 commented Feb 28, 2024

Sigmaxii commented Feb 28, 2024

ghost-dev-gr commented Feb 28, 2024

Sigmaxii commented Feb 28, 2024

Sigmaxii commented Feb 28, 2024

FaizBShah commented Feb 28, 2024

donoftime2018 commented Feb 28, 2024

vkarpov15 commented Feb 28, 2024

Sigmaxii commented Mar 1, 2024

Sigmaxii commented Mar 2, 2024

vkarpov15 commented Mar 5, 2024

github-actions bot commented Mar 20, 2024

github-actions bot commented Mar 25, 2024

New Mongoose error suddenly due to MongooseError: Buffering timeout #14388

New Mongoose error suddenly due to MongooseError: Buffering timeout #14388

Comments

Sigmaxii commented Feb 27, 2024

Prerequisites

Mongoose version

Node.js version

MongoDB version

Operating system

Operating system version (i.e. 20.04, 11.3, 10)

Issue

Error

What I've done after research :

Right now, I am using mongoose on node.js , I havent touched the code for a while and this cam up yesterday, as a result my app will not work.

FaizBShah commented Feb 27, 2024

Sigmaxii commented Feb 27, 2024

FaizBShah commented Feb 27, 2024 • edited Loading

Sigmaxii commented Feb 27, 2024

Sigmaxii commented Feb 27, 2024

Sigmaxii commented Feb 27, 2024

donoftime2018 commented Feb 28, 2024

Sigmaxii commented Feb 28, 2024

ghost-dev-gr commented Feb 28, 2024

Sigmaxii commented Feb 28, 2024

Sigmaxii commented Feb 28, 2024

FaizBShah commented Feb 28, 2024

donoftime2018 commented Feb 28, 2024

vkarpov15 commented Feb 28, 2024

Sigmaxii commented Mar 1, 2024

Sigmaxii commented Mar 2, 2024

vkarpov15 commented Mar 5, 2024

github-actions bot commented Mar 20, 2024

github-actions bot commented Mar 25, 2024

FaizBShah commented Feb 27, 2024 •

edited

Loading