@fallom/trace 0.2.16 → 0.2.17

package/dist/chunk-KFD5AQ7V.mjs

@@ -0,0 +1,308 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/models.ts
+var models_exports = {};
+__export(models_exports, {
+  get: () => get,
+  init: () => init
+});
+import { createHash } from "crypto";
+var apiKey = null;
+var baseUrl = "https://configs.fallom.com";
+var initialized = false;
+var syncInterval = null;
+var debugMode = false;
+var configCache = /* @__PURE__ */ new Map();
+var SYNC_TIMEOUT = 2e3;
+var RECORD_TIMEOUT = 1e3;
+function log(msg) {
+  if (debugMode) {
+    console.log(`[Fallom] ${msg}`);
+  }
+}
+function evaluateTargeting(targeting, customerId, context) {
+  if (!targeting || targeting.enabled === false) {
+    return null;
+  }
+  const evalContext = {
+    ...context || {},
+    ...customerId ? { customerId } : {}
+  };
+  log(`Evaluating targeting with context: ${JSON.stringify(evalContext)}`);
+  if (targeting.individualTargets) {
+    for (const target of targeting.individualTargets) {
+      const fieldValue = evalContext[target.field];
+      if (fieldValue === target.value) {
+        log(`Individual target matched: ${target.field}=${target.value} -> variant ${target.variantIndex}`);
+        return target.variantIndex;
+      }
+    }
+  }
+  if (targeting.rules) {
+    for (const rule of targeting.rules) {
+      const allConditionsMatch = rule.conditions.every((condition) => {
+        const fieldValue = evalContext[condition.field];
+        if (fieldValue === void 0) return false;
+        switch (condition.operator) {
+          case "eq":
+            return fieldValue === condition.value;
+          case "neq":
+            return fieldValue !== condition.value;
+          case "in":
+            return Array.isArray(condition.value) && condition.value.includes(fieldValue);
+          case "nin":
+            return Array.isArray(condition.value) && !condition.value.includes(fieldValue);
+          case "contains":
+            return typeof condition.value === "string" && fieldValue.includes(condition.value);
+          case "startsWith":
+            return typeof condition.value === "string" && fieldValue.startsWith(condition.value);
+          case "endsWith":
+            return typeof condition.value === "string" && fieldValue.endsWith(condition.value);
+          default:
+            return false;
+        }
+      });
+      if (allConditionsMatch) {
+        log(`Rule matched: ${JSON.stringify(rule.conditions)} -> variant ${rule.variantIndex}`);
+        return rule.variantIndex;
+      }
+    }
+  }
+  log("No targeting rules matched, falling back to weighted random");
+  return null;
+}
+function init(options = {}) {
+  apiKey = options.apiKey || process.env.FALLOM_API_KEY || null;
+  baseUrl = options.baseUrl || process.env.FALLOM_CONFIGS_URL || process.env.FALLOM_BASE_URL || "https://configs.fallom.com";
+  initialized = true;
+  if (!apiKey) {
+    return;
+  }
+  fetchConfigs().catch(() => {
+  });
+  if (!syncInterval) {
+    syncInterval = setInterval(() => {
+      fetchConfigs().catch(() => {
+      });
+    }, 3e4);
+    syncInterval.unref();
+  }
+}
+function ensureInit() {
+  if (!initialized) {
+    try {
+      init();
+    } catch {
+    }
+  }
+}
+async function fetchConfigs(timeout = SYNC_TIMEOUT) {
+  if (!apiKey) {
+    log("_fetchConfigs: No API key, skipping");
+    return;
+  }
+  try {
+    log(`Fetching configs from ${baseUrl}/configs`);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const resp = await fetch(`${baseUrl}/configs`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    log(`Response status: ${resp.status}`);
+    if (resp.ok) {
+      const data = await resp.json();
+      const configs = data.configs || [];
+      log(`Got ${configs.length} configs: ${configs.map((c) => c.key)}`);
+      for (const c of configs) {
+        const key = c.key;
+        const version = c.version || 1;
+        log(`Config '${key}' v${version}: ${JSON.stringify(c.variants)}`);
+        if (!configCache.has(key)) {
+          configCache.set(key, { versions: /* @__PURE__ */ new Map(), latest: null });
+        }
+        const cached = configCache.get(key);
+        cached.versions.set(version, c);
+        cached.latest = version;
+      }
+    } else {
+      log(`Fetch failed: ${resp.statusText}`);
+    }
+  } catch (e) {
+    log(`Fetch exception: ${e}`);
+  }
+}
+async function fetchSpecificVersion(configKey, version, timeout = SYNC_TIMEOUT) {
+  if (!apiKey) return null;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const resp = await fetch(
+      `${baseUrl}/configs/${configKey}/version/${version}`,
+      {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: controller.signal
+      }
+    );
+    clearTimeout(timeoutId);
+    if (resp.ok) {
+      const config = await resp.json();
+      if (!configCache.has(configKey)) {
+        configCache.set(configKey, { versions: /* @__PURE__ */ new Map(), latest: null });
+      }
+      configCache.get(configKey).versions.set(version, config);
+      return config;
+    }
+  } catch {
+  }
+  return null;
+}
+async function get(configKey, sessionId, options = {}) {
+  const { version, fallback, customerId, context, debug = false } = options;
+  debugMode = debug;
+  ensureInit();
+  log(
+    `get() called: configKey=${configKey}, sessionId=${sessionId}, fallback=${fallback}`
+  );
+  try {
+    let configData = configCache.get(configKey);
+    log(
+      `Cache lookup for '${configKey}': ${configData ? "found" : "not found"}`
+    );
+    if (!configData) {
+      log("Not in cache, fetching...");
+      await fetchConfigs(SYNC_TIMEOUT);
+      configData = configCache.get(configKey);
+      log(
+        `After fetch, cache lookup: ${configData ? "found" : "still not found"}`
+      );
+    }
+    if (!configData) {
+      log(`Config not found, using fallback: ${fallback}`);
+      if (fallback) {
+        console.warn(
+          `[Fallom WARNING] Config '${configKey}' not found, using fallback model: ${fallback}`
+        );
+        return returnModel(configKey, sessionId, fallback, 0);
+      }
+      throw new Error(
+        `Config '${configKey}' not found. Check that it exists in your Fallom dashboard.`
+      );
+    }
+    let config;
+    let targetVersion;
+    if (version !== void 0) {
+      config = configData.versions.get(version);
+      if (!config) {
+        config = await fetchSpecificVersion(configKey, version, SYNC_TIMEOUT) || void 0;
+      }
+      if (!config) {
+        if (fallback) {
+          console.warn(
+            `[Fallom WARNING] Config '${configKey}' version ${version} not found, using fallback: ${fallback}`
+          );
+          return returnModel(configKey, sessionId, fallback, 0);
+        }
+        throw new Error(`Config '${configKey}' version ${version} not found.`);
+      }
+      targetVersion = version;
+    } else {
+      targetVersion = configData.latest;
+      config = configData.versions.get(targetVersion);
+      if (!config) {
+        if (fallback) {
+          console.warn(
+            `[Fallom WARNING] Config '${configKey}' has no cached version, using fallback: ${fallback}`
+          );
+          return returnModel(configKey, sessionId, fallback, 0);
+        }
+        throw new Error(`Config '${configKey}' has no cached version.`);
+      }
+    }
+    const variantsRaw = config.variants;
+    const configVersion = config.version || targetVersion;
+    const variants = Array.isArray(variantsRaw) ? variantsRaw : Object.values(variantsRaw);
+    log(
+      `Config found! Version: ${configVersion}, Variants: ${JSON.stringify(
+        variants
+      )}`
+    );
+    const targetedVariantIndex = evaluateTargeting(config.targeting, customerId, context);
+    if (targetedVariantIndex !== null && variants[targetedVariantIndex]) {
+      const assignedModel2 = variants[targetedVariantIndex].model;
+      log(`\u2705 Assigned model via targeting: ${assignedModel2}`);
+      return returnModel(configKey, sessionId, assignedModel2, configVersion);
+    }
+    const hashBytes = createHash("md5").update(sessionId).digest();
+    const hashVal = hashBytes.readUInt32BE(0) % 1e6;
+    log(`Session hash: ${hashVal} (out of 1,000,000)`);
+    let cumulative = 0;
+    let assignedModel = variants[variants.length - 1].model;
+    for (const v of variants) {
+      const oldCumulative = cumulative;
+      cumulative += v.weight * 1e4;
+      log(
+        `Variant ${v.model}: weight=${v.weight}%, range=${oldCumulative}-${cumulative}, hash=${hashVal}, match=${hashVal < cumulative}`
+      );
+      if (hashVal < cumulative) {
+        assignedModel = v.model;
+        break;
+      }
+    }
+    log(`\u2705 Assigned model via weighted random: ${assignedModel}`);
+    return returnModel(configKey, sessionId, assignedModel, configVersion);
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("not found")) {
+      throw e;
+    }
+    if (fallback) {
+      console.warn(
+        `[Fallom WARNING] Error getting model for '${configKey}': ${e}. Using fallback: ${fallback}`
+      );
+      return returnModel(configKey, sessionId, fallback, 0);
+    }
+    throw e;
+  }
+}
+function returnModel(configKey, sessionId, model, version) {
+  if (version > 0) {
+    recordSession(configKey, version, sessionId, model).catch(() => {
+    });
+  }
+  return model;
+}
+async function recordSession(configKey, version, sessionId, model) {
+  if (!apiKey) return;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), RECORD_TIMEOUT);
+    await fetch(`${baseUrl}/sessions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        config_key: configKey,
+        config_version: version,
+        session_id: sessionId,
+        assigned_model: model
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+
+export {
+  __export,
+  init,
+  get,
+  models_exports
+};

package/dist/index.js

@@ -1201,7 +1201,7 @@ var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otl
 // node_modules/@opentelemetry/resources/build/esm/Resource.js
 var import_api = require("@opentelemetry/api");
 
-// node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js
+// node_modules/@opentelemetry/resources/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js
 var SemanticResourceAttributes = {
   /**
    * Name of the cloud provider.
@@ -2216,6 +2216,54 @@ function clearPromptContext() {
   promptContext = null;
 }
 
+// src/trace/wrappers/shared-utils.ts
+function sanitizeMetadataOnly(key, value) {
+  const contentKeys = [
+    "text",
+    "content",
+    "message",
+    "messages",
+    "object",
+    "prompt",
+    "system",
+    "input",
+    "output",
+    "response",
+    "toolCalls",
+    "toolResults",
+    "steps",
+    "reasoning",
+    "rawResponse",
+    "rawCall",
+    "body",
+    "candidates",
+    "parts"
+  ];
+  if (contentKeys.includes(key)) {
+    if (typeof value === "string") {
+      return `[content omitted: ${value.length} chars]`;
+    }
+    if (Array.isArray(value)) {
+      return `[content omitted: ${value.length} items]`;
+    }
+    if (typeof value === "object" && value !== null) {
+      return "[content omitted]";
+    }
+  }
+  if (typeof value === "string") {
+    if (value.startsWith("data:image/")) {
+      return "[base64 image omitted]";
+    }
+    if (value.length > 1e3) {
+      return `[large string omitted: ${value.length} chars]`;
+    }
+  }
+  if (value instanceof Uint8Array || value && value.type === "Buffer") {
+    return "[binary data omitted]";
+  }
+  return value;
+}
+
 // src/trace/wrappers/openai.ts
 function wrapOpenAI(client, sessionCtx) {
   const originalCreate = client.chat.completions.create.bind(
@@ -2263,6 +2311,13 @@ function wrapOpenAI(client, sessionCtx) {
       if (response?.usage) {
         attributes["fallom.raw.usage"] = JSON.stringify(response.usage);
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          response,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       const waterfallTimings = {
         requestStart: 0,
         requestEnd: endTime - startTime,
@@ -2389,6 +2444,13 @@ function wrapAnthropic(client, sessionCtx) {
       if (response?.usage) {
         attributes["fallom.raw.usage"] = JSON.stringify(response.usage);
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          response,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       const waterfallTimings = {
         requestStart: 0,
         requestEnd: endTime - startTime,
@@ -2509,6 +2571,13 @@ function wrapGoogleAI(model, sessionCtx) {
       if (result?.usageMetadata) {
         attributes["fallom.raw.usage"] = JSON.stringify(result.usageMetadata);
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          result,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       const waterfallTimings = {
         requestStart: 0,
         requestEnd: endTime - startTime,
@@ -2705,6 +2774,13 @@ function createGenerateTextWrapper(aiModule, sessionCtx, debug = false) {
           result.experimental_providerMetadata
         );
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          result,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       const totalDurationMs = endTime - startTime;
       const sortedToolTimings = Array.from(toolTimings.values()).sort(
         (a, b) => a.startTime - b.startTime
@@ -3033,6 +3109,10 @@ function createStreamTextWrapper(aiModule, sessionCtx, debug = false) {
           if (firstTokenTime) {
             attributes["fallom.time_to_first_token_ms"] = firstTokenTime - startTime;
           }
+          try {
+            attributes["fallom.raw.metadata"] = JSON.stringify(result, sanitizeMetadataOnly);
+          } catch {
+          }
           const totalDurationMs = endTime - startTime;
           const sortedToolTimings = Array.from(toolTimings.values()).sort(
             (a, b) => a.startTime - b.startTime
@@ -3238,6 +3318,10 @@ function createGenerateObjectWrapper(aiModule, sessionCtx, debug = false) {
           result.experimental_providerMetadata
         );
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(result, sanitizeMetadataOnly);
+      } catch {
+      }
       const promptCtx = getPromptContext();
       sendTrace({
         config_key: ctx.configKey,
@@ -3357,6 +3441,10 @@ function createStreamObjectWrapper(aiModule, sessionCtx, debug = false) {
         if (providerMetadata) {
           attributes["fallom.raw.providerMetadata"] = JSON.stringify(providerMetadata);
         }
+        try {
+          attributes["fallom.raw.metadata"] = JSON.stringify(result, sanitizeMetadataOnly);
+        } catch {
+        }
         const promptCtx = getPromptContext();
         sendTrace({
           config_key: ctx.configKey,
@@ -3453,6 +3541,13 @@ function wrapMastraAgent(agent, sessionCtx) {
         attributes["fallom.raw.request"] = JSON.stringify(input);
         attributes["fallom.raw.response"] = JSON.stringify(result);
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          result,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,

package/dist/index.mjs

@@ -41,7 +41,7 @@ import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 // node_modules/@opentelemetry/resources/build/esm/Resource.js
 import { diag } from "@opentelemetry/api";
 
-// node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js
+// node_modules/@opentelemetry/resources/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js
 var SemanticResourceAttributes = {
   /**
    * Name of the cloud provider.
@@ -1056,6 +1056,54 @@ function clearPromptContext() {
   promptContext = null;
 }
 
+// src/trace/wrappers/shared-utils.ts
+function sanitizeMetadataOnly(key, value) {
+  const contentKeys = [
+    "text",
+    "content",
+    "message",
+    "messages",
+    "object",
+    "prompt",
+    "system",
+    "input",
+    "output",
+    "response",
+    "toolCalls",
+    "toolResults",
+    "steps",
+    "reasoning",
+    "rawResponse",
+    "rawCall",
+    "body",
+    "candidates",
+    "parts"
+  ];
+  if (contentKeys.includes(key)) {
+    if (typeof value === "string") {
+      return `[content omitted: ${value.length} chars]`;
+    }
+    if (Array.isArray(value)) {
+      return `[content omitted: ${value.length} items]`;
+    }
+    if (typeof value === "object" && value !== null) {
+      return "[content omitted]";
+    }
+  }
+  if (typeof value === "string") {
+    if (value.startsWith("data:image/")) {
+      return "[base64 image omitted]";
+    }
+    if (value.length > 1e3) {
+      return `[large string omitted: ${value.length} chars]`;
+    }
+  }
+  if (value instanceof Uint8Array || value && value.type === "Buffer") {
+    return "[binary data omitted]";
+  }
+  return value;
+}
+
 // src/trace/wrappers/openai.ts
 function wrapOpenAI(client, sessionCtx) {
   const originalCreate = client.chat.completions.create.bind(
@@ -1103,6 +1151,13 @@ function wrapOpenAI(client, sessionCtx) {
       if (response?.usage) {
         attributes["fallom.raw.usage"] = JSON.stringify(response.usage);
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          response,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       const waterfallTimings = {
         requestStart: 0,
         requestEnd: endTime - startTime,
@@ -1229,6 +1284,13 @@ function wrapAnthropic(client, sessionCtx) {
       if (response?.usage) {
         attributes["fallom.raw.usage"] = JSON.stringify(response.usage);
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          response,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       const waterfallTimings = {
         requestStart: 0,
         requestEnd: endTime - startTime,
@@ -1349,6 +1411,13 @@ function wrapGoogleAI(model, sessionCtx) {
       if (result?.usageMetadata) {
         attributes["fallom.raw.usage"] = JSON.stringify(result.usageMetadata);
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          result,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       const waterfallTimings = {
         requestStart: 0,
         requestEnd: endTime - startTime,
@@ -1545,6 +1614,13 @@ function createGenerateTextWrapper(aiModule, sessionCtx, debug = false) {
           result.experimental_providerMetadata
         );
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          result,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       const totalDurationMs = endTime - startTime;
       const sortedToolTimings = Array.from(toolTimings.values()).sort(
         (a, b) => a.startTime - b.startTime
@@ -1873,6 +1949,10 @@ function createStreamTextWrapper(aiModule, sessionCtx, debug = false) {
           if (firstTokenTime) {
             attributes["fallom.time_to_first_token_ms"] = firstTokenTime - startTime;
           }
+          try {
+            attributes["fallom.raw.metadata"] = JSON.stringify(result, sanitizeMetadataOnly);
+          } catch {
+          }
           const totalDurationMs = endTime - startTime;
           const sortedToolTimings = Array.from(toolTimings.values()).sort(
             (a, b) => a.startTime - b.startTime
@@ -2078,6 +2158,10 @@ function createGenerateObjectWrapper(aiModule, sessionCtx, debug = false) {
           result.experimental_providerMetadata
         );
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(result, sanitizeMetadataOnly);
+      } catch {
+      }
       const promptCtx = getPromptContext();
       sendTrace({
         config_key: ctx.configKey,
@@ -2197,6 +2281,10 @@ function createStreamObjectWrapper(aiModule, sessionCtx, debug = false) {
         if (providerMetadata) {
           attributes["fallom.raw.providerMetadata"] = JSON.stringify(providerMetadata);
         }
+        try {
+          attributes["fallom.raw.metadata"] = JSON.stringify(result, sanitizeMetadataOnly);
+        } catch {
+        }
         const promptCtx = getPromptContext();
         sendTrace({
           config_key: ctx.configKey,
@@ -2293,6 +2381,13 @@ function wrapMastraAgent(agent, sessionCtx) {
         attributes["fallom.raw.request"] = JSON.stringify(input);
         attributes["fallom.raw.response"] = JSON.stringify(result);
       }
+      try {
+        attributes["fallom.raw.metadata"] = JSON.stringify(
+          result,
+          sanitizeMetadataOnly
+        );
+      } catch {
+      }
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,

package/dist/models-SEFDGZU2.mjs

@@ -0,0 +1,8 @@
+import {
+  get,
+  init
+} from "./chunk-KFD5AQ7V.mjs";
+export {
+  get,
+  init
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fallom/trace",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "Model A/B testing and tracing for LLM applications. Zero latency, production-ready.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",