mongodb 3.5.8 → 3.5.9

package/HISTORY.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+<a name="3.5.9"></a>
+## [3.5.9](https://github.com/mongodb/node-mongodb-native/compare/v3.5.8...v3.5.9) (2020-06-12)
+
+
+### Bug Fixes
+
+* don't try to calculate sMax if there are no viable servers ([be51347](https://github.com/mongodb/node-mongodb-native/commit/be51347))
+* use async interruptable interval for server monitoring ([1f855a4](https://github.com/mongodb/node-mongodb-native/commit/1f855a4))
+* use duration of handshake if no previous roundTripTime exists ([ddfa41b](https://github.com/mongodb/node-mongodb-native/commit/ddfa41b))
+
+
+### Features
+
+* introduce an interruptable async interval timer ([9e12cd5](https://github.com/mongodb/node-mongodb-native/commit/9e12cd5))
+
+
+
 <a name="3.5.8"></a>
 ## [3.5.8](https://github.com/mongodb/node-mongodb-native/compare/v3.5.7...v3.5.8) (2020-05-28)
 

package/lib/change_stream.js

@@ -8,6 +8,8 @@ const Cursor = require('./cursor');
 const relayEvents = require('./core/utils').relayEvents;
 const maxWireVersion = require('./core/utils').maxWireVersion;
 const maybePromise = require('./utils').maybePromise;
+const now = require('./utils').now;
+const calculateDurationInMs = require('./utils').calculateDurationInMs;
 const AggregateOperation = require('./operations/aggregate');
 
 const kResumeQueue = Symbol('resumeQueue');
@@ -459,15 +461,21 @@ function applyKnownOptions(target, source, optionNames) {
 const SELECTION_TIMEOUT = 30000;
 function waitForTopologyConnected(topology, options, callback) {
   setTimeout(() => {
-    if (options && options.start == null) options.start = process.hrtime();
-    const start = options.start || process.hrtime();
+    if (options && options.start == null) {
+      options.start = now();
+    }
+
+    const start = options.start || now();
     const timeout = options.timeout || SELECTION_TIMEOUT;
     const readPreference = options.readPreference;
+    if (topology.isConnected({ readPreference })) {
+      return callback();
+    }
+
+    if (calculateDurationInMs(start) > timeout) {
+      return callback(new MongoError('Timed out waiting for connection'));
+    }
 
-    if (topology.isConnected({ readPreference })) return callback();
-    const hrElapsed = process.hrtime(start);
-    const elapsed = (hrElapsed[0] * 1e9 + hrElapsed[1]) / 1e6;
-    if (elapsed > timeout) return callback(new MongoError('Timed out waiting for connection'));
     waitForTopologyConnected(topology, options, callback);
   }, 500); // this is an arbitrary wait time to allow SDAM to transition
 }

package/lib/cmap/connection.js

@@ -11,6 +11,8 @@ const wp = require('../core/wireprotocol');
 const apm = require('../core/connection/apm');
 const updateSessionFromResponse = require('../core/sessions').updateSessionFromResponse;
 const uuidV4 = require('../core/utils').uuidV4;
+const now = require('../utils').now;
+const calculateDurationInMs = require('../utils').calculateDurationInMs;
 
 const kStream = Symbol('stream');
 const kQueue = Symbol('queue');
@@ -37,7 +39,7 @@ class Connection extends EventEmitter {
 
     this[kDescription] = new StreamDescription(this.address, options);
     this[kGeneration] = options.generation;
-    this[kLastUseTime] = Date.now();
+    this[kLastUseTime] = now();
 
     // retain a reference to an `AutoEncrypter` if present
     if (options.autoEncrypter) {
@@ -108,7 +110,7 @@ class Connection extends EventEmitter {
   }
 
   get idleTime() {
-    return Date.now() - this[kLastUseTime];
+    return calculateDurationInMs(this[kLastUseTime]);
   }
 
   get clusterTime() {
@@ -120,7 +122,7 @@ class Connection extends EventEmitter {
   }
 
   markAvailable() {
-    this[kLastUseTime] = Date.now();
+    this[kLastUseTime] = now();
   }
 
   destroy(options, callback) {
@@ -326,7 +328,7 @@ function write(command, options, callback) {
   if (this.monitorCommands) {
     this.emit('commandStarted', new apm.CommandStartedEvent(this, command));
 
-    operationDescription.started = process.hrtime();
+    operationDescription.started = now();
     operationDescription.cb = (err, reply) => {
       if (err) {
         this.emit(

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/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
     };
@@ -89,7 +95,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 +110,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 +139,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 +187,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 +199,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

@@ -415,6 +415,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);

package/lib/core/sdam/server_selection.js

@@ -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 =

package/lib/core/sessions.js

@@ -17,7 +17,8 @@ const isTransactionCommand = require('./transactions').isTransactionCommand;
 const resolveClusterTime = require('./topologies/shared').resolveClusterTime;
 const isSharded = require('./wireprotocol/shared').isSharded;
 const maxWireVersion = require('./utils').maxWireVersion;
-
+const now = require('./../utils').now;
+const calculateDurationInMs = require('./../utils').calculateDurationInMs;
 const minWireVersionForShardedTransactions = 8;
 
 function assertAlive(session, callback) {
@@ -285,7 +286,7 @@ class ClientSession extends EventEmitter {
    * @param {TransactionOptions} [options] Optional settings for the transaction
    */
   withTransaction(fn, options) {
-    const startTime = Date.now();
+    const startTime = now();
     return attemptTransaction(this, startTime, fn, options);
   }
 }
@@ -301,7 +302,7 @@ const NON_DETERMINISTIC_WRITE_CONCERN_ERRORS = new Set([
 ]);
 
 function hasNotTimedOut(startTime, max) {
-  return Date.now() - startTime < max;
+  return calculateDurationInMs(startTime) < max;
 }
 
 function isUnknownTransactionCommitResult(err) {
@@ -558,7 +559,7 @@ function supportsRecoveryToken(session) {
 class ServerSession {
   constructor() {
     this.id = { id: new Binary(uuidV4(), Binary.SUBTYPE_UUID) };
-    this.lastUse = Date.now();
+    this.lastUse = now();
     this.txnNumber = 0;
     this.isDirty = false;
   }
@@ -573,7 +574,7 @@ class ServerSession {
     // Take the difference of the lastUse timestamp and now, which will result in a value in
     // milliseconds, and then convert milliseconds to minutes to compare to `sessionTimeoutMinutes`
     const idleTimeMinutes = Math.round(
-      (((Date.now() - this.lastUse) % 86400000) % 3600000) / 60000
+      ((calculateDurationInMs(this.lastUse) % 86400000) % 3600000) / 60000
     );
 
     return idleTimeMinutes > sessionTimeoutMinutes - 1;
@@ -708,7 +709,7 @@ function applySession(session, command, options) {
   }
 
   const serverSession = session.serverSession;
-  serverSession.lastUse = Date.now();
+  serverSession.lastUse = now();
   command.lsid = serverSession.id;
 
   // first apply non-transaction-specific sessions data

package/lib/core/topologies/replset.js

@@ -17,9 +17,10 @@ const isRetryableWritesSupported = require('./shared').isRetryableWritesSupporte
 const relayEvents = require('../utils').relayEvents;
 const isRetryableError = require('../error').isRetryableError;
 const BSON = retrieveBSON();
-const calculateDurationInMs = require('../utils').calculateDurationInMs;
 const getMMAPError = require('./shared').getMMAPError;
 const makeClientMetadata = require('../utils').makeClientMetadata;
+const now = require('../../utils').now;
+const calculateDurationInMs = require('../../utils').calculateDurationInMs;
 
 //
 // States
@@ -426,8 +427,7 @@ var pingServer = function(self, server, cb) {
       var latencyMS = new Date().getTime() - start;
 
       // Set the last updatedTime
-      var hrtime = process.hrtime();
-      server.lastUpdateTime = (hrtime[0] * 1e9 + hrtime[1]) / 1e6;
+      server.lastUpdateTime = now();
 
       // We had an error, remove it from the state
       if (err) {
@@ -1127,7 +1127,7 @@ ReplSet.prototype.selectServer = function(selector, options, callback) {
   }
 
   let lastError;
-  const start = process.hrtime();
+  const start = now();
   const _selectServer = () => {
     if (calculateDurationInMs(start) >= SERVER_SELECTION_TIMEOUT_MS) {
       if (lastError != null) {

package/lib/core/utils.js

@@ -13,17 +13,6 @@ const uuidV4 = () => {
   return result;
 };
 
-/**
- * Returns the duration calculated from two high resolution timers in milliseconds
- *
- * @param {Object} started A high resolution timestamp created from `process.hrtime()`
- * @returns {Number} The duration in milliseconds
- */
-const calculateDurationInMs = started => {
-  const hrtime = process.hrtime(started);
-  return (hrtime[0] * 1e9 + hrtime[1]) / 1e6;
-};
-
 /**
  * Relays events for a given listener and emitter
  *
@@ -261,7 +250,6 @@ const noop = () => {};
 
 module.exports = {
   uuidV4,
-  calculateDurationInMs,
   relayEvents,
   collationNotSupported,
   retrieveEJSON,

package/lib/core/wireprotocol/get_more.js

@@ -62,8 +62,13 @@ function getMore(server, ns, cursorState, batchSize, options, callback) {
     return;
   }
 
+  const cursorId =
+    cursorState.cursorId instanceof Long
+      ? cursorState.cursorId
+      : Long.fromNumber(cursorState.cursorId);
+
   const getMoreCmd = {
-    getMore: cursorState.cursorId,
+    getMore: cursorId,
     collection: collectionNamespace(ns),
     batchSize: Math.abs(batchSize)
   };

package/lib/mongo_client.js

@@ -146,6 +146,10 @@ const validOptions = require('./operations/connect').validOptions;
  * @param {Number} [options.localThresholdMS=15] **Only applies to the unified topology** The size of the latency window for selecting among multiple suitable servers
  * @param {Number} [options.serverSelectionTimeoutMS=30000] **Only applies to the unified topology** How long to block for server selection before throwing an error
  * @param {Number} [options.heartbeatFrequencyMS=10000] **Only applies to the unified topology** The frequency with which topology updates are scheduled
+ * @param {number} [options.maxPoolSize=10] **Only applies to the unified topology** The maximum number of connections that may be associated with a pool at a given time. This includes in use and available connections.
+ * @param {number} [options.minPoolSize=0] **Only applies to the unified topology** The minimum number of connections that MUST exist at any moment in a single connection pool.
+ * @param {number} [options.maxIdleTimeMS] **Only applies to the unified topology** The maximum amount of time a connection should remain idle in the connection pool before being marked idle. The default is infinity.
+ * @param {number} [options.waitQueueTimeoutMS=0] **Only applies to the unified topology** The maximum amount of time operation execution should wait for a connection to become available. The default is 0 which means there is no limit.
  * @param {AutoEncrypter~AutoEncryptionOptions} [options.autoEncryption] Optionally enable client side auto encryption
  * @param {DriverInfoOptions} [options.driverInfo] Allows a wrapping driver to amend the client metadata generated by the driver to include information about the wrapping driver
  * @param {MongoClient~connectCallback} [callback] The command result callback
@@ -415,6 +419,10 @@ MongoClient.prototype.isConnected = function(options) {
  * @param {Number} [options.localThresholdMS=15] **Only applies to the unified topology** The size of the latency window for selecting among multiple suitable servers
  * @param {Number} [options.serverSelectionTimeoutMS=30000] **Only applies to the unified topology** How long to block for server selection before throwing an error
  * @param {Number} [options.heartbeatFrequencyMS=10000] **Only applies to the unified topology** The frequency with which topology updates are scheduled
+ * @param {number} [options.maxPoolSize=10] **Only applies to the unified topology** The maximum number of connections that may be associated with a pool at a given time. This includes in use and available connections.
+ * @param {number} [options.minPoolSize=0] **Only applies to the unified topology** The minimum number of connections that MUST exist at any moment in a single connection pool.
+ * @param {number} [options.maxIdleTimeMS] **Only applies to the unified topology** The maximum amount of time a connection should remain idle in the connection pool before being marked idle. The default is infinity.
+ * @param {number} [options.waitQueueTimeoutMS=0] **Only applies to the unified topology** The maximum amount of time operation execution should wait for a connection to become available. The default is 0 which means there is no limit.
  * @param {AutoEncrypter~AutoEncryptionOptions} [options.autoEncryption] Optionally enable client side auto encryption
  * @param {DriverInfoOptions} [options.driverInfo] Allows a wrapping driver to amend the client metadata generated by the driver to include information about the wrapping driver
  * @param {MongoClient~connectCallback} [callback] The command result callback

package/lib/operations/connect.js

@@ -151,6 +151,11 @@ const validOptionNames = [
   'tlsCertificateKeyFilePassword',
   'minHeartbeatFrequencyMS',
   'heartbeatFrequencyMS',
+
+  // CMAP options
+  'maxPoolSize',
+  'minPoolSize',
+  'maxIdleTimeMS',
   'waitQueueTimeoutMS'
 ];
 

package/lib/topologies/native_topology.js

@@ -15,8 +15,18 @@ class NativeTopology extends Topology {
         cursorFactory: Cursor,
         reconnect: false,
         emitError: typeof options.emitError === 'boolean' ? options.emitError : true,
-        maxPoolSize: typeof options.poolSize === 'number' ? options.poolSize : 5,
-        minPoolSize: typeof options.minSize === 'number' ? options.minSize : 0,
+        maxPoolSize:
+          typeof options.maxPoolSize === 'number'
+            ? options.maxPoolSize
+            : typeof options.poolSize === 'number'
+            ? options.poolSize
+            : 10,
+        minPoolSize:
+          typeof options.minPoolSize === 'number'
+            ? options.minPoolSize
+            : typeof options.minSize === 'number'
+            ? options.minSize
+            : 0,
         monitorCommands:
           typeof options.monitorCommands === 'boolean' ? options.monitorCommands : false
       }

package/lib/utils.js

@@ -734,6 +734,98 @@ function maybePromise(parent, callback, fn) {
   return result;
 }
 
+function now() {
+  const hrtime = process.hrtime();
+  return Math.floor(hrtime[0] * 1000 + hrtime[1] / 1000000);
+}
+
+function calculateDurationInMs(started) {
+  if (typeof started !== 'number') {
+    throw TypeError('numeric value required to calculate duration');
+  }
+
+  const elapsed = now() - started;
+  return elapsed < 0 ? 0 : elapsed;
+}
+
+/**
+ * Creates an interval timer which is able to be woken up sooner than
+ * the interval. The timer will also debounce multiple calls to wake
+ * ensuring that the function is only ever called once within a minimum
+ * interval window.
+ *
+ * @param {function} fn An async function to run on an interval, must accept a `callback` as its only parameter
+ * @param {object} [options] Optional settings
+ * @param {number} [options.interval] The interval at which to run the provided function
+ * @param {number} [options.minInterval] The minimum time which must pass between invocations of the provided function
+ * @param {boolean} [options.immediate] Execute the function immediately when the interval is started
+ */
+function makeInterruptableAsyncInterval(fn, options) {
+  let timerId;
+  let lastCallTime;
+  let lastWakeTime;
+  let stopped = false;
+
+  options = options || {};
+  const interval = options.interval || 1000;
+  const minInterval = options.minInterval || 500;
+  const immediate = typeof options.immediate === 'boolean' ? options.immediate : false;
+
+  function wake() {
+    const currentTime = now();
+    const timeSinceLastWake = currentTime - lastWakeTime;
+    const timeSinceLastCall = currentTime - lastCallTime;
+    const timeUntilNextCall = Math.max(interval - timeSinceLastCall, 0);
+    lastWakeTime = currentTime;
+
+    // debounce multiple calls to wake within the `minInterval`
+    if (timeSinceLastWake < minInterval) {
+      return;
+    }
+
+    // reschedule a call as soon as possible, ensuring the call never happens
+    // faster than the `minInterval`
+    if (timeUntilNextCall > minInterval) {
+      reschedule(minInterval);
+    }
+  }
+
+  function stop() {
+    stopped = true;
+    if (timerId) {
+      clearTimeout(timerId);
+      timerId = null;
+    }
+
+    lastCallTime = 0;
+    lastWakeTime = 0;
+  }
+
+  function reschedule(ms) {
+    if (stopped) return;
+    clearTimeout(timerId);
+    timerId = setTimeout(executeAndReschedule, ms || interval);
+  }
+
+  function executeAndReschedule() {
+    lastWakeTime = 0;
+    lastCallTime = now();
+    fn(err => {
+      if (err) throw err;
+      reschedule(interval);
+    });
+  }
+
+  if (immediate) {
+    executeAndReschedule();
+  } else {
+    lastCallTime = now();
+    reschedule();
+  }
+
+  return { wake, stop };
+}
+
 module.exports = {
   filterOptions,
   mergeOptions,
@@ -764,5 +856,8 @@ module.exports = {
   resolveReadPreference,
   emitDeprecationWarning,
   makeCounter,
-  maybePromise
+  maybePromise,
+  now,
+  calculateDurationInMs,
+  makeInterruptableAsyncInterval
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "3.5.8",
+  "version": "3.5.9",
   "description": "The official MongoDB driver for Node.js",
   "main": "index.js",
   "files": [