@fallom/trace 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,10 +1,4 @@
 var __defProp = Object.defineProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -19,7 +13,10 @@ __export(trace_exports, {
   runWithSession: () => runWithSession,
   setSession: () => setSession,
   shutdown: () => shutdown,
-  span: () => span
+  span: () => span,
+  wrapAnthropic: () => wrapAnthropic,
+  wrapGoogleAI: () => wrapGoogleAI,
+  wrapOpenAI: () => wrapOpenAI
 });
 import { AsyncLocalStorage } from "async_hooks";
 import { NodeSDK } from "@opentelemetry/sdk-node";
@@ -655,16 +652,25 @@ var apiKey = null;
 var baseUrl = "https://spans.fallom.com";
 var initialized = false;
 var captureContent = true;
+var debugMode = false;
 var sdk = null;
+function log(...args) {
+  if (debugMode) console.log("[Fallom]", ...args);
+}
 var fallomSpanProcessor = {
   onStart(span2, _parentContext) {
+    log("\u{1F4CD} Span started:", span2.name || "unknown");
     const ctx = sessionStorage.getStore() || fallbackSession;
     if (ctx) {
       span2.setAttribute("fallom.config_key", ctx.configKey);
       span2.setAttribute("fallom.session_id", ctx.sessionId);
+      log("   Added session context:", ctx.configKey, ctx.sessionId);
+    } else {
+      log("   No session context available");
     }
   },
-  onEnd(_span) {
+  onEnd(span2) {
+    log("\u2705 Span ended:", span2.name, "duration:", span2.duration);
   },
   shutdown() {
     return Promise.resolve();
@@ -673,8 +679,10 @@ var fallomSpanProcessor = {
     return Promise.resolve();
   }
 };
-function init(options = {}) {
+async function init(options = {}) {
   if (initialized) return;
+  debugMode = options.debug ?? false;
+  log("\u{1F680} Initializing Fallom tracing...");
   apiKey = options.apiKey || process.env.FALLOM_API_KEY || null;
   baseUrl = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
   const envCapture = process.env.FALLOM_CAPTURE_CONTENT?.toLowerCase();
@@ -689,39 +697,52 @@ function init(options = {}) {
     );
   }
   initialized = true;
+  log("\u{1F4E1} Exporter URL:", `${baseUrl}/v1/traces`);
   const exporter = new OTLPTraceExporter({
     url: `${baseUrl}/v1/traces`,
     headers: {
       Authorization: `Bearer ${apiKey}`
     }
   });
+  const instrumentations = await getInstrumentations();
+  log("\u{1F527} Loaded instrumentations:", instrumentations.length);
   sdk = new NodeSDK({
     resource: new Resource({
       "service.name": "fallom-traced-app"
     }),
     traceExporter: exporter,
-    spanProcessor: fallomSpanProcessor
+    spanProcessor: fallomSpanProcessor,
+    instrumentations
   });
   sdk.start();
-  autoInstrument();
+  log("\u2705 SDK started");
   process.on("SIGTERM", () => {
     sdk?.shutdown().catch(console.error);
   });
 }
-function autoInstrument() {
+async function getInstrumentations() {
+  const instrumentations = [];
+  await tryAddInstrumentation(instrumentations, "@traceloop/instrumentation-openai", "OpenAIInstrumentation");
+  await tryAddInstrumentation(instrumentations, "@traceloop/instrumentation-anthropic", "AnthropicInstrumentation");
+  await tryAddInstrumentation(instrumentations, "@traceloop/instrumentation-cohere", "CohereInstrumentation");
+  await tryAddInstrumentation(instrumentations, "@traceloop/instrumentation-bedrock", "BedrockInstrumentation");
+  await tryAddInstrumentation(instrumentations, "@traceloop/instrumentation-google-generativeai", "GoogleGenerativeAIInstrumentation");
+  await tryAddInstrumentation(instrumentations, "@traceloop/instrumentation-azure", "AzureOpenAIInstrumentation");
+  await tryAddInstrumentation(instrumentations, "@traceloop/instrumentation-vertexai", "VertexAIInstrumentation");
+  return instrumentations;
+}
+async function tryAddInstrumentation(instrumentations, pkg, className) {
   try {
-    const traceloopModule = __require("@traceloop/node-server-sdk");
-    const Traceloop = traceloopModule.Traceloop || traceloopModule.default?.Traceloop || traceloopModule;
-    if (!Traceloop?.initialize) {
-      return;
+    const mod = await import(pkg);
+    const InstrumentationClass = mod[className] || mod.default?.[className];
+    if (InstrumentationClass) {
+      instrumentations.push(new InstrumentationClass({ traceContent: captureContent }));
+      log(`   \u2705 Loaded ${pkg}`);
+    } else {
+      log(`   \u26A0\uFE0F ${pkg} loaded but ${className} not found. Available:`, Object.keys(mod));
     }
-    Traceloop.initialize({
-      baseUrl,
-      apiKey,
-      disableBatch: true,
-      traceContent: captureContent
-    });
-  } catch {
+  } catch (e) {
+    log(`   \u274C ${pkg} not installed`);
   }
 }
 function setSession(configKey, sessionId) {
@@ -783,6 +804,169 @@ async function shutdown() {
     initialized = false;
   }
 }
+async function sendTrace(trace) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    await fetch(`${baseUrl}/v1/traces`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(trace),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    log("\u{1F4E4} Trace sent:", trace.name, trace.model);
+  } catch {
+  }
+}
+function wrapOpenAI(client) {
+  const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+  client.chat.completions.create = async function(...args) {
+    const ctx = sessionStorage.getStore() || fallbackSession;
+    if (!ctx || !initialized) {
+      return originalCreate(...args);
+    }
+    const params = args[0] || {};
+    const startTime = Date.now();
+    try {
+      const response = await originalCreate(...args);
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "chat.completions.create",
+        model: response?.model || params?.model,
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "OK",
+        prompt_tokens: response?.usage?.prompt_tokens,
+        completion_tokens: response?.usage?.completion_tokens,
+        total_tokens: response?.usage?.total_tokens,
+        input: captureContent ? JSON.stringify(params?.messages) : void 0,
+        output: captureContent ? response?.choices?.[0]?.message?.content : void 0
+      }).catch(() => {
+      });
+      return response;
+    } catch (error) {
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "chat.completions.create",
+        model: params?.model,
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "ERROR",
+        error_message: error?.message
+      }).catch(() => {
+      });
+      throw error;
+    }
+  };
+  return client;
+}
+function wrapAnthropic(client) {
+  const originalCreate = client.messages.create.bind(client.messages);
+  client.messages.create = async function(...args) {
+    const ctx = sessionStorage.getStore() || fallbackSession;
+    if (!ctx || !initialized) {
+      return originalCreate(...args);
+    }
+    const params = args[0] || {};
+    const startTime = Date.now();
+    try {
+      const response = await originalCreate(...args);
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "messages.create",
+        model: response?.model || params?.model,
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "OK",
+        prompt_tokens: response?.usage?.input_tokens,
+        completion_tokens: response?.usage?.output_tokens,
+        total_tokens: (response?.usage?.input_tokens || 0) + (response?.usage?.output_tokens || 0),
+        input: captureContent ? JSON.stringify(params?.messages) : void 0,
+        output: captureContent ? response?.content?.[0]?.text : void 0
+      }).catch(() => {
+      });
+      return response;
+    } catch (error) {
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "messages.create",
+        model: params?.model,
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "ERROR",
+        error_message: error?.message
+      }).catch(() => {
+      });
+      throw error;
+    }
+  };
+  return client;
+}
+function wrapGoogleAI(model) {
+  const originalGenerate = model.generateContent.bind(model);
+  model.generateContent = async function(...args) {
+    const ctx = sessionStorage.getStore() || fallbackSession;
+    if (!ctx || !initialized) {
+      return originalGenerate(...args);
+    }
+    const startTime = Date.now();
+    try {
+      const response = await originalGenerate(...args);
+      const endTime = Date.now();
+      const result = response?.response;
+      const usage = result?.usageMetadata;
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "generateContent",
+        model: model?.model || "gemini",
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "OK",
+        prompt_tokens: usage?.promptTokenCount,
+        completion_tokens: usage?.candidatesTokenCount,
+        total_tokens: usage?.totalTokenCount,
+        input: captureContent ? JSON.stringify(args[0]) : void 0,
+        output: captureContent ? result?.text?.() : void 0
+      }).catch(() => {
+      });
+      return response;
+    } catch (error) {
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "generateContent",
+        model: model?.model || "gemini",
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "ERROR",
+        error_message: error?.message
+      }).catch(() => {
+      });
+      throw error;
+    }
+  };
+  return model;
+}
 
 // src/models.ts
 var models_exports = {};
@@ -795,12 +979,12 @@ var apiKey2 = null;
 var baseUrl2 = "https://spans.fallom.com";
 var initialized2 = false;
 var syncInterval = null;
-var debugMode = false;
+var debugMode2 = false;
 var configCache = /* @__PURE__ */ new Map();
 var SYNC_TIMEOUT = 2e3;
 var RECORD_TIMEOUT = 1e3;
-function log(msg) {
-  if (debugMode) {
+function log2(msg) {
+  if (debugMode2) {
     console.log(`[Fallom] ${msg}`);
   }
 }
@@ -831,11 +1015,11 @@ function ensureInit() {
 }
 async function fetchConfigs(timeout = SYNC_TIMEOUT) {
   if (!apiKey2) {
-    log("_fetchConfigs: No API key, skipping");
+    log2("_fetchConfigs: No API key, skipping");
     return;
   }
   try {
-    log(`Fetching configs from ${baseUrl2}/configs`);
+    log2(`Fetching configs from ${baseUrl2}/configs`);
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     const resp = await fetch(`${baseUrl2}/configs`, {
@@ -843,15 +1027,15 @@ async function fetchConfigs(timeout = SYNC_TIMEOUT) {
       signal: controller.signal
     });
     clearTimeout(timeoutId);
-    log(`Response status: ${resp.status}`);
+    log2(`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)}`);
+      log2(`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)}`);
+        log2(`Config '${key}' v${version}: ${JSON.stringify(c.variants)}`);
         if (!configCache.has(key)) {
           configCache.set(key, { versions: /* @__PURE__ */ new Map(), latest: null });
         }
@@ -860,10 +1044,10 @@ async function fetchConfigs(timeout = SYNC_TIMEOUT) {
         cached.latest = version;
       }
     } else {
-      log(`Fetch failed: ${resp.statusText}`);
+      log2(`Fetch failed: ${resp.statusText}`);
     }
   } catch (e) {
-    log(`Fetch exception: ${e}`);
+    log2(`Fetch exception: ${e}`);
   }
 }
 async function fetchSpecificVersion(configKey, version, timeout = SYNC_TIMEOUT) {
@@ -893,20 +1077,20 @@ async function fetchSpecificVersion(configKey, version, timeout = SYNC_TIMEOUT)
 }
 async function get(configKey, sessionId, options = {}) {
   const { version, fallback, debug = false } = options;
-  debugMode = debug;
+  debugMode2 = debug;
   ensureInit();
-  log(`get() called: configKey=${configKey}, sessionId=${sessionId}, fallback=${fallback}`);
+  log2(`get() called: configKey=${configKey}, sessionId=${sessionId}, fallback=${fallback}`);
   try {
     let configData = configCache.get(configKey);
-    log(`Cache lookup for '${configKey}': ${configData ? "found" : "not found"}`);
+    log2(`Cache lookup for '${configKey}': ${configData ? "found" : "not found"}`);
     if (!configData) {
-      log("Not in cache, fetching...");
+      log2("Not in cache, fetching...");
       await fetchConfigs(SYNC_TIMEOUT);
       configData = configCache.get(configKey);
-      log(`After fetch, cache lookup: ${configData ? "found" : "still not found"}`);
+      log2(`After fetch, cache lookup: ${configData ? "found" : "still not found"}`);
     }
     if (!configData) {
-      log(`Config not found, using fallback: ${fallback}`);
+      log2(`Config not found, using fallback: ${fallback}`);
       if (fallback) {
         console.warn(`[Fallom WARNING] Config '${configKey}' not found, using fallback model: ${fallback}`);
         return returnWithTrace(configKey, sessionId, fallback, 0);
@@ -944,22 +1128,22 @@ async function get(configKey, sessionId, options = {}) {
     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)}`);
+    log2(`Config found! Version: ${configVersion}, Variants: ${JSON.stringify(variants)}`);
     const hashBytes = createHash("md5").update(sessionId).digest();
     const hashVal = hashBytes.readUInt32BE(0) % 1e6;
-    log(`Session hash: ${hashVal} (out of 1,000,000)`);
+    log2(`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}`);
+      log2(`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: ${assignedModel}`);
+    log2(`\u2705 Assigned model: ${assignedModel}`);
     return returnWithTrace(configKey, sessionId, assignedModel, configVersion);
   } catch (e) {
     if (e instanceof Error && e.message.includes("not found")) {
@@ -1008,12 +1192,13 @@ async function recordSession(configKey, version, sessionId, model) {
 }
 
 // src/init.ts
-function init3(options = {}) {
+async function init3(options = {}) {
   const baseUrl3 = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
-  init({
+  await init({
     apiKey: options.apiKey,
     baseUrl: baseUrl3,
-    captureContent: options.captureContent
+    captureContent: options.captureContent,
+    debug: options.debug
   });
   init2({
     apiKey: options.apiKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fallom/trace",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Model A/B testing and tracing for LLM applications. Zero latency, production-ready.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -20,7 +20,10 @@
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
     "test": "vitest",
     "lint": "eslint src/",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "publish:patch": "npm version patch && npm publish --access public",
+    "publish:minor": "npm version minor && npm publish --access public",
+    "publish:major": "npm version major && npm publish --access public"
   },
   "keywords": [
     "llm",
@@ -44,7 +47,7 @@
     "@opentelemetry/sdk-node": "^0.46.0",
     "@opentelemetry/sdk-trace-node": "^1.19.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.46.0",
-    "@traceloop/node-server-sdk": "^0.5.0",
+    "@traceloop/instrumentation-openai": "^0.11.0",
     "tslib": "^2.6.0"
   },
   "devDependencies": {