mongodb 4.0.0 → 4.1.2

package/src/cmap/connection.ts

@@ -17,9 +17,9 @@ import {
   HostAddress
 } from '../utils';
 import {
-  AnyError,
-  MongoDriverError,
-  MongoError,
+  MongoRuntimeError,
+  MongoMissingDependencyError,
+  MongoCompatibilityError,
   MongoNetworkError,
   MongoNetworkTimeoutError,
   MongoServerError,
@@ -35,13 +35,12 @@ import {
   OpQueryOptions,
   Msg
 } from './commands';
-import { BSONSerializeOptions, Document, Long, pluckBSONSerializeOptions } from '../bson';
+import { BSONSerializeOptions, Document, Long, pluckBSONSerializeOptions, ObjectId } from '../bson';
 import type { AutoEncrypter } from '../deps';
 import type { MongoCredentials } from './auth/mongo_credentials';
 import type { Stream } from './connect';
 import { applyCommonQueryOptions, getReadPreference, isSharded } from './wire_protocol/shared';
 import { ReadPreference, ReadPreferenceLike } from '../read_preference';
-import { isTransactionCommand } from '../transactions';
 import type { W, WriteConcern, WriteConcernOptions } from '../write_concern';
 import type { ServerApi, SupportedNodeConnectionOptions } from '../mongo_client';
 import { CancellationToken, TypedEventEmitter } from '../mongo_types';
@@ -64,6 +63,8 @@ const kDescription = Symbol('description');
 const kIsMaster = Symbol('ismaster');
 /** @internal */
 const kAutoEncrypter = Symbol('autoEncrypter');
+/** @internal */
+const kFullResult = Symbol('fullResult');
 
 /** @internal */
 export interface QueryOptions extends BSONSerializeOptions {
@@ -82,7 +83,7 @@ export interface QueryOptions extends BSONSerializeOptions {
   oplogReplay?: boolean;
 }
 
-/** @public */
+/** @internal */
 export interface CommandOptions extends BSONSerializeOptions {
   command?: boolean;
   slaveOk?: boolean;
@@ -90,7 +91,7 @@ export interface CommandOptions extends BSONSerializeOptions {
   readPreference?: ReadPreferenceLike;
   raw?: boolean;
   monitoring?: boolean;
-  fullResult?: boolean;
+  [kFullResult]?: boolean;
   socketTimeoutMS?: number;
   /** Session to use for the operation */
   session?: ClientSession;
@@ -152,6 +153,8 @@ export type ConnectionEvents = {
   clusterTimeReceived(clusterTime: Document): void;
   close(): void;
   message(message: any): void;
+  pinned(pinType: string): void;
+  unpinned(pinType: string): void;
 };
 
 /** @internal */
@@ -194,6 +197,10 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   static readonly CLOSE = 'close' as const;
   /** @event */
   static readonly MESSAGE = 'message' as const;
+  /** @event */
+  static readonly PINNED = 'pinned' as const;
+  /** @event */
+  static readonly UNPINNED = 'unpinned' as const;
 
   constructor(stream: Stream, options: ConnectionOptions) {
     super();
@@ -247,10 +254,22 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     this[kIsMaster] = response;
   }
 
+  get serviceId(): ObjectId | undefined {
+    return this.ismaster?.serviceId;
+  }
+
+  get loadBalanced(): boolean {
+    return this.description.loadBalanced;
+  }
+
   get generation(): number {
     return this[kGeneration] || 0;
   }
 
+  set generation(generation: number) {
+    this[kGeneration] = generation;
+  }
+
   get idleTime(): number {
     return calculateDurationInMs(this[kLastUseTime]);
   }
@@ -306,6 +325,9 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       options = { force: false };
     }
 
+    this.removeAllListeners(Connection.PINNED);
+    this.removeAllListeners(Connection.UNPINNED);
+
     options = Object.assign({ force: false }, options);
     if (this[kStream] == null || this.destroyed) {
       this.destroyed = true;
@@ -341,8 +363,9 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     options: CommandOptions | undefined,
     callback: Callback
   ): void {
-    if (typeof ns.db === 'undefined' || typeof ns === 'string') {
-      throw new MongoDriverError('ns cannot be a string');
+    if (!(ns instanceof MongoDBNamespace)) {
+      // TODO(NODE-3483): Replace this with a MongoCommandError
+      throw new MongoRuntimeError('Must provide a MongoDBNamespace instance');
     }
 
     const readPreference = getReadPreference(cmd, options);
@@ -351,7 +374,6 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
     let clusterTime = this.clusterTime;
     let finalCmd = Object.assign({}, cmd);
-    const inTransaction = session && (session.inTransaction() || isTransactionCommand(finalCmd));
 
     if (this.serverApi) {
       const { version, strict, deprecationErrors } = this.serverApi;
@@ -369,18 +391,6 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
         clusterTime = session.clusterTime;
       }
 
-      // We need to unpin any read or write commands that happen outside of a pinned
-      // transaction, so we check if we have a pinned transaction that is no longer
-      // active, and unpin for all except start or commit.
-      if (
-        !session.transaction.isActive &&
-        session.transaction.isPinned &&
-        !finalCmd.startTransaction &&
-        !finalCmd.commitTransaction
-      ) {
-        session.transaction.unpinServer();
-      }
-
       const err = applySession(session, finalCmd, options as CommandOptions);
       if (err) {
         return callback(err);
@@ -416,41 +426,16 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       ? new Msg(cmdNs, finalCmd, commandOptions)
       : new Query(cmdNs, finalCmd, commandOptions);
 
-    const commandResponseHandler = inTransaction
-      ? (err?: AnyError, ...args: Document[]) => {
-          // We need to add a TransientTransactionError errorLabel, as stated in the transaction spec.
-          if (
-            err &&
-            err instanceof MongoNetworkError &&
-            !err.hasErrorLabel('TransientTransactionError')
-          ) {
-            err.addErrorLabel('TransientTransactionError');
-          }
-
-          if (
-            session &&
-            !cmd.commitTransaction &&
-            err &&
-            err instanceof MongoError &&
-            err.hasErrorLabel('TransientTransactionError')
-          ) {
-            session.transaction.unpinServer();
-          }
-
-          return callback(err, ...args);
-        }
-      : callback;
-
     try {
-      write(this, message, commandOptions, commandResponseHandler);
+      write(this, message, commandOptions, callback);
     } catch (err) {
-      commandResponseHandler(err);
+      callback(err);
     }
   }
 
   /** @internal */
   query(ns: MongoDBNamespace, cmd: Document, options: QueryOptions, callback: Callback): void {
-    const isExplain = typeof cmd.$explain !== 'undefined';
+    const isExplain = cmd.$explain != null;
     const readPreference = options.readPreference ?? ReadPreference.primary;
     const batchSize = options.batchSize || 0;
     const limit = options.limit;
@@ -509,7 +494,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     write(
       this,
       query,
-      { fullResult: true, ...pluckBSONSerializeOptions(options) },
+      { [kFullResult]: true, ...pluckBSONSerializeOptions(options) },
       (err, result) => {
         if (err || !result) return callback(err, result);
         if (isExplain && result.documents && result.documents[0]) {
@@ -528,10 +513,11 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     options: GetMoreOptions,
     callback: Callback<Document>
   ): void {
-    const fullResult = typeof options.fullResult === 'boolean' ? options.fullResult : false;
+    const fullResult = !!options[kFullResult];
     const wireVersion = maxWireVersion(this);
     if (!cursorId) {
-      callback(new MongoDriverError('Invalid internal cursor state, no known cursor id'));
+      // TODO(NODE-3483): Replace this with a MongoCommandError
+      callback(new MongoRuntimeError('Invalid internal cursor state, no known cursor id'));
       return;
     }
 
@@ -542,7 +528,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
         Object.assign(options, { ...pluckBSONSerializeOptions(options) })
       );
 
-      queryOptions.fullResult = true;
+      queryOptions[kFullResult] = true;
       queryOptions.command = true;
       write(this, getMoreOp, queryOptions, (err, response) => {
         if (fullResult) return callback(err, response);
@@ -585,7 +571,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     callback: Callback
   ): void {
     if (!cursorIds || !Array.isArray(cursorIds)) {
-      throw new MongoDriverError('Invalid list of cursor ids provided: ' + cursorIds);
+      // TODO(NODE-3483): Replace this with a MongoCommandError
+      throw new MongoRuntimeError(`Invalid list of cursor ids provided: ${cursorIds}`);
     }
 
     if (maxWireVersion(this) < 4) {
@@ -606,7 +593,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     this.command(
       ns,
       { killCursors: ns.collection, cursors: cursorIds },
-      { fullResult: true, ...options },
+      { [kFullResult]: true, ...options },
       (err, response) => {
         if (err || !response) return callback(err);
         if (response.cursorNotFound) {
@@ -615,7 +602,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
         if (!Array.isArray(response.documents) || response.documents.length === 0) {
           return callback(
-            new MongoDriverError(
+            // TODO(NODE-3483)
+            new MongoRuntimeError(
               `invalid killCursors result returned for cursor id ${cursorIds[0]}`
             )
           );
@@ -648,7 +636,7 @@ export class CryptoConnection extends Connection {
   command(ns: MongoDBNamespace, cmd: Document, options: CommandOptions, callback: Callback): void {
     const autoEncrypter = this[kAutoEncrypter];
     if (!autoEncrypter) {
-      return callback(new MongoDriverError('No AutoEncrypter available for encryption'));
+      return callback(new MongoMissingDependencyError('No AutoEncrypter available for encryption'));
     }
 
     const serverWireVersion = maxWireVersion(this);
@@ -658,7 +646,9 @@ export class CryptoConnection extends Connection {
     }
 
     if (serverWireVersion < 8) {
-      callback(new MongoDriverError('Auto-encryption requires a minimum MongoDB version of 4.2'));
+      callback(
+        new MongoCompatibilityError('Auto-encryption requires a minimum MongoDB version of 4.2')
+      );
       return;
     }
 
@@ -680,8 +670,10 @@ export class CryptoConnection extends Connection {
   }
 }
 
-function hasSessionSupport(conn: Connection) {
-  return conn.description.logicalSessionTimeoutMinutes != null;
+/** @internal */
+export function hasSessionSupport(conn: Connection): boolean {
+  const description = conn.description;
+  return description.logicalSessionTimeoutMinutes != null || !!description.loadBalanced;
 }
 
 function supportsOpMsg(conn: Connection) {
@@ -784,7 +776,7 @@ function write(
     requestId: command.requestId,
     cb: callback,
     session: options.session,
-    fullResult: typeof options.fullResult === 'boolean' ? options.fullResult : false,
+    fullResult: !!options[kFullResult],
     noResponse: typeof options.noResponse === 'boolean' ? options.noResponse : false,
     documentsReturnedIn: options.documentsReturnedIn,
     command: !!options.command,

package/src/cmap/connection_pool.ts

@@ -1,9 +1,11 @@
 import Denque = require('denque');
-import { Logger } from '../logger';
 import { APM_EVENTS, Connection, ConnectionEvents, ConnectionOptions } from './connection';
+import type { ObjectId } from 'bson';
+import { Logger } from '../logger';
+import { ConnectionPoolMetrics } from './metrics';
 import { connect } from './connect';
 import { eachAsync, makeCounter, Callback } from '../utils';
-import { MongoDriverError, MongoError } from '../error';
+import { MongoError, MongoInvalidArgumentError, MongoRuntimeError } from '../error';
 import { PoolClosedError, WaitQueueTimeoutError } from './errors';
 import {
   ConnectionPoolCreatedEvent,
@@ -30,6 +32,8 @@ const kMinPoolSizeTimer = Symbol('minPoolSizeTimer');
 /** @internal */
 const kGeneration = Symbol('generation');
 /** @internal */
+const kServiceGenerations = Symbol('serviceGenerations');
+/** @internal */
 const kConnectionCounter = Symbol('connectionCounter');
 /** @internal */
 const kCancellationToken = Symbol('cancellationToken');
@@ -37,6 +41,12 @@ const kCancellationToken = Symbol('cancellationToken');
 const kWaitQueue = Symbol('waitQueue');
 /** @internal */
 const kCancelled = Symbol('cancelled');
+/** @internal */
+const kMetrics = Symbol('metrics');
+/** @internal */
+const kCheckedOut = Symbol('checkedOut');
+/** @internal */
+const kProcessingWaitQueue = Symbol('processingWaitQueue');
 
 /** @public */
 export interface ConnectionPoolOptions extends Omit<ConnectionOptions, 'id' | 'generation'> {
@@ -48,6 +58,8 @@ export interface ConnectionPoolOptions extends Omit<ConnectionOptions, 'id' | 'g
   maxIdleTimeMS: number;
   /** 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. */
   waitQueueTimeoutMS: number;
+  /** If we are in load balancer mode. */
+  loadBalanced: boolean;
 }
 
 /** @internal */
@@ -99,12 +111,22 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
    * @internal
    */
   [kGeneration]: number;
+  /** A map of generations to service ids
+   * @internal
+   */
+  [kServiceGenerations]: Map<string, number>;
   /** @internal */
   [kConnectionCounter]: Generator<number>;
   /** @internal */
   [kCancellationToken]: CancellationToken;
   /** @internal */
   [kWaitQueue]: Denque<WaitQueueMember>;
+  /** @internal */
+  [kMetrics]: ConnectionPoolMetrics;
+  /** @internal */
+  [kCheckedOut]: number;
+  /** @internal */
+  [kProcessingWaitQueue]: boolean;
 
   /**
    * Emitted when the connection pool is created.
@@ -174,7 +196,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     });
 
     if (this.options.minPoolSize > this.options.maxPoolSize) {
-      throw new MongoDriverError(
+      throw new MongoInvalidArgumentError(
         'Connection pool minimum size must not be greater than maximum pool size'
       );
     }
@@ -184,10 +206,14 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     this[kPermits] = this.options.maxPoolSize;
     this[kMinPoolSizeTimer] = undefined;
     this[kGeneration] = 0;
+    this[kServiceGenerations] = new Map();
     this[kConnectionCounter] = makeCounter(1);
     this[kCancellationToken] = new CancellationToken();
     this[kCancellationToken].setMaxListeners(Infinity);
     this[kWaitQueue] = new Denque();
+    this[kMetrics] = new ConnectionPoolMetrics();
+    this[kCheckedOut] = 0;
+    this[kProcessingWaitQueue] = false;
 
     process.nextTick(() => {
       this.emit(ConnectionPool.CONNECTION_POOL_CREATED, new ConnectionPoolCreatedEvent(this));
@@ -219,6 +245,25 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     return this[kWaitQueue].length;
   }
 
+  get loadBalanced(): boolean {
+    return this.options.loadBalanced;
+  }
+
+  get serviceGenerations(): Map<string, number> {
+    return this[kServiceGenerations];
+  }
+
+  get currentCheckedOutCount(): number {
+    return this[kCheckedOut];
+  }
+
+  /**
+   * Get the metrics information for the pool when a wait queue timeout occurs.
+   */
+  private waitQueueErrorMetrics(): string {
+    return this[kMetrics].info(this.options.maxPoolSize);
+  }
+
   /**
    * 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
@@ -250,10 +295,18 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
           ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
           new ConnectionCheckOutFailedEvent(this, 'timeout')
         );
-        waitQueueMember.callback(new WaitQueueTimeoutError(this));
+        waitQueueMember.callback(
+          new WaitQueueTimeoutError(
+            this.loadBalanced
+              ? this.waitQueueErrorMetrics()
+              : 'Timed out while checking out a connection from connection pool',
+            this.address
+          )
+        );
       }, waitQueueTimeoutMS);
     }
 
+    this[kCheckedOut] = this[kCheckedOut] + 1;
     this[kWaitQueue].push(waitQueueMember);
     process.nextTick(processWaitQueue, this);
   }
@@ -270,9 +323,10 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
 
     if (!willDestroy) {
       connection.markAvailable();
-      this[kConnections].push(connection);
+      this[kConnections].unshift(connection);
     }
 
+    this[kCheckedOut] = this[kCheckedOut] - 1;
     this.emit(ConnectionPool.CONNECTION_CHECKED_IN, new ConnectionCheckedInEvent(this, connection));
 
     if (willDestroy) {
@@ -289,9 +343,24 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
    * Pool reset is handled by incrementing the pool's generation count. Any existing connection of a
    * previous generation will eventually be pruned during subsequent checkouts.
    */
-  clear(): void {
-    this[kGeneration] += 1;
-    this.emit('connectionPoolCleared', new ConnectionPoolClearedEvent(this));
+  clear(serviceId?: ObjectId): void {
+    if (this.loadBalanced && serviceId) {
+      const sid = serviceId.toHexString();
+      const generation = this.serviceGenerations.get(sid);
+      // Only need to worry if the generation exists, since it should
+      // always be there but typescript needs the check.
+      if (generation == null) {
+        // TODO(NODE-3483)
+        throw new MongoRuntimeError('Service generations are required in load balancer mode.');
+      } else {
+        // Increment the generation for the service id.
+        this.serviceGenerations.set(sid, generation + 1);
+      }
+    } else {
+      this[kGeneration] += 1;
+    }
+
+    this.emit('connectionPoolCleared', new ConnectionPoolClearedEvent(this, serviceId));
   }
 
   /** Close the pool */
@@ -320,7 +389,8 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
           clearTimeout(waitQueueMember.timer);
         }
         if (!waitQueueMember[kCancelled]) {
-          waitQueueMember.callback(new MongoDriverError('connection pool closed'));
+          // TODO(NODE-3483): Replace with MongoConnectionPoolClosedError
+          waitQueueMember.callback(new MongoRuntimeError('Connection pool closed'));
         }
       }
     }
@@ -338,7 +408,6 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
 
     // mark the pool as closed immediately
     this.closed = true;
-
     eachAsync<Connection>(
       this[kConnections].toArray(),
       (conn, cb) => {
@@ -362,10 +431,34 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
    *
    * NOTE: please note the required signature of `fn`
    *
+   * @remarks When in load balancer mode, connections can be pinned to cursors or transactions.
+   *   In these cases we pass the connection in to this method to ensure it is used and a new
+   *   connection is not checked out.
+   *
+   * @param conn - A pinned connection for use in load balancing mode.
    * @param fn - A function which operates on a managed connection
    * @param callback - The original callback
    */
-  withConnection(fn: WithConnectionCallback, callback?: Callback<Connection>): void {
+  withConnection(
+    conn: Connection | undefined,
+    fn: WithConnectionCallback,
+    callback?: Callback<Connection>
+  ): void {
+    if (conn) {
+      // use the provided connection, and do _not_ check it in after execution
+      fn(undefined, conn, (fnErr, result) => {
+        if (typeof callback === 'function') {
+          if (fnErr) {
+            callback(fnErr);
+          } else {
+            callback(undefined, result);
+          }
+        }
+      });
+
+      return;
+    }
+
     this.checkOut((err, conn) => {
       // don't callback with `err` here, we might want to act upon it inside `fn`
       fn(err as MongoError, conn, (fnErr, result) => {
@@ -399,6 +492,13 @@ function ensureMinPoolSize(pool: ConnectionPool) {
 }
 
 function connectionIsStale(pool: ConnectionPool, connection: Connection) {
+  const serviceId = connection.serviceId;
+  if (pool.loadBalanced && serviceId) {
+    const sid = serviceId.toHexString();
+    const generation = pool.serviceGenerations.get(sid);
+    return connection.generation !== generation;
+  }
+
   return connection.generation !== pool[kGeneration];
 }
 
@@ -437,7 +537,24 @@ function createConnection(pool: ConnectionPool, callback?: Callback<Connection>)
       connection.on(event, (e: any) => pool.emit(event, e));
     }
 
-    pool.emit(ConnectionPool.CONNECTION_POOL_CREATED, new ConnectionCreatedEvent(pool, connection));
+    pool.emit(ConnectionPool.CONNECTION_CREATED, new ConnectionCreatedEvent(pool, connection));
+
+    if (pool.loadBalanced) {
+      connection.on(Connection.PINNED, pinType => pool[kMetrics].markPinned(pinType));
+      connection.on(Connection.UNPINNED, pinType => pool[kMetrics].markUnpinned(pinType));
+
+      const serviceId = connection.serviceId;
+      if (serviceId) {
+        let generation;
+        const sid = serviceId.toHexString();
+        if ((generation = pool.serviceGenerations.get(sid))) {
+          connection.generation = generation;
+        } else {
+          pool.serviceGenerations.set(sid, 0);
+          connection.generation = 0;
+        }
+      }
+    }
 
     connection.markAvailable();
     pool.emit(ConnectionPool.CONNECTION_READY, new ConnectionReadyEvent(pool, connection));
@@ -465,10 +582,11 @@ function destroyConnection(pool: ConnectionPool, connection: Connection, reason:
 }
 
 function processWaitQueue(pool: ConnectionPool) {
-  if (pool.closed) {
+  if (pool.closed || pool[kProcessingWaitQueue]) {
     return;
   }
 
+  pool[kProcessingWaitQueue] = true;
   while (pool.waitQueueSize) {
     const waitQueueMember = pool[kWaitQueue].peekFront();
     if (!waitQueueMember) {
@@ -502,11 +620,11 @@ function processWaitQueue(pool: ConnectionPool) {
       }
 
       pool[kWaitQueue].shift();
-      return waitQueueMember.callback(undefined, connection);
+      waitQueueMember.callback(undefined, connection);
+    } else {
+      const reason = connection.closed ? 'error' : isStale ? 'stale' : 'idle';
+      destroyConnection(pool, connection, reason);
     }
-
-    const reason = connection.closed ? 'error' : isStale ? 'stale' : 'idle';
-    destroyConnection(pool, connection, reason);
   }
 
   const maxPoolSize = pool.options.maxPoolSize;
@@ -518,6 +636,7 @@ function processWaitQueue(pool: ConnectionPool) {
           pool[kConnections].push(connection);
         }
 
+        pool[kProcessingWaitQueue] = false;
         return;
       }
 
@@ -537,9 +656,11 @@ function processWaitQueue(pool: ConnectionPool) {
         clearTimeout(waitQueueMember.timer);
       }
       waitQueueMember.callback(err, connection);
+      pool[kProcessingWaitQueue] = false;
+      process.nextTick(() => processWaitQueue(pool));
     });
-
-    return;
+  } else {
+    pool[kProcessingWaitQueue] = false;
   }
 }
 
@@ -565,7 +686,7 @@ export const CMAP_EVENTS = [
  * @param callback - A function to call back after connection management is complete
  */
 export type WithConnectionCallback = (
-  error: MongoError,
+  error: MongoError | undefined,
   connection: Connection | undefined,
   callback: Callback<Connection>
 ) => void;

package/src/cmap/connection_pool_events.ts

@@ -1,3 +1,4 @@
+import type { ObjectId } from '../bson';
 import type { Connection } from './connection';
 import type { ConnectionPool, ConnectionPoolOptions } from './connection_pool';
 import type { AnyError } from '../error';
@@ -90,12 +91,14 @@ export class ConnectionClosedEvent extends ConnectionPoolMonitoringEvent {
   connectionId: number | '<monitor>';
   /** The reason the connection was closed */
   reason: string;
+  serviceId?: ObjectId;
 
   /** @internal */
   constructor(pool: ConnectionPool, connection: Connection, reason: string) {
     super(pool);
     this.connectionId = connection.id;
     this.reason = reason || 'unknown';
+    this.serviceId = connection.serviceId;
   }
 }
 
@@ -166,7 +169,11 @@ export class ConnectionCheckedInEvent extends ConnectionPoolMonitoringEvent {
  */
 export class ConnectionPoolClearedEvent extends ConnectionPoolMonitoringEvent {
   /** @internal */
-  constructor(pool: ConnectionPool) {
+  serviceId?: ObjectId;
+
+  /** @internal */
+  constructor(pool: ConnectionPool, serviceId?: ObjectId) {
     super(pool);
+    this.serviceId = serviceId;
   }
 }

package/src/cmap/errors.ts

@@ -1,5 +1,4 @@
 import { MongoDriverError } from '../error';
-import type { Connection } from './connection';
 import type { ConnectionPool } from './connection_pool';
 
 /**
@@ -28,9 +27,9 @@ export class WaitQueueTimeoutError extends MongoDriverError {
   /** The address of the connection pool */
   address: string;
 
-  constructor(pool: Connection | ConnectionPool) {
-    super('Timed out while checking out a connection from connection pool');
-    this.address = pool.address;
+  constructor(message: string, address: string) {
+    super(message);
+    this.address = address;
   }
 
   get name(): string {

package/src/cmap/message_stream.ts

@@ -1,6 +1,6 @@
 import { Duplex, DuplexOptions } from 'stream';
 import { Response, Msg, BinMsg, Query, WriteProtocolMessageType, MessageHeader } from './commands';
-import { MongoDriverError, MongoParseError } from '../error';
+import { MongoDecompressionError, MongoParseError } from '../error';
 import { OP_COMPRESSED, OP_MSG } from './wire_protocol/constants';
 import {
   compress,
@@ -191,9 +191,7 @@ function processIncomingData(stream: MessageStream, callback: Callback<Buffer>)
 
     if (messageBody.length !== messageHeader.length) {
       callback(
-        new MongoDriverError(
-          'Decompressing a compressed message from the server failed. The message is corrupt.'
-        )
+        new MongoDecompressionError('Message body and message header must be the same length')
       );
 
       return;