Mongoose: 콜백이 중지됨

독립 실행형, 복제본 세트 또는 분할된 클러스터에 연결하고 있습니까? 또한 SSL을 사용하고 있는지 확인할 수 있습니까?

이것은 지난 며칠 동안 나에게 큰 문제였습니다. 실행 중인 모든 애플리케이션은 더 느리고 더 느린 이벤트 루프로 끝나고 전체 시스템에서 지연 시간이 증가했습니다. 노드 응용 프로그램을 다시 시작하면 매번 문제가 해결되었으며 몇 분 또는 몇 시간 동안 작동한 후에 다시 나타납니다.

mongoose 4.5.10으로 되돌리면 문제가 해결되었습니다.

• 복제본 세트에 연결
• SSL 사용

여기 4.6.0과 유사한 문제가 있습니다. 복제 세트에 연결하는지 여부는 확실하지 않지만 SSL을 사용하는 것은 확실합니다.

FWIW, 4.6.0은 지속적으로 연결을 끊었습니다. 4.5.10이 좋습니다.

@djanowski 연결 코드가 어떻게 생겼는지, 가지고 있는 mongodb의 버전과 같은 추가 정보를 제공할 수 있습니까?

@ vkarpov15 저는 MongoDB 3.2.6을 사용하고 있었습니다.

연결 옵션:

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

단일 몽고 또는 다중 몽고?

여러 몽고. Compose Mongo 배포 사용.

이 문제를 해결하는 데 도움이 될 수 있는 다른 작업이 있습니까? 이것은 우리가 최신 버전으로 이동하는 것을 차단하고 있습니다...

코드를 보지 않고는 실제 가설을 세우기가 어렵습니다. mongoose.connect 연결하는 경우 이 문제가 발생하기 시작할 때 mongoose.connection.readyState 값을 확인하겠습니다. 또한 모든 mongoose 작업에 대해 콘솔에 디버그 메시지를 인쇄하는 mongoose 디버그 모드 mongoose.set('debug', true) 활성화합니다. 해당 메시지가 인쇄 중인지 여부는 디버그에 확실히 도움이 될 것입니다.

@vkarpov15 이것은 내가 연결하는 데 사용하는 코드입니다. https://gist.github.com/sommestad/c0c6a7fa4feaadf84ecbb59cc3432c90
개인 모듈의 일부이므로 Gist.

_(연결 래핑 모듈을 사용하는 이유는 역사적으로 mongoose에서 잘 작동하지 않았던 다른 private NPM 모듈에서 연결이 가끔 재사용되기 때문입니다.)_

이러한 문제가 발생했을 때 연결 상태 로깅을 활성화했지만 연결 자체는 변경되지 않은 것 같습니다(최소한 이벤트는 발생하지 않음). 그래서 클라이언트의 연결이 끊어진 것 같지 않았습니다.

URI에서 replicaSet 로 연결되지 않습니다(대상 데이터베이스는 Compose Deployment ). 언급했듯이 SSL이 사용됩니다. 또한 트래픽은 AWS NAT 게이트웨이를 통해 라우팅됩니다. AWS NAT는 유휴 시간 제한이 5분이지만 이러한 문제는 트래픽이 많은 경우에도 발생했습니다.

나에게 몇 가지 문제, 당신은 그것을 해결 했습니까?

@youth7 아니 아이디어가 없습니다. 작성 배포에도 연결하고 있습니까? 추가 정보를 제공하십시오

이 문제의 원인을 찾기 위해 더 할 수 있는 일이 있습니까? 조사할 수 있는 이론이 있습니까?

@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 또한 Node의 모든 릴리스 라인(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.x LTS에 있습니다.

@djanowski 노드 4.4.2에서만 시도했습니다.

이 문제의 가능한 중복 목록 유지:

• #4638
• #4690
• #4901

참고로 4.5.10은 여기에서 잘 작동하는 것으로 보이며 지난 5시간 동안 문제가 없었습니다. 나는 또한 다운그레이드로 수정된 것으로 보이는 모든 컴퓨터에서 #4690과 같은 높은 CPU 사용량을 보였습니다.

여기에 새로운 개발 사항이 없습니까? 버그를 찾기 위해 더 할 수 있는 일이 있습니까?

@sommestad 최신 몽구스에서 여전히 이 문제가 있습니까?

지난번에 기본적으로 전체 시스템을 망가뜨렸기 때문에 아직 업그레이드를 감히 하지 않았습니다(변경 사항은 "일부" 시간 후에 나타나므로 오래 실행하지 않고는 확인하기 어렵습니다). 문제가 해결되었다고 믿을 만한 이유가 있다면 시스템의 더 격리된 부분에 시도해 볼 수 있습니까?

편집: ping @varunjayaraman

제 입장에서는 몇 주 전에 Node 6.x LTS로 전환하고 마지막 몽구스 버전으로 업그레이드했는데 그 이후로는 문제가 없었습니다.

우리는 약 두 달 전에 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
  ...
});

콜백이 중지되면 다시 시작되지 않습니다. 프로세스를 다시 시작하면 잘 연결됩니다.

문제 해결을 위해 수집할 수 있는 데이터가 있으면 기꺼이 도와드리겠습니다.

동일한 문제가 표시되며 아래 코드로 재현할 수 있습니다(빠른 목업/코드 스타일에 대해 죄송합니다).

연결 시간 초과를 시뮬레이션하기 위해 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

10초마다 데이터베이스의 readyState를 모니터링합니다. 이는 연결이 여전히 활성 상태임을 나타냅니다. 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를 사용하는 스크립트와 대조됩니다.

나는 이것이 Mongoose 대 Mongo 문제인지 여부를 배제하려고 노력하고 있으므로 이러한 스크립트의 결과를 비교하는 데 도움을 주시면 감사하겠습니다. 어쩌면 @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
• 몽고DB 2.2.30
• 몽구스 4.11.5

다음과 같이 업데이트했습니다.

• 노드 6.8.1
• 몽고DB 2.2.31
• 몽구스 4.11.7

내가 게시한 첫 번째 스크립트를 사용하여 로컬에서 여전히 문제를 재현할 수 있습니다. Mongo 연결 시간이 초과된 경우에만 발생하므로 다음을 시뮬레이션하는 쿼리를 변경할 수 있습니다.

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

(이 작업이 모든 컴퓨터에서 시간 초과를 유발하는지 확실하지 않으므로 재현을 위해 이 쿼리를 변경해야 할 수도 있습니다.)

mongoose 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 이 업데이트된 스크립트를 사용해 볼 수 있습니다. 나는 mongoose 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 with [email protected] , 이제 시간 초과 이벤트가 표시됩니다. 감사합니다. 그러나 여전히 이 콜백 문제가 표시됩니다( @bendytree 의 원래 스크립트를 사용하여 더 빠른 테스트를 위해 LONG_QUERY_DURATION_IN_MS를 2000으로, socketTimeoutMS를 1000으로 설정할 수 있음).

더 많은 테스트를 수행했으며 Mongoose 없이도 이것이 재현될 수 있다는 것을 알았습니다. 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://mongodb.github.io/node-mongodb-native/2.0/tutorials/connection_failures/ , 타임아웃 후에 콜백이 발생하지 않는 이유는 작업이 서버가 다시 연결될 때까지 기다리는 동안 버퍼링됩니다.

그래서 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가지 질문이 남습니다.

• 연결 이벤트가 발생하지 않는 이유(연결이 끊긴 이벤트가 표시될 것으로 예상됨)
• 시간 초과 이벤트 이벤트가 계속 발생하는 것 같습니다.

여기에 업데이트 된 스크립트 (@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 이벤트가 필요하지만 이 경우를 처리하기에는 충분하지 않습니다.

'disconnected'가 발생하지 않는 이유는 'timeout'이 전체 풀이 아니라 하나의 소켓이 시간 초과되었음을 의미하기 때문입니다. Mongoose는 타임아웃 이벤트가 발생했을 때 풀의 소켓이 몇 개나 아직 살아 있는지 알아야 하며, 이를 수행하는 방법을 알아내기 위해 더 많은 조사가 필요합니다.

시간 초과 이벤트가 계속 재발하는 이유를 더 조사할 것입니다. 기다려 주셔서 감사합니다 :+1:

나는 이것을 mongodb 드라이버의 몇 가지 버그로 추적했습니다: 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') 를 통해 듣기를 시도했지만 아아 그것도 작동하지 않았습니다. 빈 설치에서는 잘 작동했습니다. 그러나 다른 mongoose 플러그인 및 이벤트를 수신하는 항목과 함께 문제가 발생하는 곳입니다. connection.readyState는 영원히 0으로 유지되며 연결된 이벤트는 발생하지 않습니다.

제 생각에는 require('mongoose') !== require('mongoose') 것 같습니다. 이것이 의미가 있기를 바랍니다.

즉:

1. 사용자 스크립트 require('mongoose')
2. 플러그인 require('mongoose')
3. 플러그인 b require('mongoose')

사용자 스크립트와 플러그인은 연결에 대한 정보를 받습니다. 그러나 플러그인 b는 절대 그렇지 않습니다. 말이 됩니까?

@r3wt 참으로 그 이후 올바른 일 을 했습니다 . 불편을 끼쳐드려 죄송합니다.

연결이 준비될 때까지 차단하려면 mongoose.connection.on('connected') 가 작동해야 합니다. 다른 어떤 플러그인을 사용하고 있습니까? 실행 해보십시오 npm list | grep "mongoose" 것을, 당신의 주장을 require('mongoose') !== require('mongoose') 나에게 당신은 몽구스 곳의 여러 버전을 가지고 있다고 생각합니다.

불행히도 mongodb 드라이버가 릴리스되지 않기 때문에 이것을 다시 밀어야 합니다. 죄송하고 기다려주셔서 감사합니다 :+1: 🌴

@vkarpov15 이 수정 작업에 대해 정말 감사하다는 말을 전하고 싶었습니다. 우리는 0 문제로 지금 몇 달 동안 프로덕션에서 사용하고 있습니다.

@bendytree 이 문제를 재편집하는 데 있어 당신의 친절한 말과 인내에 감사드립니다. mongodb 드라이버 팀은 mongodb 3.6 릴리스에 맞춰 3.0을 릴리스하는 작업에 몰두했습니다. 그래서 그들은 아직 이 수정으로 2.x 릴리스를 내놓을 수 없었습니다. 다시 ping을 보내겠습니다. 즐거운 휴일 보내세요!