@stainlessdev/xray-emitter 0.1.0-branch.pedro-unify.20f830a

package/dist/chunk-AHXNYJ5A.cjs

@@ -0,0 +1,621 @@
+"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 _chunk3MVVO5I7cjs = require('./chunk-3MVVO5I7.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkGNSXLLECcjs = require('./chunk-GNSXLLEC.cjs');
+
+
+
+
+var _chunkJKW6E4L3cjs = require('./chunk-JKW6E4L3.cjs');
+
+// src/fetch/emitter.ts
+var _indexjs = require('@opentelemetry/exporter-trace-otlp-proto/build/src/platform/browser/index.js');
+function createEmitter2(config) {
+  if (!_optionalChain([config, 'access', _ => _.exporter, 'optionalAccess', _2 => _2.instance])) {
+    const hasFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch === "function";
+    if (!hasFetch) {
+      throw new Error(
+        "fetch is required to use the default @stainlessdev/xray-fetch exporter; provide exporter.instance or use @stainlessdev/xray-node instead."
+      );
+    }
+  }
+  const resolved = _chunk3MVVO5I7cjs.normalizeConfig.call(void 0, config);
+  const exporter = _nullishCoalesce(_optionalChain([config, 'access', _3 => _3.exporter, 'optionalAccess', _4 => _4.instance]), () => ( new (0, _indexjs.OTLPTraceExporter)({
+    url: resolved.exporter.endpointUrl,
+    headers: _nullishCoalesce(resolved.exporter.headers, () => ( {})),
+    timeoutMillis: resolved.exporter.timeoutMs
+  })));
+  return _chunk3MVVO5I7cjs.createEmitter.call(void 0, config, exporter);
+}
+
+// src/fetch/adapter.ts
+function wrapFetch(handler, xray, options) {
+  return async (req) => {
+    const normalizedRequest = {
+      method: req.method,
+      url: req.url,
+      route: _optionalChain([options, 'optionalAccess', _5 => _5.route]),
+      headers: _chunkGNSXLLECcjs.headerValuesFromFetchHeaders.call(void 0, req.headers),
+      requestId: _optionalChain([options, 'optionalAccess', _6 => _6.requestId]),
+      startTimeMs: Date.now()
+    };
+    const ctx = xray.startRequest(normalizedRequest);
+    _chunkGNSXLLECcjs.bindContextToObject.call(void 0, req, ctx);
+    if (_optionalChain([options, 'optionalAccess', _7 => _7.requestId])) {
+      _chunkGNSXLLECcjs.setContextRequestId.call(void 0, ctx, options.requestId);
+    }
+    if (_optionalChain([options, 'optionalAccess', _8 => _8.route])) {
+      _chunkGNSXLLECcjs.setContextRoute.call(void 0, ctx, options.route);
+    }
+    if (_optionalChain([options, 'optionalAccess', _9 => _9.capture])) {
+      _chunkGNSXLLECcjs.setCaptureOverride.call(void 0, ctx, options.capture);
+    }
+    if (_optionalChain([options, 'optionalAccess', _10 => _10.redaction])) {
+      _chunkGNSXLLECcjs.setRedactionOverride.call(void 0, ctx, options.redaction);
+    }
+    if (_optionalChain([options, 'optionalAccess', _11 => _11.onRequest])) {
+      try {
+        options.onRequest(ctx);
+      } catch (err) {
+        _chunkJKW6E4L3cjs.logWithLevel.call(void 0, xray.config.logger, "warn", xray.config.logLevel, "xray: onRequest failed", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    const capture = _optionalChain([options, 'optionalAccess', _12 => _12.capture]) ? { ...xray.config.capture, ...options.capture } : xray.config.capture;
+    const requestCapture = capture.requestBody === "none" ? null : wrapRequestBody(req, capture.maxBodyBytes);
+    const requestForHandler = _nullishCoalesce(_optionalChain([requestCapture, 'optionalAccess', _13 => _13.request]), () => ( req));
+    if (requestForHandler !== req) {
+      _chunkGNSXLLECcjs.bindContextToObject.call(void 0, requestForHandler, ctx);
+    }
+    let response;
+    try {
+      response = await handler(requestForHandler);
+    } catch (err) {
+      const log = xray.endRequest(
+        ctx,
+        {
+          statusCode: void 0,
+          headers: void 0,
+          body: void 0,
+          endTimeMs: Date.now()
+        },
+        err
+      );
+      if (_optionalChain([options, 'optionalAccess', _14 => _14.onError])) {
+        try {
+          options.onError(ctx, err);
+        } catch (errInner) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, xray.config.logger, "warn", xray.config.logLevel, "xray: onError failed", {
+            error: errInner instanceof Error ? errInner.message : String(errInner)
+          });
+        }
+      }
+      if (_optionalChain([options, 'optionalAccess', _15 => _15.onResponse])) {
+        try {
+          options.onResponse(ctx, log);
+        } catch (errInner) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, 
+            xray.config.logger,
+            "warn",
+            xray.config.logLevel,
+            "xray: onResponse failed",
+            {
+              error: errInner instanceof Error ? errInner.message : String(errInner)
+            }
+          );
+        }
+      }
+      throw err;
+    }
+    if (!(response instanceof Response)) {
+      const log = xray.endRequest(ctx, {
+        statusCode: void 0,
+        headers: void 0,
+        body: void 0,
+        endTimeMs: Date.now()
+      });
+      if (_optionalChain([options, 'optionalAccess', _16 => _16.onResponse])) {
+        try {
+          options.onResponse(ctx, log);
+        } catch (err) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, 
+            xray.config.logger,
+            "warn",
+            xray.config.logLevel,
+            "xray: onResponse failed",
+            {
+              error: err instanceof Error ? err.message : String(err)
+            }
+          );
+        }
+      }
+      return response;
+    }
+    const responseHeaders = new Headers(response.headers);
+    ensureResponseRequestIdHeaders(responseHeaders, ctx, xray);
+    const statusCode = response.status;
+    const isUpgrade = _chunkGNSXLLECcjs.isWebsocketUpgradeFetch.call(void 0, statusCode, req.headers, responseHeaders);
+    if (!response.body || isUpgrade || capture.responseBody === "none") {
+      const log = finalizeResponse(
+        ctx,
+        xray,
+        normalizedRequest,
+        capture,
+        _nullishCoalesce(_optionalChain([requestCapture, 'optionalAccess', _17 => _17.capture]), () => ( null)),
+        responseHeaders,
+        statusCode,
+        null
+      );
+      if (_optionalChain([options, 'optionalAccess', _18 => _18.onResponse])) {
+        try {
+          options.onResponse(ctx, log);
+        } catch (err) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, 
+            xray.config.logger,
+            "warn",
+            xray.config.logLevel,
+            "xray: onResponse failed",
+            {
+              error: err instanceof Error ? err.message : String(err)
+            }
+          );
+        }
+      }
+      return new Response(response.body, {
+        headers: responseHeaders,
+        status: response.status,
+        statusText: response.statusText
+      });
+    }
+    const responseCapture = new (0, _chunkGNSXLLECcjs.LimitedBuffer)(capture.maxBodyBytes);
+    let finished = false;
+    const finalize = () => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      const log = finalizeResponse(
+        ctx,
+        xray,
+        normalizedRequest,
+        capture,
+        _nullishCoalesce(_optionalChain([requestCapture, 'optionalAccess', _19 => _19.capture]), () => ( null)),
+        responseHeaders,
+        statusCode,
+        responseCapture
+      );
+      if (_optionalChain([options, 'optionalAccess', _20 => _20.onResponse])) {
+        try {
+          options.onResponse(ctx, log);
+        } catch (err) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, 
+            xray.config.logger,
+            "warn",
+            xray.config.logLevel,
+            "xray: onResponse failed",
+            {
+              error: err instanceof Error ? err.message : String(err)
+            }
+          );
+        }
+      }
+    };
+    const wrappedBody = wrapReadableStream(response.body, responseCapture, finalize, () => {
+      finalize();
+    });
+    return new Response(wrappedBody, {
+      headers: responseHeaders,
+      status: response.status,
+      statusText: response.statusText
+    });
+  };
+}
+function wrapFetchPreserve(handler, xray, options) {
+  return async (req) => {
+    const normalizedRequest = {
+      method: req.method,
+      url: req.url,
+      route: _optionalChain([options, 'optionalAccess', _21 => _21.route]),
+      headers: _chunkGNSXLLECcjs.headerValuesFromFetchHeaders.call(void 0, req.headers),
+      requestId: _optionalChain([options, 'optionalAccess', _22 => _22.requestId]),
+      startTimeMs: Date.now()
+    };
+    const ctx = xray.startRequest(normalizedRequest);
+    _chunkGNSXLLECcjs.bindContextToObject.call(void 0, req, ctx);
+    if (_optionalChain([options, 'optionalAccess', _23 => _23.requestId])) {
+      _chunkGNSXLLECcjs.setContextRequestId.call(void 0, ctx, options.requestId);
+    }
+    if (_optionalChain([options, 'optionalAccess', _24 => _24.route])) {
+      _chunkGNSXLLECcjs.setContextRoute.call(void 0, ctx, options.route);
+    }
+    if (_optionalChain([options, 'optionalAccess', _25 => _25.capture])) {
+      _chunkGNSXLLECcjs.setCaptureOverride.call(void 0, ctx, options.capture);
+    }
+    if (_optionalChain([options, 'optionalAccess', _26 => _26.redaction])) {
+      _chunkGNSXLLECcjs.setRedactionOverride.call(void 0, ctx, options.redaction);
+    }
+    if (_optionalChain([options, 'optionalAccess', _27 => _27.onRequest])) {
+      try {
+        options.onRequest(ctx);
+      } catch (err) {
+        _chunkJKW6E4L3cjs.logWithLevel.call(void 0, xray.config.logger, "warn", xray.config.logLevel, "xray: onRequest failed", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    const capture = _optionalChain([options, 'optionalAccess', _28 => _28.capture]) ? { ...xray.config.capture, ...options.capture } : xray.config.capture;
+    const requestCapturePromise = capture.requestBody === "none" ? Promise.resolve(null) : captureRequestClone(req, capture.maxBodyBytes, xray);
+    let response;
+    try {
+      response = await handler(req);
+    } catch (err) {
+      const log = xray.endRequest(
+        ctx,
+        {
+          statusCode: void 0,
+          headers: void 0,
+          body: void 0,
+          endTimeMs: Date.now()
+        },
+        err
+      );
+      if (_optionalChain([options, 'optionalAccess', _29 => _29.onError])) {
+        try {
+          options.onError(ctx, err);
+        } catch (errInner) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, xray.config.logger, "warn", xray.config.logLevel, "xray: onError failed", {
+            error: errInner instanceof Error ? errInner.message : String(errInner)
+          });
+        }
+      }
+      if (_optionalChain([options, 'optionalAccess', _30 => _30.onResponse])) {
+        try {
+          options.onResponse(ctx, log);
+        } catch (errInner) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, 
+            xray.config.logger,
+            "warn",
+            xray.config.logLevel,
+            "xray: onResponse failed",
+            {
+              error: errInner instanceof Error ? errInner.message : String(errInner)
+            }
+          );
+        }
+      }
+      throw err;
+    }
+    if (!(response instanceof Response)) {
+      const log = xray.endRequest(ctx, {
+        statusCode: void 0,
+        headers: void 0,
+        body: void 0,
+        endTimeMs: Date.now()
+      });
+      if (_optionalChain([options, 'optionalAccess', _31 => _31.onResponse])) {
+        try {
+          options.onResponse(ctx, log);
+        } catch (err) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, 
+            xray.config.logger,
+            "warn",
+            xray.config.logLevel,
+            "xray: onResponse failed",
+            {
+              error: err instanceof Error ? err.message : String(err)
+            }
+          );
+        }
+      }
+      return response;
+    }
+    const responseHeaders = new Headers(response.headers);
+    const ensured = ensureResponseRequestIdHeaders(responseHeaders, ctx, xray);
+    if (ensured.set) {
+      const headerName = canonicalHeaderName(xray.config.requestId.header);
+      try {
+        response.headers.set(headerName, _nullishCoalesce(ensured.value, () => ( "")));
+      } catch (e) {
+        response = new Response(response.body, {
+          headers: responseHeaders,
+          status: response.status,
+          statusText: response.statusText
+        });
+      }
+    }
+    const statusCode = response.status;
+    const isUpgrade = _chunkGNSXLLECcjs.isWebsocketUpgradeFetch.call(void 0, statusCode, req.headers, responseHeaders);
+    const responseCapturePromise = !response.body || isUpgrade || capture.responseBody === "none" ? Promise.resolve(null) : captureResponseClone(response, capture.maxBodyBytes, xray);
+    void (async () => {
+      const [requestCapture, responseCapture] = await Promise.all([
+        requestCapturePromise,
+        responseCapturePromise
+      ]);
+      const log = finalizeResponse(
+        ctx,
+        xray,
+        normalizedRequest,
+        capture,
+        requestCapture,
+        responseHeaders,
+        statusCode,
+        responseCapture
+      );
+      if (_optionalChain([options, 'optionalAccess', _32 => _32.onResponse])) {
+        try {
+          options.onResponse(ctx, log);
+        } catch (err) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, 
+            xray.config.logger,
+            "warn",
+            xray.config.logLevel,
+            "xray: onResponse failed",
+            {
+              error: err instanceof Error ? err.message : String(err)
+            }
+          );
+        }
+      }
+    })().catch((err) => {
+      _chunkJKW6E4L3cjs.logWithLevel.call(void 0, 
+        xray.config.logger,
+        "warn",
+        xray.config.logLevel,
+        "xray: response capture failed",
+        {
+          error: err instanceof Error ? err.message : String(err)
+        }
+      );
+    });
+    return response;
+  };
+}
+function getXrayContext(req) {
+  return _chunkGNSXLLECcjs.getXrayContextFromObject.call(void 0, req);
+}
+function wrapRequestBody(request, limit) {
+  if (limit <= 0 || !request.body || request.bodyUsed) {
+    return { capture: null, request };
+  }
+  const originalBody = request.body;
+  const capture = {
+    buffer: new (0, _chunkGNSXLLECcjs.LimitedBuffer)(limit),
+    read: false
+  };
+  let controller = null;
+  let started = false;
+  let reader = null;
+  const wrappedStream = new ReadableStream({
+    start(c) {
+      controller = c;
+    },
+    async cancel(reason) {
+      if (!started) {
+        return;
+      }
+      try {
+        await _optionalChain([reader, 'optionalAccess', _33 => _33.cancel, 'call', _34 => _34(reason)]);
+      } finally {
+      }
+    }
+  });
+  const startPump = () => {
+    if (started) {
+      return;
+    }
+    started = true;
+    reader = originalBody.getReader();
+    void (async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            _optionalChain([controller, 'optionalAccess', _35 => _35.close, 'call', _36 => _36()]);
+            return;
+          }
+          if (value) {
+            capture.read = true;
+            capture.buffer.write(value);
+            _optionalChain([controller, 'optionalAccess', _37 => _37.enqueue, 'call', _38 => _38(value)]);
+          }
+        }
+      } catch (err) {
+        _optionalChain([controller, 'optionalAccess', _39 => _39.error, 'call', _40 => _40(err)]);
+      }
+    })();
+  };
+  const originalGetReader = wrappedStream.getReader.bind(wrappedStream);
+  wrappedStream.getReader = (...args) => {
+    startPump();
+    return originalGetReader(...args);
+  };
+  const init = {
+    body: wrappedStream,
+    cache: request.cache,
+    credentials: request.credentials,
+    headers: request.headers,
+    integrity: request.integrity,
+    keepalive: request.keepalive,
+    method: request.method,
+    mode: request.mode,
+    redirect: request.redirect,
+    referrer: request.referrer,
+    referrerPolicy: request.referrerPolicy,
+    signal: request.signal
+  };
+  if (isNodeRuntime()) {
+    init.duplex = "half";
+  }
+  const wrappedRequest = new Request(request.url, init);
+  return { capture, request: wrappedRequest };
+}
+async function captureRequestClone(request, limit, xray) {
+  if (limit <= 0 || !request.body || request.bodyUsed) {
+    return null;
+  }
+  let clone;
+  try {
+    clone = request.clone();
+  } catch (e2) {
+    _chunkJKW6E4L3cjs.logWithLevel.call(void 0, xray.config.logger, "warn", xray.config.logLevel, "xray: request clone failed");
+    return null;
+  }
+  const buffer = new (0, _chunkGNSXLLECcjs.LimitedBuffer)(limit);
+  await readStreamToBuffer(clone.body, buffer);
+  return buffer;
+}
+async function captureResponseClone(response, limit, xray) {
+  if (limit <= 0 || !response.body || response.bodyUsed) {
+    return null;
+  }
+  let clone;
+  try {
+    clone = response.clone();
+  } catch (e3) {
+    _chunkJKW6E4L3cjs.logWithLevel.call(void 0, xray.config.logger, "warn", xray.config.logLevel, "xray: response clone failed");
+    return null;
+  }
+  const buffer = new (0, _chunkGNSXLLECcjs.LimitedBuffer)(limit);
+  await readStreamToBuffer(clone.body, buffer);
+  return buffer;
+}
+async function readStreamToBuffer(stream, buffer) {
+  if (!stream) {
+    return;
+  }
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return;
+      }
+      if (value) {
+        buffer.write(value);
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch (e4) {
+    }
+  }
+}
+function wrapReadableStream(stream, capture, onFinish, onError) {
+  const reader = stream.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          onFinish();
+          try {
+            reader.releaseLock();
+          } catch (e5) {
+          }
+          return;
+        }
+        if (value) {
+          capture.write(value);
+          controller.enqueue(value);
+        }
+      } catch (err) {
+        controller.error(err);
+        _optionalChain([onError, 'optionalCall', _41 => _41(err)]);
+        onFinish();
+        try {
+          reader.releaseLock();
+        } catch (e6) {
+        }
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        onFinish();
+        try {
+          reader.releaseLock();
+        } catch (e7) {
+        }
+      }
+    }
+  });
+}
+function finalizeResponse(ctx, xray, normalizedRequest, capture, requestCapture, responseHeaders, statusCode, responseCapture) {
+  if (requestCapture) {
+    const buffer = requestCapture instanceof _chunkGNSXLLECcjs.LimitedBuffer ? requestCapture : requestCapture.buffer;
+    const read = requestCapture instanceof _chunkGNSXLLECcjs.LimitedBuffer ? true : requestCapture.read;
+    if (read) {
+      normalizedRequest.body = _chunkJKW6E4L3cjs.makeCapturedBody.call(void 0, 
+        buffer.bytes(),
+        buffer.totalBytes(),
+        buffer.truncated(),
+        capture.requestBody === "text" ? "text" : "base64"
+      );
+    }
+  }
+  const responseBody = responseCapture ? _chunkJKW6E4L3cjs.makeCapturedBody.call(void 0, 
+    responseCapture.bytes(),
+    responseCapture.totalBytes(),
+    responseCapture.truncated(),
+    capture.responseBody === "text" ? "text" : "base64"
+  ) : void 0;
+  return xray.endRequest(ctx, {
+    statusCode,
+    headers: _chunkGNSXLLECcjs.headerValuesFromFetchHeaders.call(void 0, responseHeaders),
+    body: responseBody,
+    endTimeMs: Date.now()
+  });
+}
+function ensureResponseRequestIdHeaders(headers, ctx, xray) {
+  const headerName = xray.config.requestId.header;
+  const existing = normalizeRequestIdCandidate(_nullishCoalesce(headers.get(headerName), () => ( void 0)));
+  if (existing) {
+    return { value: existing, set: false };
+  }
+  const explicit = normalizeRequestIdCandidate(ctx.requestId);
+  if (explicit) {
+    headers.set(canonicalHeaderName(headerName), explicit);
+    return { value: explicit, set: true };
+  }
+  const generated = _chunkJKW6E4L3cjs.generateRequestId.call(void 0, );
+  headers.set(canonicalHeaderName(headerName), generated);
+  _chunkGNSXLLECcjs.setContextRequestId.call(void 0, ctx, generated);
+  return { value: generated, set: true };
+}
+function isNodeRuntime() {
+  const maybeProcess = globalThis.process;
+  return !!_optionalChain([maybeProcess, 'optionalAccess', _42 => _42.versions, 'optionalAccess', _43 => _43.node]);
+}
+function normalizeRequestIdCandidate(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function canonicalHeaderName(headerName) {
+  return headerName.split("-").filter(Boolean).map((part) => part ? part[0].toUpperCase() + part.slice(1) : part).join("-");
+}
+
+
+
+
+
+
+exports.createEmitter = createEmitter2; exports.wrapFetch = wrapFetch; exports.wrapFetchPreserve = wrapFetchPreserve; exports.getXrayContext = getXrayContext;
+//# sourceMappingURL=chunk-AHXNYJ5A.cjs.map