@latitude-data/telemetry 1.0.3 → 1.1.0

package/dist/index.d.ts

@@ -1,23 +1,9 @@
 import * as otel from '@opentelemetry/api';
 import { TextMapPropagator } from '@opentelemetry/api';
-import { SpanProcessor, ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-node';
+import { SpanProcessor, ReadableSpan, SpanExporter, NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 import * as latitude from '@latitude-data/sdk';
 import { z } from 'zod';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import * as anthropic from '@anthropic-ai/sdk';
-import * as bedrock from '@aws-sdk/client-bedrock-runtime';
-import * as azure from '@azure/openai';
-import * as aiplatform from '@google-cloud/aiplatform';
-import * as vertexai from '@google-cloud/vertexai';
-import * as langchain_runnables from '@langchain/core/runnables';
-import * as langchain_vectorstores from '@langchain/core/vectorstores';
-import * as cohere from 'cohere-ai';
-import * as langchain_agents from 'langchain/agents';
-import * as langchain_chains from 'langchain/chains';
-import * as langchain_tools from 'langchain/tools';
-import * as llamaindex from 'llamaindex';
-import * as openai from 'openai';
-import * as togetherai from 'together-ai';
 
 interface RedactSpanProcessorOptions {
     attributes: (string | RegExp)[];
@@ -35,121 +21,39 @@ declare class RedactSpanProcessor implements SpanProcessor {
 }
 declare const DEFAULT_REDACT_SPAN_PROCESSOR: () => RedactSpanProcessor;
 
-declare enum SegmentSource {
+interface BaseInstrumentation {
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
+}
+
+type LatitudeInstrumentationOptions = {
+    module: typeof latitude.Latitude;
+    completions?: boolean;
+};
+
+declare enum LogSources {
     API = "api",
-    AgentAsTool = "agent_as_tool",// TODO(tracing): deprecated, use SegmentType.Document with DocumentType.Agent instead
+    AgentAsTool = "agent_as_tool",
     Copilot = "copilot",
     EmailTrigger = "email_trigger",
-    Evaluation = "evaluation",// Note: from prompts of llm evaluations
+    Evaluation = "evaluation",
     Experiment = "experiment",
+    IntegrationTrigger = "integration_trigger",
     Playground = "playground",
     ScheduledTrigger = "scheduled_trigger",
-    IntegrationTrigger = "integration_trigger",
     SharedPrompt = "shared_prompt",
+    ShadowTest = "shadow_test",
+    ABTestChallenger = "ab_test_challenger",
     User = "user"
 }
-declare enum SegmentType {
-    Document = "document",
-    Step = "step"
-}
-declare const segmentBaggageSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
-    id: z.ZodString;
-    parentId: z.ZodOptional<z.ZodString>;
-    source: z.ZodNativeEnum<typeof SegmentSource>;
-}, {
-    type: z.ZodLiteral<SegmentType.Document>;
-    data: z.ZodObject<{
-        logUuid: z.ZodOptional<z.ZodString>;
-        commitUuid: z.ZodString;
-        documentUuid: z.ZodString;
-        experimentUuid: z.ZodOptional<z.ZodString>;
-        externalId: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        commitUuid: string;
-        documentUuid: string;
-        logUuid?: string | undefined;
-        experimentUuid?: string | undefined;
-        externalId?: string | undefined;
-    }, {
-        commitUuid: string;
-        documentUuid: string;
-        logUuid?: string | undefined;
-        experimentUuid?: string | undefined;
-        externalId?: string | undefined;
-    }>;
-}>, "strip", z.ZodTypeAny, {
-    id: string;
-    type: SegmentType.Document;
-    data: {
-        commitUuid: string;
-        documentUuid: string;
-        logUuid?: string | undefined;
-        experimentUuid?: string | undefined;
-        externalId?: string | undefined;
-    };
-    source: SegmentSource;
-    parentId?: string | undefined;
-}, {
-    id: string;
-    type: SegmentType.Document;
-    data: {
-        commitUuid: string;
-        documentUuid: string;
-        logUuid?: string | undefined;
-        experimentUuid?: string | undefined;
-        externalId?: string | undefined;
-    };
-    source: SegmentSource;
-    parentId?: string | undefined;
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    id: z.ZodString;
-    parentId: z.ZodOptional<z.ZodString>;
-    source: z.ZodNativeEnum<typeof SegmentSource>;
-}, {
-    type: z.ZodLiteral<SegmentType.Step>;
-    data: z.ZodOptional<z.ZodUndefined>;
-}>, "strip", z.ZodTypeAny, {
-    id: string;
-    type: SegmentType.Step;
-    source: SegmentSource;
-    data?: undefined;
-    parentId?: string | undefined;
-}, {
-    id: string;
-    type: SegmentType.Step;
-    source: SegmentSource;
-    data?: undefined;
-    parentId?: string | undefined;
-}>]>;
-type SegmentBaggage<T extends SegmentType = SegmentType> = Extract<z.infer<typeof segmentBaggageSchema>, {
-    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;
-}>;
+}, z.core.$strip>;
 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;
-};
 
 type StartSpanOptions = {
     name?: string;
@@ -177,18 +81,21 @@ type EndToolSpanOptions = EndSpanOptions & {
 type StartCompletionSpanOptions = StartSpanOptions & {
     provider: string;
     model: string;
-    configuration: Record<string, unknown>;
-    input: Record<string, unknown>[];
+    configuration?: Record<string, unknown>;
+    input?: Record<string, unknown>[];
+    versionUuid?: string;
+    promptUuid?: string;
+    experimentUuid?: string;
 };
 type EndCompletionSpanOptions = EndSpanOptions & {
-    output: Record<string, unknown>[];
-    tokens: {
-        prompt: number;
-        cached: number;
-        reasoning: number;
-        completion: number;
+    output?: Record<string, unknown>[];
+    tokens?: {
+        prompt?: number;
+        cached?: number;
+        reasoning?: number;
+        completion?: number;
     };
-    finishReason: string;
+    finishReason?: string;
 };
 type StartHttpSpanOptions = StartSpanOptions & {
     request: {
@@ -205,104 +112,62 @@ type EndHttpSpanOptions = EndSpanOptions & {
         body: string | Record<string, unknown>;
     };
 };
-type SegmentOptions = {
-    attributes?: otel.Attributes;
-    baggage?: Record<string, otel.BaggageEntry>;
-    _internal?: {
-        id?: string;
-        source?: SegmentSource;
-    };
-};
-type PromptSegmentOptions = SegmentOptions & {
-    logUuid?: string;
+type PromptSpanOptions = StartSpanOptions & {
+    documentLogUuid: string;
     versionUuid?: string;
     promptUuid: string;
+    projectId?: number;
     experimentUuid?: string;
+    testDeploymentId?: number;
     externalId?: string;
     template: string;
     parameters?: Record<string, unknown>;
+    source?: LogSources;
 };
-
-type TelemetryContext = otel.Context;
-declare const BACKGROUND: () => otel.Context;
-declare class ScopedTracerProvider implements otel.TracerProvider {
-    private readonly scope;
-    private readonly version;
-    private readonly provider;
-    constructor(scope: string, version: string, provider: otel.TracerProvider);
-    getTracer(_name: string, _version?: string, options?: otel.TracerOptions): otel.Tracer;
-}
-declare const DEFAULT_SPAN_EXPORTER: (apiKey: string) => OTLPTraceExporter;
-declare enum Instrumentation {
-    Latitude = "latitude",
-    OpenAI = "openai",
-    Anthropic = "anthropic",
-    AzureOpenAI = "azure",
-    VercelAI = "vercelai",
-    VertexAI = "vertexai",
-    AIPlatform = "aiplatform",
-    Bedrock = "bedrock",
-    TogetherAI = "togetherai",
-    Cohere = "cohere",
-    Langchain = "langchain",
-    LlamaIndex = "llamaindex"
-}
-type TelemetryOptions = {
-    instrumentations?: {
-        [Instrumentation.Latitude]?: typeof latitude.Latitude | LatitudeInstrumentationOptions;
-        [Instrumentation.OpenAI]?: typeof openai.OpenAI;
-        [Instrumentation.Anthropic]?: typeof anthropic;
-        [Instrumentation.AzureOpenAI]?: typeof azure;
-        [Instrumentation.VercelAI]?: 'manual';
-        [Instrumentation.VertexAI]?: typeof vertexai;
-        [Instrumentation.AIPlatform]?: typeof aiplatform;
-        [Instrumentation.Bedrock]?: typeof bedrock;
-        [Instrumentation.TogetherAI]?: typeof togetherai.Together;
-        [Instrumentation.Cohere]?: typeof cohere;
-        [Instrumentation.Langchain]?: {
-            chainsModule: typeof langchain_chains;
-            agentsModule: typeof langchain_agents;
-            toolsModule: typeof langchain_tools;
-            vectorStoreModule: typeof langchain_vectorstores;
-            runnablesModule: typeof langchain_runnables;
-        };
-        [Instrumentation.LlamaIndex]?: typeof llamaindex;
-    };
-    disableBatch?: boolean;
-    exporter?: SpanExporter;
-    processors?: SpanProcessor[];
-    propagators?: TextMapPropagator[];
+type ChatSpanOptions = StartSpanOptions & {
+    documentLogUuid: string;
+    previousTraceId: string;
+    source?: LogSources;
 };
-declare class LatitudeTelemetry {
-    private options;
-    private provider;
-    private telemetry;
-    private instrumentations;
-    constructor(apiKey: string, options?: TelemetryOptions);
-    flush(): Promise<void>;
-    shutdown(): Promise<void>;
-    tracerProvider(instrumentation: Instrumentation): ScopedTracerProvider;
-    tracer(instrumentation: Instrumentation): otel.Tracer;
-    private initInstrumentations;
-    instrument(): void;
-    uninstrument(): void;
-    baggage(ctx: otel.Context | TraceContext): TraceBaggage | undefined;
-    pause(ctx: otel.Context): {
-        traceparent: string;
-        tracestate?: string | undefined;
-        baggage?: string | undefined;
-    };
+type ExternalSpanOptions = StartSpanOptions & {
+    promptUuid: string;
+    documentLogUuid: string;
+    source?: LogSources;
+    versionUuid?: string;
+    externalId?: string;
+};
+type CaptureOptions = StartSpanOptions & {
+    path: string;
+    projectId: number;
+    versionUuid?: string;
+    conversationUuid?: string;
+};
+declare class ManualInstrumentation implements BaseInstrumentation {
+    private enabled;
+    private readonly tracer;
+    constructor(tracer: otel.Tracer);
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
     resume(ctx: TraceContext): otel.Context;
-    restored(ctx: otel.Context): boolean;
-    restore(ctx: otel.Context): otel.Context;
+    private capitalize;
+    private toCamelCase;
+    private toSnakeCase;
+    private toKebabCase;
+    private error;
+    private span;
     tool(ctx: otel.Context, options: StartToolSpanOptions): {
         context: otel.Context;
         end: (options: EndToolSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
     };
+    private attribifyMessageToolCalls;
+    private attribifyMessageContent;
+    private attribifyMessages;
+    private attribifyConfiguration;
     completion(ctx: otel.Context, options: StartCompletionSpanOptions): {
         context: otel.Context;
-        end: (options: EndCompletionSpanOptions) => void;
+        end: (options?: EndCompletionSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
     };
     embedding(ctx: otel.Context, options?: StartSpanOptions): {
@@ -320,22 +185,169 @@ declare class LatitudeTelemetry {
         end: (_options?: EndSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
     };
+    private attribifyHeaders;
     http(ctx: otel.Context, options: StartHttpSpanOptions): {
         context: otel.Context;
         end: (options: EndHttpSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
     };
-    prompt(ctx: otel.Context, options: PromptSegmentOptions): {
+    prompt(ctx: otel.Context, { documentLogUuid, versionUuid, promptUuid, projectId, experimentUuid, testDeploymentId, externalId, template, parameters, name, source, ...rest }: PromptSpanOptions): {
         context: otel.Context;
         end: (_options?: EndSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
     };
-    step(ctx: otel.Context, options?: SegmentOptions): {
+    step(ctx: otel.Context, options?: StartSpanOptions): {
         context: otel.Context;
         end: (_options?: EndSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
     };
+    chat(ctx: otel.Context, { documentLogUuid, previousTraceId, source, name, ...rest }: ChatSpanOptions): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    external(ctx: otel.Context, { promptUuid, documentLogUuid, source, versionUuid, externalId, name, ...rest }: ExternalSpanOptions): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    unresolvedExternal(ctx: otel.Context, { path, projectId, versionUuid, conversationUuid, name, ...rest }: CaptureOptions): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+}
+
+type TelemetryContext = otel.Context;
+declare const BACKGROUND: () => otel.Context;
+declare class SpanFactory {
+    private telemetry;
+    constructor(telemetry: ManualInstrumentation);
+    tool(options: StartToolSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (options: EndToolSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    completion(options: StartCompletionSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (options?: EndCompletionSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    embedding(options?: StartSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    retrieval(options?: StartSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    reranking(options?: StartSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    http(options: StartHttpSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (options: EndHttpSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    prompt(options: PromptSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    step(options?: StartSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    chat(options: ChatSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    external(options: ExternalSpanOptions, ctx?: TelemetryContext): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+}
+declare class ContextManager {
+    private telemetry;
+    constructor(telemetry: ManualInstrumentation);
+    resume(ctx: TraceContext): otel.Context;
+    active(): otel.Context;
+}
+declare class InstrumentationManager {
+    private instrumentations;
+    constructor(instrumentations: BaseInstrumentation[]);
+    enable(): void;
+    disable(): void;
+}
+declare class TracerManager {
+    private nodeProvider;
+    private scopeVersion;
+    constructor(nodeProvider: NodeTracerProvider, scopeVersion: string);
+    get(scope: Instrumentation): otel.Tracer;
+    provider(scope: Instrumentation): ScopedTracerProvider;
+}
+declare class ScopedTracerProvider implements otel.TracerProvider {
+    private readonly scope;
+    private readonly version;
+    private readonly provider;
+    constructor(scope: string, version: string, provider: otel.TracerProvider);
+    getTracer(_name: string, _version?: string, options?: otel.TracerOptions): otel.Tracer;
+}
+declare const DEFAULT_SPAN_EXPORTER: (apiKey: string) => OTLPTraceExporter;
+declare enum Instrumentation {
+    Anthropic = "anthropic",
+    AIPlatform = "aiplatform",
+    Bedrock = "bedrock",
+    Cohere = "cohere",
+    Langchain = "langchain",
+    Latitude = "latitude",
+    LlamaIndex = "llamaindex",
+    OpenAI = "openai",
+    TogetherAI = "togetherai",
+    VertexAI = "vertexai"
+}
+type TelemetryOptions = {
+    disableBatch?: boolean;
+    exporter?: SpanExporter;
+    processors?: SpanProcessor[];
+    propagators?: TextMapPropagator[];
+    instrumentations?: {
+        [Instrumentation.Latitude]?: typeof latitude.Latitude | LatitudeInstrumentationOptions;
+        [Instrumentation.AIPlatform]?: any;
+        [Instrumentation.Anthropic]?: any;
+        [Instrumentation.Bedrock]?: any;
+        [Instrumentation.Cohere]?: any;
+        [Instrumentation.OpenAI]?: any;
+        [Instrumentation.LlamaIndex]?: any;
+        [Instrumentation.TogetherAI]?: any;
+        [Instrumentation.VertexAI]?: any;
+        [Instrumentation.Langchain]?: {
+            callbackManagerModule?: any;
+        };
+    };
+};
+declare class LatitudeTelemetry {
+    private options;
+    private nodeProvider;
+    private manualInstrumentation;
+    private instrumentationsList;
+    readonly span: SpanFactory;
+    readonly context: ContextManager;
+    readonly instrumentation: InstrumentationManager;
+    readonly tracer: TracerManager;
+    constructor(apiKey: string, options?: TelemetryOptions);
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private initInstrumentations;
+    capture<T>(options: CaptureOptions, fn: (ctx: TelemetryContext) => T | Promise<T>): Promise<T>;
 }
 
 export { BACKGROUND, DEFAULT_REDACT_SPAN_PROCESSOR, DEFAULT_SPAN_EXPORTER, Instrumentation, LatitudeTelemetry, RedactSpanProcessor };
-export type { EndCompletionSpanOptions, EndHttpSpanOptions, EndSpanOptions, EndToolSpanOptions, ErrorOptions, PromptSegmentOptions, RedactSpanProcessorOptions, SegmentOptions, StartCompletionSpanOptions, StartHttpSpanOptions, StartSpanOptions, StartToolSpanOptions, TelemetryContext, TelemetryOptions };
+export type { CaptureOptions, ChatSpanOptions, EndCompletionSpanOptions, EndHttpSpanOptions, EndSpanOptions, EndToolSpanOptions, ErrorOptions, ExternalSpanOptions, PromptSpanOptions as PromptSegmentOptions, RedactSpanProcessorOptions, StartCompletionSpanOptions, StartHttpSpanOptions, StartSpanOptions, StartToolSpanOptions, TelemetryContext, TelemetryOptions };