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

package/dist/chunk-QUH3LJ5M.cjs

@@ -0,0 +1,634 @@
+"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/node/emitter.ts
+var _exportertraceotlpproto = require('@opentelemetry/exporter-trace-otlp-proto');
+function createEmitter2(config) {
+  const resolved = _chunk3MVVO5I7cjs.normalizeConfig.call(void 0, config);
+  const exporter = _nullishCoalesce(_optionalChain([config, 'access', _ => _.exporter, 'optionalAccess', _2 => _2.instance]), () => ( new (0, _exportertraceotlpproto.OTLPTraceExporter)({
+    url: resolved.exporter.endpointUrl,
+    headers: _nullishCoalesce(resolved.exporter.headers, () => ( {})),
+    timeoutMillis: resolved.exporter.timeoutMs
+  })));
+  return _chunk3MVVO5I7cjs.createEmitter.call(void 0, config, exporter);
+}
+
+// src/node/adapter.ts
+var _tls = require('tls');
+function wrapHttpHandler(handler, xray, options) {
+  return (req, res) => {
+    const normalizedRequest = {
+      method: _nullishCoalesce(req.method, () => ( "GET")),
+      url: fullUrl(req),
+      route: _optionalChain([options, 'optionalAccess', _3 => _3.route]),
+      headers: _chunkGNSXLLECcjs.headerValuesFromNodeHeaders.call(void 0, 
+        req.headers
+      ),
+      requestId: _optionalChain([options, 'optionalAccess', _4 => _4.requestId]),
+      remoteAddress: _optionalChain([req, 'access', _5 => _5.socket, 'optionalAccess', _6 => _6.remoteAddress]),
+      startTimeMs: Date.now()
+    };
+    trackExpressParams(req);
+    const ctx = xray.startRequest(normalizedRequest);
+    _chunkGNSXLLECcjs.bindContextToObject.call(void 0, req, ctx);
+    _chunkGNSXLLECcjs.bindContextToObject.call(void 0, res, 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 recorder = new ResponseRecorder(
+      capture.responseBody !== "none",
+      capture.maxBodyBytes,
+      (response) => {
+        ensureResponseRequestId(response, ctx, xray);
+      }
+    );
+    recorder.wrap(res);
+    let finished = false;
+    let capturedError;
+    let onErrorCalled = false;
+    const finish = () => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      if (!normalizedRequest.route) {
+        const route = resolveExpressRoute(req);
+        if (route) {
+          normalizedRequest.route = route;
+        }
+      }
+      if (requestCapture && requestCapture.read) {
+        normalizedRequest.body = _chunkJKW6E4L3cjs.makeCapturedBody.call(void 0, 
+          requestCapture.buffer.bytes(),
+          requestCapture.buffer.totalBytes(),
+          requestCapture.buffer.truncated(),
+          capture.requestBody === "text" ? "text" : "base64"
+        );
+      }
+      const responseHeaders = recorder.headersSnapshot(res.getHeaders());
+      const recordedStatus = _nullishCoalesce(recorder.statusCode(), () => ( res.statusCode));
+      const statusCode = capturedError && !recorder.hasWrittenHeader() ? 500 : recordedStatus;
+      const isUpgrade = _chunkGNSXLLECcjs.isWebsocketUpgrade.call(void 0, 
+        _nullishCoalesce(statusCode, () => ( 0)),
+        normalizedRequest.headers,
+        responseHeaders
+      );
+      const responseBody = recorder.bodyCaptured() && !isUpgrade ? _chunkJKW6E4L3cjs.makeCapturedBody.call(void 0, 
+        recorder.body(),
+        recorder.totalBytes(),
+        recorder.truncated(),
+        capture.responseBody === "text" ? "text" : "base64"
+      ) : void 0;
+      const normalizedResponse = {
+        statusCode: _nullishCoalesce(statusCode, () => ( void 0)),
+        headers: responseHeaders,
+        body: responseBody,
+        endTimeMs: Date.now()
+      };
+      const log = xray.endRequest(ctx, normalizedResponse, capturedError);
+      if (capturedError && _optionalChain([options, 'optionalAccess', _13 => _13.onError]) && !onErrorCalled) {
+        onErrorCalled = true;
+        try {
+          options.onError(ctx, capturedError);
+        } catch (err) {
+          _chunkJKW6E4L3cjs.logWithLevel.call(void 0, xray.config.logger, "warn", xray.config.logLevel, "xray: onError failed", {
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      if (_optionalChain([options, 'optionalAccess', _14 => _14.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)
+            }
+          );
+        }
+      }
+    };
+    res.once("finish", finish);
+    res.once("close", finish);
+    try {
+      const result = handler(req, res);
+      if (result && typeof result.catch === "function") {
+        void result.catch((err) => {
+          capturedError = err;
+          if (_optionalChain([options, 'optionalAccess', _15 => _15.onError]) && !onErrorCalled) {
+            onErrorCalled = true;
+            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)
+                }
+              );
+            }
+          }
+        });
+      }
+    } catch (err) {
+      capturedError = err;
+      if (_optionalChain([options, 'optionalAccess', _16 => _16.onError]) && !onErrorCalled) {
+        onErrorCalled = true;
+        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)
+          });
+        }
+      }
+      throw err;
+    }
+  };
+}
+function getXrayContext(req) {
+  return _chunkGNSXLLECcjs.getXrayContextFromObject.call(void 0, req);
+}
+function wrapRequestBody(req, limit) {
+  if (limit <= 0) {
+    return null;
+  }
+  if (!hasRequestBody(req)) {
+    return null;
+  }
+  const capture = {
+    buffer: new (0, _chunkGNSXLLECcjs.LimitedBuffer)(limit),
+    read: false,
+    userConsuming: false
+  };
+  const originalPush = req.push;
+  req.push = function push(chunk, encoding) {
+    if (chunk != null) {
+      recordChunk(capture, chunk, encoding);
+    }
+    return originalPush.call(req, chunk, encoding);
+  };
+  const originalEmit = req.emit;
+  req.emit = function emit(event, ...args) {
+    if (event === "data" && capture.userConsuming && args[0] != null) {
+      capture.read = true;
+    }
+    if (event === "end" && capture.userConsuming) {
+      capture.read = true;
+    }
+    return originalEmit.call(req, event, ...args);
+  };
+  const originalOn = req.on;
+  req.on = function on(event, listener) {
+    if (event === "data" || event === "readable") {
+      capture.userConsuming = true;
+    }
+    return originalOn.call(req, event, listener);
+  };
+  const originalOnce = req.once;
+  req.once = function once(event, listener) {
+    if (event === "data" || event === "readable") {
+      capture.userConsuming = true;
+    }
+    return originalOnce.call(req, event, listener);
+  };
+  const originalAddListener = req.addListener;
+  req.addListener = function addListener(event, listener) {
+    if (event === "data" || event === "readable") {
+      capture.userConsuming = true;
+    }
+    return originalAddListener.call(req, event, listener);
+  };
+  const originalPipe = req.pipe;
+  req.pipe = function pipe(destination, options) {
+    capture.userConsuming = true;
+    return originalPipe.call(req, destination, options);
+  };
+  const originalRead = req.read;
+  req.read = function read(size) {
+    capture.userConsuming = true;
+    const chunk = originalRead.call(req, size);
+    const readableFlowing = req.readableFlowing;
+    const hasDataListeners = typeof req.listenerCount === "function" && req.listenerCount("data") > 0;
+    if (!hasDataListeners && readableFlowing !== true && chunk != null) {
+      capture.read = true;
+    }
+    return chunk;
+  };
+  return capture;
+}
+function hasRequestBody(req) {
+  if (req.headers["content-length"] != null) {
+    return true;
+  }
+  if (req.headers["transfer-encoding"] != null) {
+    return true;
+  }
+  return false;
+}
+function recordChunk(capture, chunk, encoding) {
+  const bytes = toBytes(chunk, encoding);
+  if (!bytes) {
+    return;
+  }
+  capture.buffer.write(bytes);
+}
+function toBytes(chunk, encoding) {
+  if (chunk == null) {
+    return null;
+  }
+  if (typeof chunk === "string") {
+    return Buffer.from(chunk, encoding);
+  }
+  if (chunk instanceof Uint8Array) {
+    return chunk;
+  }
+  if (chunk instanceof ArrayBuffer) {
+    return new Uint8Array(chunk);
+  }
+  return null;
+}
+var ResponseRecorder = class {
+  constructor(captureBody, maxBodySize, onHeader) {
+    this.wroteHeader = false;
+    this.bytes = 0;
+    this.buffer = captureBody ? new (0, _chunkGNSXLLECcjs.LimitedBuffer)(maxBodySize) : null;
+    this.onHeader = onHeader;
+  }
+  body() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _17 => _17.buffer, 'optionalAccess', _18 => _18.bytes, 'call', _19 => _19()]), () => ( new Uint8Array()));
+  }
+  totalBytes() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _20 => _20.buffer, 'optionalAccess', _21 => _21.totalBytes, 'call', _22 => _22()]), () => ( 0));
+  }
+  bodyCaptured() {
+    return !!this.buffer && this.buffer.totalBytes() > 0;
+  }
+  bytesWritten() {
+    return this.bytes;
+  }
+  hasWrittenHeader() {
+    return this.wroteHeader;
+  }
+  headersSnapshot(defaultHeaders) {
+    if (this.headerSnapshot) {
+      return _chunkGNSXLLECcjs.headerValuesFromNodeHeaders.call(void 0, this.headerSnapshot);
+    }
+    return _chunkGNSXLLECcjs.headerValuesFromNodeHeaders.call(void 0, defaultHeaders);
+  }
+  statusCode() {
+    return this.status;
+  }
+  truncated() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _23 => _23.buffer, 'optionalAccess', _24 => _24.truncated, 'call', _25 => _25()]), () => ( false));
+  }
+  wrap(res) {
+    const originalWriteHead = res.writeHead;
+    res.writeHead = ((statusCode, ...args) => {
+      if (!this.wroteHeader) {
+        this.applyWriteHeadHeaders(res, args);
+      }
+      this.recordHeader(res, statusCode);
+      return originalWriteHead.call(res, statusCode, ...args);
+    });
+    const originalWrite = res.write;
+    res.write = ((chunk, encoding, cb) => {
+      this.recordHeader(res, _nullishCoalesce(res.statusCode, () => ( 200)));
+      this.recordWrite(chunk, encoding);
+      return originalWrite.call(res, chunk, encoding, cb);
+    });
+    const originalEnd = res.end;
+    res.end = ((chunk, encoding, cb) => {
+      this.recordHeader(res, _nullishCoalesce(res.statusCode, () => ( 200)));
+      if (chunk) {
+        this.recordWrite(chunk, encoding);
+      }
+      return originalEnd.call(res, chunk, encoding, cb);
+    });
+    if (typeof res.flushHeaders === "function") {
+      const originalFlush = res.flushHeaders;
+      res.flushHeaders = (() => {
+        this.recordHeader(res, _nullishCoalesce(res.statusCode, () => ( 200)));
+        return originalFlush.call(res);
+      });
+    }
+  }
+  recordHeader(res, statusCode) {
+    if (this.wroteHeader) {
+      return;
+    }
+    _optionalChain([this, 'access', _26 => _26.onHeader, 'optionalCall', _27 => _27(res)]);
+    this.wroteHeader = true;
+    this.status = statusCode;
+    this.headerSnapshot = { ...res.getHeaders() };
+  }
+  applyWriteHeadHeaders(res, args) {
+    if (args.length === 0) {
+      return;
+    }
+    const headersArg = typeof args[0] === "string" ? args[1] : args[0];
+    if (!headersArg) {
+      return;
+    }
+    if (Array.isArray(headersArg)) {
+      if (headersArg.length === 0) {
+        return;
+      }
+      if (typeof headersArg[0] === "string") {
+        for (let i = 0; i < headersArg.length - 1; i += 2) {
+          const name = headersArg[i];
+          const value = headersArg[i + 1];
+          if (typeof name === "string" && value !== void 0 && value !== null) {
+            res.setHeader(name, value);
+          }
+        }
+        return;
+      }
+      for (const entry of headersArg) {
+        if (!Array.isArray(entry)) {
+          continue;
+        }
+        const [name, value] = entry;
+        if (typeof name === "string" && value !== void 0 && value !== null) {
+          res.setHeader(name, value);
+        }
+      }
+      return;
+    }
+    if (typeof headersArg === "object") {
+      for (const [name, value] of Object.entries(headersArg)) {
+        if (value !== void 0 && value !== null) {
+          res.setHeader(name, value);
+        }
+      }
+    }
+  }
+  recordWrite(chunk, encoding) {
+    const bytes = toBytes(chunk, encoding);
+    if (!bytes) {
+      return;
+    }
+    this.bytes += bytes.length;
+    if (this.buffer) {
+      this.buffer.write(bytes);
+    }
+  }
+};
+function ensureResponseRequestId(res, ctx, xray) {
+  const headerName = xray.config.requestId.header;
+  const existing = headerValueFromNode(res.getHeader(headerName));
+  if (existing) {
+    return;
+  }
+  const explicit = normalizeRequestIdCandidate(ctx.requestId);
+  if (explicit) {
+    res.setHeader(canonicalHeaderName(headerName), explicit);
+    return;
+  }
+  const generated = _chunkJKW6E4L3cjs.generateRequestId.call(void 0, );
+  res.setHeader(canonicalHeaderName(headerName), generated);
+  _chunkGNSXLLECcjs.setContextRequestId.call(void 0, ctx, generated);
+}
+function fullUrl(req) {
+  const requestUrl = resolveRequestUrl(req);
+  if (!requestUrl) {
+    return "";
+  }
+  if (requestUrl.startsWith("http://") || requestUrl.startsWith("https://")) {
+    return requestUrl;
+  }
+  const host = req.headers["host"];
+  if (!host || typeof host !== "string") {
+    return requestUrl;
+  }
+  const scheme = req.socket instanceof _tls.TLSSocket ? "https" : "http";
+  return `${scheme}://${host}${requestUrl}`;
+}
+function resolveRequestUrl(req) {
+  const requestUrl = _nullishCoalesce(req.url, () => ( ""));
+  if (requestUrl.startsWith("http://") || requestUrl.startsWith("https://")) {
+    return requestUrl;
+  }
+  const expressReq = req;
+  if (typeof expressReq.originalUrl === "string" && expressReq.originalUrl.length > 0) {
+    return expressReq.originalUrl;
+  }
+  return requestUrl;
+}
+function headerValueFromNode(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return normalizeRequestIdCandidate(value[0]);
+  }
+  return normalizeRequestIdCandidate(`${value}`);
+}
+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("-");
+}
+var expressParamsHistory = /* @__PURE__ */ new WeakMap();
+function trackExpressParams(req) {
+  if (expressParamsHistory.has(req)) {
+    return;
+  }
+  const anyReq = req;
+  if (typeof anyReq.app !== "function") {
+    return;
+  }
+  const history = [];
+  expressParamsHistory.set(req, history);
+  const descriptor = Object.getOwnPropertyDescriptor(req, "params");
+  if (descriptor && !descriptor.configurable) {
+    if (descriptor.value && typeof descriptor.value === "object") {
+      history.push({ ...descriptor.value });
+    }
+    return;
+  }
+  let current = descriptor && "value" in descriptor ? descriptor.value : void 0;
+  if (current && typeof current === "object") {
+    history.push({ ...current });
+  }
+  Object.defineProperty(req, "params", {
+    configurable: true,
+    enumerable: _nullishCoalesce(_optionalChain([descriptor, 'optionalAccess', _28 => _28.enumerable]), () => ( true)),
+    get() {
+      return current;
+    },
+    set(value) {
+      current = value;
+      if (value && typeof value === "object") {
+        history.push({ ...value });
+      }
+    }
+  });
+}
+function resolveExpressRoute(req) {
+  const anyReq = req;
+  const routePath = extractExpressRoutePath(_optionalChain([anyReq, 'access', _29 => _29.route, 'optionalAccess', _30 => _30.path]));
+  const baseUrl = _nullishCoalesce(anyReq.baseUrl, () => ( ""));
+  if (!routePath && !baseUrl) {
+    return void 0;
+  }
+  const params = collectExpressParams(req, anyReq.params);
+  const resolvedBaseUrl = replaceBaseUrlParams(baseUrl, params, routePath);
+  return joinExpressRoute(resolvedBaseUrl, routePath);
+}
+function extractExpressRoutePath(path) {
+  if (typeof path === "string") {
+    return path;
+  }
+  if (Array.isArray(path)) {
+    for (const entry of path) {
+      if (typeof entry === "string") {
+        return entry;
+      }
+    }
+  }
+  return void 0;
+}
+function collectExpressParams(req, fallback) {
+  const history = expressParamsHistory.get(req);
+  if (!history || history.length === 0) {
+    return _nullishCoalesce(fallback, () => ( {}));
+  }
+  const merged = {};
+  for (const snapshot of history) {
+    for (const [key, value] of Object.entries(snapshot)) {
+      if (!(key in merged)) {
+        merged[key] = value;
+      }
+    }
+  }
+  if (fallback) {
+    for (const [key, value] of Object.entries(fallback)) {
+      if (!(key in merged)) {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+function replaceBaseUrlParams(baseUrl, params, routePath) {
+  if (!baseUrl) {
+    return baseUrl;
+  }
+  const entries = Object.entries(params);
+  if (entries.length === 0) {
+    return baseUrl;
+  }
+  const excluded = new Set(routePath ? extractExpressParamNames(routePath) : []);
+  const replacements = entries.filter(([name]) => !excluded.has(name)).map(([name, value]) => ({ name, value: Array.isArray(value) ? value[0] : value })).filter((entry) => !!entry.value);
+  if (replacements.length === 0) {
+    return baseUrl;
+  }
+  const used = /* @__PURE__ */ new Set();
+  const encodedCache = /* @__PURE__ */ new Map();
+  const segments = baseUrl.split("/");
+  const updated = segments.map((segment) => {
+    if (!segment) {
+      return segment;
+    }
+    for (const { name, value } of replacements) {
+      if (used.has(name)) {
+        continue;
+      }
+      const encodedValue = _nullishCoalesce(encodedCache.get(value), () => ( encodeURIComponent(value)));
+      encodedCache.set(value, encodedValue);
+      if (segment === value || segment === encodedValue) {
+        used.add(name);
+        return `:${name}`;
+      }
+    }
+    return segment;
+  });
+  return updated.join("/");
+}
+function extractExpressParamNames(path) {
+  const names = [];
+  const paramPattern = /:([A-Za-z0-9_]+)(?:\([^)]*\))?[?*+]?/g;
+  for (const match of path.matchAll(paramPattern)) {
+    const name = match[1];
+    if (name) {
+      names.push(name);
+    }
+  }
+  return names;
+}
+function joinExpressRoute(baseUrl, routePath) {
+  const base = baseUrl ? ensureLeadingSlash(baseUrl) : "";
+  const route = routePath ? ensureLeadingSlash(routePath) : "";
+  if (!base) {
+    return route || "/";
+  }
+  if (!route || route === "/") {
+    return base;
+  }
+  const trimmedBase = base.endsWith("/") ? base.slice(0, -1) : base;
+  return `${trimmedBase}${route}`;
+}
+function ensureLeadingSlash(path) {
+  if (!path) {
+    return "/";
+  }
+  return path.startsWith("/") ? path : `/${path}`;
+}
+
+
+
+
+
+exports.createEmitter = createEmitter2; exports.wrapHttpHandler = wrapHttpHandler; exports.getXrayContext = getXrayContext;
+//# sourceMappingURL=chunk-QUH3LJ5M.cjs.map