Merge pull request #7203 from cloudflare/maizatskyi/2026-09-01-rc-span-observer

switch SpanObserver to kj::Rc

Author: mikea

src/workerd/api/tracing.c++

@@ -53,7 +53,7 @@ kj::LiteralStringConst spanWarningTypeName(SpanWarningType type) {
 // ======================================================================================
 // SpanImpl
 
-SpanImpl::SpanImpl(kj::Own<workerd::SpanObserver> observer, kj::ConstString operationName)
+SpanImpl::SpanImpl(kj::Rc<workerd::SpanObserver> observer, kj::ConstString operationName)
     : builder(kj::mv(observer), kj::mv(operationName)) {}
 
 SpanImpl::SpanImpl(decltype(nullptr)): builder(nullptr) {}

src/workerd/api/tracing.h

@@ -34,7 +34,7 @@ using TagValue = kj::OneOf<bool, double, kj::String>;
 class SpanImpl final: public kj::Refcounted {
  public:
   // Construct an observed span. The builder drives the observer's onOpen immediately.
-  SpanImpl(kj::Own<workerd::SpanObserver> observer, kj::ConstString operationName);
+  SpanImpl(kj::Rc<workerd::SpanObserver> observer, kj::ConstString operationName);
 
   // Construct a no-op span (not recording). Used when there is no current user trace span
   // (e.g., running outside a traced request) or when we are in a context where we cannot

src/workerd/io/trace.c++

@@ -1810,17 +1810,16 @@ void SpanEndData::copyTo(rpc::SpanEndData::Builder builder) const {
 
 // ======================================================================================
 
-SpanBuilder::SpanBuilder(kj::Maybe<kj::Own<SpanObserver>> observer,
-    kj::ConstString operationName,
-    kj::Maybe<kj::Date> startTime) {
-  KJ_IF_SOME(obs, observer) {
+SpanBuilder::SpanBuilder(
+    kj::Rc<SpanObserver> observer, kj::ConstString operationName, kj::Maybe<kj::Date> startTime) {
+  if (observer != nullptr) {
     // TODO(o11y): Once we report the user tracing spanOpen event as soon as a span is created, we
     // should be able to fold this virtual call and just get the timestamp directly.
-    kj::Date time = startTime.orDefault([&]() { return obs->getTime(); });
+    kj::Date time = startTime.orDefault([&]() { return observer->getTime(); });
     // Report spanOpen event for user tracing spans
-    obs->onOpen(operationName.clone(), time);
+    observer->onOpen(operationName.clone(), time);
     span.emplace(kj::mv(operationName), time);
-    this->observer = kj::mv(obs);
+    this->observer = kj::mv(observer);
   }
 }
 
@@ -1836,21 +1835,21 @@ SpanBuilder::~SpanBuilder() noexcept(false) {
 }
 
 void SpanBuilder::end() {
-  KJ_IF_SOME(o, observer) {
+  if (observer != nullptr) {
     KJ_IF_SOME(s, span) {
       // TODO(performance): Fold this timer call if we are using I/O time, where we will look up
       // I/O time later.
       s.endTime = kj::systemPreciseCalendarClock().now();
-      o->onClose(s.endTime, kj::mv(s.tags), kj::mv(s.logs));
+      observer->onClose(s.endTime, kj::mv(s.tags), kj::mv(s.logs));
       span = kj::none;
     }
   }
 }
 
 void SpanBuilder::setOperationName(kj::ConstString operationName) {
   KJ_IF_SOME(s, span) {
-    KJ_IF_SOME(o, observer) {
-      o->onUpdateName(operationName.clone());
+    if (observer != nullptr) {
+      observer->onUpdateName(operationName.clone());
     }
     s.operationName = kj::mv(operationName);
   }

src/workerd/io/trace.h

@@ -1127,7 +1127,7 @@ class SpanParent {
   // Make a SpanParent that causes children not to be reported anywhere.
   SpanParent(decltype(nullptr)) {}
 
-  SpanParent(kj::Maybe<kj::Own<SpanObserver>> observer): observer(kj::mv(observer)) {}
+  SpanParent(kj::Rc<SpanObserver> observer): observer(kj::mv(observer)) {}
 
   SpanParent(SpanParent&& other) = default;
   SpanParent& operator=(SpanParent&& other) = default;
@@ -1143,7 +1143,7 @@ class SpanParent {
 
   // Useful to skip unnecessary code when not observed.
   bool isObserved() {
-    return observer != kj::none;
+    return observer != nullptr;
   }
 
   // Get the underlying SpanObserver representing the parent span.
@@ -1152,7 +1152,8 @@ class SpanParent {
   // trace IDs in a way that is specific to the trace back-end being used. The caller must downcast
   // the `SpanObserver` to the expected observer type in order to extract the trace ID.
   kj::Maybe<SpanObserver&> getObserver() {
-    return observer;
+    if (observer != nullptr) return *observer;
+    return kj::none;
   }
 
   // Return the serializable identity of this span for cross-boundary propagation.
@@ -1166,7 +1167,7 @@ class SpanParent {
   static SpanParent fromSpanContext(tracing::SpanContext context);
 
  private:
-  kj::Maybe<kj::Own<SpanObserver>> observer;
+  kj::Rc<SpanObserver> observer;
 };
 
 // Whether the span tag is a custom tag added using the user tracing binding, we do not log for
@@ -1188,7 +1189,7 @@ class SpanBuilder {
   //
   // `operationName` should be a string literal with infinite lifetime, or somehow otherwise be
   // attached to the observer observing this span.
-  explicit SpanBuilder(kj::Maybe<kj::Own<SpanObserver>> observer,
+  explicit SpanBuilder(kj::Rc<SpanObserver> observer,
       kj::ConstString operationName,
       kj::Maybe<kj::Date> startTime = kj::none);
 
@@ -1208,7 +1209,7 @@ class SpanBuilder {
 
   // Useful to skip unnecessary code when not observed.
   bool isObserved() {
-    return observer != kj::none;
+    return observer != nullptr;
   }
 
   // Get the underlying SpanObserver representing the span.
@@ -1217,7 +1218,8 @@ class SpanBuilder {
   // trace IDs in a way that is specific to the trace back-end being used. The caller must downcast
   // the `SpanObserver` to the expected observer type in order to extract the trace ID.
   kj::Maybe<SpanObserver&> getObserver() {
-    return observer;
+    if (observer != nullptr) return *observer;
+    return kj::none;
   }
 
   // Create a new child span.
@@ -1255,7 +1257,7 @@ class SpanBuilder {
   void addLog(kj::Date timestamp, kj::ConstString key, TagValue value);
 
  private:
-  kj::Maybe<kj::Own<SpanObserver>> observer;
+  kj::Rc<SpanObserver> observer;
   // The under-construction span, or null if the span has ended.
   kj::Maybe<Span> span;
 
@@ -1274,12 +1276,12 @@ class SpanObserver: public kj::Refcounted {
   // Allocate a new child span.
   //
   // Note that children can be created long after a span has completed.
-  [[nodiscard]] virtual kj::Own<SpanObserver> newChild() = 0;
+  [[nodiscard]] virtual kj::Rc<SpanObserver> newChild() = 0;
 
   // Allocate a child for a span initiated directly by user JavaScript (via
   // `ctx.tracing.enterSpan`). Allows implementations to apply different policies than for
   // runtime-issued spans (notably, edgeworker bypasses its operation-name allowlist here).
-  [[nodiscard]] virtual kj::Own<SpanObserver> newChildFromUserCode() {
+  [[nodiscard]] virtual kj::Rc<SpanObserver> newChildFromUserCode() {
     return newChild();
   }
 
@@ -1325,7 +1327,7 @@ class NonRecordingSpanObserver final: public SpanObserver {
  public:
   explicit NonRecordingSpanObserver(tracing::SpanContext context): context(kj::mv(context)) {}
 
-  kj::Own<SpanObserver> newChild() override {
+  kj::Rc<SpanObserver> newChild() override {
     return {};
   }
   void onOpen(kj::ConstString, kj::Date) override {}
@@ -1339,39 +1341,35 @@ class NonRecordingSpanObserver final: public SpanObserver {
 };
 
 inline kj::Maybe<tracing::SpanContext> SpanParent::toSpanContext() {
-  KJ_IF_SOME(obs, observer) {
-    return obs->toSpanContext();
-  }
+  if (observer != nullptr) return observer->toSpanContext();
   return kj::none;
 }
 
 inline tracing::SpanId SpanParent::getSpanId() {
-  KJ_IF_SOME(obs, observer) {
-    return obs->getSpanId();
-  }
+  if (observer != nullptr) return observer->getSpanId();
   return tracing::SpanId::nullId;
 }
 
 inline SpanParent SpanParent::fromSpanContext(tracing::SpanContext context) {
-  return SpanParent(kj::refcounted<NonRecordingSpanObserver>(kj::mv(context)));
+  return SpanParent(kj::rc<NonRecordingSpanObserver>(kj::mv(context)));
 }
 
-inline SpanParent::SpanParent(SpanBuilder& builder): observer(mapAddRef(builder.observer)) {}
+inline SpanParent::SpanParent(SpanBuilder& builder): observer(builder.observer.addRef()) {}
 
 inline SpanParent SpanParent::addRef() {
-  return SpanParent(mapAddRef(observer));
+  return SpanParent(observer.addRef());
 }
 
 inline SpanBuilder SpanParent::newChild(
     kj::ConstString operationName, kj::Maybe<kj::Date> startTime) {
-  return SpanBuilder(observer.map([](kj::Own<SpanObserver>& obs) { return obs->newChild(); }),
-      kj::mv(operationName), startTime);
+  if (observer == nullptr) return nullptr;
+  return SpanBuilder(observer->newChild(), kj::mv(operationName), startTime);
 }
 
 inline SpanBuilder SpanBuilder::newChild(
     kj::ConstString operationName, kj::Maybe<kj::Date> startTime) {
-  return SpanBuilder(observer.map([](kj::Own<SpanObserver>& obs) { return obs->newChild(); }),
-      kj::mv(operationName), startTime);
+  if (observer == nullptr) return nullptr;
+  return SpanBuilder(observer->newChild(), kj::mv(operationName), startTime);
 }
 
 class TraceContext;

src/workerd/io/tracer.c++

@@ -586,12 +586,12 @@ void WorkerTracer::setJsRpcInfo(const tracing::InvocationSpanContext& context,
   }
 }
 
-kj::Own<SpanObserver> UserSpanObserver::newChild() {
-  return kj::refcounted<UserSpanObserver>(kj::addRef(*submitter), spanId, traceId, traceFlags);
+kj::Rc<SpanObserver> UserSpanObserver::newChild() {
+  return kj::rc<UserSpanObserver>(kj::addRef(*submitter), spanId, traceId, traceFlags);
 }
 
-kj::Own<SpanObserver> UserSpanObserver::newChildFromUserCode() {
-  return kj::refcounted<UserSpanObserver>(
+kj::Rc<SpanObserver> UserSpanObserver::newChildFromUserCode() {
+  return kj::rc<UserSpanObserver>(
       kj::addRef(*submitter), spanId, traceId, traceFlags, /*fromUserCode=*/true);
 }
 

src/workerd/io/tracer.h

@@ -272,8 +272,8 @@ class UserSpanObserver final: public SpanObserver {
         fromUserCode(fromUserCode) {}
   KJ_DISALLOW_COPY(UserSpanObserver);
 
-  kj::Own<SpanObserver> newChild() override;
-  kj::Own<SpanObserver> newChildFromUserCode() override;
+  kj::Rc<SpanObserver> newChild() override;
+  kj::Rc<SpanObserver> newChildFromUserCode() override;
   void onOpen(kj::ConstString operationName, kj::Date startTime) override;
   void onClose(kj::Date endTime, Span::TagMap&& tags, kj::Vector<Span::Log>&& logs) override;
   kj::Date getTime() override;

src/workerd/server/server.c++

@@ -3914,7 +3914,7 @@ class Server::WorkerService final: public Service,
       w->setMakeUserRequestSpanFunc(
           [&w = *w, &entropySource = threadContext.getEntropySource()](
               tracing::TraceId traceId, kj::Maybe<tracing::TraceFlags> traceFlags) {
-        return SpanParent(kj::refcounted<UserSpanObserver>(
+        return SpanParent(kj::rc<UserSpanObserver>(
             kj::refcounted<SequentialSpanSubmitter>(w.getWeakRef(), entropySource), kj::mv(traceId),
             traceFlags));
       });