@juspay/neurolink 9.32.0 → 9.33.0

package/dist/client/observability/exporters/laminarExporter.js

@@ -1,302 +0,0 @@
-/**
- * Laminar Exporter
- * Exports spans to Laminar LLM tracing platform
- * @see https://docs.laminar.run/
- */
-import { logger } from "../../utils/logger.js";
-import { SpanStatus, SpanType } from "../types/spanTypes.js";
-import { BaseExporter } from "./baseExporter.js";
-/**
- * Laminar exporter for LLM pipeline tracing and monitoring
- * Supports detailed traces with input/output tracking
- */
-export class LaminarExporter extends BaseExporter {
-    apiKey;
-    projectApiKey;
-    baseUrl;
-    constructor(config) {
-        super("laminar", config);
-        this.apiKey = config.apiKey;
-        this.projectApiKey = config.projectApiKey;
-        this.baseUrl = config.baseUrl ?? "https://api.laminar.run";
-    }
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        // Verify API key by making a test call
-        try {
-            const response = await fetch(`${this.baseUrl}/v1/health`, {
-                headers: this.getHeaders(),
-            });
-            if (!response.ok) {
-                logger.warn("[Laminar] Could not verify API connection:", response.statusText);
-            }
-        }
-        catch (error) {
-            logger.warn("[Laminar] Could not verify API connection:", error instanceof Error ? error.message : error);
-        }
-        this.initialized = true;
-        this.startFlushInterval(this.config.flushIntervalMs ?? 5000);
-    }
-    /**
-     * Get authorization headers
-     */
-    getHeaders() {
-        const headers = {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${this.apiKey}`,
-        };
-        // Add project API key if provided
-        if (this.projectApiKey) {
-            headers["X-Project-Api-Key"] = this.projectApiKey;
-        }
-        return headers;
-    }
-    async exportSpan(span) {
-        const startTime = Date.now();
-        try {
-            const trace = this.convertToLaminarTrace(span);
-            const response = await fetch(`${this.baseUrl}/v1/traces`, {
-                method: "POST",
-                headers: this.getHeaders(),
-                body: JSON.stringify(trace),
-            });
-            if (!response.ok) {
-                throw new Error(`Export failed: ${response.statusText}`);
-            }
-            return this.createSuccessResult(1, Date.now() - startTime);
-        }
-        catch (error) {
-            return this.createFailureResult([span.spanId], error instanceof Error ? error.message : String(error), Date.now() - startTime);
-        }
-    }
-    async exportBatch(spans) {
-        const startTime = Date.now();
-        try {
-            const traces = spans.map((s) => this.convertToLaminarTrace(s));
-            const response = await fetch(`${this.baseUrl}/v1/traces/batch`, {
-                method: "POST",
-                headers: this.getHeaders(),
-                body: JSON.stringify({ traces }),
-            });
-            if (!response.ok) {
-                throw new Error(`Batch export failed: ${response.statusText}`);
-            }
-            return this.createSuccessResult(spans.length, Date.now() - startTime);
-        }
-        catch (error) {
-            return this.createFailureResult(spans.map((s) => s.spanId), error instanceof Error ? error.message : String(error), Date.now() - startTime);
-        }
-    }
-    async flush() {
-        if (this.buffer.length > 0) {
-            const spans = [...this.buffer];
-            this.buffer = [];
-            await this.exportBatch(spans);
-        }
-    }
-    async shutdown() {
-        await this.flush();
-        this.stopFlushInterval();
-        this.initialized = false;
-    }
-    async healthCheck() {
-        try {
-            await this.withRetry(() => this.ping(), "health check");
-            return this.createHealthStatus(true);
-        }
-        catch {
-            return this.createHealthStatus(false, ["Health check failed"]);
-        }
-    }
-    /**
-     * Verify connectivity to Laminar API
-     */
-    async ping() {
-        const response = await fetch(`${this.baseUrl}/v1/health`, {
-            headers: this.getHeaders(),
-        });
-        if (!response.ok) {
-            throw new Error(`Laminar API unreachable: ${response.status}`);
-        }
-    }
-    /**
-     * Convert span to Laminar trace format
-     */
-    convertToLaminarTrace(span) {
-        return {
-            // Core identifiers
-            trace_id: span.traceId,
-            span_id: span.spanId,
-            parent_span_id: span.parentSpanId,
-            // Trace metadata
-            name: span.name,
-            type: this.mapSpanTypeToLaminarType(span.type),
-            start_time: span.startTime,
-            end_time: span.endTime,
-            duration_ms: span.durationMs,
-            // Status
-            status: this.mapSpanStatus(span.status),
-            status_message: span.statusMessage,
-            // Model information
-            model: {
-                provider: span.attributes["ai.provider"],
-                name: span.attributes["ai.model"],
-                version: span.attributes["ai.model.version"],
-            },
-            // Token usage
-            usage: {
-                input_tokens: span.attributes["ai.tokens.input"],
-                output_tokens: span.attributes["ai.tokens.output"],
-                total_tokens: span.attributes["ai.tokens.total"],
-                cache_read_tokens: span.attributes["ai.tokens.cache_read"],
-                cache_creation_tokens: span.attributes["ai.tokens.cache_creation"],
-                reasoning_tokens: span.attributes["ai.tokens.reasoning"],
-            },
-            // Cost tracking
-            cost: {
-                input: span.attributes["ai.cost.input"],
-                output: span.attributes["ai.cost.output"],
-                total: span.attributes["ai.cost.total"],
-                currency: span.attributes["ai.cost.currency"] || "USD",
-            },
-            // Generation parameters
-            parameters: {
-                temperature: span.attributes["ai.temperature"],
-                max_tokens: span.attributes["ai.max_tokens"],
-                top_p: span.attributes["ai.top_p"],
-                stop_sequences: span.attributes["ai.stop_sequences"],
-            },
-            // Input/Output
-            input: span.attributes["input"],
-            output: span.attributes["output"],
-            // Tool information
-            tool: span.attributes["tool.name"]
-                ? {
-                    name: span.attributes["tool.name"],
-                    server: span.attributes["tool.server"],
-                    success: span.attributes["tool.success"],
-                }
-                : undefined,
-            // Error information
-            error: span.status === SpanStatus.ERROR
-                ? {
-                    type: span.attributes["error.type"],
-                    message: span.attributes["error.message"],
-                    stack: span.attributes["error.stack"],
-                }
-                : undefined,
-            // User and session context
-            context: {
-                user_id: span.attributes["user.id"],
-                session_id: span.attributes["session.id"],
-                environment: span.attributes["deployment.environment"] || this.config.environment,
-                service: {
-                    name: span.attributes["service.name"],
-                    version: span.attributes["service.version"] || this.config.version,
-                },
-            },
-            // Events
-            events: span.events.map((event) => ({
-                name: event.name,
-                timestamp: event.timestamp,
-                attributes: event.attributes,
-            })),
-            // Links to related spans
-            links: span.links.map((link) => ({
-                trace_id: link.traceId,
-                span_id: link.spanId,
-                attributes: link.attributes,
-            })),
-            // Additional metadata
-            metadata: this.extractMetadata(span.attributes),
-        };
-    }
-    /**
-     * Map NeuroLink span type to Laminar type
-     */
-    mapSpanTypeToLaminarType(type) {
-        const typeMap = {
-            [SpanType.AGENT_RUN]: "agent",
-            [SpanType.WORKFLOW_STEP]: "workflow",
-            [SpanType.TOOL_CALL]: "tool",
-            [SpanType.MODEL_GENERATION]: "llm",
-            [SpanType.EMBEDDING]: "embedding",
-            [SpanType.RETRIEVAL]: "retrieval",
-            [SpanType.MEMORY]: "memory",
-            [SpanType.CONTEXT_COMPACTION]: "custom",
-            [SpanType.RAG]: "retrieval",
-            [SpanType.EVALUATION]: "custom",
-            [SpanType.MCP_TRANSPORT]: "tool",
-            [SpanType.MEDIA_GENERATION]: "llm",
-            [SpanType.PPT_GENERATION]: "custom",
-            [SpanType.WORKFLOW]: "workflow",
-            [SpanType.TTS]: "custom",
-            [SpanType.SERVER_REQUEST]: "custom",
-            [SpanType.CUSTOM]: "custom",
-        };
-        return typeMap[type] || "custom";
-    }
-    /**
-     * Map span status to Laminar status format
-     */
-    mapSpanStatus(status) {
-        switch (status) {
-            case SpanStatus.OK:
-                return "success";
-            case SpanStatus.ERROR:
-                return "error";
-            default:
-                return "unset";
-        }
-    }
-    /**
-     * Extract additional metadata from span attributes
-     * Filters out standard attributes that are already handled
-     */
-    extractMetadata(attributes) {
-        const standardKeys = new Set([
-            "service.name",
-            "service.version",
-            "deployment.environment",
-            "user.id",
-            "session.id",
-            "ai.provider",
-            "ai.model",
-            "ai.model.version",
-            "ai.tokens.input",
-            "ai.tokens.output",
-            "ai.tokens.total",
-            "ai.tokens.cache_read",
-            "ai.tokens.cache_creation",
-            "ai.tokens.reasoning",
-            "ai.cost.input",
-            "ai.cost.output",
-            "ai.cost.total",
-            "ai.cost.currency",
-            "ai.temperature",
-            "ai.max_tokens",
-            "ai.top_p",
-            "ai.stop_sequences",
-            "tool.name",
-            "tool.server",
-            "tool.success",
-            "error.type",
-            "error.message",
-            "error.stack",
-            "error",
-            "input",
-            "output",
-            "expected",
-            "scores",
-        ]);
-        const metadata = {};
-        for (const [key, value] of Object.entries(attributes)) {
-            if (!standardKeys.has(key) && value !== undefined) {
-                metadata[key] = value;
-            }
-        }
-        return metadata;
-    }
-}

package/dist/client/observability/exporters/langfuseExporter.js

@@ -1,209 +0,0 @@
-/**
- * Langfuse Exporter
- * Exports spans to Langfuse observability platform
- */
-import { SpanType } from "../types/spanTypes.js";
-import { SpanSerializer } from "../utils/spanSerializer.js";
-import { BaseExporter } from "./baseExporter.js";
-/**
- * Langfuse exporter for LLM observability
- * Supports traces, generations, spans, and scores
- */
-export class LangfuseExporter extends BaseExporter {
-    publicKey;
-    secretKey;
-    baseUrl;
-    release;
-    redactIO;
-    constructor(config) {
-        super("langfuse", config);
-        this.publicKey = config.publicKey;
-        this.secretKey = config.secretKey;
-        this.baseUrl = config.baseUrl ?? "https://cloud.langfuse.com";
-        this.release = config.release;
-        this.redactIO = config.redactIO ?? false;
-    }
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        // Verify credentials with a simple check
-        if (!this.publicKey || !this.secretKey) {
-            throw new Error("Langfuse publicKey and secretKey are required");
-        }
-        this.initialized = true;
-        this.startFlushInterval(this.config.flushIntervalMs ?? 5000);
-    }
-    async exportSpan(span) {
-        const startTime = Date.now();
-        try {
-            // Create trace if this is a root span
-            if (!span.parentSpanId) {
-                await this.createTrace(span);
-            }
-            // Create span/generation based on type
-            if (span.type === SpanType.MODEL_GENERATION) {
-                await this.createGeneration(span);
-            }
-            else {
-                await this.createSpan(span);
-            }
-            return this.createSuccessResult(1, Date.now() - startTime);
-        }
-        catch (error) {
-            return this.createFailureResult([span.spanId], error instanceof Error ? error.message : String(error), Date.now() - startTime);
-        }
-    }
-    async exportBatch(spans) {
-        const startTime = Date.now();
-        const results = await Promise.allSettled(spans.map((s) => this.exportSpan(s)));
-        const successful = results.filter((r) => r.status === "fulfilled" && r.value.success).length;
-        const failed = spans.length - successful;
-        return {
-            success: failed === 0,
-            exportedCount: successful,
-            failedCount: failed,
-            errors: results
-                .filter((r) => r.status === "rejected" ||
-                (r.status === "fulfilled" && !r.value.success))
-                .map((r, i) => ({
-                spanId: spans[i].spanId,
-                error: r.status === "rejected" ? String(r.reason) : "Export failed",
-                retryable: true,
-            })),
-            durationMs: Date.now() - startTime,
-        };
-    }
-    async flush() {
-        if (this.buffer.length > 0) {
-            const spans = [...this.buffer];
-            this.buffer = [];
-            await this.exportBatch(spans);
-        }
-    }
-    async shutdown() {
-        await this.flush();
-        this.stopFlushInterval();
-        this.initialized = false;
-    }
-    async healthCheck() {
-        try {
-            await this.withRetry(() => this.ping(), "health check");
-            return this.createHealthStatus(true);
-        }
-        catch {
-            return this.createHealthStatus(false, ["Health check failed"]);
-        }
-    }
-    /**
-     * Verify connectivity to Langfuse API
-     */
-    async ping() {
-        const credentials = Buffer.from(`${this.publicKey}:${this.secretKey}`).toString("base64");
-        const response = await fetch(`${this.baseUrl}/api/public/health`, {
-            method: "GET",
-            headers: {
-                Authorization: `Basic ${credentials}`,
-            },
-        });
-        if (!response.ok && response.status !== 404) {
-            // 404 is acceptable as health endpoint may not exist
-            throw new Error(`Langfuse API unreachable: ${response.status}`);
-        }
-    }
-    /**
-     * Create a Langfuse trace
-     */
-    async createTrace(span) {
-        const body = {
-            id: span.traceId,
-            name: span.name,
-            userId: span.attributes["user.id"],
-            sessionId: span.attributes["session.id"],
-            // Only pick safe, non-PII attributes for metadata — intentionally excludes
-            // input, output, error.stack, and other user content to match Braintrust exporter
-            metadata: filterSafeMetadata(span.attributes),
-            release: this.release,
-            tags: this.extractTags(span),
-        };
-        await this.apiCall("/api/public/traces", body);
-    }
-    /**
-     * Create a Langfuse span
-     */
-    async createSpan(span) {
-        const langfuseSpan = SpanSerializer.toLangfuseFormat(span);
-        const body = {
-            ...langfuseSpan,
-            traceId: span.traceId,
-        };
-        if (this.redactIO) {
-            delete body["input"];
-            delete body["output"];
-        }
-        await this.apiCall("/api/public/spans", body);
-    }
-    /**
-     * Create a Langfuse generation (for LLM calls)
-     */
-    async createGeneration(span) {
-        const langfuseSpan = SpanSerializer.toLangfuseFormat(span);
-        const body = {
-            traceId: span.traceId,
-            id: langfuseSpan.id,
-            parentObservationId: langfuseSpan.parentObservationId,
-            name: langfuseSpan.name,
-            startTime: langfuseSpan.startTime,
-            endTime: langfuseSpan.endTime,
-            model: span.attributes["ai.model"],
-            modelParameters: {
-                temperature: span.attributes["ai.temperature"],
-                maxTokens: span.attributes["ai.max_tokens"],
-                topP: span.attributes["ai.top_p"],
-            },
-            input: this.redactIO ? undefined : langfuseSpan.input,
-            output: this.redactIO ? undefined : langfuseSpan.output,
-            usage: langfuseSpan.usage,
-            metadata: langfuseSpan.metadata,
-            level: langfuseSpan.level,
-            statusMessage: langfuseSpan.statusMessage,
-        };
-        await this.apiCall("/api/public/generations", body);
-    }
-    /**
-     * Make API call to Langfuse
-     */
-    async apiCall(path, body) {
-        const credentials = Buffer.from(`${this.publicKey}:${this.secretKey}`).toString("base64");
-        const response = await fetch(`${this.baseUrl}${path}`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Basic ${credentials}`,
-            },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`Langfuse API error: ${response.status} - ${text}`);
-        }
-    }
-    /**
-     * Extract tags from span attributes
-     */
-    extractTags(span) {
-        const tags = [];
-        if (span.attributes["ai.provider"]) {
-            tags.push(`provider:${span.attributes["ai.provider"]}`);
-        }
-        if (span.attributes["ai.model"]) {
-            tags.push(`model:${span.attributes["ai.model"]}`);
-        }
-        if (span.attributes["deployment.environment"]) {
-            tags.push(`env:${span.attributes["deployment.environment"]}`);
-        }
-        return tags;
-    }
-}
-// Safe metadata filtering imported from shared module to avoid duplication
-import { filterSafeMetadata } from "../utils/safeMetadata.js";

package/dist/client/observability/exporters/langsmithExporter.js

@@ -1,143 +0,0 @@
-/**
- * LangSmith Exporter
- * Exports spans to LangSmith observability platform
- */
-import { logger } from "../../utils/logger.js";
-/**
- * Build a LangSmith dotted_order value: "{datetime}.{id}"
- * Format: YYYYMMDDTHHmmssSSSSSSZ.<id> (datetime in UTC with microseconds)
- */
-function buildDottedOrder(isoTime, id) {
-    const d = new Date(isoTime);
-    const pad2 = (n) => String(n).padStart(2, "0");
-    const microseconds = String(d.getUTCMilliseconds() * 1000).padStart(6, "0");
-    const dt = `${d.getUTCFullYear()}${pad2(d.getUTCMonth() + 1)}${pad2(d.getUTCDate())}T` +
-        `${pad2(d.getUTCHours())}${pad2(d.getUTCMinutes())}${pad2(d.getUTCSeconds())}` +
-        `${microseconds}Z`;
-    return `${dt}.${id}`;
-}
-import { SpanSerializer } from "../utils/spanSerializer.js";
-import { BaseExporter } from "./baseExporter.js";
-/**
- * LangSmith exporter for LangChain ecosystem observability
- * Supports runs with proper type mapping
- */
-export class LangSmithExporter extends BaseExporter {
-    apiKey;
-    projectName;
-    endpoint;
-    constructor(config) {
-        super("langsmith", config);
-        this.apiKey = config.apiKey;
-        this.projectName = config.projectName ?? "default";
-        this.endpoint = config.endpoint ?? "https://api.smith.langchain.com";
-    }
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        // Verify API key with a test request
-        try {
-            const response = await fetch(`${this.endpoint}/api/v1/info`, {
-                headers: { "x-api-key": this.apiKey },
-            });
-            if (!response.ok) {
-                throw new Error(`LangSmith initialization failed: ${response.statusText}`);
-            }
-        }
-        catch (error) {
-            // Allow initialization to proceed even if API is unreachable
-            // This enables offline/test scenarios
-            logger.warn("[LangSmith] Could not verify API connection:", error instanceof Error ? error.message : error);
-        }
-        this.initialized = true;
-        this.startFlushInterval(this.config.flushIntervalMs ?? 5000);
-    }
-    async exportSpan(span) {
-        const startTime = Date.now();
-        try {
-            const langsmithRun = SpanSerializer.toLangSmithFormat(span);
-            const response = await fetch(`${this.endpoint}/api/v1/runs`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-api-key": this.apiKey,
-                },
-                body: JSON.stringify({
-                    ...langsmithRun,
-                    session_name: this.projectName,
-                }),
-            });
-            if (!response.ok) {
-                throw new Error(`Export failed: ${response.statusText}`);
-            }
-            return this.createSuccessResult(1, Date.now() - startTime);
-        }
-        catch (error) {
-            return this.createFailureResult([span.spanId], error instanceof Error ? error.message : String(error), Date.now() - startTime);
-        }
-    }
-    async exportBatch(spans) {
-        const startTime = Date.now();
-        try {
-            const post = spans.map((s) => {
-                const run = SpanSerializer.toLangSmithFormat(s);
-                // LangSmith /api/v1/runs/batch requires dotted_order and trace_id on each run
-                const dotted_order = buildDottedOrder(run.start_time ?? s.startTime, run.id);
-                return {
-                    ...run,
-                    trace_id: run.trace_id ?? run.id,
-                    dotted_order,
-                    session_name: this.projectName,
-                };
-            });
-            const response = await fetch(`${this.endpoint}/api/v1/runs/batch`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-api-key": this.apiKey,
-                },
-                body: JSON.stringify({ post }),
-            });
-            if (!response.ok) {
-                throw new Error(`Batch export failed: ${response.statusText}`);
-            }
-            return this.createSuccessResult(spans.length, Date.now() - startTime);
-        }
-        catch (error) {
-            return this.createFailureResult(spans.map((s) => s.spanId), error instanceof Error ? error.message : String(error), Date.now() - startTime);
-        }
-    }
-    async flush() {
-        if (this.buffer.length > 0) {
-            const spans = [...this.buffer];
-            this.buffer = [];
-            await this.exportBatch(spans);
-        }
-    }
-    async shutdown() {
-        await this.flush();
-        this.stopFlushInterval();
-        this.initialized = false;
-    }
-    async healthCheck() {
-        try {
-            await this.withRetry(() => this.ping(), "health check");
-            return this.createHealthStatus(true);
-        }
-        catch {
-            return this.createHealthStatus(false, ["Health check failed"]);
-        }
-    }
-    /**
-     * Verify connectivity to LangSmith API
-     */
-    async ping() {
-        const response = await fetch(`${this.endpoint}/api/v1/info`, {
-            headers: { "x-api-key": this.apiKey },
-        });
-        if (!response.ok) {
-            throw new Error(`LangSmith API unreachable: ${response.status}`);
-        }
-    }
-}