Mongoose: कॉलबैक बंद हो रहा है

क्या आप किसी स्टैंडअलोन, रेप्लिका सेट या शार्प किए गए क्लस्टर से कनेक्ट हो रहे हैं? साथ ही, क्या आप पुष्टि कर सकते हैं कि आप एसएसएल का उपयोग कर रहे हैं?

पिछले कुछ दिनों से यह मेरे लिए बहुत बड़ी समस्या रही है। चलने वाला प्रत्येक एप्लिकेशन धीमे और धीमे ईवेंट लूप के साथ समाप्त हुआ, जिससे पूरे सिस्टम में विलंबता बढ़ गई। नोड अनुप्रयोगों को फिर से शुरू करने से हर बार समस्या का समाधान हो जाता है, यह या तो मिनटों या घंटों के संचालन के बाद वापस आ जाता है।

नेवला 4.5.10 पर वापस जाने से समस्या हल हो गई।

• प्रतिकृति सेट से जुड़ना
• एसएसएल का उपयोग करना

4.6.0 के साथ भी इसी तरह की समस्या, मुझे यकीन नहीं है कि मैं एक प्रतिकृति सेट से कनेक्ट कर रहा हूं या नहीं, लेकिन निश्चित रूप से एसएसएल का उपयोग कर रहा हूं।

FWIW, 4.6.0 लगातार कनेक्शन छोड़ रहा था। 4.5.10 अच्छा है।

@djanowski क्या आप कोई और जानकारी प्रदान कर सकते हैं, जैसे आपका कनेक्शन कोड कैसा दिखता है और आपके पास मोंगोडब का कौन सा संस्करण है?

@ vkarpov15 मैं MongoDB 3.2.6 का उपयोग कर रहा था।

कनेक्शन विकल्प:

auth: {
  authMechanism: 'SCRAM-SHA-1',
},
mongos: {
  ssl: true,
  sslValidate: true,
  sslCA: [cert],
},

सिंगल मोंगो या मल्टीपल मोंगो?

एकाधिक मूंग। कंपोज़ मोंगो परिनियोजन का उपयोग करना।

समस्या निवारण में सहायता के लिए मैं और कुछ कर सकता हूं? यह हमें नए संस्करणों में जाने से रोक रहा है...

आपके कोड को देखे बिना मेरे लिए कोई वास्तविक परिकल्पना करना कठिन है। यदि आप mongoose.connect कनेक्ट कर रहे हैं तो मैं mongoose.connection.readyState के मान की जाँच करूँगा जब यह समस्या शुरू होगी। साथ ही, मैं नेवला डिबग मोड को सक्षम करूंगा, mongoose.set('debug', true) , जो प्रत्येक नेवला ऑपरेशन के लिए कंसोल पर डिबग संदेशों को प्रिंट करेगा। वे संदेश प्रिंट हो रहे हैं या नहीं, निश्चित रूप से डिबग में मदद करेंगे।

@vkarpov15 यह वह कोड है जिसका उपयोग मैं कनेक्ट करने के लिए कर रहा हूं: https://gist.github.com/sommestad/c0c6a7fa4feaadf84ecbb59cc3432c90
यह एक निजी मॉड्यूल का हिस्सा है, इसलिए सार।

_(कनेक्शन रैपिंग मॉड्यूल का कारण यह है कि कनेक्शन को कभी-कभी अन्य निजी एनपीएम मॉड्यूल में पुन: उपयोग किया जाता है, जिसने ऐतिहासिक रूप से नेवले के साथ अच्छा काम नहीं किया है।)_

इन समस्याओं के होने पर मेरे पास कनेक्शन स्थिति का लॉगिंग सक्षम था, लेकिन कनेक्शन स्वयं नहीं बदला (कम से कम उत्सर्जित कोई घटना नहीं)। इसलिए, ऐसा नहीं लगता था कि क्लाइंट डिस्कनेक्ट हो गया था।

यह यूआरआई में replicaSet से कनेक्ट नहीं हो रहा है (लक्षित डेटाबेस एक लिखें परिनियोजन है )। जैसा कि उल्लेख किया गया है, एसएसएल का उपयोग किया जाता है। साथ ही, ट्रैफिक को AWS NAT गेटवे के माध्यम से रूट किया जाता है। AWS NAT का निष्क्रिय समय 5 मिनट है, लेकिन ये समस्याएँ उच्च ट्रैफ़िक के दौरान भी हुईं।

मेरे लिए कुछ समस्या, क्या आपने इसे हल किया?

@ युवा 7 नहीं, कोई विचार नहीं। क्या आप कंपोज़ परिनियोजन से भी जुड़ रहे हैं? कृपया अतिरिक्त जानकारी प्रदान करें

इसका कारण जानने के लिए मैं और कुछ कर सकता हूं? कोई सिद्धांत जिसकी जांच की जा सकती है?

@ सोमेस्टेड कुछ भी ठोस नहीं है। क्या आपके पास लिखें से कोई लॉग है?

मैंने mongoose 4.7.2 की कोशिश की लेकिन 48 घंटों के बाद एक ही समस्या का अनुभव किया। इस बिंदु पर, मैं 4.4.11 पर हैमस्ट्रंग कर रहा हूं, जिसके अपने मुद्दे हैं।

मैंने लॉग एकत्र करने की उम्मीद में हमारे डेमो सर्वर पर 4.7.2 स्थापित किया, लेकिन यह बिना किसी समस्या के दो सप्ताह से चल रहा है। हो सकता है कि डेटा/कनेक्शन/आदि की मात्रा समस्या को भड़काती हो?

एक बार जब यह होना शुरू हो जाता है, तो इसे पुन: पेश करने के लिए कोड बहुत आसान होता है। मूल रूप से किसी भी क्वेरी का कॉलबैक गायब हो जाता है:

db.Something.find({}, callback); //this callback is never fired

जैसा कि मैंने उल्लेख किया है, जब यह हो रहा है, mongoose.connection.readyState === CONNECTED

अजीब। मेरा मतलब मोंगोडब लॉग था - क्या आप मोंगोडब सर्वर लॉग को डंप कर सकते हैं जब वह त्रुटि हुई थी?

जब यह विफलता हुई तो मैंने डीबी लॉग स्कैन किए और सामान्य से कुछ भी नहीं देख सका। कनेक्शन की संख्या, डिस्कनेक्ट, कनेक्टिंग या इसी तरह की समस्याओं से संबंधित कोई समस्या नहीं थी। मैं कंपोज़ करने के लिए भी पहुंचा, जो ऑर्डर से बाहर कुछ भी नहीं देख सका।

@bendytree क्या आप उस डेमो सर्वर पर कुछ वॉल्यूम फेंक सकते हैं, शायद HTTP लोड टेस्टिंग टूल का उपयोग कर रहे हैं?

@bendytree इसके अलावा, क्या यह नोड (4.x, 6.x और 7.x) की सभी रिलीज लाइनों पर होता है?

@ vkarpov15 क्या हम दरवाजे से 4.7.7 प्राप्त कर सकते हैं ताकि मैं नवीनतम MongoDB ड्राइवर के साथ परीक्षण कर सकूं? 4.7.6 एक ऐसे संस्करण पर पिन किया गया है जो बहिष्कृत लगता है।

@vkarpov15 66d559b19a86c70e30a8f083d03eb22566571b7e धन्यवाद! मै उसे करने की एक कोशिश तो करूंगा।

यहां वही, एक एसएसएल प्रतिकृति यहां, कुछ मिनटों/घंटों के बाद, अनुरोध केवल कॉलबैक() (मैंने कुछ और वर्बोज़ लॉगिंग जोड़ा है) और कोई त्रुटि नहीं है। मैंने कल रात 4.7.7 में अपग्रेड किया है लेकिन अभी भी समस्या है।

संपादित करें: मैंने 4.7.0 को डाउनग्रेड करने का प्रयास किया लेकिन यह सबसे खराब था (5 मिनट से भी कम समय में समस्या होने पर)। मैं 4.5.10 कोशिश कर रहा हूँ।

@gierschv नोड 6.9.x?

@djanowski नहीं, अभी भी 4.6/4.7.x एलटीएस पर।

@djanowski मैंने इसे केवल Node 4.4.2 . पर आज़माया है

इस मुद्दे के संभावित डुप्लिकेट की सूची रखते हुए:

• #4638
• #4690
• #4901

FYI करें, 4.5.10 यहां अच्छा काम करता है, पिछले 5 घंटों से कोई समस्या नहीं है। मेरे पास सभी मशीनों पर #4690 जैसा उच्च CPU उपयोग भी था जो डाउनग्रेड द्वारा भी तय किया गया लगता है।

यहां कोई नया विकास नहीं? बग को खोजने में मदद के लिए हम और कुछ कर सकते हैं?

@sommestad क्या आपको अभी भी नवीनतम नेवले के साथ यह समस्या है?

मैंने अभी तक अपग्रेड करने की हिम्मत नहीं की है, क्योंकि इसने मूल रूप से पिछली बार हमारे पूरे सिस्टम को तोड़ दिया था (परिवर्तन "कुछ" समय के बाद दिखाई देते हैं, इसलिए इसे लंबे समय तक चलने के बिना सत्यापित करना कठिन है)। यदि आपके पास यह मानने का कारण है कि यह तय है, तो हम सिस्टम के एक अलग हिस्से पर कोशिश कर सकते हैं?

संपादित करें: पिंग @varunjayaraman

मेरी ओर से, हमने नोड 6.x एलटीएस पर स्विच किया और कुछ सप्ताह पहले पिछले नेवला संस्करण में अपग्रेड किया, तब से कोई समस्या नहीं है।

हमने लगभग दो महीने पहले Node 6.10.2, Mongoose 4.9.9 में अपग्रेड किया था। अभी भी वही मुद्दा देख रहे हैं।

हमारे कनेक्शन स्ट्रिंग का प्रारूप mongodb://username:[email protected]:1234,db2.com:2345/db-name?ssl=true ।

console.log("fetching user...");
userCollection.findOne({_id: userId}, function(err, user){
  console.log("done"); // this never happens
  ...
});

एक बार कॉलबैक बंद हो जाने के बाद, वे फिर कभी शुरू नहीं होते हैं। अगर हम प्रक्रिया को फिर से शुरू करते हैं तो यह ठीक जुड़ जाता है।

यदि कोई डेटा है जिसे हम समस्या निवारण में सहायता के लिए एकत्र कर सकते हैं, तो हमें मदद करना अच्छा लगेगा।

मैं एक ही समस्या देख रहा हूं और इसे नीचे दिए गए कोड के साथ पुन: पेश कर सकता हूं (फास्ट मॉक-अप/कोड शैली के लिए खेद है)।

कनेक्शन टाइमआउट को अनुकरण करने के लिए, मैंने पूलसाइज को 1 तक कम कर दिया और अनुरोधों को 2 एंडपॉइंट्स (सामान्य/धीमी) पर ट्रिगर किया, जिन्हें इस क्रम में कहा जाता है:

1. सामान्य समापन बिंदु (जो तुरंत परिणाम देता है)
2. धीमा समापन बिंदु (जो एक धीमी क्वेरी शुरू करेगा)
3. सामान्य समापन बिंदु (जो 2 तक उपयोग में होने के बाद से उपलब्ध कनेक्शन की प्रतीक्षा करेगा)
4. सामान्य समापन बिंदु (जो एक मिनट के बाद ट्रिगर होगा, जब 2 और 3 के परिणामस्वरूप MongoError/कनेक्शन टाइमआउट हो जाएगा)

का उपयोग करके पुन: उत्पन्न करें:

// Require modules
const mongoose = require('mongoose');
const express = require('express');
const request = require('request');
const parseJson = require('body-parser').json();

// Use native Promises in Mongoose
mongoose.Promise = Promise;

// Create the test schema
const testSchema = new mongoose.Schema({
  name: {
    type: String,
    trim: true,
    default: 'test'
  }
});

// Create the mongoose model
mongoose.model('Test', testSchema, 'test');

// Create some test data
mongoose.model('Test').create([
  {name: 'test1'},
  {name: 'test2'},
  {name: 'test3'},
  {name: 'test4'},
  {name: 'test5'}
]);

// Create the Express based app
const app = express();

// Create the express router
const router = express.Router();

// Create a normal route
router.route('/normal').get(parseJson, function (req, res, next) {
  mongoose.model('Test').find({}).then(
    function (data) {
      res.status(200).json(data);
    }
  ).catch(
    function (err) {
      res.status(400).json(err);
    }
  );
});

// Create up a slow route
router.route('/slow').get(parseJson, function (req, res, next) {
  mongoose.model('Test').find({$where: 'sleep(10000) || true'}).then(
    function (data) {
      res.status(200).json(data);
    }
  ).catch(
    function (err) {
      res.status(400).json(err);
    }
  );
});

// Add middleware to console log every request
var requestNumber = 1;
app.use(function (req, res, next) {
  console.log('Request ' + requestNumber, req.method, req.url);
  requestNumber++;
  next();
});

// Use the router
app.use('/', router);

// Listen for requests
app.listen(4000, function () {
  console.log('Server listening on port 4000');
});

// Catch any uncaught exceptions
process.on('uncaughtException', function (err) {
  console.log('Uncaught exception', err);
});

// Catch any unhandled rejections
process.on('unhandledRejection', function (reason) {
  console.error('Unhandled Rejection', reason);
});

// Database connection options
const connectionOpts = {
  // Use the new connection logic
  useMongoClient: true,

  // Do not auto reconnect (the Node code will auto reconnect)
  autoReconnect: false,

  // Use a poolsize of 1 to simulate a timeout using multiple request to slow and normal endpoints
  poolSize: 1
};

// Connection method with retry
const connectWithRetry = function () {
  // Check if we still need to connect
  if (mongoose.connection.readyState !== mongoose.Connection.STATES.connected) {
    // Connect
    return mongoose.connect('mongodb://localhost:27017/test', connectionOpts).catch(
      function (err) {
        console.log('Can not connect to mongo', err);
      }
    );
  }
};

// Helper function to execute a request to the normal endpoint
const doRequestNormal = function () {
  request({
    url: 'http://localhost:4000/normal',
    json: true,
    timeout: 60000
  }, function (error, response, body) {
    if (error) {
      console.log('Error on normal request', error, response);
    }
    console.log('Performed normal request, body:', body);
  });
};

// Helper function to execute a request to the normal endpoint
const doRequestSlow = function () {
  request({
    url: 'http://localhost:4000/slow',
    json: true,
    timeout: 60000
  }, function (error, response, body) {
    if (error) {
      console.log('Error on slow request', error, response);
    }
    console.log('Performed slow request', body);
  });
};

// Helper function to simulate requests
const doRequests = function () {
  doRequestNormal();
  doRequestSlow();
  doRequestNormal();

  setTimeout(function () {
    console.log('Do normal request after 1 minute');
    doRequestNormal();
  }, 60000);
};

// Connecting event
mongoose.connection.on('connecting', function () {
  console.log('Connecting to database...');
});

// Connected event
mongoose.connection.on('connected', function () {
  console.log('Database is connected, start requesting...');
  doRequests();
});

// Timeout event
mongoose.connection.on('timeout', function (err) {
  console.log('Database timeout error', err);
});

// Error event
mongoose.connection.on('error', function (err) {
  console.log('Database connection error', err);
});

// Disconnected event
mongoose.connection.on('disconnected', function () {
  console.error('Database got disconnected, reconnecting in 5 sec...');

  // Reconnect in 5 seconds
  setTimeout(connectWithRetry, 5000);
});

// Connect to the database with retry
connectWithRetry();

// Log the connection state every 10 seconds
setInterval(function () {
  console.log('Mongoose connection readystate is', mongoose.connection.readyState);
}, 10000);

कंसोल आउटपुट इस प्रकार है:

Connecting to database...
Server listening on port 4000
Database is connected, start requesting...
Request 1 GET /normal
Request 2 GET /slow
Request 3 GET /normal
Performed normal request, body: [ { _id: '597f8c6f41bf2e119594ba1a', __v: 0, name: 'test1' },
  { _id: '597f8c6f41bf2e119594ba1b', __v: 0, name: 'test2' },
  { _id: '597f8c6f41bf2e119594ba1c', __v: 0, name: 'test3' },
  { _id: '597f8c6f41bf2e119594ba1d', __v: 0, name: 'test4' },
  { _id: '597f8c6f41bf2e119594ba1e', __v: 0, name: 'test5' } ]
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Performed slow request { name: 'MongoError',
  message: 'connection 0 to localhost:27017 timed out' }
Performed normal request, body: { name: 'MongoError',
  message: 'connection 0 to localhost:27017 timed out' }
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Do normal request after 1 minute
Request 4 GET /normal
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Error on normal request { Error: ESOCKETTIMEDOUT
    at ClientRequest.<anonymous> (/Users/adriaanmeuris/Documents/Projecten/Mongoose timeout/node_modules/request/request.js:819:19)
    at ClientRequest.g (events.js:291:16)
    at emitNone (events.js:86:13)
    at ClientRequest.emit (events.js:185:7)
    at Socket.emitTimeout (_http_client.js:620:10)
    at Socket.g (events.js:291:16)
    at emitNone (events.js:86:13)
    at Socket.emit (events.js:185:7)
    at Socket._onTimeout (net.js:339:8)
    at ontimeout (timers.js:365:14)
    at tryOnTimeout (timers.js:237:5)
    at Timer.listOnTimeout (timers.js:207:5) code: 'ESOCKETTIMEDOUT', connect: false } undefined
Performed normal request, body: undefined
Mongoose connection readystate is 1
Mongoose connection readystate is 1

मैं हर 10 सेकंड में डेटाबेस के तैयार स्थिति की निगरानी करता हूं, जो इंगित करता है कि कनेक्शन अभी भी सक्रिय है। कोई नेवला त्रुटि / टाइमआउट घटना ट्रिगर नहीं होती है, और अनुरोध 4 का कॉलबैक कभी नहीं कहा जाता है (यह अनुरोध पैकेज का उपयोग करके 60 के दशक के बाद समाप्त हो जाता है)। आप http://localhost :4000/slow और अगले http://localhost :4000/normal पर जाकर भी जांच कर सकते हैं।

मैं https://team.goodeggs.com/reconnecting-to-mongodb-when-mongoose-connect-fails-at-startup-83ca8496ca02 पर आधारित ऑटो रीकनेक्शन लॉजिक का उपयोग कर रहा हूं, लेकिन यह कभी भी ट्रिगर नहीं होता है क्योंकि मोंगो डिस्कनेक्ट नहीं होता है।

कुछ मौकों पर, जब मैं उस कोड पर टिप्पणी करता हूं जो कुछ परीक्षण डेटा बनाता है (इसलिए मूल रूप से एक खाली संग्रह को क्वेरी करना)

संभावित संबंधित मुद्दे:

• #4789
• #4660

किसी भी मदद की मुझे बहुत सराहना होगी।

इसलिए मैंने कुछ और खुदाई की और ऊपर की स्क्रिप्ट को नेवला का उपयोग किए बिना नोड-मोंगोडब-नेटिव के साथ काम करने के लिए फिर से लिखा। परिणाम अब बहुत अलग हैं:

कनेक्शन सेटिंग्स और अनुरोध समान हैं:

1. सामान्य समापन बिंदु (जो तुरंत परिणाम देता है)
2. धीमा समापन बिंदु (जो एक धीमी क्वेरी शुरू करेगा)
3. सामान्य समापन बिंदु (जो 2 तक उपयोग में होने के बाद से उपलब्ध कनेक्शन की प्रतीक्षा करेगा)
4. सामान्य समापन बिंदु (जो एक मिनट के बाद चालू हो जाएगा)

कोड:

// Require modules
const MongoClient = require('mongodb').MongoClient;
const Server = require('mongodb').Server;
const express = require('express');
const request = require('request');
const parseJson = require('body-parser').json();

// The db reference
var db;

// Function to insert test data
function insertTestData() {
  return new Promise(function (resolve, reject) {
    // Get the test collection
    var test = db.collection('test');

    // Insert some documents
    test.insertMany([
      {name: 'test1'},
      {name: 'test2'},
      {name: 'test3'},
      {name: 'test4'},
      {name: 'test5'}
    ], function (err, result) {
      if (err) {
        reject(err);
      } else {
        resolve();
      }
    });
  });
}

// Create the Express based app
const app = express();

// Create the express router
const router = express.Router();

// Create a normal route
router.route('/normal').get(parseJson, function (req, res, next) {
  // Get the documents collection
  var collection = db.collection('test');

  // Find some documents
  collection.find({}).toArray(function (err, data) {
    if (err) {
      res.status(400).json(err);
    } else {
      res.status(200).json(data);
    }
  });
});

// Create up a slow route
router.route('/slow').get(parseJson, function (req, res, next) {
  // Get the documents collection
  var collection = db.collection('test');

  // Find some documents
  collection.find({$where: 'sleep(10000) || true'}).toArray(function (err, data) {
    if (err) {
      res.status(400).json(err);
    } else {
      res.status(200).json(data);
    }
  });
});

// Add middleware to console log every request
var requestNumber = 1;
app.use(function (req, res, next) {
  console.log('Request ' + requestNumber, req.method, req.url);
  requestNumber++;
  next();
});

// Use the router
app.use('/', router);

// Listen for requests
app.listen(4000, function () {
  console.log('Server listening on port 4000');
});

// Catch any uncaught exceptions
process.on('uncaughtException', function (err) {
  console.log('Uncaught exception', err);
});

// Catch any unhandled rejections
process.on('unhandledRejection', function (reason) {
  console.error('Unhandled Rejection', reason);
});

// Database connection options
const connectionOpts = {
  // Do not auto reconnect (the Node code will auto reconnect)
  autoReconnect: false,

  // Use a poolsize of 1 to simulate a timeout using multiple request to slow and normal endpoints
  poolSize: 1
};

// Connection method with retry
const connectWithRetry = function () {

  return MongoClient.connect('mongodb://localhost:27017/test', connectionOpts).then(
    function (database) {
      db = database;
      setupEvents();
      console.log('Connected to mongo');
    }
  ).catch(
    function (err) {
      console.log('Can not connect to mongo', err);
      return err;
    }
  );
};

// Helper function to execute a request to the normal endpoint
const doRequestNormal = function () {
  request({
    url: 'http://localhost:4000/normal',
    json: true,
    timeout: 60000
  }, function (error, response, body) {
    if (error) {
      console.log('Error on normal request', error, response);
    }
    console.log('Performed normal request, body:', body);
  });
};

// Helper function to execute a request to the normal endpoint
const doRequestSlow = function () {
  request({
    url: 'http://localhost:4000/slow',
    json: true,
    timeout: 60000
  }, function (error, response, body) {
    if (error) {
      console.log('Error on slow request', error, response);
    }
    console.log('Performed slow request', body);
  });
};

// Helper function to simulate requests
const doRequests = function () {
  doRequestNormal();
  doRequestSlow();
  doRequestNormal();

  setTimeout(function () {
    console.log('Do normal request after 1 minute');
    doRequestNormal();
  }, 60000);
};

// Helper function to setup mongo events
function setupEvents() {
// Connecting event
  db.on('connecting', function () {
    console.log('Connecting to database...');
  });

// Connected event
  db.on('connected', function () {
    console.log('Database is connected, start requesting...');
  });

// Timeout event
  db.on('timeout', function (err) {
    console.log('Database timeout error', err);
  });

// Error event
  db.on('error', function (err) {
    console.log('Database connection error', err);
  });

// Disconnected event
  db.on('close', function () {
    console.error('Database got disconnected, reconnecting in 5 sec...');

    // Reconnect in 5 seconds
    setTimeout(connectWithRetry, 5000);
  });
}

// Connect to the database with retry
connectWithRetry().then(
  function () {
    return insertTestData();
  }
).then(
  function () {
    doRequests();
  }
);

कंसोल आउटपुट इस प्रकार है:

Server listening on port 4000
Connected to mongo
Request 1 GET /normal
Request 2 GET /slow
Request 3 GET /normal
Performed normal request, body: [ { _id: '598207c16caf9224cf3b8897', name: 'test1' },
  { _id: '598207c16caf9224cf3b8898', name: 'test2' },
  { _id: '598207c16caf9224cf3b8899', name: 'test3' },
  { _id: '598207c16caf9224cf3b889a', name: 'test4' },
  { _id: '598207c16caf9224cf3b889b', name: 'test5' } ]
Performed slow request [ { _id: '598207c16caf9224cf3b8897', name: 'test1' },
  { _id: '598207c16caf9224cf3b8898', name: 'test2' },
  { _id: '598207c16caf9224cf3b8899', name: 'test3' },
  { _id: '598207c16caf9224cf3b889a', name: 'test4' },
  { _id: '598207c16caf9224cf3b889b', name: 'test5' } ]
Performed normal request, body: [ { _id: '598207c16caf9224cf3b8897', name: 'test1' },
  { _id: '598207c16caf9224cf3b8898', name: 'test2' },
  { _id: '598207c16caf9224cf3b8899', name: 'test3' },
  { _id: '598207c16caf9224cf3b889a', name: 'test4' },
  { _id: '598207c16caf9224cf3b889b', name: 'test5' } ]
Do normal request after 1 minute
Request 4 GET /normal
Performed normal request, body: [ { _id: '598207c16caf9224cf3b8897', name: 'test1' },
  { _id: '598207c16caf9224cf3b8898', name: 'test2' },
  { _id: '598207c16caf9224cf3b8899', name: 'test3' },
  { _id: '598207c16caf9224cf3b889a', name: 'test4' },
  { _id: '598207c16caf9224cf3b889b', name: 'test5' } ]

पिछली स्क्रिप्ट की तरह कोई मोंगो त्रुटि/टाइमआउट ईवेंट ट्रिगर नहीं होता है, लेकिन अनुरोध 2 और 3 सही ढंग से हल होते हैं, और अनुरोध 4 का कॉलबैक भी ट्रिगर होता है - उस स्क्रिप्ट के विपरीत जो मोंगोस का उपयोग कर रहा है।

मैं यह पता लगाने की कोशिश कर रहा हूं कि क्या यह एक नेवला बनाम एक मोंगो मुद्दा है - इसलिए इन लिपियों के परिणामों की तुलना करने के संबंध में किसी भी मदद की सराहना की जाएगी। शायद @ vkarpov15 इस पर झंकार कर सकते हैं? धन्यवाद!

@adriaanmeuris यह अजीब है, यहाँ आउटपुट है जो मुझे आपकी पहली स्क्रिप्ट चलाने से मिलता है:

$ node gh-4513.js 
Connecting to database...
Server listening on port 4000
Database is connected, start requesting...
Request 1 GET /normal
Request 2 GET /slow
Request 3 GET /normal
Performed normal request, body: [ { _id: '5998e4a79bb81d37ac4b1a26', __v: 0, name: 'test1' },
  { _id: '5998e4a79bb81d37ac4b1a27', __v: 0, name: 'test2' },
  { _id: '5998e4a79bb81d37ac4b1a28', __v: 0, name: 'test3' },
  { _id: '5998e4a79bb81d37ac4b1a29', __v: 0, name: 'test4' },
  { _id: '5998e4a79bb81d37ac4b1a2a', __v: 0, name: 'test5' } ]
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Mongoose connection readystate is 1
Performed slow request [ { _id: '5998e4a79bb81d37ac4b1a26', __v: 0, name: 'test1' },
  { _id: '5998e4a79bb81d37ac4b1a27', __v: 0, name: 'test2' },
  { _id: '5998e4a79bb81d37ac4b1a28', __v: 0, name: 'test3' },
  { _id: '5998e4a79bb81d37ac4b1a29', __v: 0, name: 'test4' },
  { _id: '5998e4a79bb81d37ac4b1a2a', __v: 0, name: 'test5' } ]
Performed normal request, body: [ { _id: '5998e4a79bb81d37ac4b1a26', __v: 0, name: 'test1' },
  { _id: '5998e4a79bb81d37ac4b1a27', __v: 0, name: 'test2' },
  { _id: '5998e4a79bb81d37ac4b1a28', __v: 0, name: 'test3' },
  { _id: '5998e4a79bb81d37ac4b1a29', __v: 0, name: 'test4' },
  { _id: '5998e4a79bb81d37ac4b1a2a', __v: 0, name: 'test5' } ]
Mongoose connection readystate is 1
Do normal request after 1 minute
Request 4 GET /normal
Performed normal request, body: [ { _id: '5998e4a79bb81d37ac4b1a26', __v: 0, name: 'test1' },
  { _id: '5998e4a79bb81d37ac4b1a27', __v: 0, name: 'test2' },
  { _id: '5998e4a79bb81d37ac4b1a28', __v: 0, name: 'test3' },
  { _id: '5998e4a79bb81d37ac4b1a29', __v: 0, name: 'test4' },
  { _id: '5998e4a79bb81d37ac4b1a2a', __v: 0, name: 'test5' } ]
Mongoose connection readystate is 1
Mongoose connection readystate is 1
^C
$ 

नेवला जुड़ा रहता है। क्या आप मोंगोडब, नोड और नेवला के अपने संस्करणों को स्पष्ट कर सकते हैं?

परीक्षण के लिए धन्यवाद! वास्तव में नेवला हमेशा जुड़ा रहता है, लेकिन कॉलबैक होना बंद हो जाता है (आप एक्सप्रेस में आने वाले अनुरोध को देख सकते हैं, लेकिन वे समय समाप्त हो जाएंगे)

मैं इसके साथ परीक्षण कर रहा था:

• नोड 6.8.1
• मोंगोडब 2.2.30
• नेवला 4.11.5

मैंने इसमें अपडेट किया है:

• नोड 6.8.1
• मोंगोडब 2.2.31
• नेवला 4.11.7

मैं अभी भी इस मुद्दे को स्थानीय रूप से मेरे द्वारा पोस्ट की गई पहली स्क्रिप्ट के साथ पुन: पेश कर सकता हूं। यह केवल तब होता है जब एक मोंगो कनेक्शन का समय समाप्त हो जाता है, इसलिए हो सकता है कि आप उस क्वेरी को बदलना चाहें जो इसे अनुकरण करता है:

mongoose.model('Test').find({$where: 'sleep(10000) || true'})

(मुझे यकीन नहीं है कि यह प्रत्येक मशीन पर टाइमआउट ट्रिगर करेगा, इसलिए पुन: उत्पन्न करने के लिए इस क्वेरी में बदलाव आवश्यक हो सकता है)

नेवला 4.10.4 में अपडेट करने के बाद हम अब इन मुद्दों को नहीं देख रहे हैं।
थोड़ा अजीब लगता है, क्योंकि अन्य लोगों को समस्याओं का अनुभव होता है, लेकिन समस्या के वापस आने के किसी भी संकेत के बिना कुछ हफ़्ते के लिए कई सेवाएं चल रही हैं। मैं

हालाँकि, हमने पहले @adriaanmeuris की तरह ही मुद्दों को

रनिंग नोड 8.

हम अभी भी इस मुद्दे को समय-समय पर देख रहे हैं।

मैं इसे @adriaanmeuris की स्क्रिप्ट के साथ पुन: पेश नहीं कर सका, लेकिन यहां एक संशोधित संस्करण है जो इसे हर बार मेरे लिए पुन: पेश करता है:

बेंडीट्री/मोंगोज़-इश्यू-4513

धन्यवाद @bendytree , आपकी स्क्रिप्ट के साथ मैं भी पुन: पेश कर सकता हूं:

7) Database connecting...
49) Database connected...
49) Dropping...
57) Creating...
156) FastQuery-A: starting...
166) FastQuery-A: success: 1
1158) SlowQuery: starting...
2158) FastQuery-B: starting...
362165) SlowQuery: failed: MongoError: connection 0 to localhost:27017 timed out
362167) FastQuery-B: failed: MongoError: connection 0 to localhost:27017 timed out
605159) FastQuery-C: starting...
1210149) Giving Up...

यह अनिवार्य रूप से मेरी जैसी ही स्क्रिप्ट है लेकिन लंबी टाइमआउट अवधि के साथ है। मुझे लगता है कि आपके सेटअप के आधार पर स्थानीय रूप से टाइमआउट का अनुकरण करने में अधिक/कम समय लगता है, क्योंकि हर कोई मेरी स्क्रिप्ट (जो 10 की नींद का उपयोग करता है) के साथ पुन: पेश नहीं कर सकता है।

@ vkarpov15 क्या आप इस अद्यतन स्क्रिप्ट को

मैं @bendytree के साथ repro करने में कामयाब रहा, यह socketTimeoutMS बहुत कम का मामला है। NS

362591) SlowQuery: failed: MongoError: connection 0 to localhost:27017 timed out
362591) FastQuery-B: failed: MongoError: connection 0 to localhost:27017 timed out

संदेश मोंगोडब ड्राइवर के सॉकेट टाइमिंग आउट के संकेत हैं। mongodb ड्राइवर डिफ़ॉल्ट रूप से 30 सेकंड के बाद समय समाप्त हो जाता है, लेकिन आपके OS में एक सॉकेट टाइमआउट भी होता है जिसके बारे में आपको जानकारी होनी चाहिए, इसलिए आमतौर पर 15 सेकंड से अधिक समय लेने वाले प्रश्नों से बचना एक अच्छा विचार है। हालांकि, आप socketTimeoutMS विकल्प का उपयोग करके मोंगोडब के सॉकेट टाइमआउट को कॉन्फ़िगर कर सकते हैं:

mongoose.connect(DB_URL, {
  useMongoClient: true,
  autoReconnect: false,
  poolSize: 1,
  socketTimeoutMS: 0
}).catch((err)=>{ log('Connect failed', err); });

उस विकल्प के साथ 0 पर सेट होने पर, आपकी स्क्रिप्ट मेरी मशीन पर लगभग सफल हो जाती है, 10 मिनट की क्वेरी अभी भी मर जाती है लेकिन कॉलबैक जारी रहता है

$ node gh-4513.js 
9) Database connecting...
43) Database connected...
43) Dropping...
53) Creating...
177) FastQuery-A: starting...
189) FastQuery-A: success: 1
1174) SlowQuery: starting...
2174) FastQuery-B: starting...
601181) SlowQuery: failed: MongoError: Interrupted by the host
601182) FastQuery-B: success: 1
605173) FastQuery-C: starting...
605174) FastQuery-C: success: 1

लेकिन बाद की क्वेरी सफल होती है।

किसी भी तरह से, नेवले को इस मामले में एक टाइमआउट घटना का उत्सर्जन करना चाहिए, इसलिए हम उस समस्या को ठीक कर देंगे।

मुझे लगता है कि आप सॉकेटटाइमआउटएमएस (360000ms के डिफ़ॉल्ट के साथ) के साथ कनेक्टटाइमआउटएमएस (30000ms के डिफ़ॉल्ट के साथ) को भ्रमित कर रहे हैं।

यह सलाह दी जाती है कि सॉकेटटाइमआउटएमएस को ड्राइवर के माध्यम से चलने वाले सबसे धीमे ऑपरेशन की लंबाई से दो से तीन गुना अधिक सेट किया जाए, सॉकेटटाइमआउटएमएस को 0 पर सेट करने का मतलब वास्तव में ऑपरेटिंग सिस्टम डिफ़ॉल्ट सॉकेट टाइमआउट मान (http://mongodb.github.io/ पर अधिक जानकारी) को लागू करना है। नोड-मोंगोडब-देशी/2.2/संदर्भ/अक्सर पूछे जाने वाले प्रश्न/)।

तो यह प्रश्न बना रहता है: जब यह सीमा (निश्चित या डिफ़ॉल्ट OS टाइमआउट) हिट हो जाती है तो ये कॉलबैक क्यों बंद हो जाते हैं?

@ vkarpov15 [email protected] के साथ, अब मैं टाइमआउट इवेंट देखता हूं, इसके लिए धन्यवाद। हालाँकि आप अभी भी इस कॉलबैक समस्या को देखते हैं ( @bendytree की मूल स्क्रिप्ट का उपयोग करके, तेज़ परीक्षण के लिए आप LONG_QUERY_DURATION_IN_MS को 2000 और सॉकेटटाइमआउटएमएस को 1000 पर सेट कर सकते हैं)

मैंने कुछ और परीक्षण किए हैं और पाया है कि इसे नेवला के बिना भी पुन: प्रस्तुत किया जा सकता है। http://mongodb.github.io/node-mongodb-native/2.2/reference/faq/ पढ़ते समय, मुझे पता चला कि: Closing the socket forces a reconnect of the driver’s connection pool and introduces latency to any other operations which are queued up

भले ही mongoose.connection.readyState हमेशा 1 होता है, मैंने autoReconnect को true , स्क्रिप्ट को फिर से चलाया गया:

8) Database connecting...
47) Database connected...
48) Dropping...
73) Creating...
123) FastQuery-A: starting...
129) FastQuery-A: success: 1
1122) SlowQuery: starting...
2126) FastQuery-B: starting...
3130) Database timeout...
3133) SlowQuery: failed: MongoError: connection 0 to localhost:27017 timed out
3133) FastQuery-B: failed: MongoError: connection 0 to localhost:27017 timed out
6063) Database timeout...
7122) FastQuery-C: starting...
7125) FastQuery-C: success: 1
8129) Database timeout...
11070) Database timeout...
13073) Database timeout...

तो ऐसा लगता है कि कॉलबैक ऑटो रीकनेक्ट के साथ काम कर रहे हैं जो सही पर सेट है

इस लेख को आगे पढ़ने पर: http://mongodb.github.io/node-mongodb-native/2.0/tutorials/connection_failures/ , मुझे एहसास हुआ कि टाइमआउट के बाद कॉलबैक नहीं होने का कारण यह है कि ऑपरेशन है सर्वर के पुन: कनेक्ट होने की प्रतीक्षा करते समय बफ़र किया गया।

तो मैंने autoReconnect वापस false + bufferMaxEntries से 0 , यह आउटपुट है:

8) Database connecting...
51) Database connected...
51) Dropping...
58) Creating...
112) FastQuery-A: starting...
116) FastQuery-A: success: 1
1115) SlowQuery: starting...
2115) FastQuery-B: starting...
3123) Database timeout...
3123) SlowQuery: failed: MongoError: connection 0 to localhost:27017 timed out
3123) FastQuery-B: failed: MongoError: connection 0 to localhost:27017 timed out
7115) FastQuery-C: starting...
7117) FastQuery-C: failed: MongoError: no connection available for operation and number of stored operation > 0

जो बताता है कि कॉलबैक @bendytree की स्क्रिप्ट के पहले संस्करण में ट्रिगर क्यों नहीं हुआ।

@ vkarpov15 यह अब हमें 2 प्रश्नों के साथ छोड़ देता है:

• कोई कनेक्शन ईवेंट क्यों उत्सर्जित नहीं होते हैं (मैं एक डिस्कनेक्टेड ईवेंट देखने की अपेक्षा करता हूं)
• टाइमआउट घटना घटना उत्सर्जित होती रहती है

यहाँ अद्यतन स्क्रिप्ट है ( @bendytree की स्क्रिप्ट पर आधारित, [email protected] और [email protected]) के साथ परीक्षण किया गया:

const LONG_QUERY_DURATION_IN_MS = 2000;
const DB_URL = 'mongodb://localhost:27017/test_mongoose_callbacks';

const mongoose = require('mongoose');
mongoose.Promise = Promise;

var startTime = new Date().getTime();
var log = (msg) => {
  var seconds = Math.round(new Date().getTime() - startTime);
  console.log(seconds+") "+msg);
};

var Model = mongoose.model('Test', new mongoose.Schema({
  name: { type: String, trim: true, default: 'test' }
}), 'test');

mongoose.connection.on('connecting',   () => { log('Database connecting...'); });
mongoose.connection.on('timeout',      () => { log('Database timeout...'); });
mongoose.connection.on('error',        () => { log('Database error...'); });
mongoose.connection.on('disconnected', () => { log('Database disconnected...'); });

const doRequest = function (title, slow) {
  var logRequest = (msg) => { log(title+": "+msg); };

  logRequest("starting...");
  var filter = slow ? {$where: 'sleep('+LONG_QUERY_DURATION_IN_MS+') || true'} : {};
  Model.count(filter).exec((err, count) => {
    logRequest(err ? "failed: "+err : "success: "+count);
  });
};

mongoose.connection.on('connected', () => {
  log("Database connected...");
 log("Dropping...");
 mongoose.connection.db.dropDatabase(function(){
   log("Creating...");
   Model.create([ {name: 'test1'} ], function(){
      setTimeout(() => { doRequest("FastQuery-A", false); }, 0);
      setTimeout(() => { doRequest("SlowQuery", true);  }, 1000);
      setTimeout(() => { doRequest("FastQuery-B", false); }, 2000);
      setTimeout(() => { doRequest("FastQuery-C", false); }, LONG_QUERY_DURATION_IN_MS+5000);
      setTimeout(() => { log("Giving Up..."); }, LONG_QUERY_DURATION_IN_MS+30000);
    });
  });
});

mongoose.connect(DB_URL, {
  useMongoClient: true,
  autoReconnect: true,
  //bufferMaxEntries: 0, // Uncomment to disable buffering operations 
  poolSize: 1,
  socketTimeoutMS: 1000
}).catch((err)=>{ log('Connect failed', err); });

setInterval(()=>{
  if (mongoose.connection.readyState === 1) return;
  log('Mongoose.readystate = ', mongoose.connection.readyState);
}, 1000);

हाँ, आप सही कह रहे हैं हमें इसके बारे में बेहतर करने की आवश्यकता है। timeout घटना आवश्यक है, लेकिन वास्तव में इस मामले को संभालने के लिए पर्याप्त नहीं है।

'डिस्कनेक्टेड' उत्सर्जित नहीं होने का कारण यह है कि 'टाइमआउट' का अर्थ है एक सॉकेट का समय समाप्त हो गया, संपूर्ण पूल नहीं। नेवला को यह जानने की आवश्यकता होगी कि टाइमआउट घटना होने पर पूल में कितने सॉकेट अभी भी जीवित हैं, और मुझे यह पता लगाने के लिए और अधिक जांच करने की आवश्यकता होगी कि हम यह कैसे करते हैं।

अधिक जांच करेंगे कि टाइमआउट ईवेंट फिर से क्यों निकलता रहता है। आपके धैर्य के लिए धन्यवाद: +1:

मैंने इसे मोंगोडब ड्राइवर में कुछ बगों के लिए ट्रैक किया: https://github.com/mongodb-js/mongodb-core/pull/215 । इससे पहले कि हम इसे नेवला में पैच कर सकें, विलय और तैनात होने के लिए उस पर इंतजार करना होगा।

@ vkarpov15 अपने स्वयं के परीक्षण में मैं mongoose.connection.readyState अनुभव कर रहा हूं जो कभी नहीं बदलता है। क्या यह वही मुद्दा है?

@ r3wt उस मुद्दे को 4.11.13 में तय किया जाना चाहिए, आप किस संस्करण का उपयोग कर रहे हैं?

@ vkarpov15 मैं अपनी पोस्ट के समय 4.11.11 का उपयोग कर रहा था। यह निराशाजनक है कि इस तरह के एक उल्लेखनीय पुस्तकालय के लिए इस तरह का स्पष्ट बुरा व्यवहार उत्पादन में घुस सकता है। शायद कुछ बेहतर परीक्षण प्रक्रियाओं की आवश्यकता है। (मैं अपमानजनक होने की कोशिश नहीं कर रहा हूं, मुझे पता है कि ओपन सोर्स प्रोजेक्ट्स को बनाए रखना कितना कठिन है। कभी-कभी यह बेकार होता है)

@ vkarpov15 मैं एक नेवला प्लगइन विकसित कर रहा हूँ। कनेक्शन तैयार होने तक प्लगइन को ब्लॉक करना आवश्यक है, अन्यथा यह कनेक्शन (कारणों के लिए) की प्रतीक्षा में गतिरोध करता है। कनेक्शन तैयार होने की प्रतीक्षा करने के लिए मैं जिस कोड का उपयोग कर रहा हूं वह निम्नलिखित है:

function ready(){
    console.log('ready()');
    return new Promise((resolve,reject)=>{
        var _int = setInterval(()=>{
            if(mongoose.connection.readyState == 1 || forceReady){
                clearInterval(_int);
                console.log('mongoose connected ready().resolve()')
                resolve();
            }
        },200);
    })
}

मैंने mongoose.connnection.on('connected') माध्यम से सुनने की भी कोशिश की, लेकिन अफसोस कि यह भी काम नहीं किया। एक खाली स्थापना पर यह ठीक काम किया। लेकिन अन्य नेवला प्लगइन्स और घटनाओं के लिए सामान सुनने के संयोजन के साथ, यह वह जगह है जहां समस्या होती है। कनेक्शन.रेडीस्टेट हमेशा के लिए 0 रहता है और जुड़ा हुआ ईवेंट कभी उत्सर्जित नहीं होता है।

ऐसा लगता है कि मेरी राय में require('mongoose') !== require('mongoose') । मुझे आशा है कि यह समझ में आता है।

अर्थात:

1. उपयोगकर्ता स्क्रिप्ट require('mongoose')
2. प्लगइन एक require('mongoose')
3. प्लगइन बी require('mongoose')

उपयोगकर्ता स्क्रिप्ट और प्लगइन कनेक्शन के बारे में जानकारी प्राप्त करते हैं। लेकिन प्लगइन बी कभी नहीं करता है। क्या इस का कोई मतलब निकलता है?

@ r3wt वास्तव में, यह निश्चित रूप से निराशाजनक है। हमने तब से ऐसे परीक्षण जोड़े हैं नेवला सही काम करता है । परेशानी के लिए हमें खेद है।

कनेक्शन तैयार होने तक अवरुद्ध करने के लिए, mongoose.connection.on('connected') को काम करना चाहिए। आप किन अन्य प्लगइन्स का उपयोग कर रहे हैं? npm list | grep "mongoose" चलाने का प्रयास करें, आपका यह दावा कि require('mongoose') !== require('mongoose') मुझे लगता है कि आपके पास कहीं न कहीं नेवले के कई संस्करण हैं।

दुर्भाग्य से इसे फिर से पीछे धकेलना होगा क्योंकि मोंगोडब ड्राइवर को रिहा करने से रोक दिया जाता है। इसके लिए खेद है और आपके धैर्य के लिए धन्यवाद: +1:

@ vkarpov15 इस फिक्स पर आपके काम के लिए बस इतना धन्यवाद कहना चाहता था। हम इसे कुछ महीनों से 0 मुद्दों के साथ उत्पादन में उपयोग कर रहे हैं।

@bendytree इस मुद्दे को रिप्रो-एड प्राप्त करने में आपकी तरह के शब्दों और आपके धैर्य के लिए धन्यवाद। मोंगोडब ड्राइवर टीम को मोंगोडब 3.6 रिलीज के लिए समय पर 3.0 रिलीज करने पर काम कर रहा है, इसलिए वे अभी तक इस फिक्स के साथ 2.x रिलीज नहीं कर पाए हैं, मैं उन्हें फिर से पिंग करूंगा। छुट्टियां आनंददायक हों!