@hue-run/sdk 0.21.1 → 0.23.0

package/dist/cli/traces-import-convert.js

@@ -4,14 +4,15 @@ import { z } from "zod/v4";
 import { blobEntry, blobPrefix, BLOBS_KEY, MAX_BLOB_ENTRIES, textContentType } from "../blobs.js";
 import { TRUNCATED_KEY } from "../privacy.js";
 import { hueSpanId, hueTraceId } from "./langfuse.js";
-import { isZipSignature } from "./traces-import-zip.js";
 /**
- * The conversions behind `hue traces import prepare`: a source file is recognized by its content
- * (an OTLP/JSON trace export, a complete Langfuse observation export or a text ATIF export),
- * each trace becomes OTLP/JSON entries, one span each, that keep the recorded ids, hierarchy,
- * timestamps, content, errors and usage, and the entries are packed into deterministic gzip
- * batches. Nothing here depends on where a file sat or what it was called: a renamed or repacked
- * bundle converts to byte-identical batches, so the manifest's digests name the same import.
+ * The conversions behind `hue traces import prepare` that predate the format registry
+ * (`import-formats/registry.ts`, which recognizes each value and hands it to its format): OTLP/JSON
+ * spans kept as recorded, complete Langfuse observation exports and text ATIF exports, each trace
+ * as OTLP/JSON entries, one span each, that keep the recorded ids, hierarchy, timestamps,
+ * content, errors and usage; the shared attribute, large-value and JSON helpers; and the packing
+ * of entries into deterministic gzip batches and the manifest. Nothing here depends on where a
+ * file sat or what it was called: a renamed or repacked bundle converts to byte-identical
+ * batches, so the manifest's digests name the same import.
  */
 export const traceImportFormats = ["otlp_json", "langfuse_observations", "atif"];
 export const traceImportOrigins = ["production", "evaluation", "simulation", "unknown"];
@@ -45,32 +46,52 @@ const BASE64_SPAN_ID = /^[A-Za-z0-9+/]{11}=$/;
 const MAX_IDENTIFIER = 16_384;
 const MAX_SESSION = 2_048;
 const MAX_NAMESPACE = 128;
-/** The root attributes Hue reads a trace's user, session and explicit entity from. */
-const USER_KEYS = [
-    "user.id",
-    "enduser.id",
-    "hue.user.id",
-    "ai.telemetry.metadata.userId",
-    "langfuse.user.id",
-];
-const SESSION_KEYS = [
-    "gen_ai.conversation.id",
-    "session.id",
-    "hue.session.id",
-    "ai.telemetry.metadata.sessionId",
-    "langfuse.session.id",
-];
-const ENTITY_NAMESPACE = "hue.world.entity.namespace";
-const ENTITY_ID = "hue.world.entity.id";
 /** Attributes that mark a trace as an evaluation's or a simulated world's. */
 const EVALUATION_KEYS = ["hue.execution.id", "hue.eval.execution_id"];
 const SIMULATION_KEYS = ["hue.world.id", "hue.environment.run_id"];
 const SIMULATION_SCOPE = "hue.sim-gateway";
 export class ConversionError extends Error {
 }
+/**
+ * A failure that refuses only what was being read: a ConversionError as itself, and a RangeError
+ * (a value too large or nested too deep for a reader to walk) as one. Anything else is a defect
+ * and is undefined, for the caller to rethrow.
+ */
+export function conversionFailure(error) {
+    if (error instanceof ConversionError)
+        return error;
+    if (error instanceof RangeError)
+        return new ConversionError("the record is too large or nested too deep to read");
+    return undefined;
+}
+/** How deep a value read from a source may nest: far beyond any export's records, and well
+ * inside what the readers and serializers that walk a value can follow. */
+export const MAX_SOURCE_NESTING = 512;
+/** Whether a parsed JSON value nests deeper than `max` levels, walked without recursion and
+ * holding only the path to the value being looked at. */
+export function nestedTooDeep(value, max = MAX_SOURCE_NESTING) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const members = (item) => (Array.isArray(item) ? item : Object.values(item));
+    const path = [{ items: members(value), next: 0 }];
+    while (path.length) {
+        const level = path[path.length - 1];
+        if (level.next >= level.items.length) {
+            path.pop();
+            continue;
+        }
+        const child = level.items[level.next++];
+        if (child === null || typeof child !== "object")
+            continue;
+        if (path.length >= max)
+            return true;
+        path.push({ items: members(child), next: 0 });
+    }
+    return false;
+}
 export const sha256Hex = (value) => createHash("sha256").update(value).digest("hex");
-const digestHex = (text, length) => sha256Hex(text).slice(0, length);
-function isObject(value) {
+export const digestHex = (text, length) => sha256Hex(text).slice(0, length);
+export function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function object(value) {
@@ -122,6 +143,19 @@ export function parseJsonText(text) {
         throw error;
     }
 }
+/** JSON text a record holds (metadata values, tool arguments, a column a warehouse stores as text)
+ * parsed as {@link parseJsonText} parses it; text nested deeper than {@link MAX_SOURCE_NESTING}
+ * throws, so the caller keeps it as the text it is. */
+export function parseNestedJsonText(text) {
+    const parsed = parseJsonText(text);
+    if (nestedTooDeep(parsed.value))
+        throw new ConversionError("JSON text nested too deep");
+    return parsed;
+}
+/** Langfuse's experiment and evaluator environments (`sdk-experiment`, `langfuse-…`): traffic
+ * Langfuse itself marks as evaluation. */
+export const langfuseEvaluationEnvironment = (environment) => environment === "sdk-experiment" ||
+    (typeof environment === "string" && environment.startsWith("langfuse-"));
 /** Refuses a source value that JavaScript or OTLP cannot retain exactly; never omits it. */
 export function validateSource(value, depth = 0) {
     if (depth > 64)
@@ -203,95 +237,6 @@ export function validateJsonText(raw) {
         }
     }
 }
-const isOtlpEnvelope = (value) => isObject(value) && (Array.isArray(value.resourceSpans) || Array.isArray(value.resource_spans));
-const isObservation = (value) => isObject(value) &&
-    typeof value.id === "string" &&
-    typeof value.traceId === "string" &&
-    typeof value.type === "string" &&
-    typeof value.startTime === "string";
-/** What a file holds, read from its content alone; never from its name. */
-export function detectFormat(bytes) {
-    if (!bytes.byteLength)
-        return { format: "unsupported", reason: "the file is empty" };
-    if (bytes[0] === 0x1f && bytes[1] === 0x8b)
-        return { format: "unsupported", reason: "a gzip file; decompress it first" };
-    // An archive is read where the walk finds it on disk; one inside another is not opened.
-    if (isZipSignature(bytes))
-        return { format: "unsupported", reason: "a ZIP archive inside the input; extract it first" };
-    let text;
-    try {
-        text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes);
-    }
-    catch {
-        return { format: "unsupported", reason: "not UTF-8 text" };
-    }
-    let parsed;
-    try {
-        parsed = parseJsonText(text);
-    }
-    catch {
-        parsed = undefined;
-    }
-    if (!parsed) {
-        // OTLP/JSON exports are also written one request a line.
-        const lines = text.split(/\r?\n/).filter((line) => line.trim());
-        if (lines.length < 2)
-            return { format: "unsupported", reason: "not JSON" };
-        const envelopes = [];
-        for (const line of lines) {
-            let value;
-            try {
-                value = parseJsonText(line).value;
-            }
-            catch {
-                return { format: "unsupported", reason: "not JSON" };
-            }
-            if (!isOtlpEnvelope(value))
-                return { format: "unsupported", reason: "JSON Lines whose records are not OTLP exports" };
-            envelopes.push(value);
-        }
-        return { format: "otlp_json", envelopes };
-    }
-    const value = parsed.value;
-    if (Array.isArray(value)) {
-        if (value.length && value.every(isOtlpEnvelope))
-            return { format: "otlp_json", envelopes: value };
-        return { format: "unsupported", reason: "a JSON array that is not a list of OTLP exports" };
-    }
-    if (!isObject(value))
-        return { format: "unsupported", reason: "not a JSON object" };
-    if (isOtlpEnvelope(value))
-        return { format: "otlp_json", envelopes: [value] };
-    if (Array.isArray(value.resourceLogs) || Array.isArray(value.resource_logs))
-        return { format: "unsupported", reason: "an OTLP logs export; only traces are imported" };
-    if (typeof value.schema_version === "string" && value.schema_version.startsWith("ATIF-")) {
-        if (!Array.isArray(value.steps))
-            return { format: "unsupported", reason: "an ATIF document without steps" };
-        return { format: "atif", text, document: value, unsafeIntegers: parsed.unsafeIntegers };
-    }
-    const key = Array.isArray(value.data)
-        ? "data"
-        : Array.isArray(value.observations)
-            ? "observations"
-            : undefined;
-    if (key) {
-        if (value.data !== undefined && value.observations !== undefined)
-            return { format: "unsupported", reason: "two observation envelopes in one file" };
-        const records = value[key];
-        if (!records.length)
-            return { format: "unsupported", reason: "a Langfuse export without observations" };
-        if (!records.every(isObservation))
-            return { format: "unsupported", reason: "a `data` list that is not Langfuse observations" };
-        const envelope = Object.fromEntries(Object.entries(value).filter(([name]) => name !== key));
-        return {
-            format: "langfuse_observations",
-            observations: records,
-            envelope,
-            unsafeIntegers: parsed.unsafeIntegers,
-        };
-    }
-    return { format: "unsupported", reason: "a JSON document of no recognized shape" };
-}
 // --- Attributes and large values ----------------------------------------------------------------
 export function anyValue(value) {
     if (value === null)
@@ -428,39 +373,16 @@ function attributeMap(attributes) {
         map.set(attribute.key, attribute.value);
     return map;
 }
-/** A trace's identity as its root records it, in the attributes Hue reads. */
-function identityOf(root, resource) {
-    const identity = {};
-    for (const key of USER_KEYS) {
-        const user = identifier(stringOf(root.get(key)), MAX_IDENTIFIER);
-        if (user) {
-            identity.user = user;
-            break;
-        }
-    }
-    for (const source of [root, resource]) {
-        const namespace = identifier(stringOf(source.get(ENTITY_NAMESPACE)), MAX_NAMESPACE);
-        const id = identifier(stringOf(source.get(ENTITY_ID)), MAX_IDENTIFIER);
-        if (namespace && id) {
-            identity.entity = { namespace, id };
-            break;
-        }
-    }
-    for (const key of SESSION_KEYS) {
-        const session = identifier(stringOf(root.get(key)), MAX_SESSION);
-        if (session) {
-            identity.session = session;
-            break;
-        }
-    }
-    return identity.user || identity.entity || identity.session ? identity : undefined;
-}
-/** Gathers the spans of OTLP/JSON exports by trace, across files: an export writes a trace's
- * spans in the requests that carried them, which need not be one file. */
+/** The collector key of the formats that keep OTLP spans as recorded (OTLP/JSON, binary OTLP,
+ * Jaeger API v3): one {@link OtlpTraceCollector} gathers their spans together. */
+export const OTLP_SPANS = "otlp_spans";
+/** Gathers the spans of OTLP/JSON exports by trace, across files and the formats that carry
+ * them: an export writes a trace's spans in the requests that carried them, which need not be one
+ * file. Each trace is named by the format that read its first span. */
 export class OtlpTraceCollector {
     traces = new Map();
-    /** Adds every span of the envelopes; the spans refused, with their reasons. */
-    add(envelopes, sourceDigest) {
+    /** Adds every span of the envelopes `format` read; the spans refused, with their reasons. */
+    add(envelopes, sourceDigest, format) {
         const refused = [];
         for (const envelope of envelopes) {
             // An export may mix the proto field names with lowerCamelCase at any depth; every
@@ -471,9 +393,10 @@ export class OtlpTraceCollector {
                 if (!isObject(groupValue))
                     continue;
                 const { scopeSpans, ...resourceGroup } = groupValue;
-                const resource = isObject(resourceGroup.resource)
-                    ? attributeMap(readAttributes(resourceGroup.resource.attributes) ?? [])
-                    : new Map();
+                const resourceAttributes = isObject(resourceGroup.resource)
+                    ? readAttributes(resourceGroup.resource.attributes)
+                    : [];
+                const resource = attributeMap(resourceAttributes ?? []);
                 for (const scopeValue of Array.isArray(scopeSpans) ? scopeSpans : []) {
                     if (!isObject(scopeValue))
                         continue;
@@ -481,12 +404,18 @@ export class OtlpTraceCollector {
                     const scopeName = isObject(scopeGroup.scope) ? scopeGroup.scope.name : undefined;
                     for (const spanValue of Array.isArray(spans) ? spans : []) {
                         try {
-                            this.addSpan(spanValue, resourceGroup, scopeGroup, resource, scopeName, sourceDigest);
+                            if (resourceAttributes === undefined)
+                                throw new ConversionError("the span's resource has malformed attributes");
+                            this.addSpan(spanValue, resourceGroup, scopeGroup, resource, scopeName, sourceDigest, format);
                         }
                         catch (error) {
-                            if (!(error instanceof ConversionError))
+                            const failure = conversionFailure(error);
+                            if (!failure)
                                 throw error;
-                            refused.push({ reason: error.message });
+                            // A malformed span refuses its trace, never leaving a partial one; a span that names
+                            // no trace is refused alone.
+                            const traceId = isObject(spanValue) ? spanValue.traceId : undefined;
+                            refused.push(this.refuse(traceId, failure.message));
                         }
                     }
                 }
@@ -494,17 +423,23 @@ export class OtlpTraceCollector {
         }
         return refused;
     }
-    addSpan(value, resourceGroup, scopeGroup, resource, scopeName, sourceDigest) {
+    /** Refuses the trace a span names (its id as recorded), whatever else of it is read; a span
+     * that names no trace is refused alone. */
+    refuse(traceIdValue, reason) {
+        const id = otlpTraceId(traceIdValue);
+        if (id)
+            this.draft(id.traceId, id.remapped).conflict ??= reason;
+        return { ...(id ? { traceId: id.traceId } : {}), reason };
+    }
+    addSpan(value, resourceGroup, scopeGroup, resource, scopeName, sourceDigest, format) {
         if (!isObject(value))
             throw new ConversionError("a span that is not a JSON object");
         const span = { ...value };
         const originalTraceId = span.traceId;
-        if (typeof originalTraceId !== "string" || !originalTraceId)
+        const id = otlpTraceId(originalTraceId);
+        if (typeof originalTraceId !== "string" || !id)
             throw new ConversionError("a span without a trace id");
-        let traceId = normalizeId(originalTraceId, 32);
-        const remappedTraceId = traceId === undefined;
-        if (!traceId)
-            traceId = digestHex(`otlp.trace:${originalTraceId}`, 32);
+        const { traceId, remapped: remappedTraceId } = id;
         const originalSpanId = span.spanId;
         if (typeof originalSpanId !== "string" || !originalSpanId)
             throw new ConversionError("a span without a span id");
@@ -534,21 +469,8 @@ export class OtlpTraceCollector {
         const attributes = readAttributes(span.attributes);
         if (attributes === undefined)
             throw new ConversionError(`span ${spanId} has malformed attributes`);
-        let trace = this.traces.get(traceId);
-        if (!trace) {
-            trace = {
-                traceId,
-                remappedTraceId,
-                spans: new Map(),
-                blobs: new BlobSink(),
-                sourceDigests: new Set(),
-                remappedSpans: 0,
-                evaluation: false,
-                simulation: false,
-                production: false,
-            };
-            this.traces.set(traceId, trace);
-        }
+        const trace = this.draft(traceId, remappedTraceId);
+        trace.format ??= format;
         const kept = [...attributes];
         if (remappedTraceId)
             kept.push({ key: "hue.import.original_trace_id", value: { stringValue: originalTraceId } });
@@ -559,11 +481,11 @@ export class OtlpTraceCollector {
             ...resourceGroup,
             scopeSpans: [{ ...scopeGroup, spans: [span] }],
         };
-        const canonical = JSON.stringify(entry);
+        const digest = sha256Hex(JSON.stringify(entry));
         const held = trace.spans.get(spanId);
         if (held) {
             // The same span sent twice is one span; another payload under its id is a conflict.
-            if (held.canonical !== canonical)
+            if (held.digest !== digest)
                 trace.conflict ??= `span ${spanId} appears with different content`;
             trace.sourceDigests.add(sourceDigest);
             return;
@@ -588,29 +510,56 @@ export class OtlpTraceCollector {
             ...(parentSpanId ? { parentSpanId } : {}),
             start: BigInt(start),
             entry,
-            canonical,
-            attributes: map,
-            resource,
+            digest,
         });
     }
+    draft(traceId, remappedTraceId) {
+        let trace = this.traces.get(traceId);
+        if (!trace) {
+            trace = {
+                traceId,
+                remappedTraceId,
+                spans: new Map(),
+                blobs: new BlobSink(),
+                sourceDigests: new Set(),
+                remappedSpans: 0,
+                evaluation: false,
+                simulation: false,
+                production: false,
+            };
+            this.traces.set(traceId, trace);
+        }
+        return trace;
+    }
     /** Every trace gathered so far, spans in time order, and the traces refused whole. */
     finish() {
         const traces = [];
         const refused = [];
-        for (const draft of this.traces.values()) {
+        for (const [key, draft] of this.traces) {
+            // Each draft is let go once its trace is converted.
+            this.traces.delete(key);
             if (draft.conflict) {
                 refused.push({ traceId: draft.traceId, reason: draft.conflict });
                 continue;
             }
+            // A parent outside the trace is a root, as OTLP allows; a parent chain that closes on
+            // itself leaves the trace without one and is refused.
+            const parents = new Map([...draft.spans.values()].map((span) => [
+                span.spanId,
+                span.parentSpanId !== undefined && draft.spans.has(span.parentSpanId)
+                    ? span.parentSpanId
+                    : undefined,
+            ]));
+            if (ancestryIssue(parents) === "cyclic_ancestry") {
+                refused.push({ traceId: draft.traceId, reason: "The source hierarchy contains a cycle" });
+                continue;
+            }
             const spans = [...draft.spans.values()].sort((a, b) => a.start < b.start ? -1 : a.start > b.start ? 1 : a.spanId < b.spanId ? -1 : 1);
-            const root = spans.find((span) => !span.parentSpanId || !draft.spans.has(span.parentSpanId));
-            const identity = root ? identityOf(root.attributes, root.resource) : undefined;
             traces.push({
                 traceId: draft.traceId,
-                format: "otlp_json",
+                format: draft.format ?? "otlp_json",
                 entries: spans.map((span) => span.entry),
                 blobs: draft.blobs.sorted(),
-                ...(identity ? { identity } : {}),
                 origin: draft.evaluation
                     ? "evaluation"
                     : draft.simulation
@@ -626,6 +575,48 @@ export class OtlpTraceCollector {
         return { traces, refused };
     }
 }
+/** A span's OpenTelemetry trace id: the recorded one, or one derived from an id that is not. */
+function otlpTraceId(value) {
+    if (typeof value !== "string" || !value)
+        return undefined;
+    const traceId = normalizeId(value, 32);
+    return traceId
+        ? { traceId, remapped: false }
+        : { traceId: digestHex(`otlp.trace:${value}`, 32), remapped: true };
+}
+/** Whether a recorded OTLP `AnyValue` has the shape OTLP/JSON gives it: an object whose
+ * `arrayValue` and `kvlistValue` hold lists of values and of keyed values. Walked without
+ * recursion. */
+function validOtlpValue(value) {
+    const stack = [value];
+    while (stack.length) {
+        const item = stack.pop();
+        if (!isObject(item))
+            return false;
+        for (const [field, keyed] of [
+            ["arrayValue", false],
+            ["kvlistValue", true],
+        ]) {
+            const list = item[field];
+            if (list === undefined || list === null)
+                continue;
+            if (!isObject(list))
+                return false;
+            const values = list.values ?? [];
+            if (!Array.isArray(values))
+                return false;
+            for (const entry of values) {
+                if (!keyed)
+                    stack.push(entry);
+                else if (!isObject(entry) || typeof entry.key !== "string")
+                    return false;
+                else if (entry.value !== undefined && entry.value !== null)
+                    stack.push(entry.value);
+            }
+        }
+    }
+    return true;
+}
 /** An OTLP attribute list as recorded, or undefined when it is malformed. */
 function readAttributes(value) {
     if (value === undefined || value === null)
@@ -634,7 +625,7 @@ function readAttributes(value) {
         return undefined;
     const attributes = [];
     for (const item of value) {
-        if (!isObject(item) || typeof item.key !== "string" || !isObject(item.value))
+        if (!isObject(item) || typeof item.key !== "string" || !validOtlpValue(item.value))
             return undefined;
         attributes.push(item);
     }
@@ -642,7 +633,7 @@ function readAttributes(value) {
 }
 /** A recorded span's string values over the inline limit stored apart from it, listed beside
  * any values its exporter already listed. */
-function offloadOtlpValues(attributes, blobs) {
+export function offloadOtlpValues(attributes, blobs) {
     const over = attributes.filter((attribute) => typeof attribute.value.stringValue === "string" &&
         Buffer.byteLength(attribute.value.stringValue, "utf8") > MAX_INLINE_VALUE_BYTES);
     if (!over.length)
@@ -708,7 +699,8 @@ export function unixNano(value) {
         throw new ConversionError("Invalid source timestamp");
     return (BigInt(seconds) * 1000000n + BigInt((match[2] ?? "").padEnd(9, "0"))).toString();
 }
-const canonicalJson = (value) => {
+/** JSON text with object keys sorted: equal for equal values whatever their key order. */
+export const canonicalJson = (value) => {
     if (Array.isArray(value))
         return `[${value.map(canonicalJson).join(",")}]`;
     if (value && typeof value === "object")
@@ -748,32 +740,44 @@ export class LangfuseTraceCollector {
         for (const observation of observations) {
             const traceId = text(observation.traceId, true);
             const id = text(observation.id, true);
-            let draft = this.traces.get(traceId);
-            if (!draft) {
-                draft = {
-                    originalTraceId: traceId,
-                    observations: new Map(),
-                    envelopes: new Map(),
-                    sourceDigests: new Set(),
-                };
-                this.traces.set(traceId, draft);
-            }
+            const draft = this.draft(traceId);
             draft.sourceDigests.add(sourceDigest);
             draft.envelopes.set(sourceDigest, envelopeText);
-            const canonical = canonicalJson(observation);
+            const digest = sha256Hex(canonicalJson(observation));
             const held = draft.observations.get(id);
             if (held) {
-                if (held.canonical !== canonical)
+                if (held.digest !== digest)
                     draft.conflict ??= `observation ${id} appears with different content`;
                 continue;
             }
-            draft.observations.set(id, { record: observation, canonical });
+            draft.observations.set(id, { record: observation, digest });
         }
     }
+    /** Refuses a trace by its Langfuse id, whatever else of it is read. */
+    refuse(traceId, reason, sourceDigest) {
+        const draft = this.draft(traceId);
+        draft.sourceDigests.add(sourceDigest);
+        draft.conflict ??= reason;
+    }
+    draft(traceId) {
+        let draft = this.traces.get(traceId);
+        if (!draft) {
+            draft = {
+                originalTraceId: traceId,
+                observations: new Map(),
+                envelopes: new Map(),
+                sourceDigests: new Set(),
+            };
+            this.traces.set(traceId, draft);
+        }
+        return draft;
+    }
     finish() {
         const traces = [];
         const refused = [];
-        for (const draft of this.traces.values()) {
+        for (const [key, draft] of this.traces) {
+            // Each draft is let go once its trace is converted.
+            this.traces.delete(key);
             const traceId = hueTraceId(draft.originalTraceId);
             if (draft.conflict) {
                 refused.push({ traceId, reason: draft.conflict });
@@ -783,9 +787,10 @@ export class LangfuseTraceCollector {
                 traces.push(convertLangfuseTrace(draft, traceId));
             }
             catch (error) {
-                if (!(error instanceof ConversionError))
+                const failure = conversionFailure(error);
+                if (!failure)
                     throw error;
-                refused.push({ traceId, reason: error.message });
+                refused.push({ traceId, reason: failure.message });
             }
         }
         return { traces, refused };
@@ -848,10 +853,10 @@ function convertLangfuseTrace(draft, traceId) {
         imported.add(spanId);
         spanIds.set(originalId, spanId);
     }
-    let identity;
     // The origin markers the OTLP reader applies, read from the converted attributes with the same
     // precedence: an evaluation's or a simulated world's records are never production history,
-    // whatever environment the export was taken from.
+    // whatever environment the export was taken from. Langfuse's own experiment and evaluator
+    // environments are evaluation traffic too, as the `langfuse` format reads them.
     let production = false;
     let evaluation = false;
     let simulation = false;
@@ -940,6 +945,8 @@ function convertLangfuseTrace(draft, traceId) {
         attributes.add("hue.import.status_source", "langfuse.level");
         if (observation.environment === "production")
             production = true;
+        if (langfuseEvaluationEnvironment(observation.environment))
+            evaluation = true;
         const message = text(observation.statusMessage);
         const span = {
             traceId,
@@ -953,11 +960,6 @@ function convertLangfuseTrace(draft, traceId) {
             attributes: attributes.finish(),
             status: { code: observation.level === "ERROR" ? 2 : 0, ...(message ? { message } : {}) },
         };
-        // The trace's owner as the OTLP reader takes it from a root: the user (`langfuse.user.id`
-        // among the keys), an explicit entity in the root's metadata or resource attributes, and the
-        // session.
-        if (!parent)
-            identity = identityOf(attributeMap(span.attributes), attributeMap(resource));
         return {
             resource: { attributes: resource },
             scopeSpans: [
@@ -978,7 +980,6 @@ function convertLangfuseTrace(draft, traceId) {
         format: "langfuse_observations",
         entries,
         blobs: blobs.sorted(),
-        ...(identity ? { identity } : {}),
         origin: evaluation
             ? "evaluation"
             : simulation
@@ -1581,15 +1582,11 @@ export function convertAtifExport(source, rawBytes) {
             attributes: [{ key: "user.id", value: { stringValue: userId } }],
             status: { code: 0 },
         });
-    const session = identifier(document.session_id, MAX_SESSION);
     return {
         traceId,
         format: "atif",
         entries,
         blobs: blobs.sorted(),
-        ...(userId || session
-            ? { identity: { ...(userId ? { user: userId } : {}), ...(session ? { session } : {}) } }
-            : {}),
         origin: "unknown",
         sourceDigests: new Set(),
         remappedTraceId: false,