Mongoose: コールバックは起こりません

スタンドアロン、レプリカセット、またはシャードクラスターに接続していますか？ また、SSLを使用していることを確認できますか？

これは私にとって過去数日間の大きな問題でした。 実行中のすべてのアプリケーションは、イベントループがどんどん遅くなり、システム全体の遅延が増加しました。 Nodeアプリケーションを再起動すると、毎回問題が解決し、数分または数時間の操作後に問題が再発しました。

マングース4.5.10に戻すと、問題が解決しました。

• レプリカセットに接続しています
• SSLの使用

4.6.0の同様の問題で、レプリカセットに接続しているかどうかはわかりませんが、SSLを使用していることは間違いありません。

FWIW、4.6.0は常に接続を切断していました。 4.5.10は良いです。

@djanowski接続コードがどのように見えるか、どのバージョンのmongodbを使用しているかなど、さらに情報を提供できますか？

@ vkarpov15 MongoDB3.2.6を使用していました。

接続オプション：

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

単一のモンゴまたは複数のモンゴ？

複数のモンゴ。 ComposeMongoデプロイメントを使用します。

これのトラブルシューティングを支援するために他にできることはありますか？ これにより、新しいバージョンへの移行が妨げられています...

あなたのコードを見ずに本当の仮説を立てるのは難しいです。 mongoose.connectに接続している場合は、この問題が発生し始めたときにmongoose.connection.readyStateの値を確認します。 また、マングースのデバッグモードmongoose.set('debug', true)有効にします。これにより、マングースの操作ごとにデバッグメッセージがコンソールに出力されます。 それらのメッセージが印刷されているかどうかは、間違いなくデバッグに役立ちます。

@ vkarpov15これは私が接続するために使用しているコードです： https ： //gist.github.com/sommestad/c0c6a7fa4feaadf84ecbb59cc3432c90
これはプライベートモジュールの一部であるため、要点です。

_（接続ラッピングモジュールの理由は、接続が他のプライベートNPMモジュールで再利用されることがあるためです。これは、これまでマングースではうまく機能していませんでした。）_

これらの問題が発生したときに接続状態のログを有効にしましたが、接続自体は変更されていないようです（少なくともイベントは発行されませんでした）。 そのため、クライアントが切断されたようには見えませんでした。

URIのreplicaSetと接続していません（ターゲットデータベースはCompose Deploymentです）。 前述のように、SSLが使用されます。 また、トラフィックはAWSNATゲートウェイを介してルーティングされます。 AWS NATのアイドルタイムアウトは5分ですが、これらの問題はトラフィックが多い場合でも発生しました。

私にとっていくつかの問題、あなたはそれを解決しましたか？

@ youth7いやアイデアはありません。 また、composeデプロイメントに接続していますか？ 追加情報を提供してください

これの原因を見つけるために私ができることは他にありますか？ 調査できる理論はありますか？

@sommestad具体的なことは何もありません。 作曲からのログはありますか？

mongoose 4.7.2を試しましたが、48時間後に同じ問題が発生しました。 この時点で、私は独自の問題を抱えている4.4.11悩まされています。

ログを収集することを期待してデモサーバーに4.7.2をインストールしましたが、問題なく2週間実行されています。 たぶん、データ/接続などの量が問題を引き起こしますか？

それが起こり始めると、それを再現するためのコードは非常に簡単です。 基本的に、クエリのコールバックはすべて消えます。

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

私が言ったように、これが起こっているとき、 mongoose.connection.readyState === CONNECTED

変。 私はmongodbログを意味しました-そのエラーが発生したときからmongodbサーバーログをダンプできますか？

この障害が発生したときにDBログをスキャンしたところ、異常なことは何も見られませんでした。 接続数、切断数、接続の問題などに関連する問題はありませんでした。 また、順不同で何も見えなかったComposeにも連絡を取りました。

@bendytree HTTP負荷テストツールを使用して、そのデモサーバーにボリュームをスローできますか？

@bendytreeまた、ノードのすべてのリリースライン（4.x、6.x、7.x）で発生しますか？

@ vkarpov15最新のMongoDBドライバーでテストできるように、4.7.7を

@ vkarpov15 66d559b19a86c70e30a8f083d03eb22566571b7eありがとう！ やってみます。

ここでも同じですが、ここではSSLレプリカで、数分/時間後、リクエストはcallback（）で停止し（さらに詳細なログを追加しました）、エラーは発生しません。 昨夜4.7.7にアップグレードしましたが、まだ問題があります。

編集：4.7.0にダウングレードしようとしましたが、最悪でした（5分以内に問題が発生しました）。 4.5.10を試しています。

@gierschvノード6.9.x？

@djanowskiいいえ、まだ4.6 / 4.7.xLTSです。

@djanowskiノード4.4.2でのみ試しました

この問題の重複の可能性のあるリストを保持する：

• ＃4638
• ＃4690
• ＃4901

参考までに、4.5.10はここではうまく機能しているようで、過去5時間は問題ありません。 また、すべてのマシンで＃4690のような高いCPU使用率がありましたが、これもダウングレードによって修正されたようです。

ここに新しい開発はありませんか？ バグを見つけるために私たちにできることは他にありますか？

@sommestad最新のマングースでまだこの問題がありますか？

前回は基本的にシステム全体が壊れたので、まだあえてアップグレードしていません（変更は「しばらくして」から表示されるため、長時間実行しないと確認が困難です）。 修正されたと信じる理由がある場合は、システムのより分離された部分を試すことができますか？

編集：ping @varunjayaraman

私の側では、ノード6.x LTSに切り替えて、数週間前に最後のマングースバージョンにアップグレードしましたが、それ以降は問題ありません。

約2か月前にノード6.10.2、マングース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
  ...
});

コールバックが停止すると、再び開始することはありません。 プロセスを再開すると、正常に接続されます。

トラブルシューティングに役立つデータを収集できる場合は、ぜひサポートさせていただきます。

同じ問題が発生しており、以下のコードで再現できます（高速なモックアップ/コードスタイルで申し訳ありません）。

接続タイムアウトをシミュレートするために、poolSizeを1に下げ、次の順序で呼び出される2つのエンドポイント（通常/低速）への要求をトリガーします。

1. 通常のエンドポイント（結果をすぐに返します）
2. 遅いエンドポイント（遅いクエリを開始します）
3. 通常のエンドポイント（2で使用されているため、使用可能な接続を待機します）
4. 通常のエンドポイント（2と3でMongoError /接続タイムアウトが発生した場合、1分後にトリガーされます）

以下を使用して複製します。

// 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

データベースのreadyStateを10秒ごとに監視しています。これは、接続がまだアクティブであることを示しています。 Mongooseエラー/タイムアウトイベントはトリガーされず、リクエスト4のコールバックは呼び出されません（リクエストパッケージを使用して60秒後にタイムアウトします）。 http：// localhost ：4000 / slowおよび次のhttp：// localhost ：4000 / normalにアクセスしてテストすることもできます。

https://team.goodeggs.com/reconnecting-to-mongodb-when-mongoose-connect-fails-at-startup-83ca8496ca02に基づく自動再接続ロジックを使用していますが、mongoが切断されないため、これがトリガーされることはありません。

ある場合には、テストデータを作成するコードにコメントすると再現できないことがあります（したがって、基本的に空のコレクションをクエリします）

考えられる関連する問題：

• ＃4789
• ＃4660

どんな助けでも大歓迎です。

そこで、mongooseを使用せずにnode-mongodb-nativeを操作するために、上記のスクリプトを書き直してさらに掘り下げました。 結果は今では大きく異なります。

接続設定と要求は同じです。

1. 通常のエンドポイント（結果をすぐに返します）
2. 遅いエンドポイント（遅いクエリを開始します）
3. 通常のエンドポイント（2で使用されているため、使用可能な接続を待機します）
4. 通常のエンドポイント（1分後にトリガーされます）

コード：

// 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' } ]

前のスクリプトのようにMongoエラー/タイムアウトイベントはトリガーされませんが、リクエスト2と3は正しく解決され、リクエスト4のコールバックもトリガーされます-Mongooseを使用しているスクリプトとは対照的です。

私はこれがマングースとモンゴの問題であるかどうかを除外しようとしています-したがって、これらのスクリプトの結果を比較することに関する助けをいただければ幸いです。 たぶん@ 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
$ 

マングースは接続を維持します。 mongodb、node、mongooseのバージョンを明確にできますか？

テストしてくれてありがとう！ 実際、Mongooseは常に接続されたままですが、コールバックは発生しなくなります（Expressにリクエストが届くのを確認できますが、タイムアウトします）

私はテストしていました：

• ノード6.8.1
• mongodb 2.2.30
• マングース4.11.5

更新しました：

• ノード6.8.1
• mongodb 2.2.31
• マングース4.11.7

最初に投稿したスクリプトを使用して、問題をローカルで再現できます。 これは、Mongo接続がタイムアウトしたときにのみ発生するため、これをシミュレートするクエリを変更することをお勧めします。

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この更新されたスクリプトを試すことができますか？ マングース4.8.11でテストして再現しました。

@bendytreeでなんとか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ドライバーのソケットがタイムアウトしたことを示しています。 mongodbドライバーはデフォルトで30秒後にタイムアウトしますが、OSにも注意が必要なソケットタイムアウトがあるため、15秒以上かかるクエリは避けることをお勧めします。 ただし、 socketTimeoutMSオプションを使用して、mongodbのソケットタイムアウトを構成できます。

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

しかし、後続のクエリは成功します。

いずれにせよ、この場合、マングースはタイムアウトイベントを発行するはずなので、その問題を修正します。

connectTimeoutMS（デフォルトは30000ms）とsocketTimeoutMS（デフォルトは360000ms）を混同していると思います。

socketTimeoutMSを、ドライバーを介して実行される最も遅い操作の長さの2〜3倍に設定することをお勧めします。socketTimeoutMSを0に設定すると、実際にはオペレーティングシステムのデフォルトのソケットタイムアウト値が適用されます（詳細については、http：//mongodb.github.io/を参照してください）。 node-mongodb-native / 2.2 / reference / faq /）。

したがって、この質問は残ります。この制限（固定またはデフォルトのOSタイムアウト）に達したときに、なぜこれらのコールバックが発生しなくなるのですか？

vkarpov15 @ [email protected] 、私は今、そのためのおかげでタイムアウトイベントを参照してください。 ただし、このコールバックの問題は引き続き発生します（ @bendytreeの元のスクリプトを使用すると、テストを高速化するために、LONG_QUERY_DURATION_IN_MSを2000に、socketTimeoutMSを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...

したがって、コールバックはautoReconnectをtrueに設定して機能しているようです👍

この記事をさらに読んだとき： http ：

だから私はautoReconnectをfalse autoReconnect戻してみました+ 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つの質問が

• 接続イベントが発行されないのはなぜですか（切断されたイベントが表示されると思います）
• タイムアウトイベントイベントが発生し続けるようです

更新されたスクリプトは次のとおりです（

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イベントは必要ですが、このケースを処理するには実際には十分ではありません。

'disconnected'が発行されない理由は、 'timeout'は、プール全体ではなく、1つのソケットがタイムアウトしたことを意味するためです。 マングースは、タイムアウトイベントが発生したときに、プール内のまだ生きているソケットの数を知る必要があります。その方法を理解するには、さらに調査する必要があります。

タイムアウトイベントが再送信し続ける理由をさらに調査します。 お待ちいただきありがとうございます：+1：

私はこれをmongodbドライバーのいくつかのバグまで追跡しました： https ：

私自身のテストで@ vkarpov15は、 mongoose.connection.readyStateが変更されることはありません。 これは同じ問題ですか？

@ r3wtその問題は

@ vkarpov15投稿時に

@ 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')聞いてみましたが、残念ながらうまくいきませんでした。 ブランクインストールでは、正常に機能しました。 しかし、他のマングースプラグインやイベントをリッスンしているものと組み合わせて、問題が発生する場所です。 connection.readyStateは永久に0のままであり、接続されたイベントが発行されることはありません。

私の意見ではrequire('mongoose') !== require('mongoose')です。 これが理にかなっていることを願っています。

NS：

1. ユーザースクリプトrequire('mongoose')
2. プラグインrequire('mongoose')
3. プラグインb require('mongoose')

ユーザースクリプトとプラグインは、接続に関する情報を受け取ります。 しかし、プラグインbは決してそうしません。 それは意味がありますか？

@ r3wt確かに、それは間違いなくがっかりします。 それ以来、mongodbサーバーを実際に停止/起動し、mongooseが将来これが発生するのを防ぐために行うと主張するテストを追加しました。 ご迷惑をおかけして申し訳ございません。

接続の準備ができるまでブロックする場合は、 mongoose.connection.on('connected')が機能するはずです。 他にどのプラグインを使用していますか？ npm list | grep "mongoose"実行してみてください。 require('mongoose') !== require('mongoose')というあなたの主張は、どこかに複数のバージョンのマングースがあると私に思わせます。

残念ながら、mongodbドライバーのリリースが保留されているため、これをもう一度プッシュする必要があります。 申し訳ありませんが、今しばらくお待ちいただきますようお願いいたします：+1：🌴

@ vkarpov15この修正にご協力いただきありがとう

@bendytreeは、この問題を再現するための親切な言葉と忍耐に感謝します。 mongodbドライバーチームは、mongodb 3.6のリリースに間に合うように3.0のリリースに取り組んでいるため、この修正で2.xのリリースをまだ出すことができませんでした。もう一度、pingを実行します。 ハッピーホリデー！