@redthreadlabs/tracelog 1.5.0 → 1.5.1

package/lib/instrumentation/index.js

@@ -710,6 +710,14 @@ Instrumentation.prototype.addEndedTransaction = function (transaction) {
       trans: transaction.id,
       trace: transaction.traceId,
     });
+    // The transaction's name is final now, so held spans can be routed
+    // even though the transaction record itself was dropped.
+    this._drainPendingChannelSpans(
+      transaction,
+      agent._channelForTransactionName(
+        transaction._customName || transaction._defaultName,
+      ),
+    );
     return;
   }
 
@@ -718,6 +726,9 @@ Instrumentation.prototype.addEndedTransaction = function (transaction) {
     trace: transaction.traceId,
   });
   const channel = agent._channelForTransactionName(payload.name);
+  // Spans held while this transaction's name was unresolved follow the
+  // same routing decision as the transaction itself.
+  this._drainPendingChannelSpans(transaction, channel);
   if (channel && typeof agent._apmClient.sendToChannel === 'function') {
     agent._apmClient.sendToChannel(channel, 'transaction', payload);
   } else {
@@ -725,6 +736,31 @@ Instrumentation.prototype.addEndedTransaction = function (transaction) {
   }
 };
 
+// Send any span payloads that were held on the transaction because the
+// transaction's name (and so its channel routing) was not yet resolved
+// when the span ended. See `_encodeAndSendSpan`.
+Instrumentation.prototype._drainPendingChannelSpans = function (
+  transaction,
+  channel,
+) {
+  const agent = this._agent;
+  const pending = transaction._pendingChannelSpans;
+  if (!pending) {
+    return;
+  }
+  transaction._pendingChannelSpans = null;
+  if (!agent._apmClient) {
+    return;
+  }
+  for (const payload of pending) {
+    if (channel && typeof agent._apmClient.sendToChannel === 'function') {
+      agent._apmClient.sendToChannel(channel, 'span', payload);
+    } else {
+      agent._apmClient.sendSpan(payload);
+    }
+  }
+};
+
 Instrumentation.prototype.addEndedSpan = function (span) {
   var agent = this._agent;
 
@@ -847,15 +883,38 @@ Instrumentation.prototype._encodeAndSendSpan = function (span) {
         });
         if (agent._apmClient) {
           // Spans follow their transaction's channel. The transaction name
-          // may not be final until the transaction ends, so this routing is
-          // best-effort for spans that end before the route is resolved.
-          const channel = agent._channelForTransactionName(
-            span.transaction && span.transaction.name,
-          );
-          if (channel && typeof agent._apmClient.sendToChannel === 'function') {
-            agent._apmClient.sendToChannel(channel, 'span', payload);
-          } else {
+          // is only meaningful for routing once *resolved* (custom or
+          // framework-set); the `name` getter must not be used here, since
+          // until the transaction ends it falls back to
+          // '<METHOD> unknown route (unnamed)', which would spuriously
+          // match rules aimed at unmatched-route traffic. When routing is
+          // configured and the name is not yet resolved (e.g. Express only
+          // names transactions when the request finishes), hold the span on
+          // its transaction; addEndedTransaction() drains held spans with
+          // the transaction's final routing decision.
+          const trans = span.transaction;
+          const routingEnabled =
+            agent._conf.transactionChannelRules &&
+            agent._conf.transactionChannelRules.length > 0 &&
+            typeof agent._apmClient.sendToChannel === 'function';
+          if (!routingEnabled) {
             agent._apmClient.sendSpan(payload);
+          } else {
+            const resolvedName =
+              trans && (trans._customName || trans._defaultName);
+            if (!resolvedName && trans && !trans.ended) {
+              if (!trans._pendingChannelSpans) {
+                trans._pendingChannelSpans = [];
+              }
+              trans._pendingChannelSpans.push(payload);
+            } else {
+              const channel = agent._channelForTransactionName(resolvedName);
+              if (channel) {
+                agent._apmClient.sendToChannel(channel, 'span', payload);
+              } else {
+                agent._apmClient.sendSpan(payload);
+              }
+            }
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redthreadlabs/tracelog",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Node.js APM instrumentation that writes traces to JSONL files",
   "publishConfig": {
     "access": "public"