@latitude-data/telemetry 1.1.0 → 2.0.0

package/dist/index.d.ts

@@ -1,26 +1,12 @@
+import { z } from 'zod';
 import * as otel from '@opentelemetry/api';
 import { TextMapPropagator } from '@opentelemetry/api';
+import { Provider } from 'rosetta-ai';
 import { SpanProcessor, ReadableSpan, SpanExporter, NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 import * as latitude from '@latitude-data/sdk';
-import { z } from 'zod';
+import { Latitude } from '@latitude-data/sdk';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 
-interface RedactSpanProcessorOptions {
-    attributes: (string | RegExp)[];
-    mask?: (attribute: string, value: any) => string;
-}
-declare class RedactSpanProcessor implements SpanProcessor {
-    private options;
-    constructor(options: RedactSpanProcessorOptions);
-    onStart(_span: ReadableSpan, _context: otel.Context): void;
-    onEnd(span: ReadableSpan): void;
-    forceFlush(): Promise<void>;
-    shutdown(): Promise<void>;
-    private shouldRedact;
-    private redactAttributes;
-}
-declare const DEFAULT_REDACT_SPAN_PROCESSOR: () => RedactSpanProcessor;
-
 interface BaseInstrumentation {
     isEnabled(): boolean;
     enable(): void;
@@ -28,7 +14,7 @@ interface BaseInstrumentation {
 }
 
 type LatitudeInstrumentationOptions = {
-    module: typeof latitude.Latitude;
+    module: typeof Latitude;
     completions?: boolean;
 };
 
@@ -45,7 +31,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<{
@@ -82,13 +69,13 @@ type StartCompletionSpanOptions = StartSpanOptions & {
     provider: string;
     model: string;
     configuration?: Record<string, unknown>;
-    input?: Record<string, unknown>[];
+    input?: string | Record<string, unknown>[];
     versionUuid?: string;
     promptUuid?: string;
     experimentUuid?: string;
 };
 type EndCompletionSpanOptions = EndSpanOptions & {
-    output?: Record<string, unknown>[];
+    output?: string | Record<string, unknown>[];
     tokens?: {
         prompt?: number;
         cached?: number;
@@ -128,6 +115,8 @@ type ChatSpanOptions = StartSpanOptions & {
     documentLogUuid: string;
     previousTraceId: string;
     source?: LogSources;
+    versionUuid?: string;
+    promptUuid?: string;
 };
 type ExternalSpanOptions = StartSpanOptions & {
     promptUuid: string;
@@ -142,66 +131,53 @@ type CaptureOptions = StartSpanOptions & {
     versionUuid?: string;
     conversationUuid?: string;
 };
+type ManualInstrumentationOptions = {
+    provider?: Provider;
+};
 declare class ManualInstrumentation implements BaseInstrumentation {
     private enabled;
     private readonly tracer;
-    constructor(tracer: otel.Tracer);
+    private readonly options;
+    constructor(tracer: otel.Tracer, options?: ManualInstrumentationOptions);
     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): {
+    unknown(ctx: otel.Context, options?: StartSpanOptions): {
         context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    tool(ctx: otel.Context, options: StartToolSpanOptions): {
         end: (options: EndToolSpanOptions) => void;
+        context: otel.Context;
         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;
-    };
-    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): {
+    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;
     };
-    step(ctx: otel.Context, options?: StartSpanOptions): {
+    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, ...rest }: ChatSpanOptions): {
+    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;
@@ -218,47 +194,53 @@ declare class ManualInstrumentation implements BaseInstrumentation {
     };
 }
 
+interface RedactSpanProcessorOptions {
+    attributes: (string | RegExp)[];
+    mask?: (attribute: string, value: any) => string;
+}
+declare class RedactSpanProcessor implements SpanProcessor {
+    private options;
+    constructor(options: RedactSpanProcessorOptions);
+    onStart(_span: ReadableSpan, _context: otel.Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private shouldRedact;
+    private redactAttributes;
+}
+declare const DEFAULT_REDACT_SPAN_PROCESSOR: () => RedactSpanProcessor;
+
 type TelemetryContext = otel.Context;
 declare const BACKGROUND: () => otel.Context;
 declare class SpanFactory {
-    private telemetry;
+    private readonly telemetry;
     constructor(telemetry: ManualInstrumentation);
-    tool(options: StartToolSpanOptions, ctx?: TelemetryContext): {
+    span(options?: StartSpanOptions, 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;
+        end: (_options?: EndSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
     };
-    embedding(options?: StartSpanOptions, ctx?: TelemetryContext): {
+    tool(options: StartToolSpanOptions, ctx?: TelemetryContext): {
+        end: (options: EndToolSpanOptions) => void;
         context: otel.Context;
-        end: (_options?: EndSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
     };
-    retrieval(options?: StartSpanOptions, ctx?: TelemetryContext): {
+    completion(options: StartCompletionSpanOptions, ctx?: TelemetryContext): {
+        end: (options?: EndCompletionSpanOptions) => void;
         context: otel.Context;
-        end: (_options?: EndSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
     };
-    reranking(options?: StartSpanOptions, ctx?: TelemetryContext): {
+    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;
     };
-    step(options?: StartSpanOptions, ctx?: TelemetryContext): {
+    prompt(options: PromptSpanOptions, ctx?: TelemetryContext): {
         context: otel.Context;
         end: (_options?: EndSpanOptions) => void;
         fail: (_error: Error, _options?: ErrorOptions) => void;
@@ -275,20 +257,21 @@ declare class SpanFactory {
     };
 }
 declare class ContextManager {
-    private telemetry;
+    private readonly telemetry;
     constructor(telemetry: ManualInstrumentation);
     resume(ctx: TraceContext): otel.Context;
     active(): otel.Context;
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(ctx: TelemetryContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
 }
 declare class InstrumentationManager {
-    private instrumentations;
+    private readonly instrumentations;
     constructor(instrumentations: BaseInstrumentation[]);
     enable(): void;
     disable(): void;
 }
 declare class TracerManager {
-    private nodeProvider;
-    private scopeVersion;
+    private readonly nodeProvider;
+    private readonly scopeVersion;
     constructor(nodeProvider: NodeTracerProvider, scopeVersion: string);
     get(scope: Instrumentation): otel.Tracer;
     provider(scope: Instrumentation): ScopedTracerProvider;
@@ -309,6 +292,7 @@ declare enum Instrumentation {
     Langchain = "langchain",
     Latitude = "latitude",
     LlamaIndex = "llamaindex",
+    Manual = "manual",
     OpenAI = "openai",
     TogetherAI = "togetherai",
     VertexAI = "vertexai"
@@ -331,6 +315,7 @@ type TelemetryOptions = {
         [Instrumentation.Langchain]?: {
             callbackManagerModule?: any;
         };
+        [Instrumentation.Manual]?: ManualInstrumentationOptions;
     };
 };
 declare class LatitudeTelemetry {
@@ -342,6 +327,7 @@ declare class LatitudeTelemetry {
     readonly context: ContextManager;
     readonly instrumentation: InstrumentationManager;
     readonly tracer: TracerManager;
+    private readonly lifecycle;
     constructor(apiKey: string, options?: TelemetryOptions);
     flush(): Promise<void>;
     shutdown(): Promise<void>;