@latitude-data/telemetry 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -155,6 +155,16 @@ var SegmentType;
     SegmentType["Document"] = "document";
     SegmentType["Step"] = "step";
 })(SegmentType || (SegmentType = {}));
+const SEGMENT_SPECIFICATIONS = {
+    [SegmentType.Document]: {
+        name: 'Prompt',
+        description: 'A prompt',
+    },
+    [SegmentType.Step]: {
+        name: 'Step',
+        description: 'A step in a prompt',
+    },
+};
 const baseSegmentBaggageSchema = zod.z.object({
     id: zod.z.string(),
     parentId: zod.z.string().optional(),
@@ -197,14 +207,56 @@ var SpanType;
     SpanType["Segment"] = "segment";
     SpanType["Unknown"] = "unknown";
 })(SpanType || (SpanType = {}));
-const GENAI_SPANS = [
-    SpanType.Tool,
-    SpanType.Completion,
-    SpanType.Embedding,
-    SpanType.Retrieval,
-    SpanType.Reranking,
-];
-[SpanType.Http, SpanType.Segment, SpanType.Unknown];
+const SPAN_SPECIFICATIONS = {
+    [SpanType.Tool]: {
+        name: 'Tool',
+        description: 'A tool call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Completion]: {
+        name: 'Completion',
+        description: 'A completion call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Embedding]: {
+        name: 'Embedding',
+        description: 'An embedding call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Retrieval]: {
+        name: 'Retrieval',
+        description: 'A retrieval call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Reranking]: {
+        name: 'Reranking',
+        description: 'A reranking call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Http]: {
+        name: 'HTTP',
+        description: 'An HTTP request',
+        isGenAI: false,
+        isHidden: true,
+    },
+    [SpanType.Segment]: {
+        name: 'Segment',
+        description: 'A (partial) segment of a trace',
+        isGenAI: false,
+        isHidden: true,
+    },
+    [SpanType.Unknown]: {
+        name: 'Unknown',
+        description: 'An unknown span',
+        isGenAI: false,
+        isHidden: true,
+    },
+};
 var SpanStatus;
 (function (SpanStatus) {
     SpanStatus["Unset"] = "unset";
@@ -284,9 +336,9 @@ const GEN_AI_RESPONSE_FINISH_REASON_VALUE_STOP = 'stop';
 const GEN_AI_RESPONSE_FINISH_REASON_VALUE_TOOL_CALLS = 'tool_calls';
 const ATTR_HTTP_REQUEST_URL = 'http.request.url';
 const ATTR_HTTP_REQUEST_BODY = 'http.request.body';
-const ATTR_HTTP_REQUEST_HEADERS = 'http.request.header';
+const ATTR_HTTP_REQUEST_HEADER = 'http.request.header';
 const ATTR_HTTP_RESPONSE_BODY = 'http.response.body';
-const ATTR_HTTP_RESPONSE_HEADERS = 'http.response.header';
+const ATTR_HTTP_RESPONSE_HEADER = 'http.response.header';
 /* Note: Schemas for span ingestion following OpenTelemetry service request specification */
 var Otlp;
 (function (Otlp) {
@@ -318,10 +370,22 @@ var Otlp;
         spanId: zod.z.string(),
         attributes: zod.z.array(Otlp.attributeSchema).optional(),
     });
+    (function (StatusCode) {
+        StatusCode[StatusCode["Unset"] = 0] = "Unset";
+        StatusCode[StatusCode["Ok"] = 1] = "Ok";
+        StatusCode[StatusCode["Error"] = 2] = "Error";
+    })(Otlp.StatusCode || (Otlp.StatusCode = {}));
     Otlp.statusSchema = zod.z.object({
         code: zod.z.number(),
         message: zod.z.string().optional(),
     });
+    (function (SpanKind) {
+        SpanKind[SpanKind["Internal"] = 0] = "Internal";
+        SpanKind[SpanKind["Server"] = 1] = "Server";
+        SpanKind[SpanKind["Client"] = 2] = "Client";
+        SpanKind[SpanKind["Producer"] = 3] = "Producer";
+        SpanKind[SpanKind["Consumer"] = 4] = "Consumer";
+    })(Otlp.SpanKind || (Otlp.SpanKind = {}));
     Otlp.spanSchema = zod.z.object({
         traceId: zod.z.string(),
         spanId: zod.z.string(),
@@ -367,6 +431,16 @@ zod.z.object({
     isError: zod.z.boolean().optional(),
     text: zod.z.string().optional(),
 });
+var FinishReason;
+(function (FinishReason) {
+    FinishReason["Stop"] = "stop";
+    FinishReason["Length"] = "length";
+    FinishReason["ContentFilter"] = "content-filter";
+    FinishReason["ToolCalls"] = "tool-calls";
+    FinishReason["Error"] = "error";
+    FinishReason["Other"] = "other";
+    FinishReason["Unknown"] = "unknown";
+})(FinishReason || (FinishReason = {}));
 
 var ParameterType;
 (function (ParameterType) {
@@ -722,6 +796,7 @@ var IntegrationType;
     IntegrationType["Latitude"] = "latitude";
     IntegrationType["ExternalMCP"] = "custom_mcp";
     IntegrationType["HostedMCP"] = "mcp_server";
+    IntegrationType["Pipedream"] = "pipedream";
 })(IntegrationType || (IntegrationType = {}));
 var HostedIntegrationType;
 (function (HostedIntegrationType) {
@@ -1029,7 +1104,7 @@ class ManualInstrumentation {
         }
         const start = options || {};
         let operation = undefined;
-        if (GENAI_SPANS.includes(type)) {
+        if (SPAN_SPECIFICATIONS[type].isGenAI) {
             operation = type;
         }
         const span = this.tracer.startSpan(name, {
@@ -1347,18 +1422,18 @@ class ManualInstrumentation {
         };
     }
     embedding(ctx, options) {
-        return this.span(ctx, options?.name || 'Embedding', SpanType.Embedding, options);
+        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Embedding].name, SpanType.Embedding, options);
     }
     retrieval(ctx, options) {
-        return this.span(ctx, options?.name || 'Retrieval', SpanType.Retrieval, options);
+        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Retrieval].name, SpanType.Retrieval, options);
     }
     reranking(ctx, options) {
-        return this.span(ctx, options?.name || 'Reranking', SpanType.Reranking, options);
+        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Reranking].name, SpanType.Reranking, options);
     }
     attribifyHeaders(direction, headers) {
         const prefix = direction === 'request'
-            ? ATTR_HTTP_REQUEST_HEADERS
-            : ATTR_HTTP_RESPONSE_HEADERS;
+            ? ATTR_HTTP_REQUEST_HEADER
+            : ATTR_HTTP_RESPONSE_HEADER;
         const attributes = {};
         for (const key in headers) {
             const field = this.toKebabCase(key);
@@ -1372,6 +1447,7 @@ class ManualInstrumentation {
     http(ctx, options) {
         const start = options;
         const method = start.request.method.toUpperCase();
+        // Note: do not serialize headers as a single attribute because fields won't be redacted
         const attrHeaders = this.attribifyHeaders('request', start.request.headers);
         let finalBody = '';
         if (typeof start.request.body === 'string') {
@@ -1398,6 +1474,7 @@ class ManualInstrumentation {
             context: span.context,
             end: (options) => {
                 const end = options;
+                // Note: do not serialize headers as a single attribute because fields won't be redacted
                 const attrHeaders = this.attribifyHeaders('response', end.response.headers);
                 let finalBody = '';
                 if (typeof end.response.body === 'string') {
@@ -1446,9 +1523,7 @@ class ManualInstrumentation {
         };
         ctx = this.setBaggage(ctx, baggage, options.baggage);
         // Dummy wrapper to force the same trace and carry on some segment attributes
-        const span = this.span(ctx, type, SpanType.Segment, {
-            attributes: options.attributes,
-        });
+        const span = this.span(ctx, SEGMENT_SPECIFICATIONS[type].name, SpanType.Segment, { attributes: options.attributes });
         let carrier = {};
         otel.propagation.inject(span.context, carrier);
         baggage.segments.at(-1).traceparent = carrier.traceparent;
@@ -1681,7 +1756,7 @@ class LatitudeInstrumentation {
     }
 }
 
-const TRACES_URL = `${env.GATEWAY_BASE_URL}/api/v3/otlp/v1/traces`;
+const TRACES_URL = `${env.GATEWAY_BASE_URL}/api/v3/traces`;
 const SERVICE_NAME = process.env.npm_package_name || 'unknown';
 const SCOPE_VERSION = process.env.npm_package_version || 'unknown';
 const BACKGROUND = () => otel__namespace.ROOT_CONTEXT;