@latitude-data/telemetry 2.0.4 → 3.0.0-alpha.1

package/dist/index.d.cts

@@ -0,0 +1,169 @@
+import { SpanProcessor, Span, ReadableSpan, SpanExporter, NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import * as otel from '@opentelemetry/api';
+import { TracerProvider, Context } from '@opentelemetry/api';
+
+/**
+ * Supported LLM instrumentation types.
+ * Use these string identifiers to enable auto-instrumentation.
+ */
+type InstrumentationType = "openai" | "anthropic" | "bedrock" | "cohere" | "langchain" | "llamaindex" | "togetherai" | "vertexai" | "aiplatform";
+/**
+ * Options for creating LLM instrumentations.
+ */
+interface CreateInstrumentationsOptions {
+    /** List of instrumentation types to enable. */
+    instrumentations: InstrumentationType[];
+    /**
+     * Optional module references for auto-instrumentation.
+     * If not provided, the instrumentation will attempt to require the module.
+     * Used for Traceloop-based instrumentations.
+     */
+    modules?: Partial<Record<InstrumentationType, unknown>>;
+    /**
+     * Per-instrumentation token enrichment settings.
+     * @default { openai: true }
+     */
+    enrichTokens?: Partial<Record<InstrumentationType, boolean>>;
+}
+/**
+ * Registers LLM instrumentations with the global OpenTelemetry instrumentation registry.
+ *
+ * This is a convenience wrapper around `createLatitudeInstrumentations` and
+ * `@opentelemetry/instrumentation`'s `registerInstrumentations`.
+ *
+ * @example
+ * ```typescript
+ * import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node"
+ * import { registerLatitudeInstrumentations, LatitudeSpanProcessor } from "@latitude-data/telemetry"
+ *
+ * const provider = new NodeTracerProvider({
+ *   spanProcessors: [new LatitudeSpanProcessor(apiKey, projectSlug)],
+ * })
+ *
+ * await registerLatitudeInstrumentations({
+ *   instrumentations: ["openai", "anthropic"],
+ *   tracerProvider: provider,
+ * })
+ *
+ * provider.register()
+ * ```
+ */
+declare function registerLatitudeInstrumentations(options: CreateInstrumentationsOptions & {
+    tracerProvider: TracerProvider;
+}): Promise<void>;
+
+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;
+}
+
+type SmartFilterOptions = {
+    /**
+     * When true, all spans are exported (legacy behavior).
+     * Default false — only LLM-relevant spans are exported.
+     */
+    disableSmartFilter?: boolean;
+    /**
+     * When smart filter is on, also export spans for which this returns true
+     * (in addition to {@link isDefaultExportSpan}).
+     */
+    shouldExportSpan?: (span: ReadableSpan) => boolean;
+    /** Instrumentation scope names to drop (exact match) even if they pass the default predicate. */
+    blockedInstrumentationScopes?: string[];
+};
+/** Input for {@link buildShouldExportSpanFromFields}; allows `undefined` field values for ergonomics. */
+type SmartFilterFieldsInput = {
+    disableSmartFilter?: boolean | undefined;
+    shouldExportSpan?: ((span: ReadableSpan) => boolean) | undefined;
+    blockedInstrumentationScopes?: string[] | undefined;
+};
+/**
+ * Builds the export predicate from loose option fields (`exactOptionalPropertyTypes`-safe call sites).
+ */
+declare function buildShouldExportSpanFromFields(fields: SmartFilterFieldsInput): (span: ReadableSpan) => boolean;
+/** True if the span uses OpenTelemetry GenAI semantic conventions or common LLM attribute namespaces. */
+declare function isGenAiOrLlmAttributeSpan(span: ReadableSpan): boolean;
+/** True if the span was created with Latitude's tracer scopes. */
+declare function isLatitudeInstrumentationSpan(span: ReadableSpan): boolean;
+/**
+ * Default export predicate (smart filter): Latitude scopes, GenAI / LLM attributes,
+ * or known LLM instrumentation scopes.
+ */
+declare function isDefaultExportSpan(span: ReadableSpan): boolean;
+declare function buildShouldExportSpan(options: SmartFilterOptions): (span: ReadableSpan) => boolean;
+/**
+ * Drops spans that fail the export predicate before passing them to the inner processor.
+ * Inner processor should perform redaction and export.
+ */
+declare class ExportFilterSpanProcessor implements SpanProcessor {
+    private readonly shouldExport;
+    private readonly inner;
+    constructor(shouldExport: (span: ReadableSpan) => boolean, inner: SpanProcessor);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/** Runs optional redaction then the export processor (batch/simple). */
+declare class RedactThenExportSpanProcessor implements SpanProcessor {
+    private readonly redact;
+    private readonly exportProcessor;
+    constructor(redact: SpanProcessor | null, exportProcessor: SpanProcessor);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+type ContextOptions = {
+    name?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    userId?: string;
+};
+type InitLatitudeOptions = SmartFilterOptions & {
+    apiKey: string;
+    projectSlug: string;
+    instrumentations?: InstrumentationType[];
+    disableRedact?: boolean;
+    redact?: RedactSpanProcessorOptions;
+    disableBatch?: boolean;
+    exporter?: SpanExporter;
+};
+type LatitudeSpanProcessorOptions = SmartFilterOptions & {
+    disableRedact?: boolean;
+    redact?: RedactSpanProcessorOptions;
+    disableBatch?: boolean;
+    exporter?: SpanExporter;
+};
+
+declare function capture<T>(name: string, fn: () => T | Promise<T>, options?: ContextOptions): T | Promise<T>;
+
+declare function initLatitude(options: InitLatitudeOptions): {
+    provider: NodeTracerProvider;
+    flush: () => Promise<void>;
+    shutdown: () => Promise<void>;
+    ready: Promise<void>;
+};
+
+declare class LatitudeSpanProcessor implements SpanProcessor {
+    private readonly tail;
+    constructor(apiKey: string, projectSlug: string, options?: LatitudeSpanProcessorOptions);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+export { type ContextOptions, ExportFilterSpanProcessor, type InitLatitudeOptions, type InstrumentationType, LatitudeSpanProcessor, type LatitudeSpanProcessorOptions, RedactSpanProcessor, type RedactSpanProcessorOptions, RedactThenExportSpanProcessor, type SmartFilterFieldsInput, type SmartFilterOptions, buildShouldExportSpan, buildShouldExportSpanFromFields, capture, initLatitude, isDefaultExportSpan, isGenAiOrLlmAttributeSpan, isLatitudeInstrumentationSpan, registerLatitudeInstrumentations };

package/dist/index.d.ts

@@ -1,339 +1,169 @@
-import { z } from 'zod';
+import { SpanProcessor, Span, ReadableSpan, SpanExporter, NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 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 { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { TracerProvider, Context } from '@opentelemetry/api';
 
-interface BaseInstrumentation {
-    isEnabled(): boolean;
-    enable(): void;
-    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;
-};
-declare class ManualInstrumentation implements BaseInstrumentation {
-    private enabled;
-    private readonly tracer;
-    private readonly options;
-    constructor(tracer: otel.Tracer, options?: ManualInstrumentationOptions);
-    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;
-    };
+/**
+ * Supported LLM instrumentation types.
+ * Use these string identifiers to enable auto-instrumentation.
+ */
+type InstrumentationType = "openai" | "anthropic" | "bedrock" | "cohere" | "langchain" | "llamaindex" | "togetherai" | "vertexai" | "aiplatform";
+/**
+ * Options for creating LLM instrumentations.
+ */
+interface CreateInstrumentationsOptions {
+    /** List of instrumentation types to enable. */
+    instrumentations: InstrumentationType[];
+    /**
+     * Optional module references for auto-instrumentation.
+     * If not provided, the instrumentation will attempt to require the module.
+     * Used for Traceloop-based instrumentations.
+     */
+    modules?: Partial<Record<InstrumentationType, unknown>>;
+    /**
+     * Per-instrumentation token enrichment settings.
+     * @default { openai: true }
+     */
+    enrichTokens?: Partial<Record<InstrumentationType, boolean>>;
 }
+/**
+ * Registers LLM instrumentations with the global OpenTelemetry instrumentation registry.
+ *
+ * This is a convenience wrapper around `createLatitudeInstrumentations` and
+ * `@opentelemetry/instrumentation`'s `registerInstrumentations`.
+ *
+ * @example
+ * ```typescript
+ * import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node"
+ * import { registerLatitudeInstrumentations, LatitudeSpanProcessor } from "@latitude-data/telemetry"
+ *
+ * const provider = new NodeTracerProvider({
+ *   spanProcessors: [new LatitudeSpanProcessor(apiKey, projectSlug)],
+ * })
+ *
+ * await registerLatitudeInstrumentations({
+ *   instrumentations: ["openai", "anthropic"],
+ *   tracerProvider: provider,
+ * })
+ *
+ * provider.register()
+ * ```
+ */
+declare function registerLatitudeInstrumentations(options: CreateInstrumentationsOptions & {
+    tracerProvider: TracerProvider;
+}): Promise<void>;
 
 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>;
     private shouldRedact;
     private redactAttributes;
 }
-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;
-    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 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;
+type SmartFilterOptions = {
+    /**
+     * When true, all spans are exported (legacy behavior).
+     * Default false — only LLM-relevant spans are exported.
+     */
+    disableSmartFilter?: boolean;
+    /**
+     * When smart filter is on, also export spans for which this returns true
+     * (in addition to {@link isDefaultExportSpan}).
+     */
+    shouldExportSpan?: (span: ReadableSpan) => boolean;
+    /** Instrumentation scope names to drop (exact match) even if they pass the default predicate. */
+    blockedInstrumentationScopes?: string[];
+};
+/** Input for {@link buildShouldExportSpanFromFields}; allows `undefined` field values for ergonomics. */
+type SmartFilterFieldsInput = {
+    disableSmartFilter?: boolean | undefined;
+    shouldExportSpan?: ((span: ReadableSpan) => boolean) | undefined;
+    blockedInstrumentationScopes?: string[] | undefined;
+};
+/**
+ * Builds the export predicate from loose option fields (`exactOptionalPropertyTypes`-safe call sites).
+ */
+declare function buildShouldExportSpanFromFields(fields: SmartFilterFieldsInput): (span: ReadableSpan) => boolean;
+/** True if the span uses OpenTelemetry GenAI semantic conventions or common LLM attribute namespaces. */
+declare function isGenAiOrLlmAttributeSpan(span: ReadableSpan): boolean;
+/** True if the span was created with Latitude's tracer scopes. */
+declare function isLatitudeInstrumentationSpan(span: ReadableSpan): boolean;
+/**
+ * Default export predicate (smart filter): Latitude scopes, GenAI / LLM attributes,
+ * or known LLM instrumentation scopes.
+ */
+declare function isDefaultExportSpan(span: ReadableSpan): boolean;
+declare function buildShouldExportSpan(options: SmartFilterOptions): (span: ReadableSpan) => boolean;
+/**
+ * Drops spans that fail the export predicate before passing them to the inner processor.
+ * Inner processor should perform redaction and export.
+ */
+declare class ExportFilterSpanProcessor implements SpanProcessor {
+    private readonly shouldExport;
+    private readonly inner;
+    constructor(shouldExport: (span: ReadableSpan) => boolean, inner: SpanProcessor);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
 }
-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",
-    Manual = "manual",
-    OpenAI = "openai",
-    TogetherAI = "togetherai",
-    VertexAI = "vertexai"
+/** Runs optional redaction then the export processor (batch/simple). */
+declare class RedactThenExportSpanProcessor implements SpanProcessor {
+    private readonly redact;
+    private readonly exportProcessor;
+    constructor(redact: SpanProcessor | null, exportProcessor: SpanProcessor);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
 }
-type TelemetryOptions = {
+
+type ContextOptions = {
+    name?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    userId?: string;
+};
+type InitLatitudeOptions = SmartFilterOptions & {
+    apiKey: string;
+    projectSlug: string;
+    instrumentations?: InstrumentationType[];
+    disableRedact?: boolean;
+    redact?: RedactSpanProcessorOptions;
     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;
-        };
-        [Instrumentation.Manual]?: ManualInstrumentationOptions;
-    };
 };
-declare class LatitudeTelemetry {
-    private options;
-    private nodeProvider;
-    private manualInstrumentation;
-    private instrumentationsList;
-    readonly span: SpanFactory;
-    readonly context: ContextManager;
-    readonly instrumentation: InstrumentationManager;
-    readonly tracer: TracerManager;
-    private readonly lifecycle;
-    constructor(apiKey: string, options?: TelemetryOptions);
-    flush(): Promise<void>;
+type LatitudeSpanProcessorOptions = SmartFilterOptions & {
+    disableRedact?: boolean;
+    redact?: RedactSpanProcessorOptions;
+    disableBatch?: boolean;
+    exporter?: SpanExporter;
+};
+
+declare function capture<T>(name: string, fn: () => T | Promise<T>, options?: ContextOptions): T | Promise<T>;
+
+declare function initLatitude(options: InitLatitudeOptions): {
+    provider: NodeTracerProvider;
+    flush: () => Promise<void>;
+    shutdown: () => Promise<void>;
+    ready: Promise<void>;
+};
+
+declare class LatitudeSpanProcessor implements SpanProcessor {
+    private readonly tail;
+    constructor(apiKey: string, projectSlug: string, options?: LatitudeSpanProcessorOptions);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): 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 { CaptureOptions, ChatSpanOptions, EndCompletionSpanOptions, EndHttpSpanOptions, EndSpanOptions, EndToolSpanOptions, ErrorOptions, ExternalSpanOptions, PromptSpanOptions as PromptSegmentOptions, RedactSpanProcessorOptions, StartCompletionSpanOptions, StartHttpSpanOptions, StartSpanOptions, StartToolSpanOptions, TelemetryContext, TelemetryOptions };
+export { type ContextOptions, ExportFilterSpanProcessor, type InitLatitudeOptions, type InstrumentationType, LatitudeSpanProcessor, type LatitudeSpanProcessorOptions, RedactSpanProcessor, type RedactSpanProcessorOptions, RedactThenExportSpanProcessor, type SmartFilterFieldsInput, type SmartFilterOptions, buildShouldExportSpan, buildShouldExportSpanFromFields, capture, initLatitude, isDefaultExportSpan, isGenAiOrLlmAttributeSpan, isLatitudeInstrumentationSpan, registerLatitudeInstrumentations };