DOCSP-39853: Updated monitoring api (#120)

Author: norareidy

source/fundamentals/monitoring/cluster-monitoring.txt

@@ -26,24 +26,24 @@ how they affect your application.
 This guide includes the following sections:
 
 - :ref:`Event Descriptions <rust-cluster-monitoring-descriptions>` describes
-  the SDAM events that the driver can generate
+  the SDAM events that the driver can generate.
 
 - :ref:`Event Subscription Example <rust-cluster-monitoring-example>`
-  provides sample code that shows how to subscribe to an SDAM event
+  provides sample code that shows how to subscribe to SDAM events.
 
 - :ref:`Example Event Documents <rust-cluster-monitoring-documents>`
-  provides samples of each SDAM event
+  provides samples of each SDAM event.
 
 - :ref:`Additional Information <rust-cluster-addtl-info>`
   provides links to resources and API documentation for types
-  and methods mentioned in this guide
+  and methods mentioned in this guide.
 
 .. _rust-cluster-monitoring-descriptions:
 
 Event Descriptions
 ------------------
 
-You can subscribe to one or more of the following SDAM events:
+You can monitor the following SDAM events:
 
 .. list-table::
    :widths: 33 67 
@@ -85,12 +85,15 @@ You can subscribe to one or more of the following SDAM events:
 
 .. _rust-cluster-monitoring-example:
 
-Event Subscription Example
---------------------------
+Event Monitoring Example
+------------------------
 
-You can access one or more SDAM events by
-subscribing to them in your application. The following example connects
-to a MongoDB deployment and subscribes to the ``ServerOpeningEvent`` event type:
+You can monitor SDAM events by assigning an ``EventHandler`` instance as the value of the
+``sdam_event_handler`` client option. To construct an ``EventHandler``, which processes all
+SDAM events, use the ``callback()`` or ``async_callback()`` method.
+
+The following example connects to a MongoDB deployment, instructs the client to monitor
+SDAM events, and prints each event:
 
 .. literalinclude:: /includes/fundamentals/code-snippets/monitoring/sdam-subscribe.rs
    :language: rust
@@ -233,6 +236,6 @@ API Documentation
 To learn more about the methods and types mentioned in this
 guide, see the following API documentation:
 
-- `SdamEventHandler <{+api+}/event/sdam/trait.SdamEventHandler.html>`__
+- `EventHandler <{+api+}/event/enum.EventHandler.html>`__
 - `ClientOptions <{+api+}/options/struct.ClientOptions.html>`__
 - `Client::with_options() <{+api+}/struct.Client.html#method.with_options>`__

source/fundamentals/monitoring/command-monitoring.txt

@@ -23,25 +23,24 @@ how the driver executes them.
 This guide includes the following sections:
 
 - :ref:`Event Descriptions <rust-command-monitoring-descriptions>` describes
-  the command events that the driver can generate
+  the command events that the driver can generate.
 
 - :ref:`Event Subscription Example <rust-command-monitoring-example>`
-  provides sample code that shows how to subscribe to a command event
+  provides sample code that shows how to subscribe to command events.
 
 - :ref:`Example Event Documents <rust-command-monitoring-documents>`
-  provides samples of each command event
+  provides samples of each command event.
 
 - :ref:`Additional Information <rust-command-monitoring-addtl-info>`
   provides links to resources and API documentation for types
-  and methods mentioned in this guide
+  and methods mentioned in this guide.
 
 .. _rust-command-monitoring-descriptions:
 
 Event Descriptions
 ------------------
 
-You can subscribe to one or more of the following command monitoring
-events:
+You can monitor the following command events:
 
 .. list-table::
    :widths: 33 67
@@ -61,12 +60,15 @@ events:
 
 .. _rust-command-monitoring-example:
 
-Event Subscription Example
---------------------------
+Event Monitoring Example
+------------------------
 
-You can access one or more command events by
-subscribing to them in your application. The following example connects
-to a MongoDB deployment and subscribes to the ``CommandStartedEvent`` event type:
+You can monitor command events by assigning an ``EventHandler`` instance as the value of the
+``command_event_handler`` client option. To construct an ``EventHandler``, which processes all
+command events, use the ``callback()`` or ``async_callback()`` method.
+
+The following example connects to a MongoDB deployment, instructs the client to monitor
+command events, and prints each event:
 
 .. literalinclude:: /includes/fundamentals/code-snippets/monitoring/command-subscribe.rs
    :language: rust
@@ -144,6 +146,6 @@ API Documentation
 To learn more about the methods and types mentioned in this
 guide, see the following API documentation:
 
-- `CommandEventHandler <{+api+}/event/command/trait.CommandEventHandler.html>`__
+- `EventHandler <{+api+}/event/enum.EventHandler.html>`__
 - `ClientOptions <{+api+}/options/struct.ClientOptions.html>`__
 - `Client::with_options() <{+api+}/struct.Client.html#method.with_options>`__

source/fundamentals/monitoring/connection-monitoring.txt

@@ -27,25 +27,24 @@ how the driver uses connections.
 This guide includes the following sections:
 
 - :ref:`Event Descriptions <rust-cpm-descriptions>` describes
-  the connection pool events that the driver can generate
+  the connection pool events that the driver can generate.
 
 - :ref:`Event Subscription Example <rust-cpm-example>`
-  provides sample code that shows how to subscribe to a connection pool event
+  provides sample code that shows how to subscribe to connection pool events.
 
 - :ref:`Example Event Documents <rust-cpm-documents>`
-  provides samples of each connection pool event
+  provides samples of each connection pool event.
 
 - :ref:`Additional Information <rust-cpm-addtl-info>`
   provides links to resources and API documentation for types
-  and methods mentioned in this guide
+  and methods mentioned in this guide.
 
 .. _rust-cpm-descriptions:
 
 Event Descriptions
 ------------------
 
-You can subscribe to one or more of the following connection pool
-monitoring events:
+You can monitor the following connection pool events:
 
 .. list-table::
    :widths: 33 67
@@ -96,12 +95,15 @@ monitoring events:
 
 .. _rust-cpm-example:
 
-Event Subscription Example
---------------------------
+Event Monitoring Example
+------------------------
 
-You can access one or more connection pool events by
-subscribing to them in your application. The following example connects
-to a MongoDB deployment and subscribes to the ``ConnectionCreatedEvent`` event type:
+You can monitor connection pool events by assigning an ``EventHandler`` instance as the value
+of the ``cmap_event_handler`` client option. To construct an ``EventHandler``, which processes
+all connection pool events, use the ``callback()`` or ``async_callback()`` method.
+
+The following example connects to a MongoDB deployment, instructs the client to monitor
+connection pool events, and prints each event:
 
 .. literalinclude:: /includes/fundamentals/code-snippets/monitoring/cpm-subscribe.rs
    :language: rust
@@ -259,6 +261,6 @@ API Documentation
 To learn more about the methods and types mentioned in this
 guide, see the following API documentation:
 
-- `CmapEventHandler <{+api+}/event/cmap/trait.CmapEventHandler.html>`__
+- `EventHandler <{+api+}/event/enum.EventHandler.html>`__
 - `ClientOptions <{+api+}/options/struct.ClientOptions.html>`__
 - `Client::with_options() <{+api+}/struct.Client.html#method.with_options>`__

source/includes/fundamentals/code-snippets/monitoring/command-subscribe.rs

@@ -1,35 +1,21 @@
-use std::{ env, sync::Arc };
-
-use bson::Document;
 use mongodb::{
-    Client,
-    Collection,
-    event::command::{ CommandEventHandler, CommandStartedEvent },
+    bson::{doc, Document},
+    event::EventHandler,
     options::ClientOptions,
+    Client, Collection,
 };
 
-fn main() -> mongodb::error::Result<()> {
-    let uri = "<connection string>";
-
-    let mut client_options = ClientOptions::parse_async(uri).await?;
+#[tokio::main]
+async fn main() -> mongodb::error::Result<()> {
 
     // begin-command
-    struct CommandStartHandler;
-
-    impl CommandEventHandler for CommandStartHandler {
-        fn handle_command_started_event(&self, event: CommandStartedEvent) {
-            eprintln!("Command started: {:?}", event);
-        }
-    }
-
-    let handler: Arc<dyn CommandEventHandler> = Arc::new(CommandStartHandler);
-    client_options.command_event_handler = Some(handler);
+    let mut client_options = ClientOptions::parse("<connection string>").await?;
+    client_options.command_event_handler = Some(EventHandler::callback(|ev| println!("{:?}", ev)));
 
     let client = Client::with_options(client_options)?;
 
     // ... perform actions with the client to generate events
 
     // end-command
-
     Ok(())
 }

source/includes/fundamentals/code-snippets/monitoring/cpm-subscribe.rs

@@ -1,35 +1,20 @@
-use std::{ env, sync::Arc };
-
-use bson::Document;
 use mongodb::{
-    Client,
-    Collection,
-    event::cmap::{ CmapEventHandler, ConnectionCreatedEvent },
+    bson::{doc, Document},
+    event::EventHandler,
     options::ClientOptions,
+    Client, Collection,
 };
 
-fn main() -> mongodb::error::Result<()> {
-    let uri = "<connection string>";
-
-    let mut client_options = ClientOptions::parse_async(uri).await?;
-
+#[tokio::main]
+async fn main() -> mongodb::error::Result<()> {
     // begin-cmap
-    struct ConnectionCreatedHandler;
-
-    impl CmapEventHandler for ConnectionCreatedHandler {
-        fn handle_connection_created_event(&self, event: ConnectionCreatedEvent) {
-            eprintln!("Connection created: {:?}", event);
-        }
-    }
-
-    let handler: Arc<dyn CmapEventHandler> = Arc::new(ConnectionCreatedHandler);
-    client_options.cmap_event_handler = Some(handler);
+    let mut client_options = ClientOptions::parse("<connection string>").await?;
+    client_options.cmap_event_handler = Some(EventHandler::callback(|ev| println!("{:?}", ev)));
 
     let client = Client::with_options(client_options)?;
 
     // ... perform actions with the client to generate events
 
     // end-cmap
-
     Ok(())
 }

source/includes/fundamentals/code-snippets/monitoring/sdam-subscribe.rs

@@ -1,35 +1,20 @@
-use std::{ env, sync::Arc };
-
-use bson::Document;
 use mongodb::{
-    Client,
-    Collection,
-    event::sdam::{ SdamEventHandler, ServerOpeningEvent },
+    bson::{doc, Document},
+    event::EventHandler,
     options::ClientOptions,
+    Client, Collection,
 };
 
-fn main() -> mongodb::error::Result<()> {
-    let uri = "<connection string>";
-
-    let mut client_options = ClientOptions::parse_async(uri).await?;
-
+#[tokio::main]
+async fn main() -> mongodb::error::Result<()> {
     // begin-sdam
-    struct ServerOpenHandler;
-
-    impl SdamEventHandler for ServerOpenHandler {
-        fn handle_server_opening_event(&self, event: ServerOpeningEvent) {
-            eprintln!("Server opening: {:?}", event);
-        }
-    }
-
-    let handler: Arc<dyn SdamEventHandler> = Arc::new(ServerOpenHandler);
-    client_options.sdam_event_handler = Some(handler);
+    let mut client_options = ClientOptions::parse("<connection string>").await?;
+    client_options.sdam_event_handler = Some(EventHandler::callback(|ev| println!("{:?}", ev)));
 
     let client = Client::with_options(client_options)?;
 
     // ... perform actions with the client to generate events
 
     // end-sdam
-
     Ok(())
 }