@stainlessdev/xray-core 0.5.1 → 0.6.0-branch.bg-fix-req-id-gen.6d17621

package/dist/index.js

@@ -4,8 +4,9 @@ import {
   getContextState,
   logWithLevel,
   sanitizeHeaderValues,
-  sanitizeLogString
-} from "./chunk-XI5E6C7G.js";
+  sanitizeLogString,
+  uuidv7
+} from "./chunk-HGFCHC7O.js";
 
 // src/route.ts
 function normalizeRoutePattern(route) {
@@ -111,8 +112,7 @@ var defaultRedaction = {
   replacement: "[REDACTED]"
 };
 var defaultRequestId = {
-  header: "x-request-id",
-  generate: true
+  header: "request-id"
 };
 var defaultRoute = {
   normalize: true,
@@ -660,6 +660,7 @@ function redactJsonPath(value, segments, replacement) {
 
 // src/attributes.ts
 import {
+  ATTR_CLIENT_ADDRESS,
   ATTR_HTTP_REQUEST_BODY_SIZE,
   ATTR_HTTP_REQUEST_METHOD,
   ATTR_HTTP_RESPONSE_BODY_SIZE,
@@ -694,15 +695,24 @@ function setHeaderAttributes(span, headers, prefix) {
     span.setAttribute(prefix + key.toLowerCase(), Array.isArray(values) ? values : [values]);
   }
 }
-function setRequestAttributes(span, method, urlFull) {
-  span.setAttribute(ATTR_HTTP_REQUEST_METHOD, method);
-  if (urlFull) {
-    span.setAttribute(ATTR_URL_FULL, urlFull);
-    const path = extractPath(urlFull);
+function setRequestAttributes(span, request, urlFull) {
+  span.setAttribute(ATTR_HTTP_REQUEST_METHOD, request.method);
+  const effectiveUrl = urlFull ?? request.url;
+  if (effectiveUrl) {
+    span.setAttribute(ATTR_URL_FULL, effectiveUrl);
+    const path = extractPath(effectiveUrl);
     if (path) {
       span.setAttribute(ATTR_URL_PATH, path);
     }
   }
+  const clientAddress = clientAddressForRequest(
+    request.headers,
+    request.remoteAddress,
+    request.redactionReplacement
+  );
+  if (clientAddress) {
+    span.setAttribute(ATTR_CLIENT_ADDRESS, clientAddress);
+  }
 }
 function extractPath(url) {
   try {
@@ -712,6 +722,144 @@ function extractPath(url) {
     return match?.[0] || void 0;
   }
 }
+function clientAddressForRequest(headers, remoteAddress, redactionReplacement) {
+  const forwarded = forwardedClientAddress(
+    headerValues(headers, "forwarded"),
+    redactionReplacement
+  );
+  if (forwarded) {
+    return forwarded;
+  }
+  const xForwarded = xForwardedForClientAddress(
+    headerValues(headers, "x-forwarded-for"),
+    redactionReplacement
+  );
+  if (xForwarded) {
+    return xForwarded;
+  }
+  const xRealIp = xRealIpClientAddress(headerValues(headers, "x-real-ip"), redactionReplacement);
+  if (xRealIp) {
+    return xRealIp;
+  }
+  if (!remoteAddress) {
+    return void 0;
+  }
+  return remoteAddrHost(remoteAddress);
+}
+function forwardedClientAddress(values, redactionReplacement) {
+  for (const value of values) {
+    if (!value) {
+      continue;
+    }
+    const entries = value.split(",");
+    for (const entry of entries) {
+      const params = entry.split(";");
+      for (const param of params) {
+        const [rawKey, ...rest] = param.split("=");
+        if (!rawKey) {
+          continue;
+        }
+        if (rawKey.trim().toLowerCase() !== "for") {
+          continue;
+        }
+        const rawValue = rest.join("=").trim();
+        const normalized = normalizeKnownAddress(rawValue, redactionReplacement);
+        if (normalized) {
+          return normalized;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function xForwardedForClientAddress(values, redactionReplacement) {
+  for (const value of values) {
+    if (!value) {
+      continue;
+    }
+    const entries = value.split(",");
+    for (const entry of entries) {
+      const normalized = normalizeKnownAddress(entry, redactionReplacement);
+      if (normalized) {
+        return normalized;
+      }
+    }
+  }
+  return void 0;
+}
+function xRealIpClientAddress(values, redactionReplacement) {
+  for (const value of values) {
+    if (!value) {
+      continue;
+    }
+    const normalized = normalizeKnownAddress(value, redactionReplacement);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+function normalizeKnownAddress(value, redactionReplacement) {
+  const normalized = normalizeAddress(value, redactionReplacement);
+  if (!normalized) {
+    return void 0;
+  }
+  if (normalized.toLowerCase() === "unknown") {
+    return void 0;
+  }
+  return normalized;
+}
+function normalizeAddress(value, redactionReplacement) {
+  if (!value) {
+    return void 0;
+  }
+  let trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (redactionReplacement && trimmed === redactionReplacement) {
+    return void 0;
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length > 1) {
+    trimmed = trimmed.slice(1, -1).trim();
+  }
+  if (!trimmed) {
+    return void 0;
+  }
+  if (trimmed.startsWith("[")) {
+    const end = trimmed.indexOf("]");
+    if (end !== -1) {
+      return trimmed.slice(1, end);
+    }
+  }
+  const colonCount = (trimmed.match(/:/g) ?? []).length;
+  if (colonCount === 1) {
+    const host = trimmed.split(":")[0];
+    return host || void 0;
+  }
+  return trimmed;
+}
+function remoteAddrHost(value) {
+  return normalizeAddress(value);
+}
+function headerValues(headers, name) {
+  if (!headers) {
+    return [];
+  }
+  const target = name.toLowerCase();
+  const values = [];
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== target) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      values.push(...value);
+    } else {
+      values.push(value);
+    }
+  }
+  return values;
+}
 function setRequestBodyAttributes(span, body) {
   if (!body.value) {
     return;
@@ -856,7 +1004,7 @@ function createSpanProcessor(mode, exporter) {
 }
 function sdkVersion() {
   if (true) {
-    return "0.5.0";
+    return "0.6.0";
   }
   return "unknown";
 }
@@ -865,25 +1013,6 @@ function isNodeRuntime() {
   return !!maybeProcess?.versions?.node;
 }
 
-// src/uuid.ts
-function uuidv7() {
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-  const timestamp = BigInt(Date.now());
-  bytes[0] = Number(timestamp >> 40n & 0xffn);
-  bytes[1] = Number(timestamp >> 32n & 0xffn);
-  bytes[2] = Number(timestamp >> 24n & 0xffn);
-  bytes[3] = Number(timestamp >> 16n & 0xffn);
-  bytes[4] = Number(timestamp >> 8n & 0xffn);
-  bytes[5] = Number(timestamp & 0xffn);
-  const byte6 = bytes[6] ?? 0;
-  const byte8 = bytes[8] ?? 0;
-  bytes[6] = byte6 & 15 | 112;
-  bytes[8] = byte8 & 63 | 128;
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
-  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
-}
-
 // src/emitter.ts
 function createEmitter(config, exporter) {
   const resolved = normalizeConfig(config);
@@ -913,14 +1042,14 @@ function createEmitter(config, exporter) {
 function startRequest(config, tracer, req) {
   const startTimeMs = Number.isFinite(req.startTimeMs) ? req.startTimeMs : Date.now();
   req.startTimeMs = startTimeMs;
-  const requestId = resolveRequestId(config, req.requestId, req.headers);
-  req.requestId = requestId;
+  const explicitRequestId = normalizeRequestIdCandidate(req.requestId);
+  req.requestId = explicitRequestId;
   if (req.route && config.route.normalize) {
     req.route = config.route.normalizer ? config.route.normalizer(req.route) : normalizeRoutePattern(req.route);
   }
   const span = spanFromTracer(tracer, spanNameFromRequest(req));
   const context = {
-    requestId,
+    requestId: explicitRequestId ?? "",
     traceId: span?.spanContext().traceId,
     spanId: span?.spanContext().spanId,
     setUserId: (id) => {
@@ -999,8 +1128,10 @@ function endRequest(config, ctx, res, err) {
   const endTimeMs = Number.isFinite(res.endTimeMs) ? res.endTimeMs : Date.now();
   res.endTimeMs = endTimeMs;
   if (!state) {
+    const resolvedRequestId2 = resolveFinalRequestId(config, ctx.requestId, res.headers);
+    ctx.requestId = resolvedRequestId2;
     const fallbackLog = {
-      requestId: ctx.requestId,
+      requestId: resolvedRequestId2,
       serviceName: config.serviceName,
       method: res.statusCode ? "UNKNOWN" : "UNKNOWN",
       url: "",
@@ -1011,12 +1142,19 @@ function endRequest(config, ctx, res, err) {
     return fallbackLog;
   }
   const request = state.request;
+  const resolvedRequestId = resolveFinalRequestId(
+    config,
+    request.requestId || ctx.requestId,
+    res.headers
+  );
+  request.requestId = resolvedRequestId;
+  ctx.requestId = resolvedRequestId;
   const capture = resolveCapture(config.capture, state.captureOverride);
   const redaction = resolveRedaction(config.redaction, state.redactionOverride);
   const route = request.route;
   const url = sanitizeLogString(request.url);
   const log = {
-    requestId: request.requestId ?? ctx.requestId,
+    requestId: resolvedRequestId,
     traceId: state.span?.spanContext().traceId,
     spanId: state.span?.spanContext().spanId,
     serviceName: config.serviceName,
@@ -1043,7 +1181,16 @@ function endRequest(config, ctx, res, err) {
   const span = state.span;
   if (span) {
     try {
-      setRequestAttributes(span, request.method, redacted.url);
+      const clientAddressHeaders = redactHeaders(request.headers, redaction);
+      setRequestAttributes(
+        span,
+        {
+          ...request,
+          headers: clientAddressHeaders,
+          redactionReplacement: redaction.replacement
+        },
+        redacted.url
+      );
       setRequestIdAttribute(span, redacted.requestId);
       span.setAttribute("service.name", config.serviceName);
       if (redacted.statusCode != null) {
@@ -1084,22 +1231,40 @@ function endRequest(config, ctx, res, err) {
   }
   return redacted;
 }
-function resolveRequestId(config, requestId, headers) {
-  if (requestId) {
-    return requestId;
+function resolveFinalRequestId(config, explicitRequestId, responseHeaders) {
+  const explicit = normalizeRequestIdCandidate(explicitRequestId);
+  if (explicit) {
+    return explicit;
   }
-  const headerName = config.requestId.header.toLowerCase();
-  const headerValue = headers[headerName];
+  const headerValue = resolveHeaderRequestId(config.requestId.header, responseHeaders);
   if (headerValue) {
-    const value = Array.isArray(headerValue) ? headerValue[0] : headerValue;
-    if (value && value.trim()) {
-      return value.trim();
+    return headerValue;
+  }
+  return uuidv7();
+}
+function resolveHeaderRequestId(headerName, headers) {
+  if (!headers) {
+    return void 0;
+  }
+  const target = headerName.toLowerCase();
+  for (const [name, value] of Object.entries(headers)) {
+    if (name.toLowerCase() !== target) {
+      continue;
+    }
+    const entry = Array.isArray(value) ? value[0] : value;
+    const normalized = normalizeRequestIdCandidate(entry);
+    if (normalized) {
+      return normalized;
     }
   }
-  if (!config.requestId.generate) {
-    return uuidv7();
+  return void 0;
+}
+function normalizeRequestIdCandidate(value) {
+  if (!value) {
+    return void 0;
   }
-  return uuidv7();
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
 }
 function resolveCapture(base, override) {
   if (!override) {