@latitude-data/telemetry 1.0.4 → 1.1.1

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 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 { Latitude } from '@latitude-data/sdk';
 import { z } from 'zod';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 
@@ -21,8 +22,14 @@ declare class RedactSpanProcessor implements SpanProcessor {
 }
 declare const DEFAULT_REDACT_SPAN_PROCESSOR: () => RedactSpanProcessor;
 
+interface BaseInstrumentation {
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
+}
+
 type LatitudeInstrumentationOptions = {
-    module: typeof latitude.Latitude;
+    module: typeof Latitude;
     completions?: boolean;
 };
 
@@ -39,7 +46,8 @@ declare enum LogSources {
     SharedPrompt = "shared_prompt",
     ShadowTest = "shadow_test",
     ABTestChallenger = "ab_test_challenger",
-    User = "user"
+    User = "user",
+    Optimization = "optimization"
 }
 
 declare const traceContextSchema: z.ZodObject<{
@@ -75,21 +83,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;
-    };
-    finishReason: string;
+    output?: Record<string, unknown>[];
+    tokens?: {
+        prompt?: number;
+        cached?: number;
+        reasoning?: number;
+        completion?: number;
+    };
+    finishReason?: string;
 };
 type StartHttpSpanOptions = StartSpanOptions & {
     request: {
@@ -107,10 +115,10 @@ type EndHttpSpanOptions = EndSpanOptions & {
     };
 };
 type PromptSpanOptions = StartSpanOptions & {
-    documentLogUuid?: string;
+    documentLogUuid: string;
     versionUuid?: string;
     promptUuid: string;
-    projectId?: string;
+    projectId?: number;
     experimentUuid?: string;
     testDeploymentId?: number;
     externalId?: string;
@@ -118,9 +126,147 @@ type PromptSpanOptions = StartSpanOptions & {
     parameters?: Record<string, unknown>;
     source?: LogSources;
 };
+type ChatSpanOptions = StartSpanOptions & {
+    documentLogUuid: string;
+    previousTraceId: string;
+    source?: LogSources;
+    versionUuid?: string;
+    promptUuid?: string;
+};
+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;
+    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;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    embedding(ctx: otel.Context, options?: StartSpanOptions): {
+        context: otel.Context;
+        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, { 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;
+    };
+    chat(ctx: otel.Context, { documentLogUuid, previousTraceId, source, name, versionUuid, promptUuid, ...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;
+    };
+    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;
+    };
+    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;
@@ -163,59 +309,19 @@ type TelemetryOptions = {
 };
 declare class LatitudeTelemetry {
     private options;
-    private provider;
-    private telemetry;
-    private instrumentations;
+    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>;
-    tracerProvider(instrumentation: Instrumentation): ScopedTracerProvider;
-    tracer(instrumentation: Instrumentation): otel.Tracer;
     private initInstrumentations;
-    instrument(): void;
-    uninstrument(): void;
-    resume(ctx: TraceContext): otel.Context;
-    tool(ctx: otel.Context, options: StartToolSpanOptions): {
-        context: otel.Context;
-        end: (options: EndToolSpanOptions) => void;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
-    completion(ctx: otel.Context, options: StartCompletionSpanOptions): {
-        context: otel.Context;
-        end: (options: EndCompletionSpanOptions) => void;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
-    embedding(ctx: otel.Context, options?: StartSpanOptions): {
-        context: otel.Context;
-        end: (_options?: EndSpanOptions) => void;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
-    retrieval(ctx: otel.Context, options?: StartSpanOptions): {
-        context: otel.Context;
-        end: (_options?: EndSpanOptions) => void;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
-    reranking(ctx: otel.Context, options?: StartSpanOptions): {
-        context: otel.Context;
-        end: (_options?: EndSpanOptions) => void;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
-    http(ctx: otel.Context, options: StartHttpSpanOptions): {
-        context: otel.Context;
-        end: (options: EndHttpSpanOptions) => void;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
-    prompt(ctx: otel.Context, options: PromptSpanOptions): {
-        context: otel.Context;
-        end: (_options?: EndSpanOptions) => void;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
-    step(ctx: otel.Context, options?: StartSpanOptions): {
-        context: otel.Context;
-        end: (_options?: EndSpanOptions) => void;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
+    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, PromptSpanOptions as PromptSegmentOptions, RedactSpanProcessorOptions, 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 };