@glasstrace/sdk 1.8.0 → 1.9.1

package/dist/cli/validate.js

@@ -2,8 +2,8 @@ import {
   identityFingerprint,
   readMcpMarker,
   resolveEffectiveMcpCredential
-} from "../chunk-WL6BXEJ5.js";
-import "../chunk-P45NZR4J.js";
+} from "../chunk-DKV53A2C.js";
+import "../chunk-JHUNLPSS.js";
 import "../chunk-NSBPE2FW.js";
 
 // src/cli/validate.ts

package/dist/{edge-entry-AWO70gje.d.ts → correlation-id-B_K8adD6.d.ts}

@@ -1,4 +1,4 @@
-import { i as SdkDiagnosticCode, j as SessionId, C as CaptureConfig } from './index.d-Dq33YwFT.js';
+import { f as SdkDiagnosticCode, g as SessionId, C as CaptureConfig } from './index.d-CkTf_boH.js';
 import { ReadableSpan } from './export/ReadableSpan';
 import { Span } from './Span';
 import { SpanProcessor } from './SpanProcessor';

package/dist/{edge-entry-DaeG7D7S.d.cts → correlation-id-NAapJ5jn.d.cts}

@@ -1,4 +1,4 @@
-import { i as SdkDiagnosticCode, j as SessionId, C as CaptureConfig } from './index.d-Dq33YwFT.cjs';
+import { f as SdkDiagnosticCode, g as SessionId, C as CaptureConfig } from './index.d-CkTf_boH.cjs';
 import { ReadableSpan } from './export/ReadableSpan';
 import { Span } from './Span';
 import { SpanProcessor } from './SpanProcessor';

package/dist/edge-entry.cjs

@@ -22,7 +22,9 @@ var edge_entry_exports = {};
 __export(edge_entry_exports, {
   GlasstraceSpanProcessor: () => GlasstraceSpanProcessor,
   SdkError: () => SdkError,
-  captureCorrelationId: () => captureCorrelationId
+  captureCorrelationId: () => captureCorrelationId,
+  tracedRequestMiddleware: () => tracedRequestMiddleware,
+  withAsyncCausality: () => withAsyncCausality
 });
 module.exports = __toCommonJS(edge_entry_exports);
 
@@ -305,14 +307,14 @@ var BaseContext = class _BaseContext {
     self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
     self2.getValue = (key) => self2._currentContext.get(key);
     self2.setValue = (key, value) => {
-      const context = new _BaseContext(self2._currentContext);
-      context._currentContext.set(key, value);
-      return context;
+      const context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.set(key, value);
+      return context2;
     };
     self2.deleteValue = (key) => {
-      const context = new _BaseContext(self2._currentContext);
-      context._currentContext.delete(key);
-      return context;
+      const context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.delete(key);
+      return context2;
     };
   }
 };
@@ -373,8 +375,8 @@ var ContextAPI = class _ContextAPI {
    * @param thisArg optional receiver to be used for calling fn
    * @param args optional arguments forwarded to fn
    */
-  with(context, fn, thisArg, ...args) {
-    return this._getContextManager().with(context, fn, thisArg, ...args);
+  with(context2, fn, thisArg, ...args) {
+    return this._getContextManager().with(context2, fn, thisArg, ...args);
   }
   /**
    * Bind a context to a target function or event emitter
@@ -382,8 +384,8 @@ var ContextAPI = class _ContextAPI {
    * @param context context to bind to the event emitter or function. Defaults to the currently active context
    * @param target function or event emitter to bind
    */
-  bind(context, target) {
-    return this._getContextManager().bind(context, target);
+  bind(context2, target) {
+    return this._getContextManager().bind(context2, target);
   }
   _getContextManager() {
     return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
@@ -460,24 +462,24 @@ var NonRecordingSpan = class {
 
 // ../../node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
 var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
-function getSpan(context) {
-  return context.getValue(SPAN_KEY) || void 0;
+function getSpan(context2) {
+  return context2.getValue(SPAN_KEY) || void 0;
 }
 function getActiveSpan() {
   return getSpan(ContextAPI.getInstance().active());
 }
-function setSpan(context, span) {
-  return context.setValue(SPAN_KEY, span);
+function setSpan(context2, span) {
+  return context2.setValue(SPAN_KEY, span);
 }
-function deleteSpan(context) {
-  return context.deleteValue(SPAN_KEY);
+function deleteSpan(context2) {
+  return context2.deleteValue(SPAN_KEY);
 }
-function setSpanContext(context, spanContext) {
-  return setSpan(context, new NonRecordingSpan(spanContext));
+function setSpanContext(context2, spanContext) {
+  return setSpan(context2, new NonRecordingSpan(spanContext));
 }
-function getSpanContext(context) {
+function getSpanContext(context2) {
   var _a2;
-  return (_a2 = getSpan(context)) === null || _a2 === void 0 ? void 0 : _a2.spanContext();
+  return (_a2 = getSpan(context2)) === null || _a2 === void 0 ? void 0 : _a2.spanContext();
 }
 
 // ../../node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
@@ -612,12 +614,12 @@ function wrapSpanContext(spanContext) {
 var contextApi = ContextAPI.getInstance();
 var NoopTracer = class {
   // startSpan starts a noop span.
-  startSpan(name, options, context = contextApi.active()) {
+  startSpan(name, options, context2 = contextApi.active()) {
     const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
     if (root) {
       return new NonRecordingSpan();
     }
-    const parentFromContext = context && getSpanContext(context);
+    const parentFromContext = context2 && getSpanContext(context2);
     if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
       return new NonRecordingSpan(parentFromContext);
     } else {
@@ -659,8 +661,8 @@ var ProxyTracer = class {
     this.version = version2;
     this.options = options;
   }
-  startSpan(name, options, context) {
-    return this._getTracer().startSpan(name, options, context);
+  startSpan(name, options, context2) {
+    return this._getTracer().startSpan(name, options, context2);
   }
   startActiveSpan(_name, _options, _context, _fn) {
     const tracer = this._getTracer();
@@ -716,6 +718,17 @@ var ProxyTracerProvider = class {
   }
 };
 
+// ../../node_modules/@opentelemetry/api/build/esm/trace/status.js
+var SpanStatusCode;
+(function(SpanStatusCode2) {
+  SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+  SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+  SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
+
+// ../../node_modules/@opentelemetry/api/build/esm/context-api.js
+var context = ContextAPI.getInstance();
+
 // ../../node_modules/@opentelemetry/api/build/esm/api/trace.js
 var API_NAME3 = "trace";
 var TraceAPI = class _TraceAPI {
@@ -14653,6 +14666,40 @@ var GLASSTRACE_ATTRIBUTE_NAMES = {
   ELEMENT_FINGERPRINT: "glasstrace.element.fingerprint",
   ELEMENT_CONFIDENCE: "glasstrace.element.confidence",
   TAB_ID: "glasstrace.tab.id",
+  // Causal evidence (SDK-046 / DISC-1537 + DISC-1539).
+  //
+  // The SDK emits `glasstrace.causal.*` attributes on spans that
+  // carry instrumentation-time evidence about a span's relationship
+  // to its owning request trace. Two families are defined here:
+  //
+  //   - `MIDDLEWARE_FOR_REQUEST` — middleware-ownership marker. Set
+  //     on a middleware-only span by `tracedRequestMiddleware()` from
+  //     `@glasstrace/sdk/middleware`. Carries the originating
+  //     request's normalized path so the product-side trace-summary
+  //     transform can link the middleware span to the owning HTTP
+  //     request trace even when the middleware runs in an edge
+  //     runtime that does not propagate AsyncLocalStorage parents.
+  //
+  //   - `POST_RESPONSE_ASYNC` — post-response async marker. Set on a
+  //     span emitted from inside `withAsyncCausality()` from
+  //     `@glasstrace/sdk/async-context`. Carries the originating
+  //     request's trace ID (32-character hex) captured at the call
+  //     site so async work scheduled via Next.js `after()`, queues,
+  //     or webhooks can be linked back to its originating request.
+  //     Companion booleans `CAUSAL_AFFECTS_HTTP_STATUS` /
+  //     `CAUSAL_AFFECTS_HTTP_DURATION` document whether the async
+  //     work participates in the root request's outcome (default
+  //     `false` — non-outcome async work).
+  //
+  // Wire keys live under the `glasstrace.causal.*` namespace so they
+  // are namespace-distinct from `glasstrace.error.*`,
+  // `glasstrace.http.*`, `glasstrace.trpc.*`, and the side-effect
+  // family below. Adding these constants is a `@glasstrace/protocol`
+  // minor bump; existing entries are untouched.
+  CAUSAL_MIDDLEWARE_FOR_REQUEST: "glasstrace.causal.middleware_for_request",
+  CAUSAL_POST_RESPONSE_ASYNC: "glasstrace.causal.post_response_async",
+  CAUSAL_AFFECTS_HTTP_STATUS: "glasstrace.causal.affects_http_status",
+  CAUSAL_AFFECTS_HTTP_DURATION: "glasstrace.causal.affects_http_duration",
   // Side-effect evidence (SDK-049 / SCHEMA-036).
   // Top-level operation attributes attached to the active span when a
   // side-effect is recorded via `recordSideEffect()`. The wire-string
@@ -14932,10 +14979,246 @@ function firstToken(value) {
   }
   return void 0;
 }
+
+// src/optional-lifecycle.ts
+var EMIT_BRIDGE = /* @__PURE__ */ Symbol.for("glasstrace.lifecycle.emit-bridge");
+function tryEmitLifecycleEvent(event, payload) {
+  try {
+    const slot = globalThis[EMIT_BRIDGE];
+    if (!slot) return;
+    slot.emit(event, payload);
+  } catch {
+  }
+}
+
+// src/middleware/index.ts
+var ATTR2 = GLASSTRACE_ATTRIBUTE_NAMES;
+var TRACER_NAME = "@glasstrace/sdk/middleware";
+var _skippedUninstalledEmitted = false;
+function extractRequestPath(req) {
+  if (req === null || typeof req !== "object") return void 0;
+  try {
+    const nextUrl = req.nextUrl;
+    if (nextUrl !== null && typeof nextUrl === "object") {
+      const pathname = nextUrl.pathname;
+      if (typeof pathname === "string" && pathname.length > 0) {
+        return pathname;
+      }
+    }
+    const url2 = req.url;
+    if (typeof url2 === "string" && url2.length > 0) {
+      try {
+        return new URL(url2).pathname;
+      } catch {
+        try {
+          return new URL(url2, "http://localhost").pathname;
+        } catch {
+          return void 0;
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+function isNoopSpan(span) {
+  try {
+    return span.spanContext().traceId === INVALID_TRACE_ID;
+  } catch {
+    return false;
+  }
+}
+function tracedRequestMiddleware(options, handler) {
+  if (typeof options.name !== "string" || options.name.length === 0) {
+    throw new TypeError(
+      "tracedRequestMiddleware: options.name must be a non-empty string"
+    );
+  }
+  const wrapped = ((req, ...rest) => {
+    const tracer = trace.getTracer(TRACER_NAME);
+    let callbackInvoked = false;
+    try {
+      return tracer.startActiveSpan(options.name, (span) => {
+        callbackInvoked = true;
+        if (isNoopSpan(span)) {
+          if (!_skippedUninstalledEmitted) {
+            _skippedUninstalledEmitted = true;
+            tryEmitLifecycleEvent("middleware:skipped_uninstalled", {});
+          }
+          endSpanSafely(span);
+          return handler(req, ...rest);
+        }
+        try {
+          if (options.attributes) {
+            span.setAttributes(options.attributes);
+          }
+          const path = extractRequestPath(req);
+          if (path !== void 0) {
+            span.setAttribute(ATTR2.CAUSAL_MIDDLEWARE_FOR_REQUEST, path);
+          }
+        } catch {
+        }
+        let result;
+        try {
+          result = handler(req, ...rest);
+        } catch (error48) {
+          recordSpanError(span, error48);
+          endSpanSafely(span);
+          throw error48;
+        }
+        if (result !== null && typeof result === "object" && typeof result.then === "function") {
+          return result.then(
+            (value) => {
+              endSpanSafely(span);
+              return value;
+            },
+            (error48) => {
+              recordSpanError(span, error48);
+              endSpanSafely(span);
+              throw error48;
+            }
+          );
+        }
+        endSpanSafely(span);
+        return result;
+      });
+    } catch (err) {
+      if (callbackInvoked) {
+        throw err;
+      }
+      return handler(req, ...rest);
+    }
+  });
+  return wrapped;
+}
+function recordSpanError(span, error48) {
+  const normalized = error48 instanceof Error ? error48 : typeof error48 === "string" ? error48 : new Error(String(error48));
+  const statusMessage = normalized instanceof Error ? normalized.message : normalized;
+  try {
+    span.recordException(normalized);
+  } catch {
+  }
+  try {
+    span.setStatus({ code: SpanStatusCode.ERROR, message: statusMessage });
+  } catch {
+  }
+}
+function endSpanSafely(span) {
+  try {
+    span.end();
+  } catch {
+  }
+}
+
+// src/async-context/index.ts
+var ATTR3 = GLASSTRACE_ATTRIBUTE_NAMES;
+var TRACER_NAME2 = "@glasstrace/sdk/async-context";
+var INVALID_TRACE_ID2 = "00000000000000000000000000000000";
+var _skippedUninstalledEmitted2 = false;
+var _noOriginatingContextEmitted = false;
+function withAsyncCausality(options, fn) {
+  if (typeof options.name !== "string" || options.name.length === 0) {
+    throw new TypeError(
+      "withAsyncCausality: options.name must be a non-empty string"
+    );
+  }
+  if (typeof fn !== "function") {
+    throw new TypeError("withAsyncCausality: fn must be a function");
+  }
+  const capturedContext = (() => {
+    try {
+      const active = trace.getActiveSpan();
+      if (!active) return void 0;
+      const ctx = active.spanContext();
+      if (ctx.traceId === INVALID_TRACE_ID2) return void 0;
+      return ctx;
+    } catch {
+      return void 0;
+    }
+  })();
+  return async () => {
+    const tracer = trace.getTracer(TRACER_NAME2);
+    let span;
+    try {
+      span = tracer.startSpan(options.name, {
+        root: true,
+        links: capturedContext !== void 0 ? [{ context: capturedContext }] : void 0
+      });
+    } catch {
+      return Promise.resolve(fn());
+    }
+    if (isNoopSpan2(span)) {
+      if (!_skippedUninstalledEmitted2) {
+        _skippedUninstalledEmitted2 = true;
+        tryEmitLifecycleEvent("async:skipped_uninstalled", {});
+      }
+      endSpanSafely2(span);
+      return Promise.resolve(fn());
+    }
+    if (capturedContext === void 0 && !_noOriginatingContextEmitted) {
+      _noOriginatingContextEmitted = true;
+      tryEmitLifecycleEvent("async:no_originating_context", {});
+    }
+    try {
+      if (options.attributes) {
+        span.setAttributes(options.attributes);
+      }
+      if (capturedContext !== void 0) {
+        span.setAttribute(
+          ATTR3.CAUSAL_POST_RESPONSE_ASYNC,
+          capturedContext.traceId
+        );
+        span.setAttribute(ATTR3.CAUSAL_AFFECTS_HTTP_STATUS, false);
+        span.setAttribute(ATTR3.CAUSAL_AFFECTS_HTTP_DURATION, false);
+      }
+    } catch {
+    }
+    try {
+      const value = await context.with(
+        trace.setSpan(context.active(), span),
+        fn
+      );
+      return value;
+    } catch (error48) {
+      recordSpanError2(span, error48);
+      throw error48;
+    } finally {
+      endSpanSafely2(span);
+    }
+  };
+}
+function isNoopSpan2(span) {
+  try {
+    return span.spanContext().traceId === INVALID_TRACE_ID2;
+  } catch {
+    return false;
+  }
+}
+function recordSpanError2(span, error48) {
+  const normalized = error48 instanceof Error ? error48 : typeof error48 === "string" ? error48 : new Error(String(error48));
+  const statusMessage = normalized instanceof Error ? normalized.message : normalized;
+  try {
+    span.recordException(normalized);
+  } catch {
+  }
+  try {
+    span.setStatus({ code: SpanStatusCode.ERROR, message: statusMessage });
+  } catch {
+  }
+}
+function endSpanSafely2(span) {
+  try {
+    span.end();
+  } catch {
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GlasstraceSpanProcessor,
   SdkError,
-  captureCorrelationId
+  captureCorrelationId,
+  tracedRequestMiddleware,
+  withAsyncCausality
 });
 //# sourceMappingURL=edge-entry.cjs.map