mongodb 3.5.7 → 3.5.11

package/lib/cmap/connection_pool.js

@@ -198,6 +198,10 @@ class ConnectionPool extends EventEmitter {
     return this[kConnections].length;
   }
 
+  get waitQueueSize() {
+    return this[kWaitQueue].length;
+  }
+
   /**
    * Check a connection out of this pool. The connection will continue to be tracked, but no reference to it
    * will be held by the pool. This means that if a connection is checked out it MUST be checked back in or
@@ -295,7 +299,7 @@ class ConnectionPool extends EventEmitter {
     this[kCancellationToken].emit('cancel');
 
     // drain the wait queue
-    while (this[kWaitQueue].length) {
+    while (this.waitQueueSize) {
       const waitQueueMember = this[kWaitQueue].pop();
       clearTimeout(waitQueueMember.timer);
       if (!waitQueueMember[kCancelled]) {
@@ -449,13 +453,17 @@ function processWaitQueue(pool) {
     return;
   }
 
-  while (pool[kWaitQueue].length && pool.availableConnectionCount) {
+  while (pool.waitQueueSize) {
     const waitQueueMember = pool[kWaitQueue].peekFront();
     if (waitQueueMember[kCancelled]) {
       pool[kWaitQueue].shift();
       continue;
     }
 
+    if (!pool.availableConnectionCount) {
+      break;
+    }
+
     const connection = pool[kConnections].shift();
     const isStale = connectionIsStale(pool, connection);
     const isIdle = connectionIsIdle(pool, connection);
@@ -472,7 +480,7 @@ function processWaitQueue(pool) {
   }
 
   const maxPoolSize = pool.options.maxPoolSize;
-  if (pool[kWaitQueue].length && (maxPoolSize <= 0 || pool.totalConnectionCount < maxPoolSize)) {
+  if (pool.waitQueueSize && (maxPoolSize <= 0 || pool.totalConnectionCount < maxPoolSize)) {
     createConnection(pool, (err, connection) => {
       const waitQueueMember = pool[kWaitQueue].shift();
       if (waitQueueMember == null) {

package/lib/collection.js

@@ -16,7 +16,6 @@ const unordered = require('./bulk/unordered');
 const ordered = require('./bulk/ordered');
 const ChangeStream = require('./change_stream');
 const executeLegacyOperation = require('./utils').executeLegacyOperation;
-const resolveReadPreference = require('./utils').resolveReadPreference;
 const WriteConcern = require('./write_concern');
 const ReadConcern = require('./read_concern');
 const MongoDBNamespace = require('./utils').MongoDBNamespace;
@@ -399,7 +398,7 @@ Collection.prototype.find = deprecateOptions(
     newOptions.slaveOk = options.slaveOk != null ? options.slaveOk : this.s.db.slaveOk;
 
     // Add read preference if needed
-    newOptions.readPreference = resolveReadPreference(this, newOptions);
+    newOptions.readPreference = ReadPreference.resolve(this, newOptions);
 
     // Set slave ok to true if read preference different from primary
     if (
@@ -1978,7 +1977,7 @@ Collection.prototype.parallelCollectionScan = deprecate(function(options, callba
 
   options = Object.assign({}, options);
   // Ensure we have the right read preference inheritance
-  options.readPreference = resolveReadPreference(this, options);
+  options.readPreference = ReadPreference.resolve(this, options);
 
   // Add a promiseLibrary
   options.promiseLibrary = this.s.promiseLibrary;

package/lib/core/connection/apm.js

@@ -2,7 +2,7 @@
 const Msg = require('../connection/msg').Msg;
 const KillCursor = require('../connection/commands').KillCursor;
 const GetMore = require('../connection/commands').GetMore;
-const calculateDurationInMs = require('../utils').calculateDurationInMs;
+const calculateDurationInMs = require('../../utils').calculateDurationInMs;
 
 /** Commands that we want to redact because of the sensitive nature of their contents */
 const SENSITIVE_COMMANDS = new Set([

package/lib/core/connection/pool.js

@@ -21,6 +21,7 @@ const connect = require('./connect');
 const updateSessionFromResponse = require('../sessions').updateSessionFromResponse;
 const eachAsync = require('../utils').eachAsync;
 const makeStateMachine = require('../utils').makeStateMachine;
+const now = require('../../utils').now;
 
 const DISCONNECTED = 'disconnected';
 const CONNECTING = 'connecting';
@@ -898,7 +899,7 @@ Pool.prototype.write = function(command, options, cb) {
   if (self.options.monitorCommands) {
     this.emit('commandStarted', new apm.CommandStartedEvent(this, command));
 
-    operation.started = process.hrtime();
+    operation.started = now();
     operation.cb = (err, reply) => {
       if (err) {
         self.emit(

package/lib/core/cursor.js

@@ -4,7 +4,6 @@ const Logger = require('./connection/logger');
 const retrieveBSON = require('./connection/utils').retrieveBSON;
 const MongoError = require('./error').MongoError;
 const MongoNetworkError = require('./error').MongoNetworkError;
-const mongoErrorContextSymbol = require('./error').mongoErrorContextSymbol;
 const collationNotSupported = require('./utils').collationNotSupported;
 const ReadPreference = require('./topologies/read_preference');
 const isUnifiedTopology = require('./utils').isUnifiedTopology;
@@ -412,7 +411,15 @@ class CoreCursor extends Readable {
       batchSize = this.cursorState.limit - this.cursorState.currentLimit;
     }
 
-    this.server.getMore(this.ns, this.cursorState, batchSize, this.options, callback);
+    const cursorState = this.cursorState;
+    this.server.getMore(this.ns, cursorState, batchSize, this.options, (err, result, conn) => {
+      // NOTE: `getMore` modifies `cursorState`, would be very ideal not to do so in the future
+      if (err || (cursorState.cursorId && cursorState.cursorId.isZero())) {
+        this._endSession();
+      }
+
+      callback(err, result, conn);
+    });
   }
 
   _initializeCursor(callback) {
@@ -433,18 +440,15 @@ class CoreCursor extends Readable {
     }
 
     function done(err, result) {
-      if (
-        cursor.cursorState.cursorId &&
-        cursor.cursorState.cursorId.isZero() &&
-        cursor._endSession
-      ) {
+      const cursorState = cursor.cursorState;
+      if (err || (cursorState.cursorId && cursorState.cursorId.isZero())) {
         cursor._endSession();
       }
 
       if (
-        cursor.cursorState.documents.length === 0 &&
-        cursor.cursorState.cursorId &&
-        cursor.cursorState.cursorId.isZero() &&
+        cursorState.documents.length === 0 &&
+        cursorState.cursorId &&
+        cursorState.cursorId.isZero() &&
         !cursor.cmd.tailable &&
         !cursor.cmd.awaitData
       ) {
@@ -460,50 +464,41 @@ class CoreCursor extends Readable {
       }
 
       const result = r.message;
-      if (result.queryFailure) {
-        return done(new MongoError(result.documents[0]), null);
-      }
 
-      // Check if we have a command cursor
-      if (
-        Array.isArray(result.documents) &&
-        result.documents.length === 1 &&
-        (!cursor.cmd.find || (cursor.cmd.find && cursor.cmd.virtual === false)) &&
-        (typeof result.documents[0].cursor !== 'string' ||
-          result.documents[0]['$err'] ||
-          result.documents[0]['errmsg'] ||
-          Array.isArray(result.documents[0].result))
-      ) {
-        // We have an error document, return the error
-        if (result.documents[0]['$err'] || result.documents[0]['errmsg']) {
-          return done(new MongoError(result.documents[0]), null);
+      if (Array.isArray(result.documents) && result.documents.length === 1) {
+        const document = result.documents[0];
+
+        if (result.queryFailure) {
+          return done(new MongoError(document), null);
         }
 
-        // We have a cursor document
-        if (result.documents[0].cursor != null && typeof result.documents[0].cursor !== 'string') {
-          const id = result.documents[0].cursor.id;
-          // If we have a namespace change set the new namespace for getmores
-          if (result.documents[0].cursor.ns) {
-            cursor.ns = result.documents[0].cursor.ns;
+        // Check if we have a command cursor
+        if (!cursor.cmd.find || (cursor.cmd.find && cursor.cmd.virtual === false)) {
+          // We have an error document, return the error
+          if (document.$err || document.errmsg) {
+            return done(new MongoError(document), null);
           }
-          // Promote id to long if needed
-          cursor.cursorState.cursorId = typeof id === 'number' ? Long.fromNumber(id) : id;
-          cursor.cursorState.lastCursorId = cursor.cursorState.cursorId;
-          cursor.cursorState.operationTime = result.documents[0].operationTime;
-
-          // If we have a firstBatch set it
-          if (Array.isArray(result.documents[0].cursor.firstBatch)) {
-            cursor.cursorState.documents = result.documents[0].cursor.firstBatch; //.reverse();
-          }
-
-          // Return after processing command cursor
-          return done(null, result);
-        }
 
-        if (Array.isArray(result.documents[0].result)) {
-          cursor.cursorState.documents = result.documents[0].result;
-          cursor.cursorState.cursorId = Long.ZERO;
-          return done(null, result);
+          // We have a cursor document
+          if (document.cursor != null && typeof document.cursor !== 'string') {
+            const id = document.cursor.id;
+            // If we have a namespace change set the new namespace for getmores
+            if (document.cursor.ns) {
+              cursor.ns = document.cursor.ns;
+            }
+            // Promote id to long if needed
+            cursor.cursorState.cursorId = typeof id === 'number' ? Long.fromNumber(id) : id;
+            cursor.cursorState.lastCursorId = cursor.cursorState.cursorId;
+            cursor.cursorState.operationTime = document.operationTime;
+
+            // If we have a firstBatch set it
+            if (Array.isArray(document.cursor.firstBatch)) {
+              cursor.cursorState.documents = document.cursor.firstBatch; //.reverse();
+            }
+
+            // Return after processing command cursor
+            return done(null, result);
+          }
         }
       }
 
@@ -690,8 +685,8 @@ function _setCursorNotifiedImpl(self, callback) {
   self.cursorState.documents = [];
   self.cursorState.cursorIndex = 0;
 
-  if (self._endSession) {
-    self._endSession(undefined, () => callback());
+  if (self.cursorState.session) {
+    self._endSession(callback);
     return;
   }
 
@@ -774,17 +769,9 @@ function nextFunction(self, callback) {
     // Execute the next get more
     self._getMore(function(err, doc, connection) {
       if (err) {
-        if (err instanceof MongoError) {
-          err[mongoErrorContextSymbol].isGetMore = true;
-        }
-
         return handleCallback(callback, err);
       }
 
-      if (self.cursorState.cursorId && self.cursorState.cursorId.isZero() && self._endSession) {
-        self._endSession();
-      }
-
       // Save the returned connection to ensure all getMore's fire over the same connection
       self.connection = connection;
 

package/lib/core/error.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const mongoErrorContextSymbol = Symbol('mongoErrorContextSymbol');
-
 /**
  * Creates a new MongoError
  *
@@ -21,6 +19,10 @@ class MongoError extends Error {
       } else {
         super(message.message || message.errmsg || message.$err || 'n/a');
         for (var name in message) {
+          if (name === 'errmsg') {
+            continue;
+          }
+
           this[name] = message[name];
         }
       }
@@ -29,7 +31,13 @@ class MongoError extends Error {
     }
 
     this.name = 'MongoError';
-    this[mongoErrorContextSymbol] = this[mongoErrorContextSymbol] || {};
+  }
+
+  /**
+   * Legacy name for server error responses
+   */
+  get errmsg() {
+    return this.message;
   }
 
   /**
@@ -262,7 +270,6 @@ module.exports = {
   MongoTimeoutError,
   MongoServerSelectionError,
   MongoWriteConcernError,
-  mongoErrorContextSymbol,
   isRetryableError,
   isSDAMUnrecoverableError,
   isNodeShuttingDownError,

package/lib/core/index.js

@@ -22,7 +22,6 @@ module.exports = {
   MongoTimeoutError: require('./error').MongoTimeoutError,
   MongoServerSelectionError: require('./error').MongoServerSelectionError,
   MongoWriteConcernError: require('./error').MongoWriteConcernError,
-  mongoErrorContextSymbol: require('./error').mongoErrorContextSymbol,
   // Core
   Connection: require('./connection/connection'),
   Server: require('./topologies/server'),

package/lib/core/sdam/monitor.js

@@ -1,13 +1,15 @@
 'use strict';
 
 const ServerType = require('./common').ServerType;
-const calculateDurationInMs = require('../utils').calculateDurationInMs;
 const EventEmitter = require('events');
 const connect = require('../connection/connect');
 const Connection = require('../../cmap/connection').Connection;
 const common = require('./common');
 const makeStateMachine = require('../utils').makeStateMachine;
 const MongoError = require('../error').MongoError;
+const makeInterruptableAsyncInterval = require('../../utils').makeInterruptableAsyncInterval;
+const calculateDurationInMs = require('../../utils').calculateDurationInMs;
+const now = require('../../utils').now;
 
 const sdamEvents = require('./events');
 const ServerHeartbeatStartedEvent = sdamEvents.ServerHeartbeatStartedEvent;
@@ -18,7 +20,6 @@ const kServer = Symbol('server');
 const kMonitorId = Symbol('monitorId');
 const kConnection = Symbol('connection');
 const kCancellationToken = Symbol('cancellationToken');
-const kLastCheckTime = Symbol('lastCheckTime');
 
 const STATE_CLOSED = common.STATE_CLOSED;
 const STATE_CLOSING = common.STATE_CLOSING;
@@ -33,6 +34,10 @@ const stateTransition = makeStateMachine({
 
 const INVALID_REQUEST_CHECK_STATES = new Set([STATE_CLOSING, STATE_CLOSED, STATE_MONITORING]);
 
+function isInCloseState(monitor) {
+  return monitor.s.state === STATE_CLOSED || monitor.s.state === STATE_CLOSING;
+}
+
 class Monitor extends EventEmitter {
   constructor(server, options) {
     super(options);
@@ -41,6 +46,7 @@ class Monitor extends EventEmitter {
     this[kConnection] = undefined;
     this[kCancellationToken] = new EventEmitter();
     this[kCancellationToken].setMaxListeners(Infinity);
+    this[kMonitorId] = null;
     this.s = {
       state: STATE_CLOSED
     };
@@ -60,13 +66,12 @@ class Monitor extends EventEmitter {
     });
 
     // TODO: refactor this to pull it directly from the pool, requires new ConnectionPool integration
-    const addressParts = server.description.address.split(':');
     this.connectOptions = Object.freeze(
       Object.assign(
         {
           id: '<monitor>',
-          host: addressParts[0],
-          port: parseInt(addressParts[1], 10),
+          host: server.description.host,
+          port: server.description.port,
           bson: server.s.bson,
           connectionType: Connection
         },
@@ -89,7 +94,14 @@ class Monitor extends EventEmitter {
       return;
     }
 
-    monitorServer(this);
+    // start
+    const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS;
+    const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS;
+    this[kMonitorId] = makeInterruptableAsyncInterval(monitorServer(this), {
+      interval: heartbeatFrequencyMS,
+      minInterval: minHeartbeatFrequencyMS,
+      immediate: true
+    });
   }
 
   requestCheck() {
@@ -97,31 +109,19 @@ class Monitor extends EventEmitter {
       return;
     }
 
-    const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS;
-    const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS;
-    const remainingTime = heartbeatFrequencyMS - calculateDurationInMs(this[kLastCheckTime]);
-    if (remainingTime > minHeartbeatFrequencyMS && this[kMonitorId]) {
-      clearTimeout(this[kMonitorId]);
-      rescheduleMonitoring(this, minHeartbeatFrequencyMS);
-      return;
-    }
-
-    if (this[kMonitorId]) {
-      clearTimeout(this[kMonitorId]);
-    }
-
-    monitorServer(this);
+    this[kMonitorId].wake();
   }
 
   close() {
-    if (this.s.state === STATE_CLOSED || this.s.state === STATE_CLOSING) {
+    if (isInCloseState(this)) {
       return;
     }
 
     stateTransition(this, STATE_CLOSING);
     this[kCancellationToken].emit('cancel');
     if (this[kMonitorId]) {
-      clearTimeout(this[kMonitorId]);
+      this[kMonitorId].stop();
+      this[kMonitorId] = null;
     }
 
     if (this[kConnection]) {
@@ -138,7 +138,7 @@ function checkServer(monitor, callback) {
     monitor[kConnection] = undefined;
   }
 
-  const start = process.hrtime();
+  const start = now();
   monitor.emit('serverHeartbeatStarted', new ServerHeartbeatStartedEvent(monitor.address));
 
   function failureHandler(err) {
@@ -186,7 +186,7 @@ function checkServer(monitor, callback) {
       return;
     }
 
-    if (monitor.s.state === STATE_CLOSING || monitor.s.state === STATE_CLOSED) {
+    if (isInCloseState(monitor)) {
       conn.destroy({ force: true });
       failureHandler(new MongoError('monitor was destroyed'));
       return;
@@ -198,52 +198,44 @@ function checkServer(monitor, callback) {
 }
 
 function monitorServer(monitor) {
-  stateTransition(monitor, STATE_MONITORING);
-
-  // TODO: the next line is a legacy event, remove in v4
-  process.nextTick(() => monitor.emit('monitoring', monitor[kServer]));
+  return callback => {
+    stateTransition(monitor, STATE_MONITORING);
+    function done() {
+      if (!isInCloseState(monitor)) {
+        stateTransition(monitor, STATE_IDLE);
+      }
 
-  checkServer(monitor, e0 => {
-    if (e0 == null) {
-      rescheduleMonitoring(monitor);
-      return;
+      callback();
     }
 
-    // otherwise an error occured on initial discovery, also bail
-    if (monitor[kServer].description.type === ServerType.Unknown) {
-      monitor.emit('resetServer', e0);
-      rescheduleMonitoring(monitor);
-      return;
-    }
+    // TODO: the next line is a legacy event, remove in v4
+    process.nextTick(() => monitor.emit('monitoring', monitor[kServer]));
 
-    // According to the SDAM specification's "Network error during server check" section, if
-    // an ismaster call fails we reset the server's pool. If a server was once connected,
-    // change its type to `Unknown` only after retrying once.
-    monitor.emit('resetConnectionPool');
-
-    checkServer(monitor, e1 => {
-      if (e1) {
-        monitor.emit('resetServer', e1);
+    checkServer(monitor, e0 => {
+      if (e0 == null) {
+        return done();
       }
 
-      rescheduleMonitoring(monitor);
-    });
-  });
-}
+      // otherwise an error occured on initial discovery, also bail
+      if (monitor[kServer].description.type === ServerType.Unknown) {
+        monitor.emit('resetServer', e0);
+        return done();
+      }
 
-function rescheduleMonitoring(monitor, ms) {
-  const heartbeatFrequencyMS = monitor.options.heartbeatFrequencyMS;
-  if (monitor.s.state === STATE_CLOSING || monitor.s.state === STATE_CLOSED) {
-    return;
-  }
+      // According to the SDAM specification's "Network error during server check" section, if
+      // an ismaster call fails we reset the server's pool. If a server was once connected,
+      // change its type to `Unknown` only after retrying once.
+      monitor.emit('resetConnectionPool');
 
-  stateTransition(monitor, STATE_IDLE);
+      checkServer(monitor, e1 => {
+        if (e1) {
+          monitor.emit('resetServer', e1);
+        }
 
-  monitor[kLastCheckTime] = process.hrtime();
-  monitor[kMonitorId] = setTimeout(() => {
-    monitor[kMonitorId] = undefined;
-    monitor.requestCheck();
-  }, ms || heartbeatFrequencyMS);
+        done();
+      });
+    });
+  };
 }
 
 module.exports = {

package/lib/core/sdam/server.js

@@ -110,9 +110,8 @@ class Server extends EventEmitter {
 
     // create the connection pool
     // NOTE: this used to happen in `connect`, we supported overriding pool options there
-    const addressParts = this.description.address.split(':');
     const poolOptions = Object.assign(
-      { host: addressParts[0], port: parseInt(addressParts[1], 10), bson: this.s.bson },
+      { host: this.description.host, port: this.description.port, bson: this.s.bson },
       options
     );
 
@@ -415,6 +414,10 @@ Object.defineProperty(Server.prototype, 'clusterTime', {
 });
 
 function calculateRoundTripTime(oldRtt, duration) {
+  if (oldRtt === -1) {
+    return duration;
+  }
+
   const alpha = 0.2;
   return alpha * duration + (1 - alpha) * oldRtt;
 }

package/lib/core/sdam/server_description.js

@@ -4,6 +4,7 @@ const arrayStrictEqual = require('../utils').arrayStrictEqual;
 const tagsStrictEqual = require('../utils').tagsStrictEqual;
 const errorStrictEqual = require('../utils').errorStrictEqual;
 const ServerType = require('./common').ServerType;
+const now = require('../../utils').now;
 
 const WRITABLE_SERVER_TYPES = new Set([
   ServerType.RSPrimary,
@@ -70,7 +71,7 @@ class ServerDescription {
     this.address = address;
     this.error = options.error;
     this.roundTripTime = options.roundTripTime || -1;
-    this.lastUpdateTime = Date.now();
+    this.lastUpdateTime = now();
     this.lastWriteDate = ismaster.lastWrite ? ismaster.lastWrite.lastWriteDate : null;
     this.opTime = ismaster.lastWrite ? ismaster.lastWrite.opTime : null;
     this.type = parseServerType(ismaster);
@@ -112,6 +113,16 @@ class ServerDescription {
     return WRITABLE_SERVER_TYPES.has(this.type);
   }
 
+  get host() {
+    const chopLength = `:${this.port}`.length;
+    return this.address.slice(0, -chopLength);
+  }
+
+  get port() {
+    const port = this.address.split(':').pop();
+    return port ? Number.parseInt(port, 10) : port;
+  }
+
   /**
    * Determines if another `ServerDescription` is equal to this one per the rules defined
    * in the {@link https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.rst#serverdescription|SDAM spec}

package/lib/core/sdam/server_selection.js

@@ -48,7 +48,7 @@ function maxStalenessReducer(readPreference, topologyDescription, servers) {
   }
 
   if (topologyDescription.type === TopologyType.ReplicaSetWithPrimary) {
-    const primary = servers.filter(primaryFilter)[0];
+    const primary = Array.from(topologyDescription.servers.values()).filter(primaryFilter)[0];
     return servers.reduce((result, server) => {
       const stalenessMS =
         server.lastUpdateTime -
@@ -60,7 +60,13 @@ function maxStalenessReducer(readPreference, topologyDescription, servers) {
       if (staleness <= readPreference.maxStalenessSeconds) result.push(server);
       return result;
     }, []);
-  } else if (topologyDescription.type === TopologyType.ReplicaSetNoPrimary) {
+  }
+
+  if (topologyDescription.type === TopologyType.ReplicaSetNoPrimary) {
+    if (servers.length === 0) {
+      return servers;
+    }
+
     const sMax = servers.reduce((max, s) => (s.lastWriteDate > max.lastWriteDate ? s : max));
     return servers.reduce((result, server) => {
       const stalenessMS =
@@ -197,50 +203,32 @@ function readPreferenceServerSelector(readPreference) {
       return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
     }
 
-    if (readPreference.mode === ReadPreference.PRIMARY) {
+    const mode = readPreference.mode;
+    if (mode === ReadPreference.PRIMARY) {
       return servers.filter(primaryFilter);
     }
 
-    if (readPreference.mode === ReadPreference.SECONDARY) {
-      return latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(secondaryFilter);
-    } else if (readPreference.mode === ReadPreference.NEAREST) {
-      return latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(nearestFilter);
-    } else if (readPreference.mode === ReadPreference.SECONDARY_PREFERRED) {
-      const result = latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(secondaryFilter);
-
-      return result.length === 0 ? servers.filter(primaryFilter) : result;
-    } else if (readPreference.mode === ReadPreference.PRIMARY_PREFERRED) {
+    if (mode === ReadPreference.PRIMARY_PREFERRED) {
       const result = servers.filter(primaryFilter);
       if (result.length) {
         return result;
       }
+    }
 
-      return latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(secondaryFilter);
+    const filter = mode === ReadPreference.NEAREST ? nearestFilter : secondaryFilter;
+    const selectedServers = latencyWindowReducer(
+      topologyDescription,
+      tagSetReducer(
+        readPreference,
+        maxStalenessReducer(readPreference, topologyDescription, servers.filter(filter))
+      )
+    );
+
+    if (mode === ReadPreference.SECONDARY_PREFERRED && selectedServers.length === 0) {
+      return servers.filter(primaryFilter);
     }
+
+    return selectedServers;
   };
 }