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

package/dist/chunk-2NR6RZEP.js

@@ -0,0 +1,1339 @@
+import {
+  bindContext,
+  encodeBase64,
+  generateRequestId,
+  getContextState,
+  logWithLevel,
+  sanitizeHeaderValues,
+  sanitizeLogString
+} from "./chunk-YVMMCTXW.js";
+
+// src/core/route.ts
+function normalizeRoutePattern(route) {
+  if (!route) {
+    return "/";
+  }
+  const cleaned = stripQueryAndFragment(route).trim();
+  if (!cleaned) {
+    return "/";
+  }
+  const withoutMethod = stripMethodPrefix(cleaned);
+  const leading = withoutMethod.startsWith("/") ? withoutMethod : `/${withoutMethod}`;
+  const segments = leading.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return "/";
+  }
+  const normalized = segments.map(normalizeRouteSegment).join("/");
+  return `/${normalized}`;
+}
+function stripMethodPrefix(value) {
+  if (!/^[A-Z]+\s+\//.test(value)) {
+    return value;
+  }
+  const spaceIndex = value.search(/\s+/);
+  if (spaceIndex < 0) {
+    return value;
+  }
+  return value.slice(spaceIndex).trim();
+}
+function stripQueryAndFragment(value) {
+  const hashIndex = value.indexOf("#");
+  const beforeHash = hashIndex >= 0 ? value.slice(0, hashIndex) : value;
+  const queryIndex = beforeHash.indexOf("?");
+  return queryIndex >= 0 ? beforeHash.slice(0, queryIndex) : beforeHash;
+}
+function normalizeRouteSegment(segment) {
+  if (segment === "*") {
+    return "{wildcard}";
+  }
+  const param = extractRouteParam(segment);
+  if (param) {
+    return `{${param}}`;
+  }
+  return segment;
+}
+function extractRouteParam(segment) {
+  if (!segment) {
+    return null;
+  }
+  if (segment.startsWith("[") && segment.endsWith("]")) {
+    return normalizeNextParam(segment);
+  }
+  if (segment.startsWith("{") && segment.endsWith("}")) {
+    const inner = segment.slice(1, -1);
+    const trimmed = stripParamDecorators(inner);
+    return extractParamName(trimmed);
+  }
+  if (segment.startsWith(":") || segment.startsWith("$")) {
+    return extractParamName(segment.slice(1));
+  }
+  return null;
+}
+function normalizeNextParam(segment) {
+  let inner = segment.slice(1, -1);
+  if (inner.startsWith("[") && inner.endsWith("]")) {
+    inner = inner.slice(1, -1);
+  }
+  if (inner.startsWith("...")) {
+    inner = inner.slice(3);
+  }
+  return extractParamName(inner);
+}
+function stripParamDecorators(value) {
+  let trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  if (trimmed.endsWith("...")) {
+    trimmed = trimmed.slice(0, -3);
+  }
+  return trimmed.replace(/[?*+]+$/, "");
+}
+function extractParamName(value) {
+  if (!value) {
+    return null;
+  }
+  const match = value.match(/^[A-Za-z0-9_-]+/);
+  return match?.[0] ?? null;
+}
+
+// src/core/config.ts
+var defaultCapture = {
+  requestHeaders: true,
+  responseHeaders: true,
+  requestBody: "text",
+  responseBody: "text",
+  maxBodyBytes: 65536
+};
+var defaultRedaction = {
+  headers: ["authorization", "cookie", "set-cookie", "x-api-key"],
+  queryParams: [],
+  bodyJsonPaths: [],
+  replacement: "[REDACTED]"
+};
+var defaultRequestId = {
+  header: "request-id"
+};
+var defaultRoute = {
+  normalize: true,
+  normalizer: normalizeRoutePattern
+};
+var defaultExporterBase = {
+  headers: {},
+  timeoutMs: 3e4,
+  spanProcessor: "batch"
+};
+var XrayConfigError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+function normalizeConfig(config) {
+  if (!config || !config.serviceName || !config.serviceName.trim()) {
+    throw new XrayConfigError("INVALID_CONFIG", "serviceName is required");
+  }
+  const logger = config.logger ?? console;
+  const logLevel = config.logLevel ?? "warn";
+  const capture = normalizeCapture(config.capture);
+  const redaction = normalizeRedaction(config.redaction);
+  const requestId = normalizeRequestId(config.requestId);
+  const route = normalizeRoute(config.route);
+  const exporter = normalizeExporter(config.endpointUrl, config.exporter);
+  return {
+    serviceName: config.serviceName.trim(),
+    environment: config.environment?.trim() || void 0,
+    version: config.version?.trim() || void 0,
+    logger,
+    logLevel,
+    exporter,
+    capture,
+    redaction,
+    requestId,
+    route
+  };
+}
+function normalizeCapture(cfg) {
+  const capture = {
+    ...defaultCapture,
+    ...cfg
+  };
+  if (!["none", "text", "base64"].includes(capture.requestBody)) {
+    throw new XrayConfigError(
+      "INVALID_CONFIG",
+      "capture.requestBody must be none, text, or base64"
+    );
+  }
+  if (!["none", "text", "base64"].includes(capture.responseBody)) {
+    throw new XrayConfigError(
+      "INVALID_CONFIG",
+      "capture.responseBody must be none, text, or base64"
+    );
+  }
+  if (!Number.isFinite(capture.maxBodyBytes) || capture.maxBodyBytes < 0) {
+    throw new XrayConfigError("INVALID_CONFIG", "capture.maxBodyBytes must be >= 0");
+  }
+  return capture;
+}
+function normalizeRedaction(cfg) {
+  const redaction = {
+    ...defaultRedaction,
+    ...cfg
+  };
+  redaction.headers = normalizeStringList(redaction.headers);
+  redaction.queryParams = normalizeStringList(redaction.queryParams);
+  redaction.bodyJsonPaths = normalizeStringList(redaction.bodyJsonPaths);
+  redaction.replacement = redaction.replacement || defaultRedaction.replacement;
+  if (!redaction.replacement) {
+    throw new XrayConfigError("INVALID_REDACTION", "redaction.replacement must be non-empty");
+  }
+  return redaction;
+}
+function normalizeRequestId(cfg) {
+  const requestId = {
+    ...defaultRequestId,
+    ...cfg
+  };
+  requestId.header = requestId.header.trim().toLowerCase();
+  if (!requestId.header) {
+    throw new XrayConfigError("INVALID_CONFIG", "requestId.header must be non-empty");
+  }
+  return requestId;
+}
+function normalizeRoute(cfg) {
+  const route = {
+    ...defaultRoute,
+    ...cfg
+  };
+  if (route.normalize && !route.normalizer) {
+    route.normalizer = normalizeRoutePattern;
+  }
+  return route;
+}
+function normalizeExporter(endpointUrl, cfg) {
+  const resolvedEndpoint = normalizeExporterEndpoint(cfg?.endpointUrl ?? endpointUrl);
+  const rawHeaders = cfg?.headers ?? defaultExporterBase.headers ?? {};
+  const parsed = applyEndpointAuth(resolvedEndpoint, rawHeaders);
+  const exporter = {
+    endpointUrl: parsed.endpointUrl,
+    headers: parsed.headers,
+    timeoutMs: cfg?.timeoutMs ?? defaultExporterBase.timeoutMs,
+    spanProcessor: cfg?.spanProcessor ?? defaultExporterBase.spanProcessor
+  };
+  return exporter;
+}
+function normalizeExporterEndpoint(endpointUrl) {
+  const envUrl = typeof process !== "undefined" ? process.env?.["STAINLESS_XRAY_ENDPOINT_URL"] : void 0;
+  const resolved = endpointUrl ?? envUrl;
+  if (!resolved || !resolved.trim()) {
+    throw new XrayConfigError(
+      "INVALID_CONFIG",
+      "endpointUrl is required (set endpointUrl or STAINLESS_XRAY_ENDPOINT_URL)"
+    );
+  }
+  const trimmed = resolved.trim();
+  const withoutTrailingSlash = trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+  if (withoutTrailingSlash.endsWith("/v1/traces")) {
+    return withoutTrailingSlash;
+  }
+  return `${withoutTrailingSlash}/v1/traces`;
+}
+function normalizeStringList(values) {
+  if (!values) {
+    return [];
+  }
+  return values.map((entry) => entry.trim()).filter(Boolean);
+}
+var textEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+var maybeBuffer = globalThis.Buffer;
+function applyEndpointAuth(endpointUrl, headers) {
+  const resolvedHeaders = headers ?? {};
+  let url;
+  try {
+    url = new URL(endpointUrl);
+  } catch {
+    return { endpointUrl, headers: resolvedHeaders };
+  }
+  const username = decodeUserInfo(url.username);
+  const password = decodeUserInfo(url.password);
+  if (!username && !password) {
+    return { endpointUrl, headers: resolvedHeaders };
+  }
+  url.username = "";
+  url.password = "";
+  const sanitizedUrl = url.toString();
+  if (hasAuthorizationHeader(resolvedHeaders)) {
+    return { endpointUrl: sanitizedUrl, headers: resolvedHeaders };
+  }
+  const authorization = encodeBasicAuth(username, password);
+  if (!authorization) {
+    return { endpointUrl: sanitizedUrl, headers: resolvedHeaders };
+  }
+  return {
+    endpointUrl: sanitizedUrl,
+    headers: {
+      ...resolvedHeaders,
+      Authorization: authorization
+    }
+  };
+}
+function decodeUserInfo(value) {
+  if (!value) {
+    return value;
+  }
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function hasAuthorizationHeader(headers) {
+  return Object.keys(headers).some((key) => key.toLowerCase() === "authorization");
+}
+function encodeBasicAuth(username, password) {
+  const raw = `${username}:${password}`;
+  let bytes;
+  if (textEncoder) {
+    bytes = textEncoder.encode(raw);
+  } else if (maybeBuffer) {
+    bytes = maybeBuffer.from(raw, "utf8");
+  }
+  if (!bytes) {
+    return void 0;
+  }
+  const encoded = encodeBase64(bytes);
+  if (!encoded) {
+    return void 0;
+  }
+  return `Basic ${encoded}`;
+}
+
+// src/core/header_redaction.ts
+var headerNameCompactor = /[-_.]/g;
+var defaultHeaderMatcher = newHeaderRedactionMatcher(
+  defaultSensitiveHeaderNames(),
+  defaultSensitiveKeywords()
+);
+function authSchemePrefix(value) {
+  if (!value) {
+    return "";
+  }
+  const lower = value.toLowerCase();
+  if (lower.startsWith("basic")) {
+    return value.slice(0, "basic".length);
+  }
+  if (lower.startsWith("bearer")) {
+    return value.slice(0, "bearer".length);
+  }
+  if (lower.startsWith("digest")) {
+    return value.slice(0, "digest".length);
+  }
+  if (lower.startsWith("negotiate")) {
+    return value.slice(0, "negotiate".length);
+  }
+  return "";
+}
+function redactCookieValue(value, replacement) {
+  if (!value) {
+    return replacement;
+  }
+  const parts = value.split(";");
+  const redacted = [];
+  for (const part of parts) {
+    const segment = part.trim();
+    if (!segment) {
+      redacted.push(replacement);
+      continue;
+    }
+    const idx = segment.indexOf("=");
+    if (idx <= 0) {
+      redacted.push(replacement);
+      continue;
+    }
+    const name = segment.slice(0, idx);
+    if (!name) {
+      redacted.push(replacement);
+      continue;
+    }
+    redacted.push(`${name}=${replacement}`);
+  }
+  return redacted.join("; ");
+}
+function redactSetCookieValue(value, replacement) {
+  if (!value) {
+    return replacement;
+  }
+  const parts = value.split(";");
+  const first = parts.shift() ?? "";
+  const idx = first.indexOf("=");
+  if (idx <= 0) {
+    return replacement;
+  }
+  const name = first.slice(0, idx);
+  if (!name) {
+    return replacement;
+  }
+  const redacted = `${name}=${replacement}`;
+  if (parts.length === 0) {
+    return redacted;
+  }
+  return `${redacted};${parts.join(";")}`;
+}
+function addSensitiveHeaderNames(target, headers) {
+  for (const header of headers) {
+    const normalized = normalizeHeaderName(header);
+    if (normalized) {
+      target.add(normalized);
+    }
+  }
+}
+function buildKeywordSets(keywords) {
+  const tokens = /* @__PURE__ */ new Set();
+  const compacted = /* @__PURE__ */ new Set();
+  for (const keyword of keywords) {
+    const normalized = normalizeHeaderName(keyword);
+    if (!normalized) {
+      continue;
+    }
+    const compactedKeyword = compactNormalizedHeaderName(normalized);
+    if (compactedKeyword) {
+      compacted.add(compactedKeyword);
+    }
+    if (!normalized.includes("-") && !normalized.includes("_") && !normalized.includes(".")) {
+      tokens.add(normalized);
+    }
+  }
+  return {
+    compacted: Array.from(compacted).sort(),
+    tokens
+  };
+}
+function compactNormalizedHeaderName(normalized) {
+  if (!normalized) {
+    return "";
+  }
+  return normalized.replace(headerNameCompactor, "");
+}
+function defaultSensitiveHeaderNames() {
+  return [
+    "authorization",
+    "cookie",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "set-cookie",
+    "www-authenticate"
+  ];
+}
+function defaultSensitiveKeywords() {
+  return [
+    "api-key",
+    "api_key",
+    "apikey",
+    "auth",
+    "authenticate",
+    "authorization",
+    "credential",
+    "password",
+    "passwd",
+    "private-key",
+    "private_key",
+    "privatekey",
+    "secret",
+    "session",
+    "sessionid",
+    "signature",
+    "token"
+  ];
+}
+function newHeaderRedactionMatcher(names, keywords) {
+  const exactSensitive = /* @__PURE__ */ new Set();
+  addSensitiveHeaderNames(exactSensitive, names);
+  const { compacted, tokens } = buildKeywordSets(keywords);
+  return {
+    exactSensitive,
+    keywordCompacted: compacted,
+    keywordTokens: tokens
+  };
+}
+function normalizeHeaderName(name) {
+  return name.trim().toLowerCase();
+}
+
+// src/core/redaction.ts
+function applyRedaction(config, log) {
+  const redacted = { ...log };
+  if (redacted.requestHeaders) {
+    redacted.requestHeaders = redactHeaders(redacted.requestHeaders, config);
+  }
+  if (redacted.responseHeaders) {
+    redacted.responseHeaders = redactHeaders(redacted.responseHeaders, config);
+  }
+  redacted.url = redactUrl(redacted.url, config);
+  if (redacted.requestBody) {
+    redacted.requestBody = redactBody(redacted.requestBody, redacted.requestHeaders, config);
+  }
+  if (redacted.responseBody) {
+    redacted.responseBody = redactBody(redacted.responseBody, redacted.responseHeaders, config);
+  }
+  return redacted;
+}
+function redactHeaders(headers, config) {
+  const list = new Set(config.headers.map((name) => name.toLowerCase()));
+  const result = {};
+  for (const [name, value] of Object.entries(headers)) {
+    const lower = name.toLowerCase();
+    if (!list.has(lower)) {
+      result[name] = value;
+      continue;
+    }
+    const redactValue = (entry) => redactHeaderValue(lower, entry, config.replacement);
+    if (Array.isArray(value)) {
+      result[name] = value.map(redactValue);
+    } else {
+      result[name] = redactValue(value);
+    }
+  }
+  return result;
+}
+function redactHeaderValue(name, value, replacement) {
+  switch (name) {
+    case "authorization":
+    case "proxy-authorization": {
+      const scheme = authSchemePrefix(value);
+      if (!scheme) {
+        return replacement;
+      }
+      return `${scheme} ${replacement}`;
+    }
+    case "cookie":
+      return redactCookieValue(value, replacement);
+    case "set-cookie":
+      return redactSetCookieValue(value, replacement);
+    default:
+      return replacement;
+  }
+}
+function redactUrl(value, config) {
+  if (!value || config.queryParams.length === 0) {
+    return value;
+  }
+  try {
+    const parsed = new URL(value);
+    const params = parsed.searchParams;
+    if (!params || params.size === 0) {
+      return value;
+    }
+    const redact = new Set(config.queryParams.map((key) => key.toLowerCase()));
+    const next = new URLSearchParams();
+    params.forEach((val, key) => {
+      if (redact.has(key.toLowerCase())) {
+        next.append(key, config.replacement);
+      } else {
+        next.append(key, val);
+      }
+    });
+    parsed.search = next.toString();
+    return parsed.toString();
+  } catch {
+    return value;
+  }
+}
+function redactBody(body, headers, config) {
+  if (config.bodyJsonPaths.length === 0) {
+    return body;
+  }
+  if (!body.value || body.encoding !== "utf8") {
+    return body;
+  }
+  if (!isJsonContentType(headers)) {
+    return body;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body.value);
+  } catch {
+    return body;
+  }
+  for (const path of config.bodyJsonPaths) {
+    const segments = parseJsonPath(path);
+    if (!segments) {
+      continue;
+    }
+    redactJsonPath(parsed, segments, config.replacement);
+  }
+  const next = { ...body };
+  next.value = JSON.stringify(parsed);
+  return next;
+}
+function isJsonContentType(headers) {
+  if (!headers) {
+    return false;
+  }
+  const contentType = headers["content-type"] || headers["Content-Type"];
+  const value = Array.isArray(contentType) ? contentType[0] : contentType;
+  if (!value) {
+    return false;
+  }
+  const normalized = value.split(";")[0];
+  if (!normalized) {
+    return false;
+  }
+  const trimmed = normalized.trim().toLowerCase();
+  return trimmed === "application/json" || trimmed.endsWith("+json");
+}
+function parseJsonPath(path) {
+  const trimmed = path.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const normalized = trimmed.startsWith("$.") ? trimmed.slice(2) : trimmed;
+  if (!normalized) {
+    return null;
+  }
+  const segments = [];
+  const parts = normalized.split(".");
+  for (const part of parts) {
+    if (!part) {
+      continue;
+    }
+    let cursor = part;
+    const bracketIndex = cursor.indexOf("[");
+    if (bracketIndex === -1) {
+      segments.push(cursor);
+      continue;
+    }
+    const name = cursor.slice(0, bracketIndex);
+    if (name) {
+      segments.push(name);
+    }
+    cursor = cursor.slice(bracketIndex);
+    const matches = cursor.match(/\[(\d+)\]/g);
+    if (!matches) {
+      continue;
+    }
+    for (const match of matches) {
+      const indexValue = match.slice(1, -1);
+      const index = Number.parseInt(indexValue, 10);
+      if (Number.isFinite(index)) {
+        segments.push(index);
+      }
+    }
+  }
+  return segments.length > 0 ? segments : null;
+}
+function redactJsonPath(value, segments, replacement) {
+  if (!value || segments.length === 0) {
+    return;
+  }
+  let current = value;
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i];
+    if (segment === void 0) {
+      return;
+    }
+    const isLast = i === segments.length - 1;
+    if (typeof segment === "number") {
+      if (!Array.isArray(current) || segment < 0 || segment >= current.length) {
+        return;
+      }
+      if (isLast) {
+        current[segment] = replacement;
+        return;
+      }
+      current = current[segment];
+      continue;
+    }
+    if (!current || typeof current !== "object") {
+      return;
+    }
+    const record = current;
+    if (!(segment in record)) {
+      return;
+    }
+    if (isLast) {
+      record[segment] = replacement;
+      return;
+    }
+    current = record[segment];
+  }
+}
+
+// src/core/attributes.ts
+import {
+  ATTR_CLIENT_ADDRESS,
+  ATTR_HTTP_REQUEST_BODY_SIZE,
+  ATTR_HTTP_REQUEST_METHOD,
+  ATTR_HTTP_RESPONSE_BODY_SIZE,
+  ATTR_HTTP_RESPONSE_STATUS_CODE,
+  ATTR_HTTP_ROUTE,
+  ATTR_URL_FULL,
+  ATTR_URL_PATH,
+  ATTR_USER_ID
+} from "@opentelemetry/semantic-conventions/incubating";
+
+// src/core/attrkey.ts
+var AttributeKeyRequestBody = "http.request.body";
+var AttributeKeyRequestBodyEncoding = "http.request.body.encoding";
+var AttributeKeyRequestBodyTruncated = "http.request.body.truncated";
+var AttributeKeyRequestID = "http.request.id";
+var AttributeKeyResponseBody = "http.response.body";
+var AttributeKeyResponseBodyEncoding = "http.response.body.encoding";
+var AttributeKeyResponseBodyTruncated = "http.response.body.truncated";
+var AttributeKeySpanDrop = "stainlessxray.internal.drop";
+
+// src/core/attributes.ts
+function setHeaderAttributes(span, headers, prefix) {
+  if (!headers) {
+    return;
+  }
+  const keys = Object.keys(headers).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+  for (const key of keys) {
+    const values = headers[key];
+    if (!values || Array.isArray(values) && values.length === 0) {
+      continue;
+    }
+    span.setAttribute(prefix + key.toLowerCase(), Array.isArray(values) ? values : [values]);
+  }
+}
+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 {
+    return new URL(url).pathname;
+  } catch {
+    const match = url.match(/^[^?#]*/);
+    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;
+  }
+  span.setAttribute(AttributeKeyRequestBody, body.value);
+  span.setAttribute(AttributeKeyRequestBodyEncoding, body.encoding);
+  if (body.truncated) {
+    span.setAttribute(AttributeKeyRequestBodyTruncated, true);
+  }
+}
+function setRequestBodySizeAttribute(span, size) {
+  span.setAttribute(ATTR_HTTP_REQUEST_BODY_SIZE, size);
+}
+function setResponseBodyAttributes(span, body) {
+  if (!body.value) {
+    return;
+  }
+  span.setAttribute(AttributeKeyResponseBody, body.value);
+  span.setAttribute(AttributeKeyResponseBodyEncoding, body.encoding);
+  if (body.truncated) {
+    span.setAttribute(AttributeKeyResponseBodyTruncated, true);
+  }
+}
+function setResponseBodySizeAttribute(span, size) {
+  span.setAttribute(ATTR_HTTP_RESPONSE_BODY_SIZE, size);
+}
+function setResponseStatusAttribute(span, statusCode) {
+  span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, statusCode);
+}
+function setRouteAttribute(span, route) {
+  if (route) {
+    span.setAttribute(ATTR_HTTP_ROUTE, route);
+  }
+}
+function setUserIdAttribute(span, userId) {
+  span.setAttribute(ATTR_USER_ID, userId);
+}
+function setRequestIdAttribute(span, requestId) {
+  span.setAttribute(AttributeKeyRequestID, requestId);
+}
+
+// src/core/otel.ts
+import {
+  diag,
+  ROOT_CONTEXT,
+  SpanKind,
+  SpanStatusCode
+} from "@opentelemetry/api";
+import {
+  AlwaysOnSampler,
+  BasicTracerProvider,
+  BatchSpanProcessor,
+  SimpleSpanProcessor
+} from "@opentelemetry/sdk-trace-base";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_TELEMETRY_SDK_LANGUAGE,
+  ATTR_TELEMETRY_SDK_NAME,
+  ATTR_TELEMETRY_SDK_VERSION
+} from "@opentelemetry/semantic-conventions";
+var defaultAttributeCountLimit = 128;
+function createTracerProvider(config, exporter) {
+  if (config.exporter.endpointUrl.startsWith("http://")) {
+    diag.warn("xray: OTLP endpoint uses plaintext HTTP");
+  }
+  const attributeValueLengthLimit = Math.max(1, Math.ceil(config.capture.maxBodyBytes * 4 / 3));
+  const resource = resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: config.serviceName,
+    [ATTR_TELEMETRY_SDK_LANGUAGE]: isNodeRuntime() ? "nodejs" : "webjs",
+    [ATTR_TELEMETRY_SDK_NAME]: "stainless-xray",
+    [ATTR_TELEMETRY_SDK_VERSION]: sdkVersion()
+  });
+  const spanProcessor = createSpanProcessor(config.exporter.spanProcessor, exporter);
+  const dropProcessor = new DropFilterSpanProcessor(spanProcessor);
+  const provider = new BasicTracerProvider({
+    forceFlushTimeoutMillis: 3e4,
+    generalLimits: {
+      attributeCountLimit: defaultAttributeCountLimit,
+      attributeValueLengthLimit
+    },
+    resource,
+    sampler: new AlwaysOnSampler(),
+    spanLimits: {
+      attributeCountLimit: defaultAttributeCountLimit,
+      attributePerEventCountLimit: defaultAttributeCountLimit,
+      attributePerLinkCountLimit: defaultAttributeCountLimit,
+      attributeValueLengthLimit,
+      eventCountLimit: defaultAttributeCountLimit,
+      linkCountLimit: defaultAttributeCountLimit
+    },
+    spanProcessors: [dropProcessor]
+  });
+  return provider;
+}
+function tracerFromProvider(provider) {
+  return provider.getTracer("stainless-xray");
+}
+function spanFromTracer(tracer, name) {
+  return tracer.startSpan(name, { kind: SpanKind.SERVER }, ROOT_CONTEXT);
+}
+function spanStatusFromError(span, err) {
+  if (err instanceof Error) {
+    span.recordException(err);
+  } else if (typeof err === "string") {
+    span.recordException(err);
+  } else {
+    span.recordException({ message: String(err) });
+  }
+  span.setStatus({ code: SpanStatusCode.ERROR });
+}
+var DropFilterSpanProcessor = class {
+  constructor(next) {
+    this.next = next;
+  }
+  forceFlush() {
+    return this.next.forceFlush();
+  }
+  onEnd(span) {
+    if (span.attributes[AttributeKeySpanDrop] === true) {
+      return;
+    }
+    this.next.onEnd(span);
+  }
+  onStart(span, parentContext) {
+    this.next.onStart(span, parentContext);
+  }
+  shutdown() {
+    return this.next.shutdown();
+  }
+};
+function createSpanProcessor(mode, exporter) {
+  if (mode === "simple") {
+    return new SimpleSpanProcessor(exporter);
+  }
+  return new BatchSpanProcessor(exporter, {
+    maxQueueSize: 2048,
+    maxExportBatchSize: 512,
+    scheduledDelayMillis: 5e3,
+    exportTimeoutMillis: 3e4
+  });
+}
+function sdkVersion() {
+  if (typeof __XRAY_VERSION__ !== "undefined") {
+    return __XRAY_VERSION__;
+  }
+  return "unknown";
+}
+function isNodeRuntime() {
+  const maybeProcess = globalThis.process;
+  return !!maybeProcess?.versions?.node;
+}
+
+// src/core/emitter.ts
+function createEmitter(config, exporter) {
+  const resolved = normalizeConfig(config);
+  if (!exporter) {
+    throw new XrayConfigError(
+      "INVALID_CONFIG",
+      "exporter is required (use @stainlessdev/xray-node or @stainlessdev/xray-fetch)"
+    );
+  }
+  logWithLevel(resolved.logger, "info", resolved.logLevel, "xray: emitter configured", {
+    serviceName: resolved.serviceName,
+    environment: resolved.environment,
+    version: resolved.version,
+    exporterEndpoint: resolved.exporter.endpointUrl,
+    spanProcessor: resolved.exporter.spanProcessor
+  });
+  const tracerProvider = createTracerProvider(resolved, exporter);
+  const tracer = tracerFromProvider(tracerProvider);
+  return {
+    config: resolved,
+    startRequest: (req) => startRequest(resolved, tracer, req),
+    endRequest: (ctx, res, err) => endRequest(resolved, ctx, res, err),
+    flush: () => tracerProvider.forceFlush(),
+    shutdown: () => tracerProvider.shutdown()
+  };
+}
+function startRequest(config, tracer, req) {
+  const startTimeMs = Number.isFinite(req.startTimeMs) ? req.startTimeMs : Date.now();
+  req.startTimeMs = startTimeMs;
+  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: explicitRequestId ?? "",
+    traceId: span?.spanContext().traceId,
+    spanId: span?.spanContext().spanId,
+    setUserId: (id) => {
+      const state2 = getContextState(context);
+      if (!state2) {
+        return;
+      }
+      state2.userId = id;
+      if (span && id) {
+        try {
+          setUserIdAttribute(span, id);
+        } catch {
+        }
+      }
+    },
+    setSessionId: (id) => {
+      const state2 = getContextState(context);
+      if (!state2) {
+        return;
+      }
+      state2.sessionId = id;
+    },
+    setAttribute: (key, value) => {
+      const state2 = getContextState(context);
+      if (!state2) {
+        return;
+      }
+      state2.attributes[key] = value;
+      if (span) {
+        try {
+          span.setAttribute(key, value);
+        } catch {
+        }
+      }
+    },
+    addEvent: (name, attributes) => {
+      const state2 = getContextState(context);
+      if (!state2) {
+        return;
+      }
+      state2.events.push({ name, attributes });
+      if (span) {
+        try {
+          span.addEvent(name, attributes);
+        } catch {
+        }
+      }
+    },
+    setError: (err) => {
+      const state2 = getContextState(context);
+      if (!state2) {
+        return;
+      }
+      state2.error = err;
+      if (span) {
+        try {
+          spanStatusFromError(span, err);
+        } catch {
+        }
+      }
+    }
+  };
+  const state = {
+    request: req,
+    config,
+    span,
+    context,
+    attributes: {},
+    events: []
+  };
+  bindContext(context, state);
+  return context;
+}
+function endRequest(config, ctx, res, err) {
+  const state = getContextState(ctx);
+  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: resolvedRequestId2,
+      serviceName: config.serviceName,
+      method: res.statusCode ? "UNKNOWN" : "UNKNOWN",
+      url: "",
+      durationMs: 0,
+      statusCode: res.statusCode,
+      timestamp: new Date(endTimeMs).toISOString()
+    };
+    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: resolvedRequestId,
+    traceId: state.span?.spanContext().traceId,
+    spanId: state.span?.spanContext().spanId,
+    serviceName: config.serviceName,
+    method: request.method,
+    url,
+    route,
+    statusCode: res.statusCode,
+    durationMs: Math.max(0, endTimeMs - request.startTimeMs),
+    requestHeaders: capture.requestHeaders ? sanitizeHeaderValues(request.headers) : void 0,
+    responseHeaders: capture.responseHeaders ? sanitizeHeaderValues(res.headers) : void 0,
+    requestBody: capture.requestBody === "none" ? void 0 : request.body,
+    responseBody: capture.responseBody === "none" ? void 0 : res.body,
+    userId: state.userId ?? void 0,
+    sessionId: state.sessionId ?? void 0,
+    error: buildError(err ?? state.error),
+    attributes: Object.keys(state.attributes).length > 0 ? { ...state.attributes } : void 0,
+    timestamp: new Date(endTimeMs).toISOString()
+  };
+  const redacted = applyRedaction(redaction, log);
+  if (redacted.route && config.route.normalize) {
+    const normalized = config.route.normalizer ? config.route.normalizer(redacted.route) : normalizeRoutePattern(redacted.route);
+    redacted.route = normalized;
+  }
+  const span = state.span;
+  if (span) {
+    try {
+      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) {
+        setResponseStatusAttribute(span, redacted.statusCode);
+      }
+      if (redacted.route) {
+        setRouteAttribute(span, redacted.route);
+        span.updateName(`${request.method} ${redacted.route}`);
+      } else {
+        span.updateName(spanNameFromRequest(request));
+      }
+      if (redacted.requestHeaders) {
+        setHeaderAttributes(span, redacted.requestHeaders, "http.request.header.");
+      }
+      if (redacted.responseHeaders) {
+        setHeaderAttributes(span, redacted.responseHeaders, "http.response.header.");
+      }
+      if (redacted.requestBody) {
+        setRequestBodyAttributes(span, redacted.requestBody);
+        setRequestBodySizeAttribute(span, redacted.requestBody.bytes);
+      }
+      if (redacted.responseBody) {
+        setResponseBodyAttributes(span, redacted.responseBody);
+        setResponseBodySizeAttribute(span, redacted.responseBody.bytes);
+      }
+      if (state.userId) {
+        setUserIdAttribute(span, state.userId);
+      }
+      if (err ?? state.error) {
+        spanStatusFromError(span, err ?? state.error);
+      }
+      span.end();
+    } catch (spanErr) {
+      logWithLevel(config.logger, "warn", config.logLevel, "xray: span finalize failed", {
+        error: spanErr instanceof Error ? spanErr.message : String(spanErr)
+      });
+    }
+  }
+  return redacted;
+}
+function resolveFinalRequestId(config, explicitRequestId, responseHeaders) {
+  const explicit = normalizeRequestIdCandidate(explicitRequestId);
+  if (explicit) {
+    return explicit;
+  }
+  const headerValue = resolveHeaderRequestId(config.requestId.header, responseHeaders);
+  if (headerValue) {
+    return headerValue;
+  }
+  return generateRequestId();
+}
+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;
+    }
+  }
+  return void 0;
+}
+function normalizeRequestIdCandidate(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function resolveCapture(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    ...base,
+    ...override
+  };
+}
+function resolveRedaction(base, override) {
+  const merged = {
+    ...base,
+    ...override
+  };
+  merged.headers = normalizeLowercaseList(merged.headers);
+  merged.queryParams = normalizeLowercaseList(merged.queryParams);
+  merged.bodyJsonPaths = normalizeList(merged.bodyJsonPaths);
+  merged.replacement = merged.replacement || base.replacement;
+  return merged;
+}
+function normalizeLowercaseList(values) {
+  if (!values) {
+    return [];
+  }
+  return values.map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+}
+function normalizeList(values) {
+  if (!values) {
+    return [];
+  }
+  return values.map((entry) => entry.trim()).filter(Boolean);
+}
+function buildError(err) {
+  if (!err) {
+    return void 0;
+  }
+  if (err instanceof Error) {
+    return {
+      message: err.message || "Error",
+      type: err.name || "Error",
+      stack: err.stack
+    };
+  }
+  return {
+    message: String(err)
+  };
+}
+function spanNameFromRequest(req) {
+  const method = req.method || "GET";
+  if (req.route) {
+    return `${method} ${req.route}`;
+  }
+  const path = safePath(req.url);
+  return `${method} ${path}`;
+}
+function safePath(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.pathname || "/";
+  } catch {
+    const rawPath = url.split("?")[0] || "/";
+    return rawPath || "/";
+  }
+}
+
+export {
+  XrayConfigError,
+  normalizeConfig,
+  createEmitter
+};
+//# sourceMappingURL=chunk-2NR6RZEP.js.map