@latitude-data/telemetry 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -35,6 +35,27 @@ declare class RedactSpanProcessor implements SpanProcessor {
 }
 declare const DEFAULT_REDACT_SPAN_PROCESSOR: () => RedactSpanProcessor;
 
+declare const traceContextSchema: z.ZodObject<{
+    traceparent: z.ZodString;
+    tracestate: z.ZodOptional<z.ZodString>;
+    baggage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    traceparent: string;
+    tracestate?: string | undefined;
+    baggage?: string | undefined;
+}, {
+    traceparent: string;
+    tracestate?: string | undefined;
+    baggage?: string | undefined;
+}>;
+type TraceContext = z.infer<typeof traceContextSchema>;
+type TraceBaggage = {
+    segment: Pick<SegmentBaggage, 'id' | 'parentId'>;
+    segments: (SegmentBaggage & Pick<TraceContext, 'traceparent' | 'tracestate'> & {
+        paused?: boolean;
+    })[];
+};
+
 declare enum SegmentSource {
     API = "api",
     Playground = "playground",
@@ -123,27 +144,6 @@ type SegmentBaggage<T extends SegmentType = SegmentType> = Extract<z.infer<typeo
     type: T;
 }>;
 
-declare const traceContextSchema: z.ZodObject<{
-    traceparent: z.ZodString;
-    tracestate: z.ZodOptional<z.ZodString>;
-    baggage: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    traceparent: string;
-    tracestate?: string | undefined;
-    baggage?: string | undefined;
-}, {
-    traceparent: string;
-    tracestate?: string | undefined;
-    baggage?: string | undefined;
-}>;
-type TraceContext = z.infer<typeof traceContextSchema>;
-type TraceBaggage = {
-    segment: Pick<SegmentBaggage, 'id' | 'parentId'>;
-    segments: (SegmentBaggage & Pick<TraceContext, 'traceparent' | 'tracestate'> & {
-        paused?: boolean;
-    })[];
-};
-
 type LatitudeInstrumentationOptions = {
     module: typeof latitude.Latitude;
     completions?: boolean;

package/dist/index.js

@@ -135,6 +135,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 = z.object({
     id: z.string(),
     parentId: z.string().optional(),
@@ -177,14 +187,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";
@@ -264,9 +316,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) {
@@ -298,10 +350,22 @@ var Otlp;
         spanId: z.string(),
         attributes: 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 = z.object({
         code: z.number(),
         message: 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 = z.object({
         traceId: z.string(),
         spanId: z.string(),
@@ -347,6 +411,16 @@ z.object({
     isError: z.boolean().optional(),
     text: 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) {
@@ -702,6 +776,7 @@ var IntegrationType;
     IntegrationType["Latitude"] = "latitude";
     IntegrationType["ExternalMCP"] = "custom_mcp";
     IntegrationType["HostedMCP"] = "mcp_server";
+    IntegrationType["Pipedream"] = "pipedream";
 })(IntegrationType || (IntegrationType = {}));
 var HostedIntegrationType;
 (function (HostedIntegrationType) {
@@ -1009,7 +1084,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, {
@@ -1327,18 +1402,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);
@@ -1352,6 +1427,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') {
@@ -1378,6 +1454,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') {
@@ -1426,9 +1503,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 = {};
         propagation.inject(span.context, carrier);
         baggage.segments.at(-1).traceparent = carrier.traceparent;
@@ -1661,7 +1736,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.ROOT_CONTEXT;