@@ -419,9 +419,9 @@ def _set_exception_attributes(span: Span, exc: BaseException) -> str:
 
     ``record_exception`` attaches these to an "exception" *event* only, but the
     spec requires them as span *attributes* too, for both command and operation
-    spans. Formatting mirrors ``record_exception``. Returns the computed
-    ``exception.type`` value so callers (e.g. ``error.type``) can reuse it
-    without recomputing.
+    spans. Formatting mirrors ``record_exception``.
+
+    :return: The ``exception.type`` value.
     """
     module = type(exc).__module__
     qualname = type(exc).__qualname__
@@ -448,12 +448,10 @@ def end_command_span_failure(
         exception_type = _set_exception_attributes(span, exc)
         code = failure.get("code")
         if code is not None:
-            # Server error: error.type mirrors db.response.status_code, per spec.
             span.set_attribute("db.response.status_code", str(code))
             span.set_attribute("error.type", str(code))
         else:
-            # Non-server error (e.g. network failure): fall back to the
-            # exception's class name, since there's no server error code to report.
+            # A network failure gets no server reply, so there is no code to report.
             span.set_attribute("error.type", exception_type)
         span.set_status(Status(StatusCode.ERROR, description=failure.get("errmsg")))
     finally:
 
@@ -509,8 +509,8 @@ async def test_failure_records_exception_and_status_code(self):
 
     @async_client_context.require_failCommand_fail_point
     async def test_error_type_is_exception_class_name_for_connection_failure(self):
-        # A closed connection produces no server reply, so there is no error
-        # code to report: the spec falls back to the exception's class name.
+        # A closed connection produces no server reply, so error.type falls back
+        # to the exception's class name.
         client = await self.async_rs_or_single_client(tracing={"enabled": True}, retryReads=False)
         fail_command = {
             "configureFailPoint": "failCommand",
@@ -527,14 +527,12 @@ async def test_error_type_is_exception_class_name_for_connection_failure(self):
         attrs = spans[0].attributes
         self.assertNotIn("db.response.status_code", attrs)
         self.assertEqual(attrs["error.type"], _qualified_name(type(ctx.exception)))
-        # error.type and exception.type carry the same value here, by design:
-        # one is the span attribute, the other the exception event's.
+        # error.type and exception.type carry the same value on this path.
         self.assertEqual(attrs["error.type"], attrs["exception.type"])
 
     @async_client_context.require_failCommand_blockConnection
     async def test_error_type_is_exception_class_name_for_network_timeout(self):
-        # socketTimeoutMS trips before the blocked command replies, so again
-        # there is no server error code and error.type is the class name.
+        # socketTimeoutMS trips before any reply, so again no server error code.
         client = await self.async_rs_or_single_client(
             tracing={"enabled": True}, socketTimeoutMS=200, retryReads=False
         )
 
@@ -509,8 +509,8 @@ def test_failure_records_exception_and_status_code(self):
 
     @client_context.require_failCommand_fail_point
     def test_error_type_is_exception_class_name_for_connection_failure(self):
-        # A closed connection produces no server reply, so there is no error
-        # code to report: the spec falls back to the exception's class name.
+        # A closed connection produces no server reply, so error.type falls back
+        # to the exception's class name.
         client = self.rs_or_single_client(tracing={"enabled": True}, retryReads=False)
         fail_command = {
             "configureFailPoint": "failCommand",
@@ -527,14 +527,12 @@ def test_error_type_is_exception_class_name_for_connection_failure(self):
         attrs = spans[0].attributes
         self.assertNotIn("db.response.status_code", attrs)
         self.assertEqual(attrs["error.type"], _qualified_name(type(ctx.exception)))
-        # error.type and exception.type carry the same value here, by design:
-        # one is the span attribute, the other the exception event's.
+        # error.type and exception.type carry the same value on this path.
         self.assertEqual(attrs["error.type"], attrs["exception.type"])
 
     @client_context.require_failCommand_blockConnection
     def test_error_type_is_exception_class_name_for_network_timeout(self):
-        # socketTimeoutMS trips before the blocked command replies, so again
-        # there is no server error code and error.type is the class name.
+        # socketTimeoutMS trips before any reply, so again no server error code.
         client = self.rs_or_single_client(
             tracing={"enabled": True}, socketTimeoutMS=200, retryReads=False
         )