@latitude-data/telemetry 2.0.2 → 3.0.0

package/dist/index.cjs

@@ -5,7 +5,6 @@ var incubating = require('@opentelemetry/semantic-conventions/incubating');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
 var otel = require('@opentelemetry/api');
 var rosettaAi = require('rosetta-ai');
-var uuid = require('uuid');
 var baggageSpanProcessor = require('@opentelemetry/baggage-span-processor');
 var contextAsyncHooks = require('@opentelemetry/context-async-hooks');
 var core = require('@opentelemetry/core');
@@ -218,17 +217,23 @@ const expectedOutputConfiguration = zod.z.object({
     fieldAccessor: zod.z.string().optional(), // Field accessor to get the output from if it's a key-value format
 });
 const EVALUATION_TRIGGER_TARGETS = ['first', 'every', 'last'];
-const DEFAULT_LAST_INTERACTION_DEBOUNCE_SECONDS = 120;
 const LAST_INTERACTION_DEBOUNCE_MIN_SECONDS = 30;
 const LAST_INTERACTION_DEBOUNCE_MAX_SECONDS = 60 * 60 * 24; // 1 day
+const MIN_EVALUATION_SAMPLE_RATE = 0; // 0%
+const MAX_EVALUATION_SAMPLE_RATE = 100; // 100%
 const triggerConfiguration = zod.z.object({
     target: zod.z.enum(EVALUATION_TRIGGER_TARGETS),
     lastInteractionDebounce: zod.z
         .number()
         .min(LAST_INTERACTION_DEBOUNCE_MIN_SECONDS)
         .max(LAST_INTERACTION_DEBOUNCE_MAX_SECONDS)
-        .optional()
-        .default(DEFAULT_LAST_INTERACTION_DEBOUNCE_SECONDS),
+        .optional(),
+    sampleRate: zod.z
+        .number()
+        .int()
+        .min(MIN_EVALUATION_SAMPLE_RATE)
+        .max(MAX_EVALUATION_SAMPLE_RATE)
+        .optional(),
 });
 const baseEvaluationConfiguration = zod.z.object({
     reverseScale: zod.z.boolean(), // If true, lower is better, otherwise, higher is better
@@ -941,16 +946,11 @@ const ATTRIBUTES = {
     // Custom attributes added and used by Latitude spans (Prompt / External / Chat)
     LATITUDE: {
         type: 'latitude.type',
-        documentUuid: 'latitude.document_uuid',
         promptPath: 'latitude.prompt_path',
         commitUuid: 'latitude.commit_uuid',
         documentLogUuid: 'latitude.document_log_uuid',
         projectId: 'latitude.project_id',
-        experimentUuid: 'latitude.experiment_uuid',
-        source: 'latitude.source',
         externalId: 'latitude.external_id',
-        testDeploymentId: 'latitude.test_deployment_id',
-        previousTraceId: 'latitude.previous_trace_id',
         // Custom additions to the GenAI semantic conventions (deprecated)
         request: {
             _root: 'gen_ai.request',
@@ -1171,6 +1171,12 @@ const OptimizationBudgetSchema = zod.z.object({
     tokens: zod.z.number().min(0).optional(),
 });
 zod.z.object({
+    dataset: zod.z
+        .object({
+        target: zod.z.number().min(0).optional(), // Note: number of rows to curate when not provided by the user
+        label: zod.z.string().optional(), // Note: expected output column when using a labeled evaluation
+    })
+        .optional(),
     parameters: zod.z
         .record(zod.z.string(), zod.z.object({
         column: zod.z.string().optional(), // Note: corresponding column in the user-provided trainset and testset
@@ -1188,7 +1194,6 @@ zod.z.object({
 });
 
 // TODO(tracing): deprecated
-const HEAD_COMMIT = 'live';
 var Providers;
 (function (Providers) {
     Providers["OpenAI"] = "openai";
@@ -1343,6 +1348,7 @@ class ManualInstrumentation {
             jsonArguments = '{}';
         }
         const span = this.span(ctx, start.name, SpanType.Tool, {
+            ...start,
             attributes: {
                 [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.name]: start.name,
                 [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.type]: VALUES.OPENTELEMETRY.GEN_AI.tool.type.function,
@@ -1430,6 +1436,7 @@ class ManualInstrumentation {
             jsonInput = '[]';
         }
         const span = this.span(ctx, start.name || `${start.provider} / ${start.model}`, SpanType.Completion, {
+            ...start,
             attributes: {
                 [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.system]: start.provider,
                 [ATTRIBUTES.LATITUDE.request.configuration]: jsonConfiguration,
@@ -1437,9 +1444,6 @@ class ManualInstrumentation {
                 [ATTRIBUTES.OPENTELEMETRY.GEN_AI.systemInstructions]: jsonSystem,
                 [ATTRIBUTES.OPENTELEMETRY.GEN_AI.input.messages]: jsonInput,
                 ...(start.attributes || {}),
-                [ATTRIBUTES.LATITUDE.commitUuid]: start.versionUuid,
-                [ATTRIBUTES.LATITUDE.documentUuid]: start.promptUuid,
-                [ATTRIBUTES.LATITUDE.experimentUuid]: start.experimentUuid,
             },
         });
         return {
@@ -1522,6 +1526,7 @@ class ManualInstrumentation {
             }
         }
         const span = this.span(ctx, start.name || `${method} ${start.request.url}`, SpanType.Http, {
+            ...start,
             attributes: {
                 [ATTRIBUTES.OPENTELEMETRY.HTTP.request.method]: method,
                 [ATTRIBUTES.OPENTELEMETRY.HTTP.request.url]: start.request.url,
@@ -1559,7 +1564,8 @@ class ManualInstrumentation {
             },
         };
     }
-    prompt(ctx, { documentLogUuid, versionUuid, promptUuid, projectId, experimentUuid, testDeploymentId, externalId, template, parameters, name, source, ...rest }) {
+    prompt(ctx, options) {
+        const { template, parameters, name, attributes: userAttributes } = options;
         let jsonParameters = '';
         try {
             jsonParameters = JSON.stringify(parameters || {});
@@ -1570,51 +1576,27 @@ class ManualInstrumentation {
         const attributes = {
             [ATTRIBUTES.LATITUDE.request.template]: template,
             [ATTRIBUTES.LATITUDE.request.parameters]: jsonParameters,
-            [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid || HEAD_COMMIT,
-            [ATTRIBUTES.LATITUDE.documentUuid]: promptUuid,
-            [ATTRIBUTES.LATITUDE.projectId]: projectId,
-            [ATTRIBUTES.LATITUDE.documentLogUuid]: documentLogUuid,
-            ...(experimentUuid && {
-                [ATTRIBUTES.LATITUDE.experimentUuid]: experimentUuid,
-            }),
-            ...(testDeploymentId && {
-                [ATTRIBUTES.LATITUDE.testDeploymentId]: testDeploymentId,
-            }),
-            ...(externalId && { [ATTRIBUTES.LATITUDE.externalId]: externalId }),
-            ...(source && { [ATTRIBUTES.LATITUDE.source]: source }),
-            ...(rest.attributes || {}),
+            ...(userAttributes || {}),
         };
-        return this.span(ctx, name || `prompt-${promptUuid}`, SpanType.Prompt, {
-            attributes,
-        });
+        return this.span(ctx, name || 'prompt', SpanType.Prompt, { attributes });
     }
-    chat(ctx, { documentLogUuid, previousTraceId, source, name, versionUuid, promptUuid, ...rest }) {
+    chat(ctx, options) {
+        const { name, attributes: userAttributes } = options;
         const attributes = {
-            [ATTRIBUTES.LATITUDE.documentLogUuid]: documentLogUuid,
-            [ATTRIBUTES.LATITUDE.previousTraceId]: previousTraceId,
-            ...(versionUuid && { [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid }),
-            ...(promptUuid && { [ATTRIBUTES.LATITUDE.documentUuid]: promptUuid }),
-            ...(source && { [ATTRIBUTES.LATITUDE.source]: source }),
-            ...(rest.attributes || {}),
+            ...(userAttributes || {}),
         };
-        return this.span(ctx, name || `chat-${documentLogUuid}`, SpanType.Chat, {
-            attributes,
-        });
+        return this.span(ctx, name || 'chat', SpanType.Chat, { attributes });
     }
-    external(ctx, { promptUuid, documentLogUuid, source, versionUuid, externalId, name, ...rest }) {
+    external(ctx, options) {
+        const { externalId, name, attributes: userAttributes } = options;
         const attributes = {
-            [ATTRIBUTES.LATITUDE.documentUuid]: promptUuid,
-            [ATTRIBUTES.LATITUDE.documentLogUuid]: documentLogUuid,
-            [ATTRIBUTES.LATITUDE.source]: source ?? LogSources.API,
-            ...(versionUuid && { [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid }),
             ...(externalId && { [ATTRIBUTES.LATITUDE.externalId]: externalId }),
-            ...(rest.attributes || {}),
+            ...(userAttributes || {}),
         };
-        return this.span(ctx, name || `external-${promptUuid}`, SpanType.External, {
-            attributes,
-        });
+        return this.span(ctx, name || 'external', SpanType.External, { attributes });
     }
-    unresolvedExternal(ctx, { path, projectId, versionUuid, conversationUuid, name, ...rest }) {
+    unresolvedExternal(ctx, options) {
+        const { path, projectId, versionUuid, conversationUuid, name, attributes: userAttributes, } = options;
         const attributes = {
             [ATTRIBUTES.LATITUDE.promptPath]: path,
             [ATTRIBUTES.LATITUDE.projectId]: projectId,
@@ -1622,7 +1604,7 @@ class ManualInstrumentation {
             ...(conversationUuid && {
                 [ATTRIBUTES.LATITUDE.documentLogUuid]: conversationUuid,
             }),
-            ...(rest.attributes || {}),
+            ...(userAttributes || {}),
         };
         return this.span(ctx, name || `capture-${path}`, SpanType.UnresolvedExternal, { attributes });
     }
@@ -1668,9 +1650,6 @@ class LatitudeInstrumentation {
     async wrapRenderChain(fn, ...args) {
         const { prompt, parameters } = args[0];
         const $prompt = this.manualTelemetry.prompt(otel.context.active(), {
-            documentLogUuid: uuid.v4(),
-            versionUuid: prompt.versionUuid,
-            promptUuid: prompt.uuid,
             template: prompt.content,
             parameters: parameters,
         });
@@ -1874,6 +1853,51 @@ class ContextManager {
     with(ctx, fn, thisArg, ...args) {
         return otel.context.with(ctx, fn, thisArg, ...args);
     }
+    /**
+     * Sets custom attributes in the OpenTelemetry baggage that will be
+     * automatically propagated to all child spans in the trace.
+     *
+     * This is useful for setting trace-level metadata that should be
+     * inherited by all spans without manually passing them to each span.
+     *
+     * Example:
+     * ```typescript
+     * const ctx = telemetry.context.setAttributes(
+     *   telemetry.context.active(),
+     *   {
+     *     'latitude.documentLogUuid': 'uuid-123',
+     *     'latitude.documentUuid': 'prompt-456',
+     *     'latitude.commitUuid': 'commit-789',
+     *     'latitude.projectId': '123',
+     *     'custom.attribute': 'value'
+     *   }
+     * )
+     *
+     * // Latitude keys are normalized to snake_case in baggage:
+     * // latitude.document_log_uuid, latitude.document_uuid, ...
+     *
+     * // Use context.with() to make the context active
+     * // All spans created within this context will automatically
+     * // inherit the baggage attributes without explicitly passing ctx
+     * telemetry.context.with(ctx, () => {
+     *   telemetry.span.tool({ name: 'my-tool', call: { id: '1', arguments: {} } })
+     *   // ... other spans
+     * })
+     * ```
+     */
+    setAttributes(ctx, attributes) {
+        const baggage = otel.propagation.getBaggage(ctx) || otel.propagation.createBaggage({});
+        const newBaggage = Object.entries(attributes).reduce((bag, [key, value]) => bag.setEntry(this.normalizeBaggageKey(key), { value }), baggage);
+        return otel.propagation.setBaggage(ctx, newBaggage);
+    }
+    normalizeBaggageKey(key) {
+        if (!key.startsWith('latitude.'))
+            return key;
+        const [namespace, ...path] = key.split('.');
+        if (!namespace || path.length === 0)
+            return key;
+        return [namespace, ...path.map(toSnakeCase)].join('.');
+    }
 }
 class InstrumentationManager {
     instrumentations;