@stainlessdev/xray-core 0.3.1 → 0.4.0-branch.bg-rework-exporters.8c5264b

package/dist/index.cjs

@@ -159,13 +159,10 @@ var defaultRoute = {
   normalize: true,
   normalizer: normalizeRoutePattern
 };
-var DEFAULT_ENDPOINT_URL = "http://localhost:4318";
 var defaultExporterBase = {
-  endpointUrl: DEFAULT_ENDPOINT_URL,
   headers: {},
-  timeoutMs: 5e3,
-  spanProcessor: "batch",
-  sampler: { type: "ratio", ratio: 1 }
+  timeoutMs: 3e4,
+  spanProcessor: "batch"
 };
 var XrayConfigError = class extends Error {
   constructor(code, message) {
@@ -258,29 +255,23 @@ function normalizeExporter(endpointUrl, cfg) {
   const resolvedEndpoint = normalizeExporterEndpoint(cfg?.endpointUrl ?? endpointUrl);
   const rawHeaders = cfg?.headers ?? defaultExporterBase.headers ?? {};
   const parsed = applyEndpointAuth(resolvedEndpoint, rawHeaders);
-  const enabled = cfg?.enabled ?? true;
   const exporter = {
-    ...defaultExporterBase,
-    ...cfg,
-    enabled,
     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) {
   const envUrl = typeof process !== "undefined" ? process.env?.["STAINLESS_XRAY_ENDPOINT_URL"] : void 0;
-  const resolved = endpointUrl ?? envUrl ?? DEFAULT_ENDPOINT_URL;
+  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")) {
@@ -750,6 +741,9 @@ function sanitizeHeaderValues(headers) {
   return sanitized;
 }
 
+// src/attributes.ts
+var import_incubating = require("@opentelemetry/semantic-conventions/incubating");
+
 // src/attrkey.ts
 var AttributeKeyRequestBody = "http.request.body";
 var AttributeKeyRequestBodyEncoding = "http.request.body.encoding";
@@ -761,14 +755,6 @@ 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;
@@ -783,12 +769,12 @@ function setHeaderAttributes(span, headers, prefix) {
   }
 }
 function setRequestAttributes(span, method, urlFull) {
-  span.setAttribute(attributeKeyHttpRequestMethod, method);
+  span.setAttribute(import_incubating.ATTR_HTTP_REQUEST_METHOD, method);
   if (urlFull) {
-    span.setAttribute(attributeKeyUrlFull, urlFull);
+    span.setAttribute(import_incubating.ATTR_URL_FULL, urlFull);
     const path = extractPath(urlFull);
     if (path) {
-      span.setAttribute(attributeKeyUrlPath, path);
+      span.setAttribute(import_incubating.ATTR_URL_PATH, path);
     }
   }
 }
@@ -811,7 +797,7 @@ function setRequestBodyAttributes(span, body) {
   }
 }
 function setRequestBodySizeAttribute(span, size) {
-  span.setAttribute(attributeKeyHttpRequestBodySize, size);
+  span.setAttribute(import_incubating.ATTR_HTTP_REQUEST_BODY_SIZE, size);
 }
 function setResponseBodyAttributes(span, body) {
   if (!body.value) {
@@ -824,18 +810,18 @@ function setResponseBodyAttributes(span, body) {
   }
 }
 function setResponseBodySizeAttribute(span, size) {
-  span.setAttribute(attributeKeyHttpResponseBodySize, size);
+  span.setAttribute(import_incubating.ATTR_HTTP_RESPONSE_BODY_SIZE, size);
 }
 function setResponseStatusAttribute(span, statusCode) {
-  span.setAttribute(attributeKeyHttpResponseStatusCode, statusCode);
+  span.setAttribute(import_incubating.ATTR_HTTP_RESPONSE_STATUS_CODE, statusCode);
 }
 function setRouteAttribute(span, route) {
   if (route) {
-    span.setAttribute(attributeKeyHttpRoute, route);
+    span.setAttribute(import_incubating.ATTR_HTTP_ROUTE, route);
   }
 }
 function setUserIdAttribute(span, userId) {
-  span.setAttribute(attributeKeyEndUserId, userId);
+  span.setAttribute(import_incubating.ATTR_USER_ID, userId);
 }
 function setRequestIdAttribute(span, requestId) {
   span.setAttribute(AttributeKeyRequestID, requestId);
@@ -843,16 +829,11 @@ function setRequestIdAttribute(span, 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.exporter.enabled || !config.exporter.endpointUrl) {
-    return null;
-  }
+function createTracerProvider(config, exporter) {
   if (config.exporter.endpointUrl.startsWith("http://")) {
     import_api.diag.warn("xray: OTLP endpoint uses plaintext HTTP");
   }
@@ -863,12 +844,6 @@ function createTracerProvider(config) {
     [import_semantic_conventions.ATTR_TELEMETRY_SDK_NAME]: "stainless-xray",
     [import_semantic_conventions.ATTR_TELEMETRY_SDK_VERSION]: sdkVersion()
   });
-  const exporter = new FetchSpanExporter({
-    endpointUrl: config.exporter.endpointUrl,
-    headers: config.exporter.headers ?? {},
-    timeoutMillis: config.exporter.timeoutMs
-  });
-  const sampler = createSampler(config);
   const spanProcessor = createSpanProcessor(config.exporter.spanProcessor, exporter);
   const dropProcessor = new DropFilterSpanProcessor(spanProcessor);
   const provider = new import_sdk_trace_base.BasicTracerProvider({
@@ -878,7 +853,7 @@ function createTracerProvider(config) {
       attributeValueLengthLimit
     },
     resource,
-    sampler,
+    sampler: new import_sdk_trace_base.AlwaysOnSampler(),
     spanLimits: {
       attributeCountLimit: defaultAttributeCountLimit,
       attributePerEventCountLimit: defaultAttributeCountLimit,
@@ -927,69 +902,6 @@ var DropFilterSpanProcessor = class {
     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);
@@ -1001,19 +913,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.3.0";
+    return "0.4.0";
   }
   return "unknown";
 }
@@ -1051,16 +953,29 @@ function getContextState(ctx) {
 }
 
 // src/emitter.ts
-function createEmitter(config) {
+function createEmitter(config, exporter) {
   const resolved = normalizeConfig(config);
-  const tracerProvider = createTracerProvider(resolved);
-  const tracer = tracerProvider ? tracerFromProvider(tracerProvider) : null;
+  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 ? tracerProvider.forceFlush() : Promise.resolve(),
-    shutdown: () => tracerProvider ? tracerProvider.shutdown() : Promise.resolve()
+    flush: () => tracerProvider.forceFlush(),
+    shutdown: () => tracerProvider.shutdown()
   };
 }
 function startRequest(config, tracer, req) {
@@ -1071,7 +986,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,