weflayr 0.22.2 → 0.24.0

package/src/otel/span-filter.js

@@ -7,6 +7,10 @@
 //   - Translated from TypeScript to JavaScript
 //   - Dropped the LANGFUSE_TRACER_NAME special case (we have no SDK-internal tracer)
 //   - Dropped isLangfuseSpan
+//   - Export only spans from known LLM instrumentation scopes: general-purpose
+//     APM SDKs (Sentry, Datadog, ...) also instrument LLM calls with gen_ai.*
+//     attributes, so the original "any span with gen_ai.* attributes" check
+//     exported the same call twice
 //
 // See LICENSE-MIT in the package root for the full license text.
 
@@ -15,19 +19,24 @@
 const KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [
   'agent_framework',
   'ai',
+  'gen_ai',
   'haystack',
   'langsmith',
   'litellm',
+  'mistralai_sdk_tracer',
   'openinference',
   'opentelemetry.instrumentation.anthropic',
   'opentelemetry.instrumentation.aws_bedrock',
   'opentelemetry.instrumentation.bedrock',
+  'opentelemetry.instrumentation.cohere',
   'opentelemetry.instrumentation.gemini',
   'opentelemetry.instrumentation.google_genai',
   'opentelemetry.instrumentation.google_generativeai',
   'opentelemetry.instrumentation.openai',
   'opentelemetry.instrumentation.openai_v2',
-  'weflayr.instrumentation.elevenlabs',
+  'opentelemetry.instrumentation.vertex_ai',
+  'opentelemetry.instrumentation.vertexai',
+  'weflayr.instrumentation',
   'strands-agents',
   'vllm',
   '@traceloop/instrumentation-openai',
@@ -43,27 +52,18 @@ const KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [
   '@traceloop/instrumentation-mcp',
 ];
 
-const EXACT_LLM_INSTRUMENTATION_SCOPES = new Set(['ai']);
-
-function isGenAISpan(span) {
-  return Object.keys(span.attributes).some((key) => key.startsWith('gen_ai.'));
-}
-
 function isKnownLLMInstrumentor(span) {
   const scope = span.instrumentationScope.name;
   return KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES.some(
-    (prefix) =>
-      scope === prefix ||
-      (!EXACT_LLM_INSTRUMENTATION_SCOPES.has(prefix) && scope.startsWith(`${prefix}.`))
+    (prefix) => scope === prefix || scope.startsWith(`${prefix}.`)
   );
 }
 
 function isDefaultExportSpan(span) {
-  return isGenAISpan(span) || isKnownLLMInstrumentor(span);
+  return isKnownLLMInstrumentor(span);
 }
 
 module.exports = {
-  isGenAISpan,
   isKnownLLMInstrumentor,
   isDefaultExportSpan,
 };

package/src/otel/span-processor.js

@@ -49,6 +49,11 @@ function _isContentAttribute(key) {
   );
 }
 
+// Stamped on every exported span when a `mask` is configured: the mask
+// function's source code, so the stored raw event shows what redaction ran
+// client-side when debugging missing attributes.
+const MASK_FUNCTION_ATTRIBUTE = 'weflayr.mask_function';
+
 class WeflayrSpanProcessor {
   constructor({ exporter, exportMode = 'batch', defaultTags = {}, mask, shouldExportSpan } = {}) {
     if (!exporter) {
@@ -60,6 +65,7 @@ class WeflayrSpanProcessor {
         : new BatchSpanProcessor(exporter);
     this._defaultTags = defaultTags;
     this._mask = mask;
+    this._maskFunctionSource = mask ? String(mask) : null;
     this._shouldExportSpan = shouldExportSpan ?? isDefaultExportSpan;
     this._vercelAiSdkSpanFilter = new VercelAiSdkSpanFilter();
     // LLM spans we've started but not yet seen end. On forceFlush we end any
@@ -126,6 +132,8 @@ class WeflayrSpanProcessor {
       } catch {
         for (const k of Object.keys(span.attributes)) delete span.attributes[k];
       }
+      // Stamped after masking so the mask can't strip it.
+      span.attributes[MASK_FUNCTION_ATTRIBUTE] = this._maskFunctionSource;
     }
 
     return this._delegate.onEnd(span);

package/src/otel/vercel-ai-sdk-span-filter.js

@@ -65,7 +65,7 @@ class VercelAiSdkSpanFilter {
 // `@ai-sdk/otel` reports the Vercel AI Gateway as the bare provider id
 // "gateway" — too generic a name to special-case downstream. Stamp the weflayr
 // provider override (which the normalizer prefers) with the canonical name.
-// A providerName set through propagateMetadata was stamped at span start and
+// A providerNameOverride set through propagateMetadata was stamped at span start and
 // wins.
 function stampVercelGatewayProviderName(span) {
   if (

package/tests/api/index.test.js

@@ -274,6 +274,82 @@ test('deleteKeyMetrics sends the userNames filter and parses the deleted count',
   });
 });
 
+// ── Margin ────────────────────────────────────────────────────────────────────
+
+test('getMargin parses the returned rows into camelCase', async () => {
+  const wireRow = {
+    customer_name: 'c_1',
+    revenue: 1000.0,
+    cost: 200.0,
+    margin: 800.0,
+    margin_pct: 80.0,
+    profitability_status: 'healthy',
+  };
+  await withClientReturning(
+    { rows: [wireRow], next_cursor: null, has_more: false },
+    200,
+    async (client) => {
+      const { data } = await api.getMargin({ client, throwOnError: true });
+      assert.deepEqual(data.rows, [
+        {
+          customerName: 'c_1',
+          revenue: 1000.0,
+          cost: 200.0,
+          margin: 800.0,
+          marginPct: 80.0,
+          profitabilityStatus: 'healthy',
+        },
+      ]);
+    }
+  );
+});
+
+test('getMargin sends the cursor and limit query params', async () => {
+  await withClientReturning(
+    { rows: [], next_cursor: 'Y19h', has_more: true },
+    200,
+    async (client, seenRequests) => {
+      const { data } = await api.getMargin({
+        client,
+        throwOnError: true,
+        query: { cursor: 'abc123', limit: 2 },
+      });
+      assert.equal(data.nextCursor, 'Y19h');
+      assert.equal(data.hasMore, true);
+      const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+      assert.equal(query.get('cursor'), 'abc123');
+      assert.equal(query.get('limit'), '2');
+    }
+  );
+});
+
+test('getMargin sends the customerNames filter as repeated params', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    const { data } = await api.getMargin({
+      client,
+      throwOnError: true,
+      query: { customerNames: ['c_1', 'c_2'] },
+    });
+    assert.deepEqual(data, { rows: [] });
+    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+    assert.deepEqual(query.getAll('customer_names'), ['c_1', 'c_2']);
+  });
+});
+
+test('getMargin sends the dateFrom/dateTo/applyCredits filters in snake_case', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    await api.getMargin({
+      client,
+      throwOnError: true,
+      query: { dateFrom: '2026-06-01', dateTo: '2026-06-30', applyCredits: true },
+    });
+    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
+    assert.equal(query.get('date_from'), '2026-06-01');
+    assert.equal(query.get('date_to'), '2026-06-30');
+    assert.equal(query.get('apply_credits'), 'true');
+  });
+});
+
 // ── Customer tags ─────────────────────────────────────────────────────────────
 
 test('setCustomersTags posts the customers in snake_case and parses the updated count', async () => {

package/tests/index.test.js

@@ -234,22 +234,32 @@ test('buildExporter does not warn when warnOnExportError is false', async () =>
 
 // ── span-filter ───────────────────────────────────────────────────────────────
 
-test('isDefaultExportSpan accepts spans with gen_ai.* attributes', () => {
+test('isDefaultExportSpan accepts spans from known instrumentation scopes', () => {
   const span = makeFakeSpan({
-    attributes: { 'gen_ai.system': 'openai' },
-    instrumentationScope: { name: 'unknown' },
+    attributes: {},
+    instrumentationScope: { name: 'opentelemetry.instrumentation.openai' },
   });
   assert.equal(isDefaultExportSpan(span), true);
 });
 
-test('isDefaultExportSpan accepts spans from known instrumentation scopes', () => {
+test('isDefaultExportSpan accepts weflayr instrumentation spans', () => {
   const span = makeFakeSpan({
     attributes: {},
-    instrumentationScope: { name: 'opentelemetry.instrumentation.openai' },
+    instrumentationScope: { name: 'weflayr.instrumentation.openai_audio' },
   });
   assert.equal(isDefaultExportSpan(span), true);
 });
 
+test('isDefaultExportSpan rejects gen_ai spans from unknown scopes', () => {
+  // APM SDKs (Sentry, Datadog, ...) also instrument LLM calls with gen_ai.*
+  // attributes — exporting them would duplicate the instrumentor's span.
+  const span = makeFakeSpan({
+    attributes: { 'gen_ai.system': 'openai' },
+    instrumentationScope: { name: '@sentry/node' },
+  });
+  assert.equal(isDefaultExportSpan(span), false);
+});
+
 test('isDefaultExportSpan rejects unrelated spans', () => {
   const span = makeFakeSpan({
     attributes: { 'http.method': 'GET' },
@@ -335,6 +345,26 @@ test('WeflayrSpanProcessor applies mask before export', async () => {
   assert.equal(span.attributes['gen_ai.prompt'], '[REDACTED]');
 });
 
+test('WeflayrSpanProcessor stamps mask function source on exported spans', async () => {
+  const exporter = makeExporterStub();
+  const mask = (attrs) => attrs;
+  const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate', mask });
+  const span = makeFakeSpan({ attributes: { 'gen_ai.system': 'openai' } });
+  proc.onEnd(span);
+  await proc.forceFlush();
+  const maskFunctionSource = exporter.exported[0].attributes['weflayr.mask_function'];
+  assert.ok(maskFunctionSource.includes('(attrs) => attrs'));
+});
+
+test('WeflayrSpanProcessor omits mask function attribute without mask', async () => {
+  const exporter = makeExporterStub();
+  const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
+  const span = makeFakeSpan({ attributes: { 'gen_ai.system': 'openai' } });
+  proc.onEnd(span);
+  await proc.forceFlush();
+  assert.equal(exporter.exported[0].attributes['weflayr.mask_function'], undefined);
+});
+
 test('WeflayrSpanProcessor strips message content when capture disabled', async () => {
   // Instrumentors gate content on their own env vars (openllmetry captures by
   // default), so the processor itself must drop message content when
@@ -395,7 +425,7 @@ function _makeMetadataHarness() {
   const exporter = makeExporterStub();
   const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
   const provider = new BasicTracerProvider({ spanProcessors: [proc] });
-  const tracer = provider.getTracer('test');
+  const tracer = provider.getTracer('opentelemetry.instrumentation.openai');
   return { exporter, proc, provider, tracer };
 }
 
@@ -558,9 +588,34 @@ test('propagateMetadata callable form runs function', async () => {
   await provider.shutdown();
 });
 
-test('propagateMetadata providerName writes attribute', async () => {
+test('propagateMetadata providerNameOverride writes attribute', async () => {
+  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
+
+  await weflayr.propagateMetadata(
+    {
+      featureName: 'f',
+      customerName: 'c',
+      providerNameOverride: weflayr.AIProviderName.VERCEL_AI_GATEWAY,
+    },
+    async () => {
+      const span = tracer.startSpan('child');
+      span.setAttribute('gen_ai.system', 'openai');
+      span.end();
+    }
+  );
+
+  await proc.forceFlush();
+  assert.equal(exporter.exported[0].attributes['weflayr.provider_name'], 'vercel_ai_gateway');
+  await provider.shutdown();
+});
+
+test('propagateMetadata deprecated providerName still works', async () => {
   const { exporter, proc, provider, tracer } = _makeMetadataHarness();
 
+  const warnings = [];
+  const onWarning = (warning) => warnings.push(warning);
+  process.on('warning', onWarning);
+
   await weflayr.propagateMetadata(
     {
       featureName: 'f',
@@ -574,6 +629,11 @@ test('propagateMetadata providerName writes attribute', async () => {
     }
   );
 
+  // process.emitWarning delivers on a later tick; drain it before asserting.
+  await new Promise((resolve) => process.nextTick(resolve));
+  process.removeListener('warning', onWarning);
+  assert.ok(warnings.some((warning) => /providerName.*deprecated/.test(warning.message)));
+
   await proc.forceFlush();
   assert.equal(exporter.exported[0].attributes['weflayr.provider_name'], 'vercel_ai_gateway');
   await provider.shutdown();

package/tests/instrumentation/anthropic/get_cache_and_reasoning_telemetry.test.js

@@ -63,6 +63,29 @@ test('stamps cache read on a warm call', () => {
   assert.equal(span.attrs['gen_ai.usage.cache_creation_input_tokens'], undefined);
 });
 
+test('stamps usage.cache_creation verbatim', () => {
+  const instrumentation = { _endSpan() {} };
+  new AnthropicPromptCachingInstrumentor().instrument(instrumentation);
+
+  const span = fakeSpan();
+  instrumentation._endSpan({
+    span,
+    type: 'completion',
+    result: {
+      usage: {
+        input_tokens: 10,
+        cache_creation_input_tokens: 5300,
+        cache_creation: { ephemeral_5m_input_tokens: 4000, ephemeral_1h_input_tokens: 1300 },
+      },
+    },
+  });
+
+  assert.deepEqual(JSON.parse(span.attrs['weflayr.cache.creation']), {
+    ephemeral_5m_input_tokens: 4000,
+    ephemeral_1h_input_tokens: 1300,
+  });
+});
+
 test('sets nothing for an uncached call', () => {
   const instrumentation = { _endSpan() {} };
   new AnthropicPromptCachingInstrumentor().instrument(instrumentation);

package/tests/instrumentation/anthropic/get_cache_config_telemetry.test.js

@@ -0,0 +1,92 @@
+'use strict';
+
+// Tests for the Anthropic request-side cache_control breakpoint capture.
+//
+// The traceloop instrumentation instance is stubbed with a `startSpan` that
+// returns a fake span, so the wrap can be exercised without the real SDK.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  AnthropicCacheConfigInstrumentor,
+  extractCacheBreakpoints,
+} = require('../../../src/instrumentation/anthropic/get_cache_config_telemetry');
+
+function makeFakeSpan() {
+  const attributes = {};
+  return {
+    attributes,
+    setAttribute(key, value) {
+      attributes[key] = value;
+    },
+  };
+}
+
+function makeStubInstrumentation() {
+  return {
+    startSpan() {
+      return makeFakeSpan();
+    },
+  };
+}
+
+test('stamps breakpoints from system, message content and tools', () => {
+  const instrumentation = makeStubInstrumentation();
+  new AnthropicCacheConfigInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation.startSpan({
+    type: 'chat',
+    params: {
+      system: [{ type: 'text', text: 'big prefix', cache_control: { type: 'ephemeral' } }],
+      messages: [
+        { role: 'user', content: 'plain string content' },
+        {
+          role: 'user',
+          content: [{ type: 'text', text: 'doc', cache_control: { type: 'ephemeral', ttl: '1h' } }],
+        },
+      ],
+      tools: [
+        { name: 'get_weather', cache_control: { type: 'ephemeral' } },
+        { name: 'uncached_tool' },
+      ],
+    },
+  });
+
+  assert.deepEqual(JSON.parse(span.attributes['weflayr.cache.breakpoints']), [
+    { location: 'system' },
+    { location: 'messages[1]', ttl: '1h' },
+    { location: 'tools[0]' },
+  ]);
+});
+
+test('no attribute without breakpoints', () => {
+  const instrumentation = makeStubInstrumentation();
+  new AnthropicCacheConfigInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation.startSpan({
+    type: 'chat',
+    params: { messages: [{ role: 'user', content: 'hello' }] },
+  });
+
+  assert.ok(!('weflayr.cache.breakpoints' in span.attributes));
+});
+
+test('extractCacheBreakpoints omits the ttl when the request sets none', () => {
+  assert.deepEqual(
+    extractCacheBreakpoints({
+      system: [{ type: 'text', text: 'p', cache_control: { type: 'ephemeral' } }],
+    }),
+    [{ location: 'system' }]
+  );
+});
+
+test('uninstrument restores the original startSpan', () => {
+  const instrumentation = makeStubInstrumentation();
+  const original = instrumentation.startSpan;
+  const instrumentor = new AnthropicCacheConfigInstrumentor();
+  instrumentor.instrument(instrumentation);
+  assert.notEqual(instrumentation.startSpan, original);
+  instrumentor.uninstrument();
+  assert.equal(instrumentation.startSpan, original);
+});

package/tests/instrumentation/anthropic/get_tool_definitions_telemetry.test.js

@@ -52,6 +52,21 @@ test('stamps tool definitions from the request params', () => {
   assert.deepEqual(JSON.parse(span.attributes['gen_ai.tool.definitions']), [WEATHER_TOOL]);
 });
 
+test('drops cache_control from the stamped tool definitions', () => {
+  const instrumentation = makeStubInstrumentation();
+  new AnthropicToolDefinitionsInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation.startSpan({
+    type: 'chat',
+    params: {
+      model: 'claude-haiku-4-5',
+      tools: [{ ...WEATHER_TOOL, cache_control: { type: 'ephemeral', ttl: '1h' } }],
+    },
+  });
+
+  assert.deepEqual(JSON.parse(span.attributes['gen_ai.tool.definitions']), [WEATHER_TOOL]);
+});
+
 test('no attribute when the request has no tools', () => {
   const instrumentation = makeStubInstrumentation();
   new AnthropicToolDefinitionsInstrumentor().instrument(instrumentation);

package/tests/instrumentation/bedrock/get_cache_config_telemetry.test.js

@@ -0,0 +1,107 @@
+'use strict';
+
+// Tests for the Bedrock request-side cache breakpoint capture.
+//
+// The extractor reads both body schemas an InvokeModel request can carry:
+// Anthropic-on-Bedrock `cache_control` blocks and Amazon Nova `cachePoint`
+// blocks (attached to a content block or standing alone). The traceloop
+// instrumentation instance is stubbed with a `_startSpan` returning a fake
+// span, so the wrap can be exercised without the real SDK.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  BedrockCacheConfigInstrumentor,
+  extractBedrockCacheBreakpoints,
+} = require('../../../src/instrumentation/bedrock/get_cache_config_telemetry');
+
+function makeFakeSpan() {
+  const attributes = {};
+  return {
+    attributes,
+    setAttribute(key, value) {
+      attributes[key] = value;
+    },
+  };
+}
+
+function makeStubInstrumentation() {
+  return {
+    _startSpan() {
+      return makeFakeSpan();
+    },
+  };
+}
+
+test('extracts nova cache points', () => {
+  const body = {
+    system: [{ text: 'sys' }, { cachePoint: { type: 'default' } }],
+    messages: [
+      {
+        role: 'user',
+        content: [
+          { text: 'big prefix', cachePoint: { type: 'default' } },
+          { text: 'Reply with OK.' },
+        ],
+      },
+    ],
+    toolConfig: {
+      tools: [
+        { toolSpec: { name: 'get_weather' } },
+        { cachePoint: { type: 'default', ttl: '1h' } },
+      ],
+    },
+  };
+  assert.deepEqual(extractBedrockCacheBreakpoints(body), [
+    { location: 'system' },
+    { location: 'messages[0]' },
+    { location: 'tools[1]', ttl: '1h' },
+  ]);
+});
+
+test('extracts anthropic-on-bedrock cache_control', () => {
+  const body = {
+    anthropic_version: 'bedrock-2023-05-31',
+    system: [{ type: 'text', text: 'big prefix', cache_control: { type: 'ephemeral', ttl: '1h' } }],
+    messages: [{ role: 'user', content: 'Reply with OK.' }],
+  };
+  assert.deepEqual(extractBedrockCacheBreakpoints(body), [{ location: 'system', ttl: '1h' }]);
+});
+
+test('no breakpoints without cache blocks', () => {
+  assert.deepEqual(
+    extractBedrockCacheBreakpoints({ messages: [{ role: 'user', content: 'hello' }] }),
+    []
+  );
+});
+
+test('stamps breakpoints from the request body', () => {
+  const instrumentation = makeStubInstrumentation();
+  new BedrockCacheConfigInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation._startSpan({
+    params: {
+      input: {
+        modelId: 'amazon.nova-micro-v1:0',
+        body: JSON.stringify({
+          messages: [{ role: 'user', content: [{ text: 'p', cachePoint: { type: 'default' } }] }],
+        }),
+      },
+    },
+  });
+
+  assert.deepEqual(JSON.parse(span.attributes['weflayr.cache.breakpoints']), [
+    { location: 'messages[0]' },
+  ]);
+});
+
+test('uninstrument restores the original _startSpan', () => {
+  const instrumentation = makeStubInstrumentation();
+  const original = instrumentation._startSpan;
+  const instrumentor = new BedrockCacheConfigInstrumentor();
+  instrumentor.instrument(instrumentation);
+  assert.notEqual(instrumentation._startSpan, original);
+  instrumentor.uninstrument();
+  assert.equal(instrumentation._startSpan, original);
+});

package/tests/instrumentation/bedrock/get_cache_telemetry.test.js

@@ -32,6 +32,22 @@ function passthroughInstrumentation() {
   return { _wrapPromise: (_span, promise) => Promise.resolve(promise) };
 }
 
+test('stamps cache write from an anthropic-on-bedrock usage shape', () => {
+  const instrumentation = { _wrapPromise: (span, promise) => promise };
+  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
+
+  const span = fakeSpan();
+  const body = new TextEncoder().encode(
+    JSON.stringify({
+      usage: { input_tokens: 10, cache_creation_input_tokens: 5300, cache_read_input_tokens: 0 },
+    })
+  );
+  return instrumentation._wrapPromise(span, Promise.resolve({ body })).then(() => {
+    assert.equal(span.attrs['gen_ai.usage.cache_creation_input_tokens'], 5300);
+    assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], undefined);
+  });
+});
+
 test('stamps cache read/write from a buffered InvokeModel body', async () => {
   const instrumentation = passthroughInstrumentation();
   new BedrockPromptCachingInstrumentor().instrument(instrumentation);