various cleanup

Author: patrickfreed

src/client/executor.rs

@@ -400,7 +400,6 @@ impl Client {
             bytes: serialized,
         };
 
-        let start_time = Instant::now();
         self.emit_command_event(|handler| {
             let command_body = if should_redact {
                 Document::new()
@@ -419,6 +418,7 @@ impl Client {
             handler.handle_command_started_event(command_started_event);
         });
 
+        let start_time = Instant::now();
         let command_result = match connection.send_raw_command(raw_cmd, request_id).await {
             Ok(response) => {
                 match T::Response::deserialize_response(&response) {

src/operation/insert/mod.rs

@@ -25,7 +25,7 @@ pub(crate) struct Insert<'a, T> {
     ns: Namespace,
     documents: Vec<&'a T>,
     inserted_ids: Vec<Bson>,
-    options: InsertManyOptions,
+    options: Option<InsertManyOptions>,
 }
 
 impl<'a, T> Insert<'a, T> {
@@ -34,9 +34,6 @@ impl<'a, T> Insert<'a, T> {
         documents: Vec<&'a T>,
         options: Option<InsertManyOptions>,
     ) -> Self {
-        let mut options =
-            options.unwrap_or_else(|| InsertManyOptions::builder().ordered(true).build());
-        options.ordered = Some(options.ordered.unwrap_or(true));
         Self {
             ns,
             options,
@@ -46,7 +43,10 @@ impl<'a, T> Insert<'a, T> {
     }
 
     fn is_ordered(&self) -> bool {
-        self.options.ordered.unwrap_or(true)
+        self.options
+            .as_ref()
+            .and_then(|o| o.ordered)
+            .unwrap_or(true)
     }
 }
 
@@ -58,13 +58,6 @@ impl<'a, T: Serialize> Operation for Insert<'a, T> {
     const NAME: &'static str = "insert";
 
     fn build(&mut self, description: &StreamDescription) -> Result<Command<InsertCommand>> {
-        if self.documents.is_empty() {
-            return Err(ErrorKind::InvalidArgument {
-                message: "must specify at least one document to insert".to_string(),
-            }
-            .into());
-        }
-
         let mut docs: Vec<Vec<u8>> = Vec::new();
         let mut size = 0;
 
@@ -79,14 +72,19 @@ impl<'a, T: Serialize> Operation for Insert<'a, T> {
                 Some(b) => b,
                 None => {
                     let oid = ObjectId::new();
-                    let new_len = doc.len() as i32 + 1 + 4 + 12;
-                    doc.splice(0..4, new_len.to_le_bytes().iter().cloned());
 
-                    let mut new_doc = Vec::new();
-                    new_doc.write_u8(ElementType::ObjectId as u8)?;
-                    new_doc.write_all(b"_id\0")?;
-                    new_doc.extend(oid.bytes().iter());
-                    doc.splice(4..4, new_doc.into_iter());
+                    // write element to temporary buffer
+                    let mut new_id = Vec::new();
+                    new_id.write_u8(ElementType::ObjectId as u8)?;
+                    new_id.write_all(b"_id\0")?;
+                    new_id.extend(oid.bytes().iter());
+
+                    // insert element to beginning of existing doc after length
+                    doc.splice(4..4, new_id.into_iter());
+
+                    // update length of doc
+                    let new_len = doc.len() as i32;
+                    doc.splice(0..4, new_len.to_le_bytes().iter().cloned());
 
                     Bson::ObjectId(oid)
                 }
@@ -112,13 +110,16 @@ impl<'a, T: Serialize> Operation for Insert<'a, T> {
             .into());
         }
 
+        let mut options = self.options.clone().unwrap_or_default();
+        options.ordered = Some(self.is_ordered());
+
         let body = InsertCommand {
             insert: self.ns.coll.clone(),
             documents: DocumentArraySpec {
                 documents: docs,
                 length: size as i32,
             },
-            options: self.options.clone(),
+            options,
         };
 
         Ok(Command::new("insert".to_string(), self.ns.db.clone(), body))
@@ -161,7 +162,7 @@ impl<'a, T: Serialize> Operation for Insert<'a, T> {
 
         // update length of original doc
         let final_length = serialized.len() as i32;
-        (&mut serialized[0..4]).write_all(&final_length.to_le_bytes())?;
+        serialized.splice(0..4, final_length.to_le_bytes().iter().cloned());
 
         Ok(serialized)
     }
@@ -211,7 +212,7 @@ impl<'a, T: Serialize> Operation for Insert<'a, T> {
     }
 
     fn write_concern(&self) -> Option<&WriteConcern> {
-        self.options.write_concern.as_ref()
+        self.options.as_ref().and_then(|o| o.write_concern.as_ref())
     }
 
     fn retryability(&self) -> Retryability {

src/operation/mod.rs

@@ -69,6 +69,7 @@ pub(crate) trait Operation {
     /// The output type of this operation.
     type O;
 
+    /// The format of the command body constructed in `build`.
     type Command: CommandBody;
 
     /// The format of the command response from the server.
@@ -81,6 +82,8 @@ pub(crate) trait Operation {
     /// The operation may store some additional state that is required for handling the response.
     fn build(&mut self, description: &StreamDescription) -> Result<Command<Self::Command>>;
 
+    /// Perform custom serialization of the built command.
+    /// By default, this will just call through to the `Serialize` implementation of the command.
     fn serialize_command(&mut self, cmd: Command<Self::Command>) -> Result<Vec<u8>> {
         Ok(bson::to_vec(&cmd)?)
     }
@@ -141,15 +144,19 @@ pub(crate) trait CommandBody: Serialize {
 
 impl CommandBody for Document {
     fn should_redact(&self) -> bool {
-        self.contains_key("speculativeAuthenticate")
+        if let Some(command_name) = bson_util::first_key(self) {
+            HELLO_COMMAND_NAMES.contains(command_name.to_lowercase().as_str())
+                && self.contains_key("speculativeAuthenticate")
+        } else {
+            false
+        }
     }
 }
 
 impl<T: CommandBody> Command<T> {
     pub(crate) fn should_redact(&self) -> bool {
         let name = self.name.to_lowercase();
-        REDACTED_COMMANDS.contains(name.as_str())
-            || HELLO_COMMAND_NAMES.contains(name.as_str()) && self.body.should_redact()
+        REDACTED_COMMANDS.contains(name.as_str()) || self.body.should_redact()
     }
 }