Rename lime tracing => user tracing

src/workerd/api/cache.c++

@@ -519,7 +519,7 @@ jsg::Promise<bool> Cache::delete_(
 kj::Own<kj::HttpClient> Cache::getHttpClient(
  IoContext& context, kj::Maybe<kj::String> cfBlobJson, kj::LiteralStringConst operationName) {
  auto span = context.makeTraceSpan(operationName);
- auto limeSpan = context.makeLimeTraceSpan(operationName);
+ auto userSpan = context.makeUserTraceSpan(operationName);
 
  auto cacheClient = context.getCacheClient();
  auto httpClient = cacheName

src/workerd/api/memory-cache.c++

@@ -383,7 +383,7 @@ jsg::Promise<jsg::JsRef<jsg::JsValue>> MemoryCache::read(jsg::Lock& js,
  }
 
  auto readSpan = IoContext::current().makeTraceSpan("memory_cache_read"_kjc);
- auto limeReadSpan = IoContext::current().makeLimeTraceSpan("memory_cache_read"_kjc);
+ auto userReadSpan = IoContext::current().makeUserTraceSpan("memory_cache_read"_kjc);
 
  KJ_IF_SOME(fallback, optionalFallback) {
  KJ_SWITCH_ONEOF(cacheUse.getWithFallback(key.value, readSpan)) {
@@ -395,7 +395,7 @@ jsg::Promise<jsg::JsRef<jsg::JsValue>> MemoryCache::read(jsg::Lock& js,
  KJ_CASE_ONEOF(promise, kj::Promise<SharedMemoryCache::Use::GetWithFallbackOutcome>) {
  return IoContext::current().awaitIo(js, kj::mv(promise),
  [fallback = kj::mv(fallback), key = kj::str(key.value), span = kj::mv(readSpan),
- limeSpan = kj::mv(limeReadSpan)](
+ userSpan = kj::mv(userReadSpan)](
  jsg::Lock& js, SharedMemoryCache::Use::GetWithFallbackOutcome cacheResult) mutable
  -> jsg::Promise<jsg::JsRef<jsg::JsValue>> {
  KJ_SWITCH_ONEOF(cacheResult) {

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

@@ -787,16 +787,16 @@ kj::Own<WorkerInterface> IoContext::getSubrequestNoChecks(
  kj::FunctionParam<kj::Own<WorkerInterface>(TraceContext&, IoChannelFactory&)> func,
  SubrequestOptions options) {
  SpanBuilder span = nullptr;
- SpanBuilder limeSpan = nullptr;
+ SpanBuilder userSpan = nullptr;
 
  KJ_IF_SOME(n, options.operationName) {
  // TODO(cleanup): Using kj::Maybe<kj::LiteralStringConst> for operationName instead would remove
  // a memory allocation here, but there might be use cases for dynamically allocated strings.
  span = makeTraceSpan(kj::ConstString(kj::str(n)));
- limeSpan = makeLimeTraceSpan(kj::ConstString(kj::mv(n)));
+ userSpan = makeUserTraceSpan(kj::ConstString(kj::mv(n)));
  }
 
- TraceContext tracing(kj::mv(span), kj::mv(limeSpan));
+ TraceContext tracing(kj::mv(span), kj::mv(userSpan));
  auto ret = func(tracing, getIoChannelFactory());
 
  if (options.wrapMetrics) {
@@ -809,8 +809,8 @@ kj::Own<WorkerInterface> IoContext::getSubrequestNoChecks(
  if (tracing.span.isObserved()) {
  ret = ret.attach(kj::mv(tracing.span));
  }
- if (tracing.limeSpan.isObserved()) {
- ret = ret.attach(kj::mv(tracing.limeSpan));
+ if (tracing.userSpan.isObserved()) {
+ ret = ret.attach(kj::mv(tracing.userSpan));
  }
 
  return kj::mv(ret);
@@ -925,18 +925,18 @@ SpanParent IoContext::getCurrentTraceSpan() {
  return getMetrics().getSpan();
 }
 
-SpanParent IoContext::getCurrentLimeTraceSpan() {
+SpanParent IoContext::getCurrentUserTraceSpan() {
  // TODO(o11y): Add support for retrieving span from storage scope lock for more accurate span
  // context, as with Jaeger spans.
- return getMetrics().getLimeSpan();
+ return getMetrics().getUserSpan();
 }
 
 SpanBuilder IoContext::makeTraceSpan(kj::ConstString operationName) {
  return getCurrentTraceSpan().newChild(kj::mv(operationName));
 }
 
-SpanBuilder IoContext::makeLimeTraceSpan(kj::ConstString operationName) {
- return getCurrentLimeTraceSpan().newChild(kj::mv(operationName));
+SpanBuilder IoContext::makeUserTraceSpan(kj::ConstString operationName) {
+ return getCurrentUserTraceSpan().newChild(kj::mv(operationName));
 }
 
 void IoContext::taskFailed(kj::Exception&& exception) {

src/workerd/io/io-context.h

@@ -751,13 +751,13 @@ class IoContext final: public kj::Refcounted, private kj::TaskSet::ErrorHandler
  // Returns the current span being recorded. If called while the JS lock is held, uses the trace
  // information from the current async context, if available.
  SpanParent getCurrentTraceSpan();
- SpanParent getCurrentLimeTraceSpan();
+ SpanParent getCurrentUserTraceSpan();
 
  // Returns a builder for recording tracing spans (or a no-op builder if tracing is inactive).
  // If called while the JS lock is held, uses the trace information from the current async
  // context, if available.
  SpanBuilder makeTraceSpan(kj::ConstString operationName);
- SpanBuilder makeLimeTraceSpan(kj::ConstString operationName);
+ SpanBuilder makeUserTraceSpan(kj::ConstString operationName);
 
  // Implement per-IoContext rate limiting for Cache.put(). Pass the body of a Cache API PUT
  // request and get a possibly wrapped stream back.

src/workerd/io/observer.h

@@ -99,7 +99,7 @@ class RequestObserver: public kj::Refcounted {
  virtual SpanParent getSpan() {
  return nullptr;
  }
- virtual SpanParent getLimeSpan() {
+ virtual SpanParent getUserSpan() {
  return nullptr;
  }
 

src/workerd/io/trace.c++

@@ -21,7 +21,7 @@ static constexpr size_t MAX_TRACE_BYTES = 128 * 1024;
 // Limit spans to at most 512, it could be difficult to fit e.g. 1024 spans within MAX_TRACE_BYTES
 // unless most of the included spans do not include tags. If use cases arise where this amount is
 // insufficient, merge smaller spans together or drop smaller spans.
-static constexpr size_t MAX_LIME_SPANS = 512;
+static constexpr size_t MAX_USER_SPANS = 512;
 
 namespace {
 
@@ -637,8 +637,8 @@ void WorkerTracer::log(kj::Date timestamp, LogLevel logLevel, kj::String message
 
 void WorkerTracer::addSpan(const Span& span, kj::String spanContext) {
  // This is where we'll actually encode the span for now.
- // Drop any spans beyond MAX_LIME_SPANS.
- if (trace->numSpans >= MAX_LIME_SPANS) {
+ // Drop any spans beyond MAX_USER_SPANS.
+ if (trace->numSpans >= MAX_USER_SPANS) {
  return;
  }
  if (isPredictableModeForTest()) {

src/workerd/io/trace.h

@@ -394,7 +394,7 @@ class WorkerTracer final: public kj::Refcounted {
 
  // Adds log line to trace. For Spectre, timestamp should only be as accurate as JS Date.now().
  // The isSpan parameter allows for logging spans, which will be emitted after regular logs. There
- // can be at most MAX_LIME_SPANS spans in a trace.
+ // can be at most MAX_USER_SPANS spans in a trace.
  void log(kj::Date timestamp, LogLevel logLevel, kj::String message, bool isSpan = false);
  // Add a span, which will be represented as a log.
  void addSpan(const Span& span, kj::String spanContext);
@@ -670,42 +670,42 @@ inline SpanBuilder SpanBuilder::newChild(kj::ConstString operationName, kj::Date
 }
 
 // TraceContext to keep track of user tracing/existing tracing better
-// TODO(o11y): When creating lime child spans, verify that operationName is within a set of
+// TODO(o11y): When creating user child spans, verify that operationName is within a set of
 // supported operations. This is important to avoid adding spans to the wrong tracing system.
 
-// Interface to track trace context including both Jaeger and Lime spans.
+// Interface to track trace context including both Jaeger and User 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 user spans will not needed in all places where we have the
 // existing spans, so synergies will likely be limited.
 struct TraceContext {
- TraceContext(SpanBuilder span, SpanBuilder limeSpan)
+ TraceContext(SpanBuilder span, SpanBuilder userSpan)
  : span(kj::mv(span)),
- limeSpan(kj::mv(limeSpan)) {}
+ userSpan(kj::mv(userSpan)) {}
  TraceContext(TraceContext&& other) = default;
  TraceContext& operator=(TraceContext&& other) = default;
  KJ_DISALLOW_COPY(TraceContext);
 
  SpanBuilder span;
- SpanBuilder limeSpan;
+ SpanBuilder userSpan;
 };
 
 // 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. In particular, add functions like newLimeChild() here to make it easier
+// without modifying them. In particular, add functions like newUserChild() here to make it easier
 // to add a span for the right parent.
 struct TraceParentContext {
  TraceParentContext(TraceContext& tracing)
  : parentSpan(tracing.span),
- limeParentSpan(tracing.limeSpan) {}
- TraceParentContext(SpanParent span, SpanParent limeSpan)
+ userParentSpan(tracing.userSpan) {}
+ TraceParentContext(SpanParent span, SpanParent userSpan)
  : parentSpan(kj::mv(span)),
- limeParentSpan(kj::mv(limeSpan)) {}
+ userParentSpan(kj::mv(userSpan)) {}
  TraceParentContext(TraceParentContext&& other) = default;
  TraceParentContext& operator=(TraceParentContext&& other) = default;
  KJ_DISALLOW_COPY(TraceParentContext);
 
  SpanParent parentSpan;
- SpanParent limeParentSpan;
+ SpanParent userParentSpan;
 };
 
 // RAII object that measures the time duration over its lifetime. It tags this duration onto a