fix minor logic, logging, typo, and some comments

Signed-off-by: Emelia Lei <[email protected]>

Author: emelialei88

src/groups/bmq/bmqa/bmqa_messageeventbuilder.cpp

@@ -33,9 +33,7 @@
 #include <bslma_managedptr.h>
 #include <bslmf_assert.h>
 #include <bsls_assert.h>
-#include <bsls_nullptr.h>
 #include <bsls_performancehint.h>
-#include <bslstl_sharedptr.h>
 
 namespace BloombergLP {
 namespace bmqa {
@@ -154,9 +152,9 @@ MessageEventBuilder::packMessage(const bmqa::QueueId& queueId)
     // If distributed tracing is enabled, create a span and inject trace
     // span into message properties
     bsl::shared_ptr<bmqp::MessageProperties> propsWithDT;
-    bsl::shared_ptr<bmqpi::DTSpan>           span;
+    bsl::shared_ptr<bmqpi::DTSpan>           childSpan;
     if (d_impl.d_dtTracer_sp && d_impl.d_dtContext_sp) {
-        copyPropertiesAndInjectDT(&propsWithDT, &span, builder, queueId);
+        copyPropertiesAndInjectDT(&propsWithDT, &childSpan, builder, queueId);
     }
 
     if (queueSpRef->isOldStyle()) {
@@ -182,7 +180,10 @@ MessageEventBuilder::packMessage(const bmqa::QueueId& queueId)
         }
 
         // Add message related info into the event on success.
-        msgImplRef.d_event_p->addMessageInfo(queueSpRef, guid, corrId, span);
+        msgImplRef.d_event_p->addMessageInfo(queueSpRef,
+                                             guid,
+                                             corrId,
+                                             childSpan);
     }
 
     return rc;
@@ -305,9 +306,8 @@ void MessageEventBuilder::copyPropertiesAndInjectDT(
     bsl::vector<unsigned char> serializedSpan;
     int rc = d_impl.d_dtTracer_sp->serializeSpan(&serializedSpan, childSpan);
     if (rc != 0) {
-        BALL_LOG_WARN << "Failed to serialize span for trace context "
-                      << "injection, rc: " << rc;
-        childSpan->finish();
+        BALL_LOG_WARN
+            << "Failed to serialize span for trace span injection, rc: " << rc;
         return;  // RETURN
     }
 
@@ -318,9 +318,9 @@ void MessageEventBuilder::copyPropertiesAndInjectDT(
         bmqp::MessageProperties::k_TRACE_PROPERTY_NAME,
         traceSpanData);
     if (rc != 0) {
-        BALL_LOG_WARN << "Failed to inject trace span into "
-                      << "message properties, rc: " << rc;
-        childSpan->finish();
+        BALL_LOG_WARN
+            << "Failed to inject trace span into message properties, rc: "
+            << rc;
         return;  // RETURN
     }
 

src/groups/bmq/bmqa/bmqa_messageeventbuilder.h

@@ -256,10 +256,9 @@
 
 #include <bmqa_message.h>
 #include <bmqa_messageevent.h>
-#include <bmqp_puteventbuilder.h>
+#include <bmqp_messageproperties.h>
 #include <bmqpi_dtcontext.h>
 #include <bmqpi_dttracer.h>
-#include <bmqt_resultcode.h>
 
 // BDE
 #include <bsl_memory.h>
@@ -272,6 +271,8 @@ class QueueId;
 }
 namespace bmqp {
 class MessageGUIDGenerator;
+class PutEventBuilder;
+class MessageProperties;
 }
 
 namespace bmqa {
@@ -316,6 +317,7 @@ struct MessageEventBuilderImpl {
     /// Distributed tracing tracer object.
     bsl::shared_ptr<bmqpi::DTTracer> d_dtTracer_sp;
 
+    /// Distributed tracing context object.
     bsl::shared_ptr<bmqpi::DTContext> d_dtContext_sp;
 };
 
@@ -390,7 +392,7 @@ class MessageEventBuilder {
   private:
     // ACCESSORS
 
-    /// Create a distributed tracing span and inject it into message
+    /// Create a child distributed tracing span and inject it into the message
     /// properties.  Load into the specified `properties` a copy of the
     /// message properties from the specified `builder` with the trace
     /// context injected, and load into the specified `span` the created

src/groups/bmq/bmqa/bmqa_session.cpp

@@ -805,15 +805,9 @@ void Session::loadMessageEventBuilder(MessageEventBuilder* builder)
 
     builderImplRef.d_guidGenerator_sp = d_impl.d_guidGenerator_sp;
 
-    // Set distributed tracing tracer
-    const bsl::shared_ptr<bmqpi::DTTracer>& tracer =
-        d_impl.d_sessionOptions.tracer();
-    const bsl::shared_ptr<bmqpi::DTContext>& context =
-        d_impl.d_sessionOptions.traceContext();
-    if (tracer && context) {
-        builderImplRef.d_dtTracer_sp  = tracer;
-        builderImplRef.d_dtContext_sp = context;
-    }
+    // Set distributed tracing tracer and context
+    builderImplRef.d_dtTracer_sp  = d_impl.d_sessionOptions.tracer();
+    builderImplRef.d_dtContext_sp = d_impl.d_sessionOptions.traceContext();
 
     // Get bmqimp::Event sharedptr from MessageEventBuilderImpl
     bsl::shared_ptr<bmqimp::Event>& eventImplSpRef =

src/groups/bmq/bmqimp/bmqimp_brokersession.cpp

@@ -3611,7 +3611,9 @@ void BrokerSession::processPushEvent(const bmqp::Event& event)
             msgIterator,
             "bmq.message.push",
             baggage);
-        d_consumerSpans[guid] = span;
+        if (span) {
+            d_consumerSpans[guid] = span;
+        }
     }
 
     // Update event stats
@@ -5623,7 +5625,7 @@ BrokerSession::BrokerSession(
 , d_usingSessionEventHandler(eventHandlerCb)  // UnspecifiedBool operator ...
 , d_messageCorrelationIdContainer(
       d_allocators.get("messageCorrelationIdContainer"))
-, d_consumerSpans(d_allocators.get("consumerSpans"))
+, d_consumerSpans(allocator)
 , d_fsmThread(bslmt::ThreadUtil::invalidHandle())
 , d_fsmThreadChecker()
 , d_fsmEventQueue(k_FSMQUEUE_INITIAL_CAPACITY,
@@ -7108,38 +7110,32 @@ bslma::ManagedPtr<void> BrokerSession::restoreDTPropertyAndActivateChildSpan(
         return bslma::ManagedPtr<void>();  // RETURN
     }
 
-    bmqp::MessageProperties properties;
-    int                     rc = iterator.loadMessageProperties(&properties);
-    if (BSLS_PERFORMANCEHINT_PREDICT_UNLIKELY(rc != 0)) {
-        BSLS_PERFORMANCEHINT_UNLIKELY_HINT;
-        BALL_LOG_ERROR << id()
-                       << "Unable to load message properties, rc: " << rc
-                       << "";
-        return bslma::ManagedPtr<void>();  // RETURN
-    }
-
     // If we fail at any step, create a span without parent
     bsl::shared_ptr<bmqpi::DTSpan> childSpan;
     bsl::vector<unsigned char>     vecUnsignedChar;
 
-    if (!properties.hasProperty(
-            bmqp::MessageProperties::k_TRACE_PROPERTY_NAME)) {
-        BALL_LOG_INFO
-            << "Not restoring distributed trace from message properties. No "
-               "distributed trace in message properties.";
+    bmqp::MessageProperties properties;
+    const int               rc = iterator.loadMessageProperties(&properties);
+    if (rc != 0 || !properties.hasProperty(
+                       bmqp::MessageProperties::k_TRACE_PROPERTY_NAME)) {
+        // If we fail to load message properties or the property
+        // is not present, create a span without parent
+        childSpan = tracer->createChildSpan(bsl::shared_ptr<bmqpi::DTSpan>(),
+                                            operation,
+                                            baggage);
     }
     else {
         const bsl::vector<char>& vecChar = properties.getPropertyAsBinary(
             bmqp::MessageProperties::k_TRACE_PROPERTY_NAME);
 
         vecUnsignedChar.resize(vecChar.size());
         bsl::copy(vecChar.begin(), vecChar.end(), vecUnsignedChar.begin());
-    }
 
-    tracer->deserializeAndCreateChildSpan(&childSpan,
-                                          vecUnsignedChar,
-                                          operation,
-                                          baggage);
+        tracer->deserializeAndCreateChildSpan(&childSpan,
+                                              vecUnsignedChar,
+                                              operation,
+                                              baggage);
+    }
 
     // scope on the childSpan if we can successfully create one
     return context->scope(childSpan);

src/groups/bmq/bmqimp/bmqimp_brokersession.h

@@ -1495,8 +1495,8 @@ class BrokerSession BSLS_CPP11_FINAL {
                      bmqpi::DTSpan::Baggage()) const;
 
     /// Restore the DTContext from the properties of the given `iterator` and
-    /// create a child span based on the current span. Return a managed pointer
-    /// to the current span which might be NULL.
+    /// create a child span based on the current span.  Return a managed
+    /// pointer to the current span which might be NULL.
     bslma::ManagedPtr<void> restoreDTPropertyAndActivateChildSpan(
         const bmqp::PushMessageIterator& iterator,
         const bsl::string_view&          operation,