[o11y] Do not throw error if WorkerTracer is unused for alarm event

Author: fhanau

src/workerd/io/tracer.c++

@@ -130,6 +130,10 @@ WorkerTracer::~WorkerTracer() noexcept(false) {
     return;
   }
 
+  if (destroyed) {
+    return;
+  }
+
   // Report the outcome event if STWs are present. All worker events need to call setEventInfo at
   // the start of the invocation to submit the onset event before any other tail events.
   KJ_IF_SOME(writer, maybeTailStreamWriter) {
@@ -157,6 +161,11 @@ WorkerTracer::~WorkerTracer() noexcept(false) {
   }
 };
 
+void WorkerTracer::setDestroyed() {
+  maybeTailStreamWriter = kj::none;
+  destroyed = true;
+}
+
 constexpr kj::LiteralStringConst logSizeExceeded =
     "[\"Log size limit exceeded: More than 256KB of data (across console.log statements, exception, request metadata and headers) was logged during a single request. Subsequent data for this request will not be recorded in logs, appear when tailing this Worker's logs, or in Tail Workers.\"]"_kjc;
 

src/workerd/io/tracer.h

@@ -137,6 +137,8 @@ class BaseTracer: public kj::Refcounted {
 
   SpanParent makeUserRequestSpan();
 
+  virtual void setDestroyed() = 0;
+
   using MakeUserRequestSpanFunc = kj::Function<SpanParent()>;
 
   // Allow setting the user request span after the tracer has been created so its observer can
@@ -179,6 +181,13 @@ class WorkerTracer final: public BaseTracer {
   virtual ~WorkerTracer() noexcept(false);
   KJ_DISALLOW_COPY_AND_MOVE(WorkerTracer);
 
+  // Used to indicate that no events are expected for this tracer, we can deallocate its tail stream
+  // writer early (if present) and won't log a warning about deallocating a WorkerTracer that didn't
+  // receive any events. Intended for (hopefully rare) cases where we end up not using a
+  // WorkerInterface but can only determine this after the WorkerInterface and associated
+  // WorkerTracer have already been allocated.
+  void setDestroyed() override;
+
   void addLog(const tracing::InvocationSpanContext& context,
       kj::Date timestamp,
       LogLevel logLevel,
@@ -233,5 +242,8 @@ class WorkerTracer final: public BaseTracer {
   kj::Maybe<kj::Rc<PipelineTracer>> parentPipeline;
 
   kj::Maybe<kj::Own<tracing::TailStreamWriter>> maybeTailStreamWriter;
+
+  // Indicates that we are not expecting any events for this tail stream writer, that
+  bool destroyed;
 };
 }  // namespace workerd

src/workerd/io/worker-entrypoint.c++

@@ -631,6 +631,13 @@ kj::Promise<WorkerInterface::AlarmResult> WorkerEntrypoint::runAlarmImpl(
   auto& actor = KJ_REQUIRE_NONNULL(context.getActor(), "alarm() should only work with actors");
 
   KJ_IF_SOME(promise, actor.getAlarm(scheduledTime)) {
+    // Mark the WorkerTracer as destroyed so that we don't log a warning about it being allocated
+    // without being used. Ideally we'd avoid this by detecting that an alarm is already scheduled
+    // before allocating the WorkerInterface/WorkerTracer.
+    KJ_IF_SOME(t, incomingRequest->getWorkerTracer()) {
+      t.setDestroyed();
+    }
+
     // There is a pre-existing alarm for `scheduledTime`, we can just wait for its result.
     // TODO(someday) If the request responsible for fulfilling this alarm were to be cancelled, then
     // we could probably take over and try to fulfill it ourselves. Maybe we'd want to loop on