Use TraceParentContext, simplifying code using SubrequestMetadata

src/workerd/api/actor.c++

@@ -35,7 +35,7 @@ public:
       }
 
       return KJ_REQUIRE_NONNULL(actorChannel)
-          ->startRequest({.cfBlobJson = kj::mv(cfStr), .parentSpan = spans.span});
+          ->startRequest({.cfBlobJson = kj::mv(cfStr), .spans = spans});
     },
         {.inHouse = true,
           .wrapMetrics = true,
@@ -77,7 +77,7 @@ public:
       }
 
       return KJ_REQUIRE_NONNULL(actorChannel)
-          ->startRequest({.cfBlobJson = kj::mv(cfStr), .parentSpan = spans.span});
+          ->startRequest({.cfBlobJson = kj::mv(cfStr), .spans = spans});
     },
         {.inHouse = true,
           .wrapMetrics = true,

src/workerd/io/io-channels.h

@@ -88,8 +88,7 @@ class IoChannelFactory {
     kj::Maybe<kj::String> cfBlobJson;
 
     // Specifies the parent span for the subrequest for tracing purposes.
-    SpanParent parentSpan = nullptr;
-    LimeSpanParent limeParentSpan = nullptr;
+    TraceParentContext spans = TraceParentContext(nullptr, nullptr);
 
     // Serialized JSON value to pass in ew_compat field of control header to FL. If this subrequest
     // does not go directly to FL, this value is ignored. Flags marked with `$neededByFl` in

src/workerd/io/io-context.c++

@@ -852,8 +852,7 @@ kj::Own<WorkerInterface> IoContext::getSubrequestChannelImpl(uint channel,
     IoChannelFactory& channelFactory) {
   IoChannelFactory::SubrequestMetadata metadata{
     .cfBlobJson = kj::mv(cfBlobJson),
-    .parentSpan = spans.span,
-    .limeParentSpan = spans.limeSpan,
+    .spans = spans,
     .featureFlagsForFl = worker->getIsolate().getFeatureFlagsForFl(),
   };
 

src/workerd/io/trace.h

@@ -448,10 +448,9 @@ inline kj::String truncateScriptId(kj::StringPtr id) {
 //   is currently designed to feed tracing of the Workers Runtime itself for the benefit of the
 //   developers of the runtime.
 //
-//   However, we might potentially want to give trace workers some access to span tracing as well.
-//   But, that hasn't been designed yet, and it's not clear if that would be based on the same
-//   concept of spans or completely separate. In the latter case, these classes should probably
-//   move to a different header.
+//   We might potentially want to give trace workers some access to span tracing as well, but with
+//   that the trace worker and span interfaces should still be largely independent of each other;
+//   separate span tracing into a separate header.
 
 class SpanBuilder;
 class SpanBuilderBase;
@@ -739,7 +738,7 @@ inline LimeSpanBuilder LimeSpanBuilder::newLimeChild(kj::ConstString operationNa
 
 // Interface to track trace context including both Jaeger and Lime spans.
 // TODO(o11y): Consider fleshing this out to make it a proper class, support adding tags/child spans
-// to both, ... we expect that tracking lime spans will not needed in all places where we have the
+// to both,... We expect that tracking lime spans will not needed in all places where we have the
 // existing spans, so synergies will likely be limited.
 struct TraceContext {
   TraceContext(SpanBuilder span, LimeSpanBuilder limeSpan)
@@ -753,4 +752,20 @@ struct TraceContext {
   LimeSpanBuilder limeSpan;
 };
 
+// TraceContext variant tracking span parents instead. This is useful for code interacting with
+// IoChannelFactory::SubrequestMetadata, which often needs to pass through both spans together
+// without modifying them.
+struct TraceParentContext {
+  TraceParentContext(TraceContext& spans): parentSpan(spans.span), limeParentSpan(spans.limeSpan) {}
+  TraceParentContext(SpanParent span, LimeSpanParent limeSpan)
+      : parentSpan(kj::mv(span)),
+        limeParentSpan(kj::mv(limeSpan)) {}
+  TraceParentContext(TraceParentContext&& other) = default;
+  TraceParentContext& operator=(TraceParentContext&& other) = default;
+  KJ_DISALLOW_COPY(TraceParentContext);
+
+  SpanParent parentSpan;
+  LimeSpanParent limeParentSpan;
+};
+
 }  // namespace workerd

src/workerd/server/server.c++

@@ -2138,7 +2138,8 @@ private:
         kj::Maybe<kj::String> cacheName,
         kj::Maybe<kj::String> cfBlobJson,
         SpanParent parentSpan)
-        : client(asHttpClient(parent.startRequest({kj::mv(cfBlobJson), kj::mv(parentSpan)}))),
+        : client(asHttpClient(parent.startRequest(
+              {kj::mv(cfBlobJson), TraceParentContext(kj::mv(parentSpan), nullptr)}))),
           cacheName(kj::mv(cacheName)),
           cacheNamespaceHeader(cacheNamespaceHeader) {}