@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-E3UK5IIB.cjs

@@ -1,593 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/tracing.ts
-
-
-
-
-
-
-
-
-var _api = require('@opentelemetry/api');
-var FARM_TRACER_NAME = "@farm.js/core";
-var ALL_SPAN_KINDS = [
-  "request",
-  "render",
-  "middleware",
-  "api",
-  "integration",
-  "storage",
-  "ppr",
-  "build",
-  "plugin"
-];
-var DEFAULT_IGNORED_PATHS = [
-  "/@vite/",
-  "/@fs/",
-  "/@id/",
-  "/@react-refresh",
-  "/node_modules/",
-  "/__vite",
-  "/.well-known/appspecific/"
-];
-var FARM_REQUEST_METHOD_CONTEXT_KEY = _api.createContextKey.call(void 0, "@farm.js/core/request-method");
-var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
-var runtime = globalThis;
-var tracingState = _nullishCoalesce(runtime[TRACING_RUNTIME], () => ( (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false))));
-function normalizeFarmTracingConfig(config) {
-  if (!config) {
-    return {
-      enabled: false,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  if (config === true) {
-    return {
-      enabled: true,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  return {
-    enabled: _nullishCoalesce(config.enabled, () => ( true)),
-    spans: new Set(_nullishCoalesce(config.spans, () => ( ALL_SPAN_KINDS))),
-    recordEvents: _nullishCoalesce(config.recordEvents, () => ( true)),
-    attributes: { ...config.attributes },
-    ignorePaths: [...DEFAULT_IGNORED_PATHS, ..._nullishCoalesce(config.ignorePaths, () => ( []))]
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmTracingConfig, "normalizeFarmTracingConfig");
-function configureFarmTracing(config) {
-  if (isResolvedFarmTracingConfig(config)) {
-    Object.assign(tracingState, {
-      ...config,
-      spans: new Set(config.spans),
-      attributes: { ...config.attributes },
-      ignorePaths: [...config.ignorePaths]
-    });
-    return;
-  }
-  Object.assign(
-    tracingState,
-    normalizeFarmTracingConfig(config)
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, configureFarmTracing, "configureFarmTracing");
-function isResolvedFarmTracingConfig(config) {
-  return !!config && typeof config === "object" && typeof config.enabled === "boolean" && config.spans instanceof Set && typeof config.recordEvents === "boolean" && Array.isArray(config.ignorePaths);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isResolvedFarmTracingConfig, "isResolvedFarmTracingConfig");
-function resetFarmTracing() {
-  Object.assign(tracingState, normalizeFarmTracingConfig(false));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resetFarmTracing, "resetFarmTracing");
-function getFarmTraceContext() {
-  return getSpanTraceContext(_api.trace.getSpan(_api.context.active()));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmTraceContext, "getFarmTraceContext");
-async function runWithFarmSpan(name, handler, options = {}) {
-  const spanFamily = options.kind;
-  if (!tracingState.enabled || spanFamily !== void 0 && !tracingState.spans.has(spanFamily)) {
-    return await handler();
-  }
-  const tracer = _api.trace.getTracer(FARM_TRACER_NAME);
-  return await tracer.startActiveSpan(
-    name,
-    {
-      kind: _nullishCoalesce(options.spanKind, () => ( _api.SpanKind.INTERNAL)),
-      attributes: {
-        ...tracingState.attributes,
-        ...options.attributes
-      }
-    },
-    async (span) => {
-      try {
-        return await handler();
-      } catch (error) {
-        recordSpanError(span, error);
-        throw error;
-      } finally {
-        span.end();
-      }
-    }
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, runWithFarmSpan, "runWithFarmSpan");
-async function _runWithFarmRequestSpan(request, handler, options = {}) {
-  const startedAt = Date.now();
-  const url = tracingState.enabled && tracingState.spans.has("request") ? new URL(request.url) : void 0;
-  const shouldTrace = url && !tracingState.ignorePaths.some((prefix) => url.pathname.startsWith(prefix));
-  if (!shouldTrace) {
-    _optionalChain([options, 'access', _ => _.onStart, 'optionalCall', _2 => _2()]);
-    try {
-      const result = await handler();
-      _optionalChain([options, 'access', _3 => _3.onComplete, 'optionalCall', _4 => _4(resolveResultStatus(result, options), Date.now() - startedAt)]);
-      return result;
-    } catch (error) {
-      _optionalChain([options, 'access', _5 => _5.onError, 'optionalCall', _6 => _6(error, Date.now() - startedAt)]);
-      throw error;
-    }
-  }
-  const extractedContext = _api.propagation.extract(_api.context.active(), request.headers, {
-    keys(carrier) {
-      return Array.from(carrier.keys());
-    },
-    get(carrier, key) {
-      return _nullishCoalesce(carrier.get(key), () => ( void 0));
-    }
-  });
-  const requestContext = extractedContext.setValue(FARM_REQUEST_METHOD_CONTEXT_KEY, request.method);
-  const tracer = _api.trace.getTracer(FARM_TRACER_NAME);
-  const attributes = {
-    ...tracingState.attributes,
-    "http.request.method": request.method,
-    "url.path": url.pathname,
-    "url.scheme": url.protocol.replace(/:$/, ""),
-    "server.address": url.hostname
-  };
-  if (url.port) attributes["server.port"] = Number(url.port);
-  return await tracer.startActiveSpan(
-    `${request.method} ${url.pathname}`,
-    { kind: _api.SpanKind.SERVER, attributes },
-    requestContext,
-    async (span) => {
-      _optionalChain([options, 'access', _7 => _7.onStart, 'optionalCall', _8 => _8()]);
-      try {
-        const result = await handler();
-        const status = resolveResultStatus(result, options);
-        setResponseStatus(span, status);
-        _optionalChain([options, 'access', _9 => _9.onComplete, 'optionalCall', _10 => _10(status, Date.now() - startedAt)]);
-        return result;
-      } catch (error) {
-        recordSpanError(span, error);
-        _optionalChain([options, 'access', _11 => _11.onError, 'optionalCall', _12 => _12(error, Date.now() - startedAt)]);
-        throw error;
-      } finally {
-        span.end();
-      }
-    }
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithFarmRequestSpan, "_runWithFarmRequestSpan");
-function recordFarmEventTrace(event) {
-  if (!tracingState.enabled) return void 0;
-  const activeContext = _api.context.active();
-  const activeSpan = _api.trace.getSpan(activeContext);
-  const traceContext = getSpanTraceContext(activeSpan);
-  if (activeSpan && traceContext) {
-    if (event.type === "route.matched") {
-      const method = _nullishCoalesce(activeContext.getValue(FARM_REQUEST_METHOD_CONTEXT_KEY), () => ( "HTTP"));
-      activeSpan.updateName(`${method} ${event.route}`);
-      activeSpan.setAttribute("http.route", event.route);
-      activeSpan.setAttribute("farm.route", event.route);
-    }
-    if (tracingState.recordEvents) {
-      activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
-    }
-    const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) {
-      if (event.type === "render.error") {
-        recordSpanException(activeSpan, error);
-      } else {
-        recordSpanError(activeSpan, error);
-      }
-    }
-  }
-  const completedTraceContext = recordCompletedEventSpan(event, activeContext);
-  return _nullishCoalesce(traceContext, () => ( completedTraceContext));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, recordFarmEventTrace, "recordFarmEventTrace");
-function recordCompletedEventSpan(event, parentContext) {
-  const descriptor = getCompletedSpanDescriptor(event);
-  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
-  const tracer = _api.trace.getTracer(FARM_TRACER_NAME);
-  const span = tracer.startSpan(
-    descriptor.name,
-    {
-      kind: _api.SpanKind.INTERNAL,
-      startTime: event.timestamp - descriptor.durationMs,
-      attributes: {
-        ...tracingState.attributes,
-        ...toEventAttributes(event),
-        "farm.event.type": event.type
-      }
-    },
-    parentContext
-  );
-  const status = "status" in event && typeof event.status === "number" ? event.status : void 0;
-  if (status !== void 0) setResponseStatus(span, status);
-  const error = getEventError(event);
-  if (error !== void 0) recordSpanError(span, error);
-  const traceContext = getSpanTraceContext(span);
-  span.end(event.timestamp);
-  return traceContext;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, recordCompletedEventSpan, "recordCompletedEventSpan");
-function getCompletedSpanDescriptor(event) {
-  if (!("durationMs" in event) || typeof event.durationMs !== "number") return void 0;
-  switch (event.type) {
-    case "render.complete":
-      return { kind: "render", name: `farm.render ${event.route}`, durationMs: event.durationMs };
-    case "render.stream.shellReady":
-      return {
-        kind: "render",
-        name: `farm.render.shell ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "render.stream.complete":
-      return {
-        kind: "render",
-        name: `farm.render.stream ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "middleware.complete":
-      return {
-        kind: "middleware",
-        name: `farm.middleware ${_nullishCoalesce(_nullishCoalesce(event.name, () => ( event.route)), () => ( "anonymous"))}`,
-        durationMs: event.durationMs
-      };
-    case "api.request.complete":
-    case "api.error":
-      return {
-        kind: "api",
-        name: `farm.api ${event.method} ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "integration.api.call.complete":
-      return {
-        kind: "integration",
-        name: `farm.integration ${event.integration}.${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "storage.query.complete":
-      return {
-        kind: "storage",
-        name: `farm.storage ${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "ppr.refresh.complete":
-      return {
-        kind: "ppr",
-        name: `farm.ppr.refresh ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "build.complete":
-      return {
-        kind: "build",
-        name: `farm.build${event.target ? ` ${event.target}` : ""}`,
-        durationMs: event.durationMs
-      };
-    case "plugin.hook.complete":
-      return {
-        kind: "plugin",
-        name: `farm.plugin ${event.plugin}.${event.hook}`,
-        durationMs: event.durationMs
-      };
-    default:
-      return void 0;
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
-function hashFarmCacheKey(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index++) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, hashFarmCacheKey, "hashFarmCacheKey");
-function toEventAttributes(event) {
-  const attributes = {};
-  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
-  for (const [key, value] of Object.entries(event)) {
-    if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
-      continue;
-    }
-    if (redactKey && key === "key" && typeof value === "string") {
-      attributes["farm.key_hash"] = hashFarmCacheKey(value);
-      continue;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      attributes[`farm.${key}`] = value;
-    } else if (Array.isArray(value)) {
-      if (value.every((entry) => typeof entry === "string")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "number")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "boolean")) {
-        attributes[`farm.${key}`] = value;
-      }
-    }
-  }
-  return attributes;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, toEventAttributes, "toEventAttributes");
-function getEventError(event) {
-  return "error" in event ? event.error : void 0;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getEventError, "getEventError");
-function recordSpanException(span, error) {
-  const normalized = error instanceof Error ? error : new Error(String(error));
-  span.recordException(normalized);
-  return normalized;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, recordSpanException, "recordSpanException");
-function recordSpanError(span, error) {
-  const normalized = recordSpanException(span, error);
-  span.setStatus({ code: _api.SpanStatusCode.ERROR, message: normalized.message });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, recordSpanError, "recordSpanError");
-function setResponseStatus(span, status) {
-  span.setAttribute("http.response.status_code", status);
-  if (status >= 500) {
-    span.setStatus({ code: _api.SpanStatusCode.ERROR });
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, setResponseStatus, "setResponseStatus");
-function resolveResultStatus(result, options) {
-  if (result instanceof Response) return result.status;
-  return _nullishCoalesce(_optionalChain([options, 'access', _13 => _13.getStatusCode, 'optionalCall', _14 => _14()]), () => ( 200));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resolveResultStatus, "resolveResultStatus");
-function getSpanTraceContext(span) {
-  if (!span) return void 0;
-  const spanContext = span.spanContext();
-  if (!_api.isSpanContextValid.call(void 0, spanContext)) return void 0;
-  return {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    traceSampled: (spanContext.traceFlags & 1) === 1
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getSpanTraceContext, "getSpanTraceContext");
-
-// src/observability.ts
-var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
-var runtime2 = globalThis;
-var shared = _nullishCoalesce(runtime2[OBSERVABILITY_RUNTIME], () => ( (runtime2[OBSERVABILITY_RUNTIME] = {
-  handlers: /* @__PURE__ */ new Set(),
-  unfilteredHandlers: /* @__PURE__ */ new Set(),
-  config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
-})));
-var runtimeHandlers = shared.handlers;
-var unfilteredRuntimeHandlers = shared.unfilteredHandlers;
-var observabilityState = shared.config;
-function configureFarmObservability(config) {
-  Object.assign(
-    observabilityState,
-    { events: void 0 },
-    normalizeFarmObservabilityConfig(config)
-  );
-  configureFarmTracing(observabilityState.tracing);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, configureFarmObservability, "configureFarmObservability");
-function normalizeFarmObservabilityConfig(config) {
-  if (config === void 0 || config === false) {
-    return { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) };
-  }
-  if (config === true) {
-    return { logs: true, handlers: [], tracing: normalizeFarmTracingConfig(false) };
-  }
-  const handlers = config.onEvent ? Array.isArray(config.onEvent) ? [...config.onEvent] : [config.onEvent] : [];
-  return {
-    logs: _nullishCoalesce(config.logs, () => ( false)),
-    handlers,
-    events: config.events ? new Set(config.events) : void 0,
-    tracing: normalizeFarmTracingConfig(config.tracing)
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmObservabilityConfig, "normalizeFarmObservabilityConfig");
-function onFarmEvent(handler, options = {}) {
-  const handlers = options.unfiltered ? unfilteredRuntimeHandlers : runtimeHandlers;
-  handlers.add(handler);
-  return () => {
-    handlers.delete(handler);
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, onFarmEvent, "onFarmEvent");
-function resetFarmObservability() {
-  runtimeHandlers.clear();
-  unfilteredRuntimeHandlers.clear();
-  Object.assign(observabilityState, {
-    logs: false,
-    handlers: [],
-    events: void 0,
-    tracing: normalizeFarmTracingConfig(false)
-  });
-  resetFarmTracing();
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resetFarmObservability, "resetFarmObservability");
-function emitFarmEvent(input) {
-  const event = {
-    timestamp: Date.now(),
-    level: inferFarmEventLevel(input.type),
-    ...input
-  };
-  const traceContext = recordFarmEventTrace(event);
-  if (traceContext) {
-    event.traceId = traceContext.traceId;
-    event.spanId = traceContext.spanId;
-    event.traceSampled = traceContext.traceSampled;
-  }
-  notifyFarmEventHandlers(event, unfilteredRuntimeHandlers);
-  if (!shouldEmitFarmEvent(event)) return event;
-  if (observabilityState.logs) {
-    logFarmEvent(event);
-  }
-  notifyFarmEventHandlers(event, [...observabilityState.handlers, ...runtimeHandlers]);
-  return event;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, emitFarmEvent, "emitFarmEvent");
-function notifyFarmEventHandlers(event, handlers) {
-  for (const handler of handlers) {
-    try {
-      Promise.resolve(handler(event)).catch((error) => {
-        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-      });
-    } catch (error) {
-      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-    }
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, notifyFarmEventHandlers, "notifyFarmEventHandlers");
-async function runWithFarmRequestSpan(request, handler, options = {}) {
-  const url = new URL(request.url);
-  const method = request.method || "GET";
-  return await _runWithFarmRequestSpan(request, handler, {
-    ...options,
-    onStart() {
-      emitFarmEvent({ type: "request.start", method, pathname: url.pathname });
-      _optionalChain([options, 'access', _15 => _15.onStart, 'optionalCall', _16 => _16()]);
-    },
-    onComplete(status, durationMs) {
-      emitFarmEvent({
-        type: "request.complete",
-        method,
-        pathname: url.pathname,
-        status,
-        durationMs
-      });
-      _optionalChain([options, 'access', _17 => _17.onComplete, 'optionalCall', _18 => _18(status, durationMs)]);
-    },
-    onError(error, durationMs) {
-      emitFarmEvent({
-        type: "request.error",
-        method,
-        pathname: url.pathname,
-        durationMs,
-        error
-      });
-      _optionalChain([options, 'access', _19 => _19.onError, 'optionalCall', _20 => _20(error, durationMs)]);
-    }
-  });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, runWithFarmRequestSpan, "runWithFarmRequestSpan");
-function shouldEmitFarmEvent(event) {
-  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
-    return false;
-  }
-  if (observabilityState.events && !observabilityState.events.has(event.type)) {
-    return false;
-  }
-  return true;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, shouldEmitFarmEvent, "shouldEmitFarmEvent");
-function inferFarmEventLevel(type) {
-  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
-    return "error";
-  }
-  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
-    return "warn";
-  }
-  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
-    return "debug";
-  }
-  return "info";
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, inferFarmEventLevel, "inferFarmEventLevel");
-function logFarmEvent(event) {
-  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
-  switch (event.level) {
-    case "error":
-      console.error(message);
-      break;
-    case "warn":
-      console.warn(message);
-      break;
-    default:
-      console.log(message);
-      break;
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, logFarmEvent, "logFarmEvent");
-function formatFarmEventDetails(event) {
-  const details = [];
-  const record = event;
-  for (const key of [
-    "route",
-    "pathname",
-    "method",
-    "status",
-    "key",
-    "tag",
-    "path",
-    "reason",
-    "durationMs",
-    "integration",
-    "server",
-    "tool",
-    "outcome",
-    "operation",
-    "plugin",
-    "hook",
-    "target",
-    "count"
-  ]) {
-    const value = record[key];
-    if (value !== void 0) {
-      details.push(`${key}=${formatDetailValue(value)}`);
-    }
-  }
-  return details.length > 0 ? ` ${details.join(" ")}` : "";
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, formatFarmEventDetails, "formatFarmEventDetails");
-function formatDetailValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value);
-  } catch (e) {
-    return String(value);
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, formatDetailValue, "formatDetailValue");
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, formatError, "formatError");
-
-
-
-
-
-
-
-
-
-
-
-
-exports.normalizeFarmTracingConfig = normalizeFarmTracingConfig; exports.configureFarmTracing = configureFarmTracing; exports.getFarmTraceContext = getFarmTraceContext; exports.runWithFarmSpan = runWithFarmSpan; exports.configureFarmObservability = configureFarmObservability; exports.normalizeFarmObservabilityConfig = normalizeFarmObservabilityConfig; exports.onFarmEvent = onFarmEvent; exports.resetFarmObservability = resetFarmObservability; exports.emitFarmEvent = emitFarmEvent; exports.runWithFarmRequestSpan = runWithFarmRequestSpan;