@stainlessdev/xray-core 0.5.0-dev.ce9d113 → 0.5.1-branch.bg-client-ip-addr.341865f

package/dist/index.cjs

@@ -768,23 +768,226 @@ function setHeaderAttributes(span, headers, prefix) {
     span.setAttribute(prefix + key.toLowerCase(), Array.isArray(values) ? values : [values]);
   }
 }
-function setRequestAttributes(span, method, urlFull) {
-  span.setAttribute(import_incubating.ATTR_HTTP_REQUEST_METHOD, method);
-  if (urlFull) {
-    span.setAttribute(import_incubating.ATTR_URL_FULL, urlFull);
-    const path = extractPath(urlFull);
+function setRequestAttributes(span, request, urlFull) {
+  span.setAttribute(import_incubating.ATTR_HTTP_REQUEST_METHOD, request.method);
+  const effectiveUrl = urlFull ?? request.url;
+  if (effectiveUrl) {
+    span.setAttribute(import_incubating.ATTR_URL_FULL, effectiveUrl);
+    const scheme = extractScheme(effectiveUrl);
+    if (scheme) {
+      span.setAttribute(import_incubating.ATTR_URL_SCHEME, scheme);
+    }
+    const path = extractPath(effectiveUrl);
     if (path) {
       span.setAttribute(import_incubating.ATTR_URL_PATH, path);
     }
+    const query = extractQuery(effectiveUrl);
+    if (query) {
+      span.setAttribute(import_incubating.ATTR_URL_QUERY, query);
+    }
+  }
+  const clientAddress = clientAddressForRequest(request.headers, request.remoteAddress);
+  if (clientAddress) {
+    span.setAttribute(import_incubating.ATTR_CLIENT_ADDRESS, clientAddress);
+  }
+  if (request.protocolVersion) {
+    span.setAttribute(import_incubating.ATTR_NETWORK_PROTOCOL_VERSION, request.protocolVersion);
+  }
+  const transport = networkTransportForRemoteAddress(request.remoteAddress);
+  if (transport) {
+    span.setAttribute(import_incubating.ATTR_NETWORK_TRANSPORT, transport);
   }
 }
 function extractPath(url) {
+  if (!url) {
+    return void 0;
+  }
   try {
-    return new URL(url).pathname;
+    const pathname = new URL(url).pathname;
+    return pathname || "/";
   } catch {
     const match = url.match(/^[^?#]*/);
-    return match?.[0] || void 0;
+    if (!match) {
+      return void 0;
+    }
+    return match[0] || "/";
+  }
+}
+function extractScheme(url) {
+  if (!url) {
+    return void 0;
+  }
+  try {
+    const protocol = new URL(url).protocol;
+    if (!protocol) {
+      return void 0;
+    }
+    const normalized = protocol.endsWith(":") ? protocol.slice(0, -1) : protocol;
+    return normalized || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function extractQuery(url) {
+  if (!url) {
+    return void 0;
+  }
+  try {
+    const query = new URL(url).search;
+    if (!query || query === "?") {
+      return void 0;
+    }
+    return query.startsWith("?") ? query.slice(1) : query;
+  } catch {
+    const match = url.match(/\?([^#]*)/);
+    if (!match) {
+      return void 0;
+    }
+    const value = match[1] ?? "";
+    return value ? value : void 0;
+  }
+}
+function clientAddressForRequest(headers, remoteAddress) {
+  const forwarded = forwardedClientAddress(headerValues(headers, "forwarded"));
+  if (forwarded) {
+    return forwarded;
+  }
+  const xForwarded = xForwardedForClientAddress(headerValues(headers, "x-forwarded-for"));
+  if (xForwarded) {
+    return xForwarded;
+  }
+  const xRealIp = xRealIpClientAddress(headerValues(headers, "x-real-ip"));
+  if (xRealIp) {
+    return xRealIp;
+  }
+  if (!remoteAddress) {
+    return void 0;
+  }
+  return remoteAddrHost(remoteAddress);
+}
+function forwardedClientAddress(values) {
+  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);
+        if (normalized) {
+          return normalized;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function xForwardedForClientAddress(values) {
+  for (const value of values) {
+    if (!value) {
+      continue;
+    }
+    const entries = value.split(",");
+    for (const entry of entries) {
+      const normalized = normalizeKnownAddress(entry);
+      if (normalized) {
+        return normalized;
+      }
+    }
+  }
+  return void 0;
+}
+function xRealIpClientAddress(values) {
+  for (const value of values) {
+    if (!value) {
+      continue;
+    }
+    const normalized = normalizeKnownAddress(value);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+function normalizeKnownAddress(value) {
+  const normalized = normalizeAddress(value);
+  if (!normalized) {
+    return void 0;
+  }
+  if (normalized.toLowerCase() === "unknown") {
+    return void 0;
+  }
+  return normalized;
+}
+function normalizeAddress(value) {
+  if (!value) {
+    return void 0;
+  }
+  let trimmed = value.trim();
+  if (!trimmed) {
+    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 networkTransportForRemoteAddress(remoteAddress) {
+  if (!remoteAddress) {
+    return void 0;
+  }
+  const trimmed = remoteAddress.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (trimmed.startsWith("/") || trimmed.startsWith("@")) {
+    return "unix";
   }
+  return "tcp";
 }
 function setRequestBodyAttributes(span, body) {
   if (!body.value) {
@@ -915,7 +1118,7 @@ function createSpanProcessor(mode, exporter) {
 }
 function sdkVersion() {
   if (true) {
-    return "0.5.0";
+    return "0.5.1";
   }
   return "unknown";
 }
@@ -1111,7 +1314,7 @@ function endRequest(config, ctx, res, err) {
   const span = state.span;
   if (span) {
     try {
-      setRequestAttributes(span, request.method, redacted.url);
+      setRequestAttributes(span, request, redacted.url);
       setRequestIdAttribute(span, redacted.requestId);
       span.setAttribute("service.name", config.serviceName);
       if (redacted.statusCode != null) {