@stainlessdev/xray-core 0.1.0-branch.bg-publish-to-npm.18b1cb1

package/dist/index.cjs

@@ -0,0 +1,1191 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  XrayConfigError: () => XrayConfigError,
+  createEmitter: () => createEmitter,
+  normalizeConfig: () => normalizeConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/route.ts
+function normalizeRoutePattern(route) {
+  if (!route) {
+    return "/";
+  }
+  const cleaned = stripQueryAndFragment(route).trim();
+  if (!cleaned) {
+    return "/";
+  }
+  const leading = cleaned.startsWith("/") ? cleaned : `/${cleaned}`;
+  const segments = leading.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return "/";
+  }
+  const normalized = segments.map(normalizeRouteSegment).join("/");
+  return `/${normalized}`;
+}
+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 "*";
+  }
+  if (segment.startsWith("[") && segment.endsWith("]")) {
+    const inner = segment.slice(1, -1);
+    if (inner.startsWith("...") || inner.startsWith("[...")) {
+      return "*";
+    }
+    return `:${inner}`;
+  }
+  if (segment.startsWith("{") && segment.endsWith("}")) {
+    return `:${segment.slice(1, -1)}`;
+  }
+  if (segment.startsWith("$")) {
+    return `:${segment.slice(1)}`;
+  }
+  if (segment.startsWith(":")) {
+    return `:${segment.slice(1)}`;
+  }
+  return segment;
+}
+
+// src/config.ts
+var defaultCapture = {
+  requestHeaders: true,
+  responseHeaders: true,
+  requestBody: "none",
+  responseBody: "none",
+  maxBodyBytes: 65536
+};
+var defaultRedaction = {
+  headers: ["authorization", "cookie", "set-cookie", "x-api-key"],
+  queryParams: [],
+  bodyJsonPaths: [],
+  replacement: "[REDACTED]"
+};
+var defaultRequestId = {
+  header: "x-request-id",
+  generate: true
+};
+var defaultRoute = {
+  normalize: true,
+  normalizer: normalizeRoutePattern
+};
+var defaultOtelBase = {
+  endpointUrl: void 0,
+  headers: {},
+  timeoutMs: 5e3,
+  spanProcessor: "batch",
+  sampler: { type: "ratio", ratio: 1 }
+};
+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 otel = normalizeOtel(config.otel);
+  return {
+    serviceName: config.serviceName.trim(),
+    environment: config.environment?.trim() || void 0,
+    version: config.version?.trim() || void 0,
+    logger,
+    logLevel,
+    otel,
+    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 normalizeOtel(cfg) {
+  const endpointUrl = cfg?.endpointUrl?.trim() || void 0;
+  const enabled = cfg?.enabled ?? !!endpointUrl;
+  const otel = {
+    ...defaultOtelBase,
+    ...cfg,
+    enabled,
+    endpointUrl,
+    headers: cfg?.headers ?? defaultOtelBase.headers,
+    timeoutMs: cfg?.timeoutMs ?? defaultOtelBase.timeoutMs,
+    spanProcessor: cfg?.spanProcessor ?? defaultOtelBase.spanProcessor,
+    sampler: cfg?.sampler ?? defaultOtelBase.sampler
+  };
+  if (otel.enabled && !otel.endpointUrl) {
+    throw new XrayConfigError("INVALID_OTEL", "otel.endpointUrl is required when enabled");
+  }
+  if (otel.sampler.type === "ratio") {
+    const ratio = otel.sampler.ratio ?? 1;
+    if (!Number.isFinite(ratio) || ratio < 0 || ratio > 1) {
+      throw new XrayConfigError("INVALID_OTEL", "otel.sampler.ratio must be between 0 and 1");
+    }
+    otel.sampler = { type: "ratio", ratio };
+  }
+  return otel;
+}
+function normalizeStringList(values) {
+  if (!values) {
+    return [];
+  }
+  return values.map((entry) => entry.trim()).filter(Boolean);
+}
+
+// src/logger.ts
+var logLevelOrder = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function logWithLevel(logger, level, threshold, message, fields) {
+  if (logLevelOrder[level] < logLevelOrder[threshold]) {
+    return;
+  }
+  const fn = logger[level] ?? logger.warn ?? logger.info ?? logger.debug ?? logger.error ?? console.log;
+  try {
+    fn.call(logger, message, fields);
+  } catch {
+  }
+}
+
+// src/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/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/encoding.ts
+var utf8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { fatal: true }) : null;
+var utf8DecoderLenient = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8") : null;
+var maybeBuffer = globalThis.Buffer;
+
+// src/request_log.ts
+var controlChars = /[\x00-\x1F\x7F]/g;
+function sanitizeLogString(value) {
+  if (!value) {
+    return value;
+  }
+  return value.replace(controlChars, "");
+}
+function sanitizeHeaderValues(headers) {
+  if (!headers) {
+    return void 0;
+  }
+  const sanitized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const name = sanitizeLogString(key);
+    if (Array.isArray(value)) {
+      sanitized[name] = value.map((entry) => sanitizeLogString(entry));
+    } else {
+      sanitized[name] = sanitizeLogString(value);
+    }
+  }
+  return sanitized;
+}
+
+// src/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/attributes.ts
+var attributeKeyEndUserId = "enduser.id";
+var attributeKeyHttpRequestBodySize = "http.request.body.size";
+var attributeKeyHttpRequestMethod = "http.request.method";
+var attributeKeyHttpResponseBodySize = "http.response.body.size";
+var attributeKeyHttpResponseStatusCode = "http.response.status_code";
+var attributeKeyHttpRoute = "http.route";
+var attributeKeyUrlPath = "url.path";
+var attributeKeyUrlFull = "url.full";
+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, method, urlFull) {
+  span.setAttribute(attributeKeyHttpRequestMethod, method);
+  if (urlFull) {
+    span.setAttribute(attributeKeyUrlFull, urlFull);
+    const path = extractPath(urlFull);
+    if (path) {
+      span.setAttribute(attributeKeyUrlPath, path);
+    }
+  }
+}
+function extractPath(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    const match = url.match(/^[^?#]*/);
+    return match?.[0] || void 0;
+  }
+}
+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(attributeKeyHttpRequestBodySize, 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(attributeKeyHttpResponseBodySize, size);
+}
+function setResponseStatusAttribute(span, statusCode) {
+  span.setAttribute(attributeKeyHttpResponseStatusCode, statusCode);
+}
+function setRouteAttribute(span, route) {
+  if (route) {
+    span.setAttribute(attributeKeyHttpRoute, route);
+  }
+}
+function setUserIdAttribute(span, userId) {
+  span.setAttribute(attributeKeyEndUserId, userId);
+}
+function setRequestIdAttribute(span, requestId) {
+  span.setAttribute(AttributeKeyRequestID, requestId);
+}
+
+// src/otel.ts
+var import_api = require("@opentelemetry/api");
+var import_core = require("@opentelemetry/core");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_resources = require("@opentelemetry/resources");
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var import_otlp_transformer = require("@opentelemetry/otlp-transformer");
+var defaultAttributeCountLimit = 128;
+function createTracerProvider(config) {
+  if (!config.otel.enabled || !config.otel.endpointUrl) {
+    return null;
+  }
+  if (config.otel.endpointUrl.startsWith("http://")) {
+    import_api.diag.warn("xray: OTLP endpoint uses plaintext HTTP");
+  }
+  const attributeValueLengthLimit = Math.max(1, Math.ceil(config.capture.maxBodyBytes * 4 / 3));
+  const resource = (0, import_resources.resourceFromAttributes)({
+    [import_semantic_conventions.ATTR_SERVICE_NAME]: config.serviceName,
+    [import_semantic_conventions.ATTR_TELEMETRY_SDK_LANGUAGE]: isNodeRuntime() ? "nodejs" : "webjs",
+    [import_semantic_conventions.ATTR_TELEMETRY_SDK_NAME]: "stainless-xray",
+    [import_semantic_conventions.ATTR_TELEMETRY_SDK_VERSION]: sdkVersion()
+  });
+  const exporter = new FetchSpanExporter({
+    endpointUrl: config.otel.endpointUrl,
+    headers: config.otel.headers ?? {},
+    timeoutMillis: config.otel.timeoutMs
+  });
+  const sampler = createSampler(config);
+  const spanProcessor = createSpanProcessor(config.otel.spanProcessor, exporter);
+  const dropProcessor = new DropFilterSpanProcessor(spanProcessor);
+  const provider = new import_sdk_trace_base.BasicTracerProvider({
+    forceFlushTimeoutMillis: 3e4,
+    generalLimits: {
+      attributeCountLimit: defaultAttributeCountLimit,
+      attributeValueLengthLimit
+    },
+    resource,
+    sampler,
+    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: import_api.SpanKind.SERVER }, import_api.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: import_api.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();
+  }
+};
+var FetchSpanExporter = class {
+  constructor(options) {
+    this.endpointUrl = options.endpointUrl;
+    this.headers = { ...options.headers };
+    this.timeoutMillis = options.timeoutMillis;
+    this.isShutdown = false;
+    const protobufSerializer = import_otlp_transformer.ProtobufTraceSerializer && typeof import_otlp_transformer.ProtobufTraceSerializer.serializeRequest === "function" ? import_otlp_transformer.ProtobufTraceSerializer : null;
+    this.serializer = protobufSerializer ?? import_otlp_transformer.JsonTraceSerializer;
+    this.contentType = protobufSerializer ? "application/x-protobuf" : "application/json";
+  }
+  export(spans, resultCallback) {
+    if (this.isShutdown) {
+      resultCallback({ code: import_core.ExportResultCode.FAILED });
+      return;
+    }
+    const payload = this.serializer.serializeRequest(spans);
+    if (!payload) {
+      resultCallback({
+        code: import_core.ExportResultCode.FAILED,
+        error: new Error("OTLP export failed: empty payload")
+      });
+      return;
+    }
+    const headers = {
+      ...this.headers,
+      "Content-Type": this.contentType
+    };
+    const controller = typeof AbortController !== "undefined" ? new AbortController() : null;
+    let timeout;
+    if (controller) {
+      timeout = setTimeout(() => controller.abort(), this.timeoutMillis);
+    }
+    const doExport = async () => {
+      const response = await fetch(this.endpointUrl, {
+        method: "POST",
+        headers,
+        body: payload,
+        signal: controller?.signal
+      });
+      if (!response.ok) {
+        throw new Error(`OTLP export failed: ${response.status}`);
+      }
+    };
+    doExport().then(() => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      resultCallback({ code: import_core.ExportResultCode.SUCCESS });
+    }).catch((err) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      import_api.diag.error("OTLP export failed", err);
+      resultCallback({ code: import_core.ExportResultCode.FAILED, error: err });
+    });
+  }
+  async forceFlush() {
+    return;
+  }
+  async shutdown() {
+    this.isShutdown = true;
+  }
+};
+function createSpanProcessor(mode, exporter) {
+  if (mode === "simple") {
+    return new import_sdk_trace_base.SimpleSpanProcessor(exporter);
+  }
+  return new import_sdk_trace_base.BatchSpanProcessor(exporter, {
+    maxQueueSize: 2048,
+    maxExportBatchSize: 512,
+    scheduledDelayMillis: 5e3,
+    exportTimeoutMillis: 3e4
+  });
+}
+function createSampler(config) {
+  const sampler = config.otel.sampler;
+  if (sampler.type === "always_off") {
+    return new import_sdk_trace_base.AlwaysOffSampler();
+  }
+  if (sampler.type === "ratio") {
+    return new import_sdk_trace_base.TraceIdRatioBasedSampler(sampler.ratio ?? 1);
+  }
+  return new import_sdk_trace_base.AlwaysOnSampler();
+}
+function sdkVersion() {
+  if (true) {
+    return "0.1.0";
+  }
+  return "unknown";
+}
+function isNodeRuntime() {
+  const maybeProcess = globalThis.process;
+  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/state.ts
+var contextMap = /* @__PURE__ */ new WeakMap();
+function bindContext(ctx, state) {
+  contextMap.set(ctx, state);
+}
+function getContextState(ctx) {
+  return contextMap.get(ctx);
+}
+
+// src/emitter.ts
+function createEmitter(config) {
+  const resolved = normalizeConfig(config);
+  const tracerProvider = createTracerProvider(resolved);
+  const tracer = tracerProvider ? tracerFromProvider(tracerProvider) : null;
+  return {
+    config: resolved,
+    startRequest: (req) => startRequest(resolved, tracer, req),
+    endRequest: (ctx, res, err) => endRequest(resolved, ctx, res, err),
+    flush: () => tracerProvider ? tracerProvider.forceFlush() : Promise.resolve(),
+    shutdown: () => tracerProvider ? tracerProvider.shutdown() : Promise.resolve()
+  };
+}
+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;
+  if (req.route && config.route.normalize) {
+    req.route = config.route.normalizer ? config.route.normalizer(req.route) : normalizeRoutePattern(req.route);
+  }
+  const span = tracer ? spanFromTracer(tracer, spanNameFromRequest(req)) : void 0;
+  const context = {
+    requestId,
+    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 fallbackLog = {
+      requestId: ctx.requestId,
+      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 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,
+    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);
+  const span = state.span;
+  if (span) {
+    try {
+      setRequestAttributes(span, request.method, redacted.url);
+      setRequestIdAttribute(span, redacted.requestId);
+      span.setAttribute("service.name", config.serviceName);
+      if (redacted.statusCode != null) {
+        setResponseStatusAttribute(span, redacted.statusCode);
+      }
+      if (redacted.route) {
+        const normalized = config.route.normalize ? config.route.normalizer ? config.route.normalizer(redacted.route) : normalizeRoutePattern(redacted.route) : redacted.route;
+        setRouteAttribute(span, normalized);
+        span.updateName(`${request.method} ${normalized}`);
+      } 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 resolveRequestId(config, requestId, headers) {
+  if (requestId) {
+    return requestId;
+  }
+  const headerName = config.requestId.header.toLowerCase();
+  const headerValue = headers[headerName];
+  if (headerValue) {
+    const value = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+    if (value && value.trim()) {
+      return value.trim();
+    }
+  }
+  if (!config.requestId.generate) {
+    return uuidv7();
+  }
+  return uuidv7();
+}
+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 || "/";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  XrayConfigError,
+  createEmitter,
+  normalizeConfig
+});
+//# sourceMappingURL=index.cjs.map