apitally 0.25.7 → 1.0.0-alpha.1

package/dist/requestObservationNode.d.ts

@@ -0,0 +1,29 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Context } from '@opentelemetry/api';
+import { BodyCapture, CapturedBody } from './bodyCapture.js';
+import { RequestObservation } from './requestObservation.js';
+import '@opentelemetry/core';
+import './context.js';
+
+interface StartNodeRequestObservationOptions {
+    request: IncomingMessage;
+    tracerName: string;
+}
+interface NodeRequestObservation extends RequestObservation {
+    requestBodyCapture: BodyCapture;
+    requestUrl: string;
+}
+interface StartedNodeRequestObservation {
+    observation: NodeRequestObservation;
+    requestContext: Context;
+}
+declare function startNodeRequestObservation(options: StartNodeRequestObservationOptions): StartedNodeRequestObservation;
+interface NodeResponseCompletion extends CapturedBody {
+    completedAtMillis: number;
+    responseFinished: boolean;
+    requestBody: CapturedBody;
+}
+declare function captureNodeResponse(response: ServerResponse, shouldCaptureBody: boolean, requestBodyCapture?: BodyCapture, resolveResponseHeader?: (name: string) => string | number | string[] | undefined): Promise<NodeResponseCompletion>;
+declare function registerServerCloseFlush(request: IncomingMessage): void;
+
+export { type NodeRequestObservation, type NodeResponseCompletion, type StartNodeRequestObservationOptions, type StartedNodeRequestObservation, captureNodeResponse, registerServerCloseFlush, startNodeRequestObservation };

package/dist/requestObservationNode.js

@@ -0,0 +1,170 @@
+import { context, propagation, ROOT_CONTEXT } from "@opentelemetry/api";
+import { flushTelemetry } from "./activation.js";
+import { BodyCapture } from "./bodyCapture.js";
+import { getConfig } from "./config.js";
+import { logDebug } from "./logger.js";
+import {
+  resolveHttpRequestStartAttributes,
+  startRequestObservation
+} from "./requestObservation.js";
+const flushOnCloseServers = /* @__PURE__ */ new WeakSet();
+function startNodeRequestObservation(options) {
+  const { request } = options;
+  const startTimeMillis = performance.now();
+  const method = (request.method ?? "GET").toUpperCase();
+  const requestUrl = request.url ?? "/";
+  const requestBodyCapture = new BodyCapture({
+    captureBody: getConfig().captureRequestBody,
+    contentType: request.headers["content-type"],
+    contentLength: request.headers["content-length"],
+    transferEncoding: request.headers["transfer-encoding"]
+  });
+  observeRequestBody(request, requestBodyCapture);
+  const queryIndex = requestUrl.indexOf("?");
+  const scheme = request.socket?.encrypted ? "https" : "http";
+  const host = request.headers.host;
+  let serverAddress;
+  if (host) {
+    try {
+      serverAddress = new URL(`${scheme}://${host}`).hostname;
+    } catch {
+    }
+  }
+  const startAttributes = resolveHttpRequestStartAttributes({
+    method,
+    path: queryIndex === -1 ? requestUrl : requestUrl.slice(0, queryIndex),
+    query: queryIndex === -1 ? void 0 : requestUrl.slice(queryIndex + 1) || void 0,
+    scheme,
+    serverAddress,
+    fullUrl: host ? `${scheme}://${host}${requestUrl}` : void 0,
+    clientAddress: request.socket?.remoteAddress || void 0,
+    userAgent: typeof request.headers["user-agent"] === "string" ? request.headers["user-agent"] : void 0,
+    requestBodySize: requestBodyCapture.size
+  });
+  const { requestRecord, requestContext, spanHandle, rpcMetadata } = startRequestObservation({
+    activeContext: context.active(),
+    extractedContext: propagation.extract(ROOT_CONTEXT, request.headers),
+    tracerName: options.tracerName,
+    method,
+    startAttributes,
+    requestBodyCapture
+  });
+  return {
+    observation: {
+      requestRecord,
+      spanHandle,
+      rpcMetadata,
+      requestBodyCapture,
+      startTimeMillis,
+      method,
+      requestUrl
+    },
+    requestContext
+  };
+}
+function captureNodeResponse(response, shouldCaptureBody, requestBodyCapture, resolveResponseHeader = (name) => response.getHeader(name)) {
+  let responseBodyCapture;
+  const ensureResponseBodyCapture = () => {
+    responseBodyCapture ??= new BodyCapture({
+      captureBody: shouldCaptureBody,
+      contentType: firstStringValue(resolveResponseHeader("content-type")),
+      contentLength: resolveResponseHeader("content-length"),
+      transferEncoding: resolveResponseHeader("transfer-encoding")
+    });
+    return responseBodyCapture;
+  };
+  const recordResponseChunk = (args) => {
+    try {
+      const chunk = args[0];
+      if (typeof chunk === "string" || Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {
+        ensureResponseBodyCapture().addChunk(
+          chunk,
+          typeof args[1] === "string" ? args[1] : void 0
+        );
+      }
+    } catch (error) {
+      logDebug(`Error observing a response chunk: ${String(error)}`);
+    }
+  };
+  const originalWrite = response.write;
+  response.write = function(...args) {
+    recordResponseChunk(args);
+    return originalWrite.apply(this, args);
+  };
+  const originalEnd = response.end;
+  response.end = function(...args) {
+    recordResponseChunk(args);
+    return originalEnd.apply(this, args);
+  };
+  return new Promise((resolve) => {
+    let completed = false;
+    const complete = (responseFinished) => {
+      if (completed) {
+        return;
+      }
+      completed = true;
+      const completedAtMillis = performance.now();
+      const capture = ensureResponseBodyCapture();
+      if (responseFinished) {
+        capture.markComplete();
+      }
+      resolve({
+        body: capture.body,
+        size: capture.size,
+        completedAtMillis,
+        responseFinished,
+        requestBody: {
+          body: requestBodyCapture?.body,
+          size: requestBodyCapture?.size
+        }
+      });
+    };
+    response.on("finish", () => complete(true));
+    response.on("close", () => complete(false));
+  });
+}
+function registerServerCloseFlush(request) {
+  const server = request.socket?.server;
+  if (!server || typeof server.on !== "function" || flushOnCloseServers.has(server)) {
+    return;
+  }
+  flushOnCloseServers.add(server);
+  server.on("close", () => {
+    flushTelemetry().catch((error) => {
+      logDebug(`Error flushing telemetry on server close: ${String(error)}`);
+    });
+  });
+}
+function observeRequestBody(request, requestBodyCapture) {
+  const originalEmit = request.emit;
+  request.emit = function(event, ...args) {
+    try {
+      if (event === "data") {
+        const chunk = args[0];
+        if (typeof chunk === "string" || Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {
+          requestBodyCapture.addChunk(chunk);
+        }
+      } else if (event === "end") {
+        requestBodyCapture.markComplete();
+      }
+    } catch (error) {
+      logDebug(`Error observing a request body chunk: ${String(error)}`);
+    }
+    return originalEmit.call(this, event, ...args);
+  };
+}
+function firstStringValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return void 0;
+}
+export {
+  captureNodeResponse,
+  registerServerCloseFlush,
+  startNodeRequestObservation
+};
+//# sourceMappingURL=requestObservationNode.js.map

package/dist/requestObservationNode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/requestObservationNode.ts"],"sourcesContent":["import type { IncomingMessage, ServerResponse } from \"node:http\";\nimport { type Context, context, propagation, ROOT_CONTEXT } from \"@opentelemetry/api\";\nimport { flushTelemetry } from \"./activation.js\";\nimport { BodyCapture, type CapturedBody } from \"./bodyCapture.js\";\nimport { getConfig } from \"./config.js\";\nimport { logDebug } from \"./logger.js\";\nimport {\n  type RequestObservation,\n  resolveHttpRequestStartAttributes,\n  startRequestObservation,\n} from \"./requestObservation.js\";\n\nconst flushOnCloseServers = new WeakSet<object>();\n\nexport interface StartNodeRequestObservationOptions {\n  request: IncomingMessage;\n  tracerName: string;\n}\n\nexport interface NodeRequestObservation extends RequestObservation {\n  requestBodyCapture: BodyCapture;\n  requestUrl: string;\n}\n\nexport interface StartedNodeRequestObservation {\n  observation: NodeRequestObservation;\n  requestContext: Context;\n}\n\nexport function startNodeRequestObservation(\n  options: StartNodeRequestObservationOptions,\n): StartedNodeRequestObservation {\n  const { request } = options;\n  const startTimeMillis = performance.now();\n  const method = (request.method ?? \"GET\").toUpperCase();\n  const requestUrl = request.url ?? \"/\";\n  const requestBodyCapture = new BodyCapture({\n    captureBody: getConfig().captureRequestBody,\n    contentType: request.headers[\"content-type\"],\n    contentLength: request.headers[\"content-length\"],\n    transferEncoding: request.headers[\"transfer-encoding\"],\n  });\n  observeRequestBody(request, requestBodyCapture);\n\n  const queryIndex = requestUrl.indexOf(\"?\");\n  const scheme = (request.socket as { encrypted?: boolean } | undefined)?.encrypted\n    ? \"https\"\n    : \"http\";\n  const host = request.headers.host;\n  let serverAddress: string | undefined;\n  if (host) {\n    try {\n      serverAddress = new URL(`${scheme}://${host}`).hostname;\n    } catch {\n      // An invalid Host header leaves the server address unset.\n    }\n  }\n  const startAttributes = resolveHttpRequestStartAttributes({\n    method,\n    path: queryIndex === -1 ? requestUrl : requestUrl.slice(0, queryIndex),\n    query: queryIndex === -1 ? undefined : requestUrl.slice(queryIndex + 1) || undefined,\n    scheme,\n    serverAddress,\n    fullUrl: host ? `${scheme}://${host}${requestUrl}` : undefined,\n    clientAddress: request.socket?.remoteAddress || undefined,\n    userAgent:\n      typeof request.headers[\"user-agent\"] === \"string\" ? request.headers[\"user-agent\"] : undefined,\n    requestBodySize: requestBodyCapture.size,\n  });\n  const { requestRecord, requestContext, spanHandle, rpcMetadata } = startRequestObservation({\n    activeContext: context.active(),\n    extractedContext: propagation.extract(ROOT_CONTEXT, request.headers),\n    tracerName: options.tracerName,\n    method,\n    startAttributes,\n    requestBodyCapture,\n  });\n  return {\n    observation: {\n      requestRecord,\n      spanHandle,\n      rpcMetadata,\n      requestBodyCapture,\n      startTimeMillis,\n      method,\n      requestUrl,\n    },\n    requestContext,\n  };\n}\n\nexport interface NodeResponseCompletion extends CapturedBody {\n  completedAtMillis: number;\n  responseFinished: boolean;\n  requestBody: CapturedBody;\n}\n\n// Patching write and end before framework dispatch lets compression wrappers\n// feed their final wire bytes through capture.\nexport function captureNodeResponse(\n  response: ServerResponse,\n  shouldCaptureBody: boolean,\n  requestBodyCapture?: BodyCapture,\n  resolveResponseHeader: (name: string) => string | number | string[] | undefined = (name) =>\n    response.getHeader(name),\n): Promise<NodeResponseCompletion> {\n  let responseBodyCapture: BodyCapture | undefined;\n  const ensureResponseBodyCapture = (): BodyCapture => {\n    responseBodyCapture ??= new BodyCapture({\n      captureBody: shouldCaptureBody,\n      contentType: firstStringValue(resolveResponseHeader(\"content-type\")),\n      contentLength: resolveResponseHeader(\"content-length\"),\n      transferEncoding: resolveResponseHeader(\"transfer-encoding\") as string | string[] | undefined,\n    });\n    return responseBodyCapture;\n  };\n  const recordResponseChunk = (args: unknown[]): void => {\n    try {\n      const chunk = args[0];\n      if (typeof chunk === \"string\" || Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {\n        ensureResponseBodyCapture().addChunk(\n          chunk,\n          typeof args[1] === \"string\" ? (args[1] as BufferEncoding) : undefined,\n        );\n      }\n    } catch (error) {\n      logDebug(`Error observing a response chunk: ${String(error)}`);\n    }\n  };\n  const originalWrite = response.write as (...args: unknown[]) => boolean;\n  response.write = function (this: ServerResponse, ...args: unknown[]): boolean {\n    recordResponseChunk(args);\n    return originalWrite.apply(this, args);\n  } as typeof response.write;\n  const originalEnd = response.end as (...args: unknown[]) => ServerResponse;\n  response.end = function (this: ServerResponse, ...args: unknown[]): ServerResponse {\n    recordResponseChunk(args);\n    return originalEnd.apply(this, args);\n  } as typeof response.end;\n\n  return new Promise((resolve) => {\n    let completed = false;\n    const complete = (responseFinished: boolean): void => {\n      if (completed) {\n        return;\n      }\n      completed = true;\n      const completedAtMillis = performance.now();\n      const capture = ensureResponseBodyCapture();\n      if (responseFinished) {\n        capture.markComplete();\n      }\n      resolve({\n        body: capture.body,\n        size: capture.size,\n        completedAtMillis,\n        responseFinished,\n        requestBody: {\n          body: requestBodyCapture?.body,\n          size: requestBodyCapture?.size,\n        },\n      });\n    };\n    response.on(\"finish\", () => complete(true));\n    response.on(\"close\", () => complete(false));\n  });\n}\n\n// Closing a server triggers a flush of buffered telemetry, never a teardown:\n// an app bound to several servers keeps exporting on the still-open ones.\nexport function registerServerCloseFlush(request: IncomingMessage): void {\n  const server = (request.socket as { server?: unknown } | undefined)?.server;\n  if (\n    !server ||\n    typeof (server as { on?: unknown }).on !== \"function\" ||\n    flushOnCloseServers.has(server as object)\n  ) {\n    return;\n  }\n  flushOnCloseServers.add(server as object);\n  (server as { on: (event: string, listener: () => void) => void }).on(\"close\", () => {\n    flushTelemetry().catch((error: unknown) => {\n      logDebug(`Error flushing telemetry on server close: ${String(error)}`);\n    });\n  });\n}\n\n// Wrapping emit observes only bytes delivered to application consumers and does\n// not change the stream's flow state.\nfunction observeRequestBody(request: IncomingMessage, requestBodyCapture: BodyCapture): void {\n  const originalEmit = request.emit as (...args: unknown[]) => boolean;\n  (request as { emit: unknown }).emit = function (\n    this: IncomingMessage,\n    event: string | symbol,\n    ...args: unknown[]\n  ): boolean {\n    try {\n      if (event === \"data\") {\n        const chunk = args[0];\n        if (typeof chunk === \"string\" || Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {\n          requestBodyCapture.addChunk(chunk);\n        }\n      } else if (event === \"end\") {\n        requestBodyCapture.markComplete();\n      }\n    } catch (error) {\n      logDebug(`Error observing a request body chunk: ${String(error)}`);\n    }\n    return originalEmit.call(this, event, ...args);\n  };\n}\n\nfunction firstStringValue(value: string | number | string[] | undefined): string | undefined {\n  if (typeof value === \"string\") {\n    return value;\n  }\n  if (Array.isArray(value)) {\n    return value[0];\n  }\n  return undefined;\n}\n"],"mappings":"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","names":[]}

package/dist/requestObservationWeb.cjs

@@ -0,0 +1,202 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var requestObservationWeb_exports = {};
+__export(requestObservationWeb_exports, {
+  captureWebRequestBody: () => captureWebRequestBody,
+  captureWebResponse: () => captureWebResponse,
+  isWebSocketUpgrade: () => isWebSocketUpgrade,
+  startWebRequestObservation: () => startWebRequestObservation
+});
+module.exports = __toCommonJS(requestObservationWeb_exports);
+var import_api = require("@opentelemetry/api");
+var import_bodyCapture = require('./bodyCapture.cjs');
+var import_config = require('./config.cjs');
+var import_requestObservation = require('./requestObservation.cjs');
+const READ_TIMEOUT_MILLIS = 5e3;
+const WEB_HEADERS_GETTER = {
+  get: (carrier, key) => carrier.get(key) ?? void 0,
+  keys: (carrier) => [...carrier.keys()]
+};
+function isWebSocketUpgrade(request) {
+  return request.headers.get("upgrade")?.toLowerCase() === "websocket";
+}
+function startWebRequestObservation(options) {
+  const { request } = options;
+  const startTimeMillis = performance.now();
+  const method = request.method.toUpperCase();
+  const requestBodyCapture = new import_bodyCapture.BodyCapture({
+    captureBody: (0, import_config.getConfig)().captureRequestBody,
+    contentType: request.headers.get("content-type"),
+    contentLength: request.headers.get("content-length"),
+    transferEncoding: request.headers.get("transfer-encoding")
+  });
+  const attributeInput = {
+    method,
+    clientAddress: options.clientAddress,
+    userAgent: request.headers.get("user-agent") ?? void 0,
+    requestBodySize: requestBodyCapture.size
+  };
+  let startAttributes = (0, import_requestObservation.resolveHttpRequestStartAttributes)(attributeInput);
+  try {
+    const url = new URL(request.url);
+    startAttributes = (0, import_requestObservation.resolveHttpRequestStartAttributes)({
+      ...attributeInput,
+      path: url.pathname,
+      query: url.search.slice(1) || void 0,
+      scheme: url.protocol.replace(/:$/, ""),
+      serverAddress: url.hostname,
+      fullUrl: request.url
+    });
+  } catch {
+  }
+  const { requestRecord, requestContext, spanHandle, rpcMetadata } = (0, import_requestObservation.startRequestObservation)({
+    activeContext: import_api.context.active(),
+    extractedContext: import_api.propagation.extract(import_api.ROOT_CONTEXT, request.headers, WEB_HEADERS_GETTER),
+    tracerName: options.tracerName,
+    method,
+    startAttributes,
+    requestBodyCapture
+  });
+  return {
+    observation: {
+      requestRecord,
+      spanHandle,
+      rpcMetadata,
+      requestBodyCapture,
+      requestHeaders: request.headers,
+      startTimeMillis,
+      method
+    },
+    requestContext
+  };
+}
+function captureWebRequestBody(request, bodyCapture, readTimeoutMillis = READ_TIMEOUT_MILLIS) {
+  if (!request.body || !bodyCapture.isBuffering) {
+    return Promise.resolve();
+  }
+  let reader;
+  try {
+    reader = request.clone().body?.getReader();
+  } catch {
+    return Promise.resolve();
+  }
+  if (!reader) {
+    return Promise.resolve();
+  }
+  let isStopped = false;
+  const readPromise = (async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (isStopped) {
+          return;
+        }
+        if (done) {
+          bodyCapture.markComplete();
+          return;
+        }
+        bodyCapture.addChunk(value);
+        if (!bodyCapture.isBuffering) {
+          cancelReader(reader);
+          return;
+        }
+      }
+    } catch {
+    }
+  })();
+  let readTimeout;
+  const timeoutPromise = new Promise((resolve) => {
+    readTimeout = setTimeout(() => {
+      isStopped = true;
+      bodyCapture.stopBuffering();
+      cancelReader(reader);
+      resolve();
+    }, readTimeoutMillis);
+    readTimeout.unref();
+  });
+  return Promise.race([readPromise, timeoutPromise]).finally(() => clearTimeout(readTimeout));
+}
+function captureWebResponse(response, shouldCaptureBody, readTimeoutMillis = READ_TIMEOUT_MILLIS) {
+  const bodyCapture = new import_bodyCapture.BodyCapture({
+    captureBody: shouldCaptureBody,
+    contentType: response.headers.get("content-type"),
+    contentLength: response.headers.get("content-length"),
+    transferEncoding: response.headers.get("transfer-encoding")
+  });
+  if (!response.body) {
+    bodyCapture.markComplete();
+    return {
+      response,
+      completion: Promise.resolve({
+        body: bodyCapture.body,
+        size: bodyCapture.size,
+        completedAtMillis: performance.now()
+      })
+    };
+  }
+  let readStarted = false;
+  const { readable, writable } = new TransformStream({
+    transform: (chunk, controller) => {
+      readStarted = true;
+      bodyCapture.addChunk(chunk);
+      controller.enqueue(chunk);
+    }
+  });
+  const pipePromise = response.body.pipeTo(writable).then(
+    () => {
+      const completedAtMillis = performance.now();
+      bodyCapture.markComplete();
+      return { body: bodyCapture.body, size: bodyCapture.size, completedAtMillis };
+    },
+    () => ({ completedAtMillis: performance.now() })
+  );
+  let readTimeout;
+  const timeoutPromise = new Promise((resolve) => {
+    readTimeout = setTimeout(() => {
+      if (!readStarted) {
+        resolve({ completedAtMillis: performance.now() });
+      }
+    }, readTimeoutMillis);
+    readTimeout.unref();
+  });
+  const capturedResponse = new Response(readable, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  const completion = Promise.race([pipePromise, timeoutPromise]).finally(
+    () => clearTimeout(readTimeout)
+  );
+  return { response: capturedResponse, completion };
+}
+function cancelReader(reader) {
+  try {
+    reader.cancel().catch(() => {
+    });
+  } catch {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureWebRequestBody,
+  captureWebResponse,
+  isWebSocketUpgrade,
+  startWebRequestObservation
+});
+//# sourceMappingURL=requestObservationWeb.cjs.map

package/dist/requestObservationWeb.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/requestObservationWeb.ts"],"sourcesContent":["import {\n  type Context,\n  context,\n  propagation,\n  ROOT_CONTEXT,\n  type TextMapGetter,\n} from \"@opentelemetry/api\";\nimport { BodyCapture, type CapturedBody } from \"./bodyCapture.js\";\nimport { getConfig } from \"./config.js\";\nimport {\n  type RequestObservation,\n  resolveHttpRequestStartAttributes,\n  startRequestObservation,\n} from \"./requestObservation.js\";\n\nconst READ_TIMEOUT_MILLIS = 5_000;\n\nconst WEB_HEADERS_GETTER: TextMapGetter<Headers> = {\n  get: (carrier, key) => carrier.get(key) ?? undefined,\n  keys: (carrier) => [...carrier.keys()],\n};\n\nexport interface StartWebRequestObservationOptions {\n  request: Request;\n  tracerName: string;\n  clientAddress?: string;\n}\n\nexport function isWebSocketUpgrade(request: Request): boolean {\n  return request.headers.get(\"upgrade\")?.toLowerCase() === \"websocket\";\n}\n\nexport interface WebRequestObservation extends RequestObservation {\n  requestBodyCapture: BodyCapture;\n  requestHeaders: Headers;\n}\n\nexport interface StartedWebRequestObservation {\n  observation: WebRequestObservation;\n  requestContext: Context;\n}\n\nexport function startWebRequestObservation(\n  options: StartWebRequestObservationOptions,\n): StartedWebRequestObservation {\n  const { request } = options;\n  const startTimeMillis = performance.now();\n  const method = request.method.toUpperCase();\n  const requestBodyCapture = new BodyCapture({\n    captureBody: getConfig().captureRequestBody,\n    contentType: request.headers.get(\"content-type\"),\n    contentLength: request.headers.get(\"content-length\"),\n    transferEncoding: request.headers.get(\"transfer-encoding\"),\n  });\n  const attributeInput = {\n    method,\n    clientAddress: options.clientAddress,\n    userAgent: request.headers.get(\"user-agent\") ?? undefined,\n    requestBodySize: requestBodyCapture.size,\n  };\n  let startAttributes = resolveHttpRequestStartAttributes(attributeInput);\n  try {\n    const url = new URL(request.url);\n    startAttributes = resolveHttpRequestStartAttributes({\n      ...attributeInput,\n      path: url.pathname,\n      query: url.search.slice(1) || undefined,\n      scheme: url.protocol.replace(/:$/, \"\"),\n      serverAddress: url.hostname,\n      fullUrl: request.url,\n    });\n  } catch {\n    // An unparseable request URL leaves only attributes from other request metadata.\n  }\n  const { requestRecord, requestContext, spanHandle, rpcMetadata } = startRequestObservation({\n    activeContext: context.active(),\n    extractedContext: propagation.extract(ROOT_CONTEXT, request.headers, WEB_HEADERS_GETTER),\n    tracerName: options.tracerName,\n    method,\n    startAttributes,\n    requestBodyCapture,\n  });\n  return {\n    observation: {\n      requestRecord,\n      spanHandle,\n      rpcMetadata,\n      requestBodyCapture,\n      requestHeaders: request.headers,\n      startTimeMillis,\n      method,\n    },\n    requestContext,\n  };\n}\n\nexport function captureWebRequestBody(\n  request: Request,\n  bodyCapture: BodyCapture,\n  readTimeoutMillis: number = READ_TIMEOUT_MILLIS,\n): Promise<void> {\n  if (!request.body || !bodyCapture.isBuffering) {\n    return Promise.resolve();\n  }\n  let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;\n  try {\n    reader = request.clone().body?.getReader();\n  } catch {\n    return Promise.resolve();\n  }\n  if (!reader) {\n    return Promise.resolve();\n  }\n  let isStopped = false;\n  const readPromise = (async () => {\n    try {\n      while (true) {\n        const { done, value } = await reader.read();\n        if (isStopped) {\n          return;\n        }\n        if (done) {\n          bodyCapture.markComplete();\n          return;\n        }\n        bodyCapture.addChunk(value);\n        if (!bodyCapture.isBuffering) {\n          cancelReader(reader);\n          return;\n        }\n      }\n    } catch {\n      // A partial body is intentionally unavailable when the clone cannot be read.\n    }\n  })();\n  let readTimeout: NodeJS.Timeout | undefined;\n  const timeoutPromise = new Promise<void>((resolve) => {\n    readTimeout = setTimeout(() => {\n      isStopped = true;\n      bodyCapture.stopBuffering();\n      cancelReader(reader);\n      resolve();\n    }, readTimeoutMillis);\n    readTimeout.unref();\n  });\n  return Promise.race([readPromise, timeoutPromise]).finally(() => clearTimeout(readTimeout));\n}\n\nexport interface WebResponseCompletion extends CapturedBody {\n  completedAtMillis: number;\n}\n\nexport interface CapturedWebResponse {\n  response: Response;\n  completion: Promise<WebResponseCompletion>;\n}\n\n// The response is teed so capture does not consume or delay the application's\n// copy. Observation ends on completion, stream failure, or read timeout.\nexport function captureWebResponse(\n  response: Response,\n  shouldCaptureBody: boolean,\n  readTimeoutMillis: number = READ_TIMEOUT_MILLIS,\n): CapturedWebResponse {\n  const bodyCapture = new BodyCapture({\n    captureBody: shouldCaptureBody,\n    contentType: response.headers.get(\"content-type\"),\n    contentLength: response.headers.get(\"content-length\"),\n    transferEncoding: response.headers.get(\"transfer-encoding\"),\n  });\n  if (!response.body) {\n    bodyCapture.markComplete();\n    return {\n      response,\n      completion: Promise.resolve({\n        body: bodyCapture.body,\n        size: bodyCapture.size,\n        completedAtMillis: performance.now(),\n      }),\n    };\n  }\n  let readStarted = false;\n  const { readable, writable } = new TransformStream<Uint8Array, Uint8Array>({\n    transform: (chunk, controller) => {\n      readStarted = true;\n      bodyCapture.addChunk(chunk);\n      controller.enqueue(chunk);\n    },\n  });\n  const pipePromise = response.body.pipeTo(writable).then(\n    () => {\n      const completedAtMillis = performance.now();\n      bodyCapture.markComplete();\n      return { body: bodyCapture.body, size: bodyCapture.size, completedAtMillis };\n    },\n    () => ({ completedAtMillis: performance.now() }),\n  );\n  let readTimeout: NodeJS.Timeout | undefined;\n  const timeoutPromise = new Promise<WebResponseCompletion>((resolve) => {\n    readTimeout = setTimeout(() => {\n      if (!readStarted) {\n        resolve({ completedAtMillis: performance.now() });\n      }\n    }, readTimeoutMillis);\n    readTimeout.unref();\n  });\n  const capturedResponse = new Response(readable, {\n    status: response.status,\n    statusText: response.statusText,\n    headers: response.headers,\n  });\n  const completion = Promise.race([pipePromise, timeoutPromise]).finally(() =>\n    clearTimeout(readTimeout),\n  );\n  return { response: capturedResponse, completion };\n}\n\nfunction cancelReader(reader: ReadableStreamDefaultReader<Uint8Array>): void {\n  try {\n    reader.cancel().catch(() => {});\n  } catch {\n    // Cancellation is best-effort after capture has already stopped.\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/requestObservationWeb.d.cts

@@ -0,0 +1,32 @@
+import { Context } from '@opentelemetry/api';
+import { CapturedBody, BodyCapture } from './bodyCapture.cjs';
+import { RequestObservation } from './requestObservation.cjs';
+import '@opentelemetry/core';
+import './context.cjs';
+
+interface StartWebRequestObservationOptions {
+    request: Request;
+    tracerName: string;
+    clientAddress?: string;
+}
+declare function isWebSocketUpgrade(request: Request): boolean;
+interface WebRequestObservation extends RequestObservation {
+    requestBodyCapture: BodyCapture;
+    requestHeaders: Headers;
+}
+interface StartedWebRequestObservation {
+    observation: WebRequestObservation;
+    requestContext: Context;
+}
+declare function startWebRequestObservation(options: StartWebRequestObservationOptions): StartedWebRequestObservation;
+declare function captureWebRequestBody(request: Request, bodyCapture: BodyCapture, readTimeoutMillis?: number): Promise<void>;
+interface WebResponseCompletion extends CapturedBody {
+    completedAtMillis: number;
+}
+interface CapturedWebResponse {
+    response: Response;
+    completion: Promise<WebResponseCompletion>;
+}
+declare function captureWebResponse(response: Response, shouldCaptureBody: boolean, readTimeoutMillis?: number): CapturedWebResponse;
+
+export { type CapturedWebResponse, type StartWebRequestObservationOptions, type StartedWebRequestObservation, type WebRequestObservation, type WebResponseCompletion, captureWebRequestBody, captureWebResponse, isWebSocketUpgrade, startWebRequestObservation };

package/dist/requestObservationWeb.d.ts

@@ -0,0 +1,32 @@
+import { Context } from '@opentelemetry/api';
+import { CapturedBody, BodyCapture } from './bodyCapture.js';
+import { RequestObservation } from './requestObservation.js';
+import '@opentelemetry/core';
+import './context.js';
+
+interface StartWebRequestObservationOptions {
+    request: Request;
+    tracerName: string;
+    clientAddress?: string;
+}
+declare function isWebSocketUpgrade(request: Request): boolean;
+interface WebRequestObservation extends RequestObservation {
+    requestBodyCapture: BodyCapture;
+    requestHeaders: Headers;
+}
+interface StartedWebRequestObservation {
+    observation: WebRequestObservation;
+    requestContext: Context;
+}
+declare function startWebRequestObservation(options: StartWebRequestObservationOptions): StartedWebRequestObservation;
+declare function captureWebRequestBody(request: Request, bodyCapture: BodyCapture, readTimeoutMillis?: number): Promise<void>;
+interface WebResponseCompletion extends CapturedBody {
+    completedAtMillis: number;
+}
+interface CapturedWebResponse {
+    response: Response;
+    completion: Promise<WebResponseCompletion>;
+}
+declare function captureWebResponse(response: Response, shouldCaptureBody: boolean, readTimeoutMillis?: number): CapturedWebResponse;
+
+export { type CapturedWebResponse, type StartWebRequestObservationOptions, type StartedWebRequestObservation, type WebRequestObservation, type WebResponseCompletion, captureWebRequestBody, captureWebResponse, isWebSocketUpgrade, startWebRequestObservation };