@latitude-data/telemetry 0.0.4 → 1.0.1

package/dist/index.d.ts

@@ -1,152 +1,339 @@
-import * as _opentelemetry_api from '@opentelemetry/api';
-import { OTLPExporterBase, OTLPExporterConfigBase } from '@opentelemetry/otlp-exporter-base';
-import { SpanExporter, ReadableSpan, SimpleSpanProcessor, SpanProcessor, BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { SpanExporter as SpanExporter$1, SimpleSpanProcessor as SimpleSpanProcessor$1, BatchSpanProcessor as BatchSpanProcessor$1 } from '@opentelemetry/sdk-trace-node';
-import * as openai from 'openai';
+import * as otel from '@opentelemetry/api';
+import { TextMapPropagator } from '@opentelemetry/api';
+import { SpanProcessor, ReadableSpan, SpanExporter } 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 azure from '@azure/openai';
-import * as cohere from 'cohere-ai';
 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 pinecone from '@pinecone-database/pinecone';
-import * as ChainsModule from 'langchain/chains';
-import * as AgentsModule from 'langchain/agents';
-import * as ToolsModule from 'langchain/tools';
-import * as RunnableModule from '@langchain/core/runnables';
-import * as VectorStoreModule from '@langchain/core/vectorstores';
+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 chromadb from 'chromadb';
-import * as qdrant from '@qdrant/js-client-rest';
+import * as openai from 'openai';
+import * as togetherai from 'together-ai';
 
-interface OTLPHttpExporterConfig extends OTLPExporterConfigBase {
-    apiKey: string;
-    endpoint?: string;
+interface RedactSpanProcessorOptions {
+    attributes: (string | RegExp)[];
+    mask?: (attribute: string, value: any) => string;
 }
-declare class LatitudeExporter extends OTLPExporterBase<any, any, any> implements SpanExporter {
-    url: string;
-    private headers;
-    constructor(config: OTLPHttpExporterConfig);
-    export(spans: ReadableSpan[], resultCallback: (result: any) => void): Promise<void>;
+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>;
-    onShutdown(): Promise<void>;
-    onInit(): Promise<void>;
-    send(spans: ReadableSpan[], onSuccess: () => void, onError: (error: Error) => void): Promise<void>;
-    convert(spans: ReadableSpan[]): {
-        resourceSpans: {
-            resource: {
-                attributes: {
-                    key: string;
-                    value: {
-                        stringValue?: string;
-                        intValue?: number;
-                        boolValue?: boolean;
-                    };
-                }[];
-            };
-            scopeSpans: {
-                spans: {
-                    traceId: string;
-                    spanId: string;
-                    parentSpanId: string | undefined;
-                    name: string;
-                    kind: _opentelemetry_api.SpanKind;
-                    startTimeUnixNano: string;
-                    endTimeUnixNano: string | undefined;
-                    attributes: {
-                        key: string;
-                        value: {
-                            stringValue?: string;
-                            intValue?: number;
-                            boolValue?: boolean;
-                        };
-                    }[];
-                    status: {
-                        code: _opentelemetry_api.SpanStatusCode;
-                        message: string | undefined;
-                    };
-                    events: {
-                        timeUnixNano: string;
-                        name: string;
-                        attributes: {
-                            key: string;
-                            value: {
-                                stringValue?: string;
-                                intValue?: number;
-                                boolValue?: boolean;
-                            };
-                        }[];
-                    }[];
-                    links: {
-                        traceId: string;
-                        spanId: string;
-                        attributes: {
-                            key: string;
-                            value: {
-                                stringValue?: string;
-                                intValue?: number;
-                                boolValue?: boolean;
-                            };
-                        }[];
-                    }[];
-                }[];
-            }[];
-        }[];
-    };
-    getDefaultUrl(config: any): string;
-    private get __defaultUrl();
-    private convertAttributes;
-    private convertAttributeValue;
+    private shouldRedact;
+    private redactAttributes;
 }
+declare const DEFAULT_REDACT_SPAN_PROCESSOR: () => RedactSpanProcessor;
 
-declare class VercelSpanProcessor extends SimpleSpanProcessor implements SpanProcessor {
-    onEnd(span: ReadableSpan): void;
+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;
+}>;
+type TraceContext = z.infer<typeof traceContextSchema>;
+type TraceBaggage = {
+    segment: Pick<SegmentBaggage, 'id' | 'parentId'>;
+    segments: (SegmentBaggage & Pick<TraceContext, 'traceparent' | 'tracestate'> & {
+        paused?: boolean;
+    })[];
+};
+
+declare enum SegmentSource {
+    API = "api",
+    Playground = "playground",
+    Evaluation = "evaluation",// Note: from prompts of llm evaluations
+    Experiment = "experiment",
+    User = "user",
+    SharedPrompt = "shared_prompt",
+    AgentAsTool = "agent_as_tool",// TODO(tracing): deprecated, use SegmentType.Document with DocumentType.Agent instead
+    EmailTrigger = "email_trigger",
+    ScheduledTrigger = "scheduled_trigger"
 }
-declare class VercelBatchSpanProcessor extends BatchSpanProcessor implements SpanProcessor {
-    onEnd(span: ReadableSpan): void;
+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;
+}>;
 
-type IModules = {
-    openAI?: typeof openai.OpenAI;
-    anthropic?: typeof anthropic;
-    azureOpenAI?: typeof azure;
-    cohere?: typeof cohere;
-    bedrock?: typeof bedrock;
-    google_vertexai?: typeof vertexAI;
-    google_aiplatform?: typeof aiplatform;
-    pinecone?: typeof pinecone;
-    langchain?: {
-        chainsModule?: typeof ChainsModule;
-        agentsModule?: typeof AgentsModule;
-        toolsModule?: typeof ToolsModule;
-        runnablesModule?: typeof RunnableModule;
-        vectorStoreModule?: typeof VectorStoreModule;
-    };
-    llamaIndex?: typeof llamaindex;
-    chromadb?: typeof chromadb;
-    qdrant?: typeof qdrant;
+type LatitudeInstrumentationOptions = {
+    module: typeof latitude.Latitude;
+    completions?: boolean;
 };
-type SpanAttributes = {
+
+type StartSpanOptions = {
     name?: string;
-    metadata?: Record<string, unknown>;
-    prompt?: {
-        uuid: string;
-        versionUuid?: string;
-        parameters?: Record<string, unknown>;
+    attributes?: otel.Attributes;
+};
+type EndSpanOptions = {
+    attributes?: otel.Attributes;
+};
+type ErrorOptions = {
+    attributes?: otel.Attributes;
+};
+type StartToolSpanOptions = StartSpanOptions & {
+    name: string;
+    call: {
+        id: string;
+        arguments: Record<string, unknown>;
+    };
+};
+type EndToolSpanOptions = EndSpanOptions & {
+    result: {
+        value: unknown;
+        isError: boolean;
+    };
+};
+type StartCompletionSpanOptions = StartSpanOptions & {
+    provider: string;
+    model: string;
+    configuration: Record<string, unknown>;
+    input: Record<string, unknown>[];
+};
+type EndCompletionSpanOptions = EndSpanOptions & {
+    output: Record<string, unknown>[];
+    tokens: {
+        prompt: number;
+        cached: number;
+        reasoning: number;
+        completion: number;
     };
-    distinctId?: string;
+    finishReason: string;
 };
-type LatitudeTelemetrySDKConfig = {
-    exporter: SpanExporter$1;
-    modules?: IModules;
+type StartHttpSpanOptions = StartSpanOptions & {
+    request: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+        body: string | Record<string, unknown>;
+    };
+};
+type EndHttpSpanOptions = EndSpanOptions & {
+    response: {
+        status: number;
+        headers: Record<string, string>;
+        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;
+    versionUuid?: string;
+    promptUuid: string;
+    experimentUuid?: string;
+    externalId?: string;
+    template: string;
+    parameters?: Record<string, unknown>;
+};
+
+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;
-    processors?: (typeof SimpleSpanProcessor$1)[] | (typeof BatchSpanProcessor$1)[];
+    exporter?: SpanExporter;
+    processors?: SpanProcessor[];
+    propagators?: TextMapPropagator[];
 };
-declare class LatitudeTelemetrySDK {
-    private exporter;
-    constructor({ exporter, modules, disableBatch, processors, }: LatitudeTelemetrySDKConfig);
-    private _init;
-    span<T>(s: SpanAttributes, fn: (span: any) => T): Promise<T>;
+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;
+    };
+    resume(ctx: TraceContext): otel.Context;
+    restored(ctx: otel.Context): boolean;
+    restore(ctx: otel.Context): 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: PromptSegmentOptions): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
+    step(ctx: otel.Context, options?: SegmentOptions): {
+        context: otel.Context;
+        end: (_options?: EndSpanOptions) => void;
+        fail: (_error: Error, _options?: ErrorOptions) => void;
+    };
 }
 
-export { LatitudeExporter, LatitudeTelemetrySDK, type LatitudeTelemetrySDKConfig, VercelBatchSpanProcessor, VercelSpanProcessor };
+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 };