basic implementation completed

Author: aditi-khare-mongoDB

src/index.ts

@@ -147,6 +147,13 @@ export {
   TopologyDescriptionChangedEvent,
   TopologyOpeningEvent
 } from './sdam/events';
+export {
+  ServerSelectionEvent,
+  ServerSelectionFailedEvent,
+  ServerSelectionStartedEvent,
+  ServerSelectionSucceededEvent,
+  WaitingForSuitableServerEvent
+} from './sdam/server_selection_events';
 export { SrvPollingEvent } from './sdam/srv_polling';
 
 // type only exports below, these are removed from emitted JS
@@ -305,7 +312,11 @@ export type {
   CONNECTION_POOL_CREATED,
   CONNECTION_POOL_READY,
   CONNECTION_READY,
-  MONGO_CLIENT_EVENTS
+  MONGO_CLIENT_EVENTS,
+  SERVER_SELECTION_FAILED,
+  SERVER_SELECTION_STARTED,
+  SERVER_SELECTION_SUCCEEDED,
+  WAITING_FOR_SUITABLE_SERVER
 } from './constants';
 export type {
   AbstractCursorEvents,

src/mongo_logger.ts

@@ -17,7 +17,6 @@ import type {
   ConnectionPoolClearedEvent,
   ConnectionPoolClosedEvent,
   ConnectionPoolCreatedEvent,
-  ConnectionPoolMonitoringEvent,
   ConnectionPoolReadyEvent,
   ConnectionReadyEvent
 } from './cmap/connection_pool_events';
@@ -35,8 +34,19 @@ import {
   CONNECTION_POOL_CLOSED,
   CONNECTION_POOL_CREATED,
   CONNECTION_POOL_READY,
-  CONNECTION_READY
+  CONNECTION_READY,
+  SERVER_SELECTION_FAILED,
+  SERVER_SELECTION_STARTED,
+  SERVER_SELECTION_SUCCEEDED,
+  WAITING_FOR_SUITABLE_SERVER
 } from './constants';
+import type {
+  ServerSelectionEvent,
+  ServerSelectionFailedEvent,
+  ServerSelectionStartedEvent,
+  ServerSelectionSucceededEvent,
+  WaitingForSuitableServerEvent
+} from './sdam/server_selection_events';
 import { HostAddress, parseUnsignedInteger } from './utils';
 
 /** @internal */
@@ -272,6 +282,10 @@ function compareSeverity(s0: SeverityLevel, s1: SeverityLevel): 1 | 0 | -1 {
 
 /** @internal */
 export type LoggableEvent =
+  | ServerSelectionStartedEvent
+  | ServerSelectionFailedEvent
+  | ServerSelectionSucceededEvent
+  | WaitingForSuitableServerEvent
   | CommandStartedEvent
   | CommandSucceededEvent
   | CommandFailedEvent
@@ -310,6 +324,20 @@ function isLogConvertible(obj: Loggable): obj is LogConvertible {
   return objAsLogConvertible.toLog !== undefined && typeof objAsLogConvertible.toLog === 'function';
 }
 
+function attachServerSelectionFields(
+  log: Record<string, any>,
+  serverSelectionEvent: ServerSelectionEvent,
+  maxDocumentLength: number = DEFAULT_MAX_DOCUMENT_LENGTH
+) {
+  const { selector, operation, topologyDescription, message } = serverSelectionEvent;
+  log.selector = stringifyWithMaxLen(selector, maxDocumentLength);
+  log.operation = operation;
+  log.topologyDescription = stringifyWithMaxLen(topologyDescription, maxDocumentLength);
+  log.message = message;
+
+  return log;
+}
+
 function attachCommandFields(
   log: Record<string, any>,
   commandEvent: CommandStartedEvent | CommandSucceededEvent | CommandFailedEvent
@@ -327,11 +355,8 @@ function attachCommandFields(
   return log;
 }
 
-function attachConnectionFields(
-  log: Record<string, any>,
-  connectionPoolEvent: ConnectionPoolMonitoringEvent
-) {
-  const { host, port } = HostAddress.fromString(connectionPoolEvent.address).toHostPort();
+function attachConnectionFields(log: Record<string, any>, event: any) {
+  const { host, port } = HostAddress.fromString(event.address).toHostPort();
   log.serverHost = host;
   log.serverPort = port;
 
@@ -345,6 +370,21 @@ function defaultLogTransform(
   let log: Omit<Log, 's' | 't' | 'c'> = Object.create(null);
 
   switch (logObject.name) {
+    case SERVER_SELECTION_STARTED:
+      log = attachServerSelectionFields(log, logObject, maxDocumentLength);
+      return log;
+    case SERVER_SELECTION_FAILED:
+      log = attachServerSelectionFields(log, logObject, maxDocumentLength);
+      log.failure = logObject.failure.message;
+      return log;
+    case SERVER_SELECTION_SUCCEEDED:
+      log = attachServerSelectionFields(log, logObject, maxDocumentLength);
+      log = attachConnectionFields(log, logObject);
+      return log;
+    case WAITING_FOR_SUITABLE_SERVER:
+      log = attachServerSelectionFields(log, logObject, maxDocumentLength);
+      log.remainingTimeMS = logObject.remainingTimeMS;
+      return log;
     case COMMAND_STARTED:
       log = attachCommandFields(log, logObject);
       log.message = 'Command started';

src/operations/execute_operation.ts

@@ -151,7 +151,10 @@ async function executeOperationAsync<
     selector = readPreference;
   }
 
-  const server = await topology.selectServerAsync(selector, { session });
+  const server = await topology.selectServerAsync(selector, {
+    session: session,
+    operationName: operation.commandName
+  });
 
   if (session == null) {
     // No session also means it is not retryable, early exit
@@ -251,7 +254,10 @@ async function retryOperation<
   }
 
   // select a new server, and attempt to retry the operation
-  const server = await topology.selectServerAsync(selector, { session });
+  const server = await topology.selectServerAsync(selector, {
+    session: session,
+    operationName: operation.commandName
+  });
 
   if (isWriteOperation && !supportsRetryableWrites(server)) {
     throw new MongoUnexpectedServerResponseError(

src/sdam/server_selection_events.ts

@@ -5,23 +5,24 @@ import {
   WAITING_FOR_SUITABLE_SERVER
 } from '../constants';
 import { type ReadPreference } from '../read_preference';
+import { HostAddress } from '../utils';
 import { type ServerSelector } from './server_selection';
 import type { TopologyDescription } from './topology_description';
 
 /**
- * The base export class for all monitoring events published from server selection
- * @public
- * @category Event
+ * The base export class for all logs published from server selection
+ * @internal
+ * @category Log Type
  */
 export abstract class ServerSelectionEvent {
   /** String representation of the selector being used to select the server.
    *  Defaults to 'custom selector' for application-provided custom selector case.
    */
-  selector: string;
+  selector: string | ReadPreference | ServerSelector;
   /** The name of the operation for which a server is being selected.  */
   operation: string;
-  /** 	String representation of the current topology description.  */
-  topologyDescription: string;
+  /** 	The current topology description.  */
+  topologyDescription: TopologyDescription;
 
   /** @internal */
   abstract name:
@@ -30,26 +31,23 @@ export abstract class ServerSelectionEvent {
     | typeof SERVER_SELECTION_FAILED
     | typeof WAITING_FOR_SUITABLE_SERVER;
 
+  abstract message: string;
+
   /** @internal */
   constructor(
     selector: string | ReadPreference | ServerSelector,
-    operation: string | undefined,
-    topologyDescription: TopologyDescription
+    topologyDescription: TopologyDescription,
+    operation?: string
   ) {
-    this.selector =
-      typeof selector === 'string'
-        ? selector
-        : typeof selector === 'function'
-        ? 'custom selector'
-        : JSON.stringify(selector.toJSON(), null, 2);
-    this.operation = operation ?? 'custom operation';
-    this.topologyDescription = topologyDescription.toString();
+    this.selector = selector;
+    this.operation = operation ?? 'n/a';
+    this.topologyDescription = topologyDescription;
   }
 }
 
 /**
  * An event published when server selection starts
- * @public
+ * @internal
  * @category Event
  */
 export class ServerSelectionStartedEvent extends ServerSelectionEvent {
@@ -60,43 +58,43 @@ export class ServerSelectionStartedEvent extends ServerSelectionEvent {
   /** @internal */
   constructor(
     selector: string | ReadPreference | ServerSelector,
-    operation: string | undefined,
-    topologyDescription: TopologyDescription
+    topologyDescription: TopologyDescription,
+    operation?: string
   ) {
-    super(selector, operation, topologyDescription);
+    super(selector, topologyDescription, operation);
   }
 }
 
 /**
  * An event published when a server selection fails
- * @public
+ * @internal
  * @category Event
  */
 export class ServerSelectionFailedEvent extends ServerSelectionEvent {
   /** @internal */
   name = SERVER_SELECTION_FAILED;
   message = 'Server selection failed';
   /** Representation of the error the driver will throw regarding server selection failing. */
-  failure: string;
+  failure: Error;
 
   /** @internal */
   constructor(
     selector: string | ReadPreference | ServerSelector,
-    operation: string | undefined,
     topologyDescription: TopologyDescription,
-    errMsg: string
+    error: Error,
+    operation?: string
   ) {
-    super(selector, operation, topologyDescription);
-    this.failure = errMsg;
+    super(selector, topologyDescription, operation);
+    this.failure = error;
   }
 }
 
 /**
  * An event published when server selection succeeds
- * @public
+ * @internal
  * @category Event
  */
-export class ServerSelectionSuccessEvent extends ServerSelectionEvent {
+export class ServerSelectionSucceededEvent extends ServerSelectionEvent {
   /** @internal */
   name = SERVER_SELECTION_SUCCEEDED;
   message = 'Server selection succeeded';
@@ -110,39 +108,37 @@ export class ServerSelectionSuccessEvent extends ServerSelectionEvent {
   /** @internal */
   constructor(
     selector: string | ReadPreference | ServerSelector,
-    operation: string | undefined,
     topologyDescription: TopologyDescription,
-    serverHost: string,
-    serverPort: number
+    address: string,
+    operation?: string
   ) {
-    super(selector, operation, topologyDescription);
-    this.serverHost = serverHost;
-    this.serverPort = serverPort;
+    super(selector, topologyDescription, operation);
+    const { host, port } = HostAddress.fromString(address).toHostPort();
+    this.serverHost = host;
+    this.serverPort = port;
   }
 }
 
 /**
  * An event published when server selection is waiting for a suitable server to become available
- * @public
+ * @internal
  * @category Event
  */
 export class WaitingForSuitableServerEvent extends ServerSelectionEvent {
   /** @internal */
   name = WAITING_FOR_SUITABLE_SERVER;
   message = 'Waiting for suitable server to become available';
   /** The remaining time left until server selection will time out. */
-  remainingTimeMS?: number;
+  remainingTimeMS: number;
 
   /** @internal */
   constructor(
     selector: string | ReadPreference | ServerSelector,
-    operation: string | undefined,
     topologyDescription: TopologyDescription,
-    remainingTimeMS: number | undefined
+    remainingTimeMS: number,
+    operation?: string
   ) {
-    super(selector, operation, topologyDescription);
-    if (remainingTimeMS) {
-      this.remainingTimeMS = remainingTimeMS;
-    }
+    super(selector, topologyDescription, operation);
+    this.remainingTimeMS = remainingTimeMS;
   }
 }