@stainlessdev/xray-core 0.3.0 → 0.3.1-branch.bg-visibility.8b15a0a

package/dist/{chunk-SQHI5JZH.js → chunk-XI5E6C7G.js}

@@ -160,6 +160,7 @@ function findNestedTarget(obj) {
 }
 
 export {
+  encodeBase64,
   logWithLevel,
   sanitizeLogString,
   sanitizeHeaderValues,
@@ -169,4 +170,4 @@ export {
   bindObject,
   getContextFromObject
 };
-//# sourceMappingURL=chunk-SQHI5JZH.js.map
+//# sourceMappingURL=chunk-XI5E6C7G.js.map

package/dist/index.cjs

@@ -26,6 +26,28 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// 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;
+function encodeBase64(bytes) {
+  if (maybeBuffer) {
+    return maybeBuffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 1) {
+    const byte = bytes[i];
+    if (byte === void 0) {
+      continue;
+    }
+    binary += String.fromCharCode(byte);
+  }
+  if (typeof btoa !== "undefined") {
+    return btoa(binary);
+  }
+  return "";
+}
+
 // src/route.ts
 function normalizeRoutePattern(route) {
   if (!route) {
@@ -142,8 +164,7 @@ var defaultExporterBase = {
   endpointUrl: DEFAULT_ENDPOINT_URL,
   headers: {},
   timeoutMs: 5e3,
-  spanProcessor: "batch",
-  sampler: { type: "ratio", ratio: 1 }
+  spanProcessor: "batch"
 };
 var XrayConfigError = class extends Error {
   constructor(code, message) {
@@ -234,24 +255,15 @@ function normalizeRoute(cfg) {
 }
 function normalizeExporter(endpointUrl, cfg) {
   const resolvedEndpoint = normalizeExporterEndpoint(cfg?.endpointUrl ?? endpointUrl);
-  const enabled = cfg?.enabled ?? true;
+  const rawHeaders = cfg?.headers ?? defaultExporterBase.headers ?? {};
+  const parsed = applyEndpointAuth(resolvedEndpoint, rawHeaders);
   const exporter = {
     ...defaultExporterBase,
-    ...cfg,
-    enabled,
-    endpointUrl: resolvedEndpoint,
-    headers: cfg?.headers ?? defaultExporterBase.headers,
+    endpointUrl: parsed.endpointUrl,
+    headers: parsed.headers,
     timeoutMs: cfg?.timeoutMs ?? defaultExporterBase.timeoutMs,
-    spanProcessor: cfg?.spanProcessor ?? defaultExporterBase.spanProcessor,
-    sampler: cfg?.sampler ?? defaultExporterBase.sampler
+    spanProcessor: cfg?.spanProcessor ?? defaultExporterBase.spanProcessor
   };
-  if (exporter.sampler.type === "ratio") {
-    const ratio = exporter.sampler.ratio ?? 1;
-    if (!Number.isFinite(ratio) || ratio < 0 || ratio > 1) {
-      throw new XrayConfigError("INVALID_EXPORTER", "sampler.ratio must be between 0 and 1");
-    }
-    exporter.sampler = { type: "ratio", ratio };
-  }
   return exporter;
 }
 function normalizeExporterEndpoint(endpointUrl) {
@@ -270,6 +282,69 @@ function normalizeStringList(values) {
   }
   return values.map((entry) => entry.trim()).filter(Boolean);
 }
+var textEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+var maybeBuffer2 = 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 (maybeBuffer2) {
+    bytes = maybeBuffer2.from(raw, "utf8");
+  }
+  if (!bytes) {
+    return void 0;
+  }
+  const encoded = encodeBase64(bytes);
+  if (!encoded) {
+    return void 0;
+  }
+  return `Basic ${encoded}`;
+}
 
 // src/logger.ts
 var logLevelOrder = {
@@ -639,11 +714,6 @@ function redactJsonPath(value, segments, replacement) {
   }
 }
 
-// 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) {
@@ -768,9 +838,6 @@ var import_semantic_conventions = require("@opentelemetry/semantic-conventions")
 var import_otlp_transformer = require("@opentelemetry/otlp-transformer");
 var defaultAttributeCountLimit = 128;
 function createTracerProvider(config) {
-  if (!config.exporter.enabled || !config.exporter.endpointUrl) {
-    return null;
-  }
   if (config.exporter.endpointUrl.startsWith("http://")) {
     import_api.diag.warn("xray: OTLP endpoint uses plaintext HTTP");
   }
@@ -784,9 +851,10 @@ function createTracerProvider(config) {
   const exporter = new FetchSpanExporter({
     endpointUrl: config.exporter.endpointUrl,
     headers: config.exporter.headers ?? {},
-    timeoutMillis: config.exporter.timeoutMs
+    timeoutMillis: config.exporter.timeoutMs,
+    logger: config.logger,
+    logLevel: config.logLevel
   });
-  const sampler = createSampler(config);
   const spanProcessor = createSpanProcessor(config.exporter.spanProcessor, exporter);
   const dropProcessor = new DropFilterSpanProcessor(spanProcessor);
   const provider = new import_sdk_trace_base.BasicTracerProvider({
@@ -796,7 +864,7 @@ function createTracerProvider(config) {
       attributeValueLengthLimit
     },
     resource,
-    sampler,
+    sampler: new import_sdk_trace_base.AlwaysOnSampler(),
     spanLimits: {
       attributeCountLimit: defaultAttributeCountLimit,
       attributePerEventCountLimit: defaultAttributeCountLimit,
@@ -851,6 +919,8 @@ var FetchSpanExporter = class {
     this.headers = { ...options.headers };
     this.timeoutMillis = options.timeoutMillis;
     this.isShutdown = false;
+    this.logger = options.logger;
+    this.logLevel = options.logLevel;
     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";
@@ -862,6 +932,9 @@ var FetchSpanExporter = class {
     }
     const payload = this.serializer.serializeRequest(spans);
     if (!payload) {
+      logWithLevel(this.logger, "warn", this.logLevel, "xray: OTLP export failed", {
+        error: "OTLP export failed: empty payload"
+      });
       resultCallback({
         code: import_core.ExportResultCode.FAILED,
         error: new Error("OTLP export failed: empty payload")
@@ -897,6 +970,9 @@ var FetchSpanExporter = class {
       if (timeout) {
         clearTimeout(timeout);
       }
+      logWithLevel(this.logger, "warn", this.logLevel, "xray: OTLP export failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
       import_api.diag.error("OTLP export failed", err);
       resultCallback({ code: import_core.ExportResultCode.FAILED, error: err });
     });
@@ -919,19 +995,9 @@ function createSpanProcessor(mode, exporter) {
     exportTimeoutMillis: 3e4
   });
 }
-function createSampler(config) {
-  const sampler = config.exporter.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.2.0";
+    return "0.3.1";
   }
   return "unknown";
 }
@@ -971,14 +1037,21 @@ function getContextState(ctx) {
 // src/emitter.ts
 function createEmitter(config) {
   const resolved = normalizeConfig(config);
+  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);
-  const tracer = tracerProvider ? tracerFromProvider(tracerProvider) : null;
+  const tracer = tracerFromProvider(tracerProvider);
   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()
+    flush: () => tracerProvider.forceFlush(),
+    shutdown: () => tracerProvider.shutdown()
   };
 }
 function startRequest(config, tracer, req) {
@@ -989,7 +1062,7 @@ function startRequest(config, tracer, req) {
   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 span = spanFromTracer(tracer, spanNameFromRequest(req));
   const context = {
     requestId,
     traceId: span?.spanContext().traceId,