@juspay/neurolink 12.58.1 → 13.0.0

package/dist/observability/exporterSpanProcessor.d.ts

@@ -0,0 +1,50 @@
+import { type Context } from "@opentelemetry/api";
+import type { ReadableSpan, Span, SpanProcessor as OtelSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import type { ExporterRegistry } from "./exporterRegistry.js";
+/**
+ * @description OpenTelemetry span processor that turns every observation span into `SpanData` and hands it to an `ExporterRegistry`, so one instrumentation feeds Langfuse, Datadog, Sentry and every other registered exporter. Spans that are not observations are skipped and their children are re-parented onto the nearest exported ancestor. Delivery never blocks the span's thread.
+ */
+export declare class ExporterSpanProcessor implements OtelSpanProcessor {
+    private readonly registry;
+    private readonly open;
+    private readonly ended;
+    /**
+     * @description Creates a processor bound to a registry.
+     * @param registry {ExporterRegistry} - Registry that receives every exported span.
+     */
+    constructor(registry: ExporterRegistry);
+    /**
+     * @description Copies the propagated Langfuse trace attributes (user, session, trace name, tags, metadata) from the parent context onto the new span and remembers it until it ends.
+     * @param span {Span} - Span that just started.
+     * @param parentContext {Context} - Context the span was started in.
+     * @returns {void} Nothing.
+     */
+    onStart(span: Span, parentContext: Context): void;
+    /**
+     * @description Exports an ended observation span without waiting for the exporters.
+     * @param span {ReadableSpan} - Span that just ended.
+     * @returns {void} Nothing.
+     */
+    onEnd(span: ReadableSpan): void;
+    /**
+     * @description Flushes every exporter in the registry.
+     * @returns {Promise<void>} Resolves when all exporters have flushed.
+     */
+    forceFlush(): Promise<void>;
+    /**
+     * @description Shuts down every exporter in the registry.
+     * @returns {Promise<void>} Resolves when all exporters have shut down.
+     */
+    shutdown(): Promise<void>;
+    private exportQuietly;
+    private remember;
+    private nearestExportedAncestor;
+}
+/**
+ * @description Creates a span processor that feeds NeuroLink's observation spans to an exporter registry. Add it to a host `TracerProvider` to deliver spans through the registered exporters (such as `LangfuseExporter`) instead of `LangfuseSpanProcessor`.
+ * @param registry {ExporterRegistry} - Registry to export to; defaults to the process-wide registry.
+ * @returns {ExporterSpanProcessor} A processor ready to be added to a TracerProvider.
+ * @example
+ * const provider = new NodeTracerProvider({ spanProcessors: [createExporterSpanProcessor()] });
+ */
+export declare function createExporterSpanProcessor(registry?: ExporterRegistry): ExporterSpanProcessor;

package/dist/observability/exporterSpanProcessor.js

@@ -0,0 +1,181 @@
+import { getPropagatedAttributesFromContext } from "@langfuse/core";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { MAX_REMEMBERED_SPANS } from "../constants/telemetry.js";
+import { SpanStatus, SpanType } from "../types/index.js";
+import { logger } from "../utils/logger.js";
+import { getExporterRegistry } from "./exporterRegistry.js";
+const LANGFUSE_OBSERVATION_TYPE = "langfuse.observation.type";
+const GEN_AI_OBSERVATION_TYPE = "gen_ai.observation.type";
+const GEN_AI_OPERATION = "gen_ai.operation.name";
+const OBSERVATION_SPAN_TYPES = {
+    agent: SpanType.AGENT_RUN,
+    tool: SpanType.TOOL_CALL,
+    chain: SpanType.WORKFLOW_STEP,
+    retriever: SpanType.RETRIEVAL,
+    evaluator: SpanType.EVALUATION,
+    embedding: SpanType.EMBEDDING,
+};
+function isObservation(span) {
+    return (span.attributes[LANGFUSE_OBSERVATION_TYPE] !== undefined ||
+        span.attributes[GEN_AI_OBSERVATION_TYPE] !== undefined ||
+        Object.keys(span.attributes).some((key) => key.startsWith("gen_ai.")));
+}
+function spanTypeOf(span) {
+    const observationType = String(span.attributes[LANGFUSE_OBSERVATION_TYPE] ?? "").toLowerCase();
+    if (observationType === "generation") {
+        return span.attributes[GEN_AI_OPERATION] === "decide"
+            ? SpanType.MODEL_DECISION
+            : SpanType.MODEL_GENERATION;
+    }
+    return OBSERVATION_SPAN_TYPES[observationType] ?? SpanType.CUSTOM;
+}
+const STATUS_BY_CODE = {
+    [SpanStatusCode.UNSET]: SpanStatus.UNSET,
+    [SpanStatusCode.OK]: SpanStatus.OK,
+    [SpanStatusCode.ERROR]: SpanStatus.ERROR,
+};
+function toMillis(time) {
+    return time[0] * 1_000 + time[1] / 1_000_000;
+}
+function toIso(time) {
+    return new Date(toMillis(time)).toISOString();
+}
+function toSpanData(span, parentSpanId) {
+    const { traceId, spanId } = span.spanContext();
+    return {
+        spanId,
+        traceId,
+        ...(parentSpanId && { parentSpanId }),
+        type: spanTypeOf(span),
+        name: span.name,
+        startTime: toIso(span.startTime),
+        endTime: toIso(span.endTime),
+        durationMs: toMillis(span.duration),
+        status: STATUS_BY_CODE[span.status.code],
+        ...(span.status.message && { statusMessage: span.status.message }),
+        attributes: { ...span.attributes },
+        events: span.events.map((event) => ({
+            name: event.name,
+            timestamp: toIso(event.time),
+            ...(event.attributes && { attributes: { ...event.attributes } }),
+        })),
+        links: span.links.map((link) => ({
+            traceId: link.context.traceId,
+            spanId: link.context.spanId,
+            ...(link.attributes && { attributes: { ...link.attributes } }),
+        })),
+    };
+}
+/**
+ * @description OpenTelemetry span processor that turns every observation span into `SpanData` and hands it to an `ExporterRegistry`, so one instrumentation feeds Langfuse, Datadog, Sentry and every other registered exporter. Spans that are not observations are skipped and their children are re-parented onto the nearest exported ancestor. Delivery never blocks the span's thread.
+ */
+export class ExporterSpanProcessor {
+    registry;
+    open = new Map();
+    ended = new Map();
+    /**
+     * @description Creates a processor bound to a registry.
+     * @param registry {ExporterRegistry} - Registry that receives every exported span.
+     */
+    constructor(registry) {
+        this.registry = registry;
+    }
+    /**
+     * @description Copies the propagated Langfuse trace attributes (user, session, trace name, tags, metadata) from the parent context onto the new span and remembers it until it ends.
+     * @param span {Span} - Span that just started.
+     * @param parentContext {Context} - Context the span was started in.
+     * @returns {void} Nothing.
+     */
+    onStart(span, parentContext) {
+        span.setAttributes(getPropagatedAttributesFromContext(parentContext));
+        this.open.set(span.spanContext().spanId, span);
+        if (this.open.size > MAX_REMEMBERED_SPANS) {
+            const oldest = this.open.keys().next().value;
+            if (oldest !== undefined) {
+                this.open.delete(oldest);
+            }
+        }
+    }
+    /**
+     * @description Exports an ended observation span without waiting for the exporters.
+     * @param span {ReadableSpan} - Span that just ended.
+     * @returns {void} Nothing.
+     */
+    onEnd(span) {
+        const { spanId } = span.spanContext();
+        this.open.delete(spanId);
+        const observation = isObservation(span);
+        this.remember(spanId, span.parentSpanContext?.spanId, observation);
+        if (!observation) {
+            return;
+        }
+        const spanData = toSpanData(span, this.nearestExportedAncestor(span));
+        void this.exportQuietly(spanData);
+    }
+    /**
+     * @description Flushes every exporter in the registry.
+     * @returns {Promise<void>} Resolves when all exporters have flushed.
+     */
+    forceFlush() {
+        return this.registry.flushAll();
+    }
+    /**
+     * @description Shuts down every exporter in the registry.
+     * @returns {Promise<void>} Resolves when all exporters have shut down.
+     */
+    shutdown() {
+        return this.registry.shutdownAll();
+    }
+    async exportQuietly(spanData) {
+        try {
+            await this.registry.exportToAll(spanData);
+        }
+        catch (error) {
+            logger.debug("[ExporterSpanProcessor] Export failed", {
+                spanId: spanData.spanId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    remember(spanId, parentSpanId, observation) {
+        this.ended.set(spanId, { parentSpanId, observation });
+        if (this.ended.size > MAX_REMEMBERED_SPANS) {
+            const oldest = this.ended.keys().next().value;
+            if (oldest !== undefined) {
+                this.ended.delete(oldest);
+            }
+        }
+    }
+    nearestExportedAncestor(span) {
+        let candidate = span.parentSpanContext?.spanId;
+        while (candidate) {
+            const live = this.open.get(candidate);
+            if (live) {
+                if (isObservation(live)) {
+                    return candidate;
+                }
+                candidate = live.parentSpanContext?.spanId;
+                continue;
+            }
+            const finished = this.ended.get(candidate);
+            if (!finished) {
+                return undefined;
+            }
+            if (finished.observation) {
+                return candidate;
+            }
+            candidate = finished.parentSpanId;
+        }
+        return undefined;
+    }
+}
+/**
+ * @description Creates a span processor that feeds NeuroLink's observation spans to an exporter registry. Add it to a host `TracerProvider` to deliver spans through the registered exporters (such as `LangfuseExporter`) instead of `LangfuseSpanProcessor`.
+ * @param registry {ExporterRegistry} - Registry to export to; defaults to the process-wide registry.
+ * @returns {ExporterSpanProcessor} A processor ready to be added to a TracerProvider.
+ * @example
+ * const provider = new NodeTracerProvider({ spanProcessors: [createExporterSpanProcessor()] });
+ */
+export function createExporterSpanProcessor(registry = getExporterRegistry()) {
+    return new ExporterSpanProcessor(registry);
+}

package/dist/observability/exporters/langfuseExporter.d.ts

@@ -1,48 +1,27 @@
-/**
- * Langfuse Exporter
- * Exports spans to Langfuse observability platform
- */
 import type { ExporterHealthStatus, ExportResult, LangfuseExporterConfig, SpanData } from "../../types/index.js";
 import { BaseExporter } from "./baseExporter.js";
 /**
- * Langfuse exporter for LLM observability
- * Supports traces, generations, spans, and scores
+ * @description Exporter that delivers observation spans to Langfuse's OTLP/HTTP JSON endpoint (`POST /api/public/otel/v1/traces`), which keeps native observation types and identity on every observation. Spans are queued without blocking and sent in batches; failed requests are retried with backoff when the failure is transient (429, 5xx, network).
  */
 export declare class LangfuseExporter extends BaseExporter {
-    private readonly publicKey;
-    private readonly secretKey;
+    private readonly langfuse;
+    private readonly authorization;
     private readonly baseUrl;
-    private readonly release?;
-    private readonly redactIO;
-    constructor(config: LangfuseExporterConfig);
+    private readonly policy;
+    private readonly inflight;
+    /**
+     * @description Creates an exporter for one Langfuse project.
+     * @param config {LangfuseExporterConfig} - Credentials, endpoint, environment, release, masking and batching options. `environment` and `release` fall back to `LANGFUSE_TRACING_ENVIRONMENT` and `LANGFUSE_RELEASE`, and only fill spans that do not carry them already.
+     */
+    constructor(langfuse: LangfuseExporterConfig);
     initialize(): Promise<void>;
     exportSpan(span: SpanData): Promise<ExportResult>;
     exportBatch(spans: SpanData[]): Promise<ExportResult>;
     flush(): Promise<void>;
+    private exportQuietly;
     shutdown(): Promise<void>;
     healthCheck(): Promise<ExporterHealthStatus>;
-    /**
-     * Verify connectivity to Langfuse API
-     */
     protected ping(): Promise<void>;
-    /**
-     * Create a Langfuse trace
-     */
-    private createTrace;
-    /**
-     * Create a Langfuse span
-     */
-    private createSpan;
-    /**
-     * Create a Langfuse generation (for LLM calls)
-     */
-    private createGeneration;
-    /**
-     * Make API call to Langfuse
-     */
-    private apiCall;
-    /**
-     * Extract tags from span attributes
-     */
-    private extractTags;
+    private deliver;
+    private post;
 }

package/dist/observability/exporters/langfuseExporter.js

@@ -1,85 +1,78 @@
-/**
- * Langfuse Exporter
- * Exports spans to Langfuse observability platform
- */
-import { SpanType } from "../../types/index.js";
-import { SpanSerializer } from "../utils/spanSerializer.js";
+import { DEFAULT_BASE_URL, DEFAULT_FLUSH_AT, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_TIMEOUT_MS, HEALTH_PATH, TRACES_PATH, } from "../../constants/langfuse.js";
+import { logger } from "../../utils/logger.js";
+import { chunkOtlpSpans, toOtlpAttributes, toOtlpSpan, } from "../otlpEncoding.js";
 import { BaseExporter } from "./baseExporter.js";
+let credentialsWarned = false;
+function isRetryable(status) {
+    return status === 429 || status >= 500;
+}
 /**
- * Langfuse exporter for LLM observability
- * Supports traces, generations, spans, and scores
+ * @description Exporter that delivers observation spans to Langfuse's OTLP/HTTP JSON endpoint (`POST /api/public/otel/v1/traces`), which keeps native observation types and identity on every observation. Spans are queued without blocking and sent in batches; failed requests are retried with backoff when the failure is transient (429, 5xx, network).
  */
 export class LangfuseExporter extends BaseExporter {
-    publicKey;
-    secretKey;
+    langfuse;
+    authorization;
     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;
+    policy;
+    inflight = new Set();
+    /**
+     * @description Creates an exporter for one Langfuse project.
+     * @param config {LangfuseExporterConfig} - Credentials, endpoint, environment, release, masking and batching options. `environment` and `release` fall back to `LANGFUSE_TRACING_ENVIRONMENT` and `LANGFUSE_RELEASE`, and only fill spans that do not carry them already.
+     */
+    constructor(langfuse) {
+        super("langfuse", {
+            ...langfuse,
+            maxBufferSize: langfuse.maxBufferSize ?? DEFAULT_FLUSH_AT,
+        });
+        this.langfuse = langfuse;
+        this.authorization = `Basic ${Buffer.from(`${langfuse.publicKey}:${langfuse.secretKey}`).toString("base64")}`;
+        this.baseUrl = (langfuse.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.policy = {
+            environment: langfuse.environment ?? process.env.LANGFUSE_TRACING_ENVIRONMENT,
+            release: langfuse.release ?? process.env.LANGFUSE_RELEASE,
+            redactIO: langfuse.redactIO ?? false,
+            mask: langfuse.mask,
+        };
     }
     async initialize() {
         if (this.initialized) {
             return;
         }
-        // Verify credentials with a simple check
-        if (!this.publicKey || !this.secretKey) {
+        if (!this.langfuse.publicKey || !this.langfuse.secretKey) {
             throw new Error("Langfuse publicKey and secretKey are required");
         }
         this.initialized = true;
-        this.startFlushInterval(this.config.flushIntervalMs ?? 5000);
+        this.startFlushInterval(this.config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS);
+        this.flushInterval?.unref();
     }
     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);
-        }
+        this.bufferSpan(span);
+        return this.createSuccessResult(1, 0);
     }
     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,
-        };
+        await this.deliver(spans.map((span) => toOtlpSpan(span, this.policy)));
+        return this.createSuccessResult(spans.length, Date.now() - startTime);
     }
     async flush() {
-        if (this.buffer.length > 0) {
-            const spans = [...this.buffer];
-            this.buffer = [];
+        const spans = this.buffer;
+        this.buffer = [];
+        if (spans.length > 0) {
+            const pending = this.exportQuietly(spans);
+            this.inflight.add(pending);
+            void pending.finally(() => this.inflight.delete(pending));
+        }
+        await Promise.all(this.inflight);
+    }
+    async exportQuietly(spans) {
+        try {
             await this.exportBatch(spans);
         }
+        catch (error) {
+            logger.warn("[langfuse] Export failed", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
     }
     async shutdown() {
         await this.flush();
@@ -95,115 +88,69 @@ export class LangfuseExporter extends BaseExporter {
             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}`,
-            },
+        const response = await fetch(`${this.baseUrl}${HEALTH_PATH}`, {
+            headers: { Authorization: this.authorization },
+            signal: AbortSignal.timeout(this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS),
         });
-        if (!response.ok && response.status !== 404) {
-            // 404 is acceptable as health endpoint may not exist
+        if (!response.ok) {
             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"];
+    async deliver(spans) {
+        for (const chunk of chunkOtlpSpans(spans)) {
+            try {
+                await this.withRetry(() => this.post(chunk), "export");
+            }
+            catch (error) {
+                logger.warn(`[langfuse] Dropped ${chunk.length} spans`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
         }
-        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}`, {
+    async post(spans) {
+        const response = await fetch(`${this.baseUrl}${TRACES_PATH}`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
-                Authorization: `Basic ${credentials}`,
+                Authorization: this.authorization,
+                "x-langfuse-sdk-name": "javascript",
+                "x-langfuse-ingestion-version": "4",
+                "x-langfuse-public-key": this.langfuse.publicKey,
             },
-            body: JSON.stringify(body),
+            body: JSON.stringify({
+                resourceSpans: [
+                    {
+                        resource: {
+                            attributes: toOtlpAttributes({ "service.name": "service" }),
+                        },
+                        scopeSpans: [{ scope: { name: "sdk" }, spans }],
+                    },
+                ],
+            }),
+            signal: AbortSignal.timeout(this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS),
         });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`Langfuse API error: ${response.status} - ${text}`);
+        if (response.status === 401 || response.status === 403) {
+            if (!credentialsWarned) {
+                credentialsWarned = true;
+                logger.warn("[langfuse] Langfuse credentials rejected");
+            }
+            return;
         }
-    }
-    /**
-     * Extract tags from span attributes
-     */
-    extractTags(span) {
-        const tags = [];
-        if (span.attributes["ai.provider"]) {
-            tags.push(`provider:${span.attributes["ai.provider"]}`);
+        if (isRetryable(response.status)) {
+            throw new Error(`Langfuse API error: ${response.status}`);
         }
-        if (span.attributes["ai.model"]) {
-            tags.push(`model:${span.attributes["ai.model"]}`);
+        if (!response.ok) {
+            logger.warn(`[langfuse] Export rejected with ${response.status}`);
+            return;
         }
-        if (span.attributes["deployment.environment"]) {
-            tags.push(`env:${span.attributes["deployment.environment"]}`);
+        const body = (await response.json().catch(() => ({})));
+        const rejected = Number(body.partialSuccess?.rejectedSpans ?? 0);
+        if (rejected > 0) {
+            logger.warn(`[langfuse] ${rejected} spans rejected`, {
+                message: body.partialSuccess?.errorMessage,
+            });
         }
-        return tags;
     }
 }
-// Safe metadata filtering imported from shared module to avoid duplication
-import { filterSafeMetadata } from "../utils/safeMetadata.js";

package/dist/observability/index.d.ts

@@ -3,6 +3,7 @@
  * Multi-platform observability with OpenTelemetry integration
  */
 export { ExporterRegistry, getExporterRegistry, resetExporterRegistry, } from "./exporterRegistry.js";
+export { createExporterSpanProcessor, ExporterSpanProcessor, } from "./exporterSpanProcessor.js";
 export { ArizeExporter } from "./exporters/arizeExporter.js";
 export { BaseExporter, NoOpExporter } from "./exporters/baseExporter.js";
 export { BraintrustExporter } from "./exporters/braintrustExporter.js";

package/dist/observability/index.js

@@ -4,6 +4,7 @@
  */
 // Core - Registry with singleton pattern
 export { ExporterRegistry, getExporterRegistry, resetExporterRegistry, } from "./exporterRegistry.js";
+export { createExporterSpanProcessor, ExporterSpanProcessor, } from "./exporterSpanProcessor.js";
 export { ArizeExporter } from "./exporters/arizeExporter.js";
 // Exporters
 export { BaseExporter, NoOpExporter } from "./exporters/baseExporter.js";

package/dist/observability/langfuseMasking.d.ts

@@ -0,0 +1,8 @@
+import type { LangfuseAttributePolicy, SpanAttributes } from "../types/index.js";
+/**
+ * @description Applies the exporter's policy to a span's attributes: fills environment and release when the span has none, removes input and output when `redactIO` is set, and masks input, output and metadata when a mask is configured.
+ * @param attributes {SpanAttributes} - Attributes of the span being exported.
+ * @param policy {LangfuseAttributePolicy} - Environment, release, redaction and mask settings.
+ * @returns {SpanAttributes} A new attribute record; the input is not modified.
+ */
+export declare function protectAttributes(attributes: SpanAttributes, policy: LangfuseAttributePolicy): SpanAttributes;

package/dist/observability/langfuseMasking.js

@@ -0,0 +1,47 @@
+import { CONTENT_KEYS, FULLY_MASKED, METADATA_PREFIXES, } from "../constants/langfuse.js";
+function parseContent(value) {
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text ?? null;
+    }
+}
+function maskValue(value, mask) {
+    try {
+        const masked = mask?.({ data: parseContent(value) });
+        return typeof masked === "string" ? masked : JSON.stringify(masked);
+    }
+    catch {
+        return FULLY_MASKED;
+    }
+}
+/**
+ * @description Applies the exporter's policy to a span's attributes: fills environment and release when the span has none, removes input and output when `redactIO` is set, and masks input, output and metadata when a mask is configured.
+ * @param attributes {SpanAttributes} - Attributes of the span being exported.
+ * @param policy {LangfuseAttributePolicy} - Environment, release, redaction and mask settings.
+ * @returns {SpanAttributes} A new attribute record; the input is not modified.
+ */
+export function protectAttributes(attributes, policy) {
+    const result = {
+        ...(policy.environment && { "langfuse.environment": policy.environment }),
+        ...(policy.release && { "langfuse.release": policy.release }),
+        ...attributes,
+    };
+    for (const key of Object.keys(result)) {
+        if (CONTENT_KEYS.has(key)) {
+            if (policy.redactIO) {
+                delete result[key];
+            }
+            else if (policy.mask) {
+                result[key] = maskValue(result[key], policy.mask);
+            }
+        }
+        else if (policy.mask &&
+            METADATA_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+            result[key] = maskValue(result[key], policy.mask);
+        }
+    }
+    return result;
+}