@latitude-data/telemetry 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -141,20 +141,32 @@ const env = { GATEWAY_BASE_URL: GET_GATEWAY_BASE_URL() };
 var SegmentSource;
 (function (SegmentSource) {
     SegmentSource["API"] = "api";
-    SegmentSource["Playground"] = "playground";
-    SegmentSource["Evaluation"] = "evaluation";
-    SegmentSource["Experiment"] = "experiment";
-    SegmentSource["User"] = "user";
-    SegmentSource["SharedPrompt"] = "shared_prompt";
     SegmentSource["AgentAsTool"] = "agent_as_tool";
+    SegmentSource["Copilot"] = "copilot";
     SegmentSource["EmailTrigger"] = "email_trigger";
+    SegmentSource["Evaluation"] = "evaluation";
+    SegmentSource["Experiment"] = "experiment";
+    SegmentSource["Playground"] = "playground";
     SegmentSource["ScheduledTrigger"] = "scheduled_trigger";
+    SegmentSource["IntegrationTrigger"] = "integration_trigger";
+    SegmentSource["SharedPrompt"] = "shared_prompt";
+    SegmentSource["User"] = "user";
 })(SegmentSource || (SegmentSource = {}));
 var SegmentType;
 (function (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 +209,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: false,
+    },
+    [SpanType.Unknown]: {
+        name: 'Unknown',
+        description: 'An unknown span',
+        isGenAI: false,
+        isHidden: true,
+    },
+};
 var SpanStatus;
 (function (SpanStatus) {
     SpanStatus["Unset"] = "unset";
@@ -284,9 +338,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 +372,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(),
@@ -704,17 +770,18 @@ var LegacyChainEventTypes;
 
 var ChainEventTypes;
 (function (ChainEventTypes) {
+    ChainEventTypes["ChainCompleted"] = "chain-completed";
+    ChainEventTypes["ChainError"] = "chain-error";
     ChainEventTypes["ChainStarted"] = "chain-started";
-    ChainEventTypes["StepStarted"] = "step-started";
-    ChainEventTypes["ProviderStarted"] = "provider-started";
+    ChainEventTypes["IntegrationWakingUp"] = "integration-waking-up";
     ChainEventTypes["ProviderCompleted"] = "provider-completed";
-    ChainEventTypes["ToolsStarted"] = "tools-started";
-    ChainEventTypes["ToolCompleted"] = "tool-completed";
+    ChainEventTypes["ProviderStarted"] = "provider-started";
     ChainEventTypes["StepCompleted"] = "step-completed";
-    ChainEventTypes["ChainCompleted"] = "chain-completed";
-    ChainEventTypes["ChainError"] = "chain-error";
+    ChainEventTypes["StepStarted"] = "step-started";
+    ChainEventTypes["ToolCompleted"] = "tool-completed";
     ChainEventTypes["ToolsRequested"] = "tools-requested";
-    ChainEventTypes["IntegrationWakingUp"] = "integration-waking-up";
+    ChainEventTypes["ToolResult"] = "tool-result";
+    ChainEventTypes["ToolsStarted"] = "tools-started";
 })(ChainEventTypes || (ChainEventTypes = {}));
 
 var IntegrationType;
@@ -722,6 +789,7 @@ var IntegrationType;
     IntegrationType["Latitude"] = "latitude";
     IntegrationType["ExternalMCP"] = "custom_mcp";
     IntegrationType["HostedMCP"] = "mcp_server";
+    IntegrationType["Pipedream"] = "pipedream";
 })(IntegrationType || (IntegrationType = {}));
 var HostedIntegrationType;
 (function (HostedIntegrationType) {
@@ -826,6 +894,14 @@ var EvaluationResultableType;
     EvaluationResultableType["Number"] = "evaluation_resultable_numbers";
 })(EvaluationResultableType || (EvaluationResultableType = {}));
 
+var MessageRole;
+(function (MessageRole) {
+    MessageRole["system"] = "system";
+    MessageRole["user"] = "user";
+    MessageRole["assistant"] = "assistant";
+    MessageRole["tool"] = "tool";
+})(MessageRole || (MessageRole = {}));
+
 var ModifiedDocumentType;
 (function (ModifiedDocumentType) {
     ModifiedDocumentType["Created"] = "created";
@@ -861,6 +937,7 @@ var DocumentTriggerType;
 (function (DocumentTriggerType) {
     DocumentTriggerType["Email"] = "email";
     DocumentTriggerType["Scheduled"] = "scheduled";
+    DocumentTriggerType["Integration"] = "integration";
 })(DocumentTriggerType || (DocumentTriggerType = {}));
 var DocumentTriggerParameters;
 (function (DocumentTriggerParameters) {
@@ -1029,7 +1106,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 +1424,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 +1449,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 +1476,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 +1525,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;
@@ -1532,11 +1609,11 @@ class LatitudeInstrumentation {
     }
     async wrapToolHandler(fn, ...args) {
         const toolArguments = args[0];
-        const { toolId, toolName } = args[1];
+        const { id, name } = args[1];
         const $tool = this.telemetry.tool(otel.context.active(), {
-            name: toolName,
+            name,
             call: {
-                id: toolId,
+                id,
                 arguments: toolArguments,
             },
         });
@@ -1584,25 +1661,6 @@ class LatitudeInstrumentation {
         $prompt.end();
         return result;
     }
-    async wrapRenderAgent(fn, ...args) {
-        const { prompt, parameters } = args[0];
-        const $prompt = this.telemetry.prompt(otel.context.active(), {
-            versionUuid: prompt.versionUuid,
-            promptUuid: prompt.uuid,
-            template: prompt.content,
-            parameters: parameters,
-        });
-        let result;
-        try {
-            result = await otel.context.with($prompt.context, async () => await fn(...args));
-        }
-        catch (error) {
-            $prompt.fail(error);
-            throw error;
-        }
-        $prompt.end();
-        return result;
-    }
     async wrapRenderStep(fn, ...args) {
         const $step = this.telemetry.step(otel.context.active());
         let result;
@@ -1681,7 +1739,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;