@latitude-data/telemetry 2.0.2 → 3.0.0-alpha.0

package/dist/index.d.cts

@@ -0,0 +1,123 @@
+import * as otel from '@opentelemetry/api';
+import { TextMapPropagator } from '@opentelemetry/api';
+import { SpanProcessor, Span, ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-node';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+
+interface BaseInstrumentation {
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
+}
+
+type CaptureOptions = {
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    userId?: string;
+};
+declare class ManualInstrumentation implements BaseInstrumentation {
+    private enabled;
+    private readonly _tracer;
+    constructor(tracer: otel.Tracer);
+    get tracer(): otel.Tracer;
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
+    resume(ctx: {
+        traceparent: string;
+        baggage?: string;
+    }): otel.Context;
+}
+
+interface RedactSpanProcessorOptions {
+    attributes: (string | RegExp)[];
+    mask?: (attribute: string, value: unknown) => string;
+}
+declare class RedactSpanProcessor implements SpanProcessor {
+    private options;
+    constructor(options: RedactSpanProcessorOptions);
+    onStart(_span: Span, _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 class ContextManager {
+    private readonly telemetry;
+    constructor(telemetry: ManualInstrumentation);
+    resume(ctx: {
+        traceparent: string;
+        baggage?: string;
+    }): 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 readonly instrumentations;
+    constructor(instrumentations: BaseInstrumentation[]);
+    enable(): void;
+    disable(): void;
+}
+declare const DEFAULT_SPAN_EXPORTER: (apiKey: string, projectSlug: string) => OTLPTraceExporter;
+declare enum Instrumentation {
+    Anthropic = "anthropic",
+    AIPlatform = "aiplatform",
+    Bedrock = "bedrock",
+    Cohere = "cohere",
+    Langchain = "langchain",
+    LlamaIndex = "llamaindex",
+    Manual = "manual",
+    OpenAI = "openai",
+    TogetherAI = "togetherai",
+    VertexAI = "vertexai"
+}
+type TelemetryOptions = {
+    serviceName?: string;
+    disableBatch?: boolean;
+    exporter?: SpanExporter;
+    processors?: SpanProcessor[];
+    propagators?: TextMapPropagator[];
+    instrumentations?: {
+        [Instrumentation.AIPlatform]?: unknown;
+        [Instrumentation.Anthropic]?: unknown;
+        [Instrumentation.Bedrock]?: unknown;
+        [Instrumentation.Cohere]?: unknown;
+        [Instrumentation.OpenAI]?: unknown;
+        [Instrumentation.LlamaIndex]?: unknown;
+        [Instrumentation.TogetherAI]?: unknown;
+        [Instrumentation.VertexAI]?: unknown;
+        [Instrumentation.Langchain]?: {
+            callbackManagerModule?: unknown;
+        };
+    };
+};
+declare class LatitudeTelemetry {
+    private options;
+    private nodeProvider;
+    private instrumentationsList;
+    /** OpenTelemetry tracer for creating custom spans. */
+    readonly tracer: otel.Tracer;
+    readonly context: ContextManager;
+    readonly instrumentation: InstrumentationManager;
+    private readonly lifecycle;
+    constructor(apiKey: string, projectSlug: string, options?: TelemetryOptions);
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private initProviderInstrumentations;
+    /**
+     * Wrap a block of code with trace-wide context attributes.
+     * Baggage entries (tags, metadata, sessionId, userId) are propagated
+     * to all spans created within the callback via BaggageSpanProcessor.
+     *
+     * If there is no active span, a root span is created so all child spans
+     * are grouped under a single trace. If a span is already active, only
+     * baggage is set without creating an extra wrapper span.
+     */
+    capture<T>(options: CaptureOptions, fn: (ctx: TelemetryContext) => T | Promise<T>): Promise<T>;
+}
+
+export { type CaptureOptions, DEFAULT_REDACT_SPAN_PROCESSOR, DEFAULT_SPAN_EXPORTER, Instrumentation, LatitudeTelemetry, RedactSpanProcessor, type RedactSpanProcessorOptions, type TelemetryContext, type TelemetryOptions };

package/dist/index.d.ts

@@ -1,10 +1,6 @@
-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 { Latitude } from '@latitude-data/sdk';
+import { SpanProcessor, Span, ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-node';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 
 interface BaseInstrumentation {
@@ -13,195 +9,34 @@ interface BaseInstrumentation {
     disable(): void;
 }
 
-type LatitudeInstrumentationOptions = {
-    module: typeof Latitude;
-    completions?: boolean;
-};
-
-declare enum LogSources {
-    API = "api",
-    AgentAsTool = "agent_as_tool",
-    Copilot = "copilot",
-    EmailTrigger = "email_trigger",
-    Evaluation = "evaluation",
-    Experiment = "experiment",
-    IntegrationTrigger = "integration_trigger",
-    Playground = "playground",
-    ScheduledTrigger = "scheduled_trigger",
-    SharedPrompt = "shared_prompt",
-    ShadowTest = "shadow_test",
-    ABTestChallenger = "ab_test_challenger",
-    User = "user",
-    Optimization = "optimization"
-}
-
-declare const traceContextSchema: z.ZodObject<{
-    traceparent: z.ZodString;
-    tracestate: z.ZodOptional<z.ZodString>;
-    baggage: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type TraceContext = z.infer<typeof traceContextSchema>;
-
-type StartSpanOptions = {
-    name?: string;
-    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?: string | Record<string, unknown>[];
-    versionUuid?: string;
-    promptUuid?: string;
-    experimentUuid?: string;
-};
-type EndCompletionSpanOptions = EndSpanOptions & {
-    output?: string | Record<string, unknown>[];
-    tokens?: {
-        prompt?: number;
-        cached?: number;
-        reasoning?: number;
-        completion?: number;
-    };
-    finishReason?: string;
-};
-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 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 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;
-};
-type ManualInstrumentationOptions = {
-    provider?: Provider;
+type CaptureOptions = {
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    userId?: string;
 };
 declare class ManualInstrumentation implements BaseInstrumentation {
     private enabled;
-    private readonly tracer;
-    private readonly options;
-    constructor(tracer: otel.Tracer, options?: ManualInstrumentationOptions);
+    private readonly _tracer;
+    constructor(tracer: otel.Tracer);
+    get tracer(): otel.Tracer;
     isEnabled(): boolean;
     enable(): void;
     disable(): void;
-    resume(ctx: TraceContext): otel.Context;
-    private error;
-    private span;
-    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 attribifyConfiguration;
-    completion(ctx: otel.Context, options: StartCompletionSpanOptions): {
-        end: (options?: EndCompletionSpanOptions) => void;
-        context: otel.Context;
-        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): {
-        end: (options: EndHttpSpanOptions) => void;
-        context: otel.Context;
-        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;
-    };
+    resume(ctx: {
+        traceparent: string;
+        baggage?: string;
+    }): otel.Context;
 }
 
 interface RedactSpanProcessorOptions {
     attributes: (string | RegExp)[];
-    mask?: (attribute: string, value: any) => string;
+    mask?: (attribute: string, value: unknown) => string;
 }
 declare class RedactSpanProcessor implements SpanProcessor {
     private options;
     constructor(options: RedactSpanProcessorOptions);
-    onStart(_span: ReadableSpan, _context: otel.Context): void;
+    onStart(_span: Span, _context: otel.Context): void;
     onEnd(span: ReadableSpan): void;
     forceFlush(): Promise<void>;
     shutdown(): Promise<void>;
@@ -211,55 +46,13 @@ declare class RedactSpanProcessor implements SpanProcessor {
 declare const DEFAULT_REDACT_SPAN_PROCESSOR: () => RedactSpanProcessor;
 
 type TelemetryContext = otel.Context;
-declare const BACKGROUND: () => otel.Context;
-declare class SpanFactory {
-    private readonly telemetry;
-    constructor(telemetry: ManualInstrumentation);
-    span(options?: StartSpanOptions, ctx?: TelemetryContext): {
-        context: otel.Context;
-        end: (_options?: EndSpanOptions) => void;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
-    tool(options: StartToolSpanOptions, ctx?: TelemetryContext): {
-        end: (options: EndToolSpanOptions) => void;
-        context: otel.Context;
-        fail: (_error: Error, _options?: ErrorOptions) => void;
-    };
-    completion(options: StartCompletionSpanOptions, ctx?: TelemetryContext): {
-        end: (options?: EndCompletionSpanOptions) => void;
-        context: otel.Context;
-        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): {
-        end: (options: EndHttpSpanOptions) => void;
-        context: otel.Context;
-        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 readonly telemetry;
     constructor(telemetry: ManualInstrumentation);
-    resume(ctx: TraceContext): otel.Context;
+    resume(ctx: {
+        traceparent: string;
+        baggage?: string;
+    }): 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>;
 }
@@ -269,28 +62,13 @@ declare class InstrumentationManager {
     enable(): void;
     disable(): void;
 }
-declare class TracerManager {
-    private readonly nodeProvider;
-    private readonly 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 const DEFAULT_SPAN_EXPORTER: (apiKey: string, projectSlug: string) => OTLPTraceExporter;
 declare enum Instrumentation {
     Anthropic = "anthropic",
     AIPlatform = "aiplatform",
     Bedrock = "bedrock",
     Cohere = "cohere",
     Langchain = "langchain",
-    Latitude = "latitude",
     LlamaIndex = "llamaindex",
     Manual = "manual",
     OpenAI = "openai",
@@ -298,42 +76,48 @@ declare enum Instrumentation {
     VertexAI = "vertexai"
 }
 type TelemetryOptions = {
+    serviceName?: string;
     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.AIPlatform]?: unknown;
+        [Instrumentation.Anthropic]?: unknown;
+        [Instrumentation.Bedrock]?: unknown;
+        [Instrumentation.Cohere]?: unknown;
+        [Instrumentation.OpenAI]?: unknown;
+        [Instrumentation.LlamaIndex]?: unknown;
+        [Instrumentation.TogetherAI]?: unknown;
+        [Instrumentation.VertexAI]?: unknown;
         [Instrumentation.Langchain]?: {
-            callbackManagerModule?: any;
+            callbackManagerModule?: unknown;
         };
-        [Instrumentation.Manual]?: ManualInstrumentationOptions;
     };
 };
 declare class LatitudeTelemetry {
     private options;
     private nodeProvider;
-    private manualInstrumentation;
     private instrumentationsList;
-    readonly span: SpanFactory;
+    /** OpenTelemetry tracer for creating custom spans. */
+    readonly tracer: otel.Tracer;
     readonly context: ContextManager;
     readonly instrumentation: InstrumentationManager;
-    readonly tracer: TracerManager;
     private readonly lifecycle;
-    constructor(apiKey: string, options?: TelemetryOptions);
+    constructor(apiKey: string, projectSlug: string, options?: TelemetryOptions);
     flush(): Promise<void>;
     shutdown(): Promise<void>;
-    private initInstrumentations;
+    private initProviderInstrumentations;
+    /**
+     * Wrap a block of code with trace-wide context attributes.
+     * Baggage entries (tags, metadata, sessionId, userId) are propagated
+     * to all spans created within the callback via BaggageSpanProcessor.
+     *
+     * If there is no active span, a root span is created so all child spans
+     * are grouped under a single trace. If a span is already active, only
+     * baggage is set without creating an extra wrapper span.
+     */
     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 { CaptureOptions, ChatSpanOptions, EndCompletionSpanOptions, EndHttpSpanOptions, EndSpanOptions, EndToolSpanOptions, ErrorOptions, ExternalSpanOptions, PromptSpanOptions as PromptSegmentOptions, RedactSpanProcessorOptions, StartCompletionSpanOptions, StartHttpSpanOptions, StartSpanOptions, StartToolSpanOptions, TelemetryContext, TelemetryOptions };
+export { type CaptureOptions, DEFAULT_REDACT_SPAN_PROCESSOR, DEFAULT_SPAN_EXPORTER, Instrumentation, LatitudeTelemetry, RedactSpanProcessor, type RedactSpanProcessorOptions, type TelemetryContext, type TelemetryOptions };