@stainlessdev/xray-core 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -159,11 +159,9 @@ var defaultRoute = {
   normalize: true,
   normalizer: normalizeRoutePattern
 };
-var DEFAULT_ENDPOINT_URL = "http://localhost:4318";
 var defaultExporterBase = {
-  endpointUrl: DEFAULT_ENDPOINT_URL,
   headers: {},
-  timeoutMs: 5e3,
+  timeoutMs: 3e4,
   spanProcessor: "batch"
 };
 var XrayConfigError = class extends Error {
@@ -258,7 +256,6 @@ function normalizeExporter(endpointUrl, cfg) {
   const rawHeaders = cfg?.headers ?? defaultExporterBase.headers ?? {};
   const parsed = applyEndpointAuth(resolvedEndpoint, rawHeaders);
   const exporter = {
-    ...defaultExporterBase,
     endpointUrl: parsed.endpointUrl,
     headers: parsed.headers,
     timeoutMs: cfg?.timeoutMs ?? defaultExporterBase.timeoutMs,
@@ -268,7 +265,13 @@ function normalizeExporter(endpointUrl, cfg) {
 }
 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")) {
@@ -738,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";
@@ -749,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;
@@ -771,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);
     }
   }
 }
@@ -799,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) {
@@ -812,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);
@@ -831,13 +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) {
+function createTracerProvider(config, exporter) {
   if (config.exporter.endpointUrl.startsWith("http://")) {
     import_api.diag.warn("xray: OTLP endpoint uses plaintext HTTP");
   }
@@ -848,13 +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,
-    logger: config.logger,
-    logLevel: config.logLevel
-  });
   const spanProcessor = createSpanProcessor(config.exporter.spanProcessor, exporter);
   const dropProcessor = new DropFilterSpanProcessor(spanProcessor);
   const provider = new import_sdk_trace_base.BasicTracerProvider({
@@ -913,77 +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;
-    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";
-  }
-  export(spans, resultCallback) {
-    if (this.isShutdown) {
-      resultCallback({ code: import_core.ExportResultCode.FAILED });
-      return;
-    }
-    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")
-      });
-      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);
-      }
-      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 });
-    });
-  }
-  async forceFlush() {
-    return;
-  }
-  async shutdown() {
-    this.isShutdown = true;
-  }
-};
 function createSpanProcessor(mode, exporter) {
   if (mode === "simple") {
     return new import_sdk_trace_base.SimpleSpanProcessor(exporter);
@@ -997,7 +915,7 @@ function createSpanProcessor(mode, exporter) {
 }
 function sdkVersion() {
   if (true) {
-    return "0.3.1";
+    return "0.4.0";
   }
   return "unknown";
 }
@@ -1035,8 +953,14 @@ function getContextState(ctx) {
 }
 
 // src/emitter.ts
-function createEmitter(config) {
+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,
@@ -1044,7 +968,7 @@ function createEmitter(config) {
     exporterEndpoint: resolved.exporter.endpointUrl,
     spanProcessor: resolved.exporter.spanProcessor
   });
-  const tracerProvider = createTracerProvider(resolved);
+  const tracerProvider = createTracerProvider(resolved, exporter);
   const tracer = tracerFromProvider(tracerProvider);
   return {
     config: resolved,