weflayr 0.24.0 → 0.26.1

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

@@ -1,181 +0,0 @@
-'use strict';
-
-// Tests for the Anthropic cached-prompt token complement. It wraps the primary
-// instrumentor's `_endSpan({ span, type, result })` to stamp
-// gen_ai.usage.cache_read_input_tokens / cache_creation_input_tokens from the
-// response's `usage.cache_read_input_tokens` / `cache_creation_input_tokens`.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const {
-  AnthropicPromptCachingInstrumentor,
-} = require('../../../src/instrumentation/anthropic/get_cache_and_reasoning_telemetry');
-
-function fakeSpan() {
-  const attrs = {};
-  return {
-    attrs,
-    isRecording: () => true,
-    setAttribute(key, value) {
-      attrs[key] = value;
-    },
-  };
-}
-
-test('stamps cache write and still calls the original _endSpan', () => {
-  const calls = [];
-  const instrumentation = {
-    _endSpan(args) {
-      calls.push(args);
-    },
-  };
-  new AnthropicPromptCachingInstrumentor().instrument(instrumentation);
-
-  const span = fakeSpan();
-  instrumentation._endSpan({
-    span,
-    type: 'completion',
-    result: {
-      usage: { input_tokens: 10, cache_creation_input_tokens: 5269, cache_read_input_tokens: 0 },
-    },
-  });
-
-  assert.equal(span.attrs['gen_ai.usage.cache_creation_input_tokens'], 5269);
-  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], undefined);
-  assert.equal(calls.length, 1);
-});
-
-test('stamps cache read on a warm call', () => {
-  const instrumentation = { _endSpan() {} };
-  new AnthropicPromptCachingInstrumentor().instrument(instrumentation);
-
-  const span = fakeSpan();
-  instrumentation._endSpan({
-    span,
-    type: 'completion',
-    result: {
-      usage: { input_tokens: 10, cache_creation_input_tokens: 0, cache_read_input_tokens: 5271 },
-    },
-  });
-
-  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], 5271);
-  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);
-
-  const span = fakeSpan();
-  instrumentation._endSpan({ span, type: 'completion', result: { usage: { input_tokens: 13 } } });
-
-  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], undefined);
-  assert.equal(span.attrs['gen_ai.usage.cache_creation_input_tokens'], undefined);
-});
-
-test('stamps extended thinking tokens from output_tokens_details', () => {
-  const instrumentation = { _endSpan() {} };
-  new AnthropicPromptCachingInstrumentor().instrument(instrumentation);
-
-  const span = fakeSpan();
-  instrumentation._endSpan({
-    span,
-    type: 'completion',
-    result: { usage: { input_tokens: 10, output_tokens_details: { thinking_tokens: 150 } } },
-  });
-
-  assert.equal(span.attrs['gen_ai.usage.output_tokens_details.thinking_tokens'], 150);
-});
-
-test('stamps cache + raw input from the streamed message_start usage', async () => {
-  const instrumentation = {
-    _endSpan() {},
-    _streamingWrapPromise() {
-      return (async function* () {
-        yield {
-          type: 'message_start',
-          message: {
-            usage: {
-              input_tokens: 10,
-              cache_read_input_tokens: 5270,
-              cache_creation_input_tokens: 0,
-            },
-          },
-        };
-        yield { type: 'content_block_delta', delta: { text: 'OK' } };
-      })();
-    },
-  };
-  new AnthropicPromptCachingInstrumentor().instrument(instrumentation);
-
-  const span = fakeSpan();
-  for await (const _chunk of instrumentation._streamingWrapPromise('client', 'mod', { span })) {
-    void _chunk;
-  }
-
-  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], 5270);
-  assert.equal(span.attrs['gen_ai.usage.input_tokens'], 10);
-});
-
-test('re-yields every stream chunk unchanged — no telemetry collision with the payload', async () => {
-  const emitted = [
-    {
-      type: 'message_start',
-      message: { usage: { input_tokens: 10, cache_read_input_tokens: 5270 } },
-    },
-    { type: 'content_block_delta', delta: { text: 'O' } },
-    { type: 'content_block_delta', delta: { text: 'K' } },
-  ];
-  const instrumentation = {
-    _endSpan() {},
-    _streamingWrapPromise() {
-      return (async function* () {
-        for (const chunk of emitted) yield chunk;
-      })();
-    },
-  };
-  new AnthropicPromptCachingInstrumentor().instrument(instrumentation);
-
-  const span = fakeSpan();
-  const collected = [];
-  for await (const chunk of instrumentation._streamingWrapPromise('client', 'mod', { span })) {
-    collected.push(chunk);
-  }
-
-  // Same count, order, and object identity: observeCache re-yields each chunk by
-  // reference without copying or mutating it.
-  assert.equal(collected.length, emitted.length);
-  collected.forEach((chunk, index) => assert.equal(chunk, emitted[index]));
-  // …while still stamping cache + raw input off the message_start chunk.
-  assert.equal(span.attrs['gen_ai.usage.input_tokens'], 10);
-});
-
-test('is a no-op when the instrumentor has no _endSpan', () => {
-  const instrumentation = {};
-  new AnthropicPromptCachingInstrumentor().instrument(instrumentation);
-  assert.equal(instrumentation._endSpan, undefined);
-});

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

@@ -1,92 +0,0 @@
-'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_streaming_stop_reason_telemetry.test.js

@@ -1,117 +0,0 @@
-'use strict';
-
-// Tests for the Anthropic streamed stop-reason complement.
-//
-// The traceloop instrumentation instance is stubbed the way the real one works:
-// `_streamingWrapPromise` returns `new moduleExports.APIPromise(...)` whose
-// parse step wraps the SDK stream with an accumulating iterator that calls
-// `_endSpan` when exhausted — so the test exercises the complement's APIPromise
-// interposition end to end.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const {
-  AnthropicStreamingStopReasonInstrumentor,
-} = require('../../../src/instrumentation/anthropic/get_streaming_stop_reason_telemetry');
-
-class StubStream {
-  constructor(iteratorFactory, controller) {
-    this._iteratorFactory = iteratorFactory;
-    this.controller = controller;
-  }
-
-  [Symbol.asyncIterator]() {
-    return this._iteratorFactory();
-  }
-}
-
-class StubAPIPromise {
-  constructor(client, responsePromise, parseResponse) {
-    this.parsed = parseResponse(client, responsePromise);
-  }
-}
-
-function makeStubInstrumentation() {
-  const finalized = [];
-  return {
-    finalized,
-    _streamingWrapPromise(client, moduleExports, { span, promise }) {
-      const self = this;
-      return new moduleExports.APIPromise(
-        client,
-        promise,
-        async (parseClient, realStreamPromise) => {
-          const realStream = await realStreamPromise;
-          // Mimics traceloop: re-wrap the stream with an accumulating iterator
-          // that finalizes the span once exhausted.
-          return new realStream.constructor(
-            () =>
-              (async function* accumulate() {
-                const result = { stop_reason: null };
-                for await (const chunk of realStream) yield chunk;
-                self._endSpan({ span, result });
-              })(),
-            realStream.controller
-          );
-        }
-      );
-    },
-    _endSpan(args) {
-      finalized.push(args.result);
-    },
-  };
-}
-
-function chunkStream() {
-  return new StubStream(async function* chunks() {
-    yield { type: 'message_start', message: { usage: { input_tokens: 5 } } };
-    yield { type: 'content_block_delta', delta: { type: 'text_delta', text: 'Hello' } };
-    yield {
-      type: 'message_delta',
-      delta: { stop_reason: 'end_turn' },
-      usage: { output_tokens: 3 },
-    };
-    yield { type: 'message_stop' };
-  });
-}
-
-test('injects the streamed stop reason into the result before endSpan', async () => {
-  const instrumentation = makeStubInstrumentation();
-  new AnthropicStreamingStopReasonInstrumentor().instrument(instrumentation);
-
-  const span = { name: 'anthropic.chat' };
-  const apiPromise = instrumentation._streamingWrapPromise(
-    {},
-    { APIPromise: StubAPIPromise },
-    { span, type: 'chat', promise: Promise.resolve(chunkStream()) }
-  );
-
-  const stream = await apiPromise.parsed;
-  const seen = [];
-  for await (const chunk of stream) seen.push(chunk.type);
-
-  assert.deepEqual(seen, ['message_start', 'content_block_delta', 'message_delta', 'message_stop']);
-  assert.equal(instrumentation.finalized.length, 1);
-  assert.equal(instrumentation.finalized[0].stop_reason, 'end_turn');
-});
-
-test('leaves an already-set stop reason untouched', () => {
-  const instrumentation = makeStubInstrumentation();
-  new AnthropicStreamingStopReasonInstrumentor().instrument(instrumentation);
-
-  const span = { name: 'anthropic.chat' };
-  instrumentation._endSpan({ span, result: { stop_reason: 'max_tokens' } });
-  assert.equal(instrumentation.finalized[0].stop_reason, 'max_tokens');
-});
-
-test('uninstrument restores the original methods', () => {
-  const instrumentation = makeStubInstrumentation();
-  const streamOriginal = instrumentation._streamingWrapPromise;
-  const endSpanOriginal = instrumentation._endSpan;
-  const instrumentor = new AnthropicStreamingStopReasonInstrumentor();
-  instrumentor.instrument(instrumentation);
-  instrumentor.uninstrument();
-  assert.equal(instrumentation._streamingWrapPromise, streamOriginal);
-  assert.equal(instrumentation._endSpan, endSpanOriginal);
-});

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

@@ -1,97 +0,0 @@
-'use strict';
-
-// Tests for the Anthropic tool-definitions complement.
-//
-// 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 {
-  AnthropicToolDefinitionsInstrumentor,
-} = require('../../../src/instrumentation/anthropic/get_tool_definitions_telemetry');
-
-function makeFakeSpan() {
-  const attributes = {};
-  return {
-    attributes,
-    setAttribute(key, value) {
-      attributes[key] = value;
-    },
-  };
-}
-
-function makeStubInstrumentation() {
-  return {
-    startSpan(request) {
-      const span = makeFakeSpan();
-      span.attributes['gen_ai.request.model'] = request.params.model;
-      return span;
-    },
-  };
-}
-
-const WEATHER_TOOL = {
-  name: 'get_weather',
-  description: 'Get the current weather for a city.',
-  input_schema: { type: 'object', properties: { city: { type: 'string' } } },
-};
-
-test('stamps tool definitions from the request params', () => {
-  const instrumentation = makeStubInstrumentation();
-  const instrumentor = new AnthropicToolDefinitionsInstrumentor();
-  instrumentor.instrument(instrumentation);
-
-  const span = instrumentation.startSpan({
-    type: 'chat',
-    params: { model: 'claude-haiku-4-5', tools: [WEATHER_TOOL] },
-  });
-
-  assert.equal(span.attributes['gen_ai.request.model'], 'claude-haiku-4-5');
-  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);
-
-  const span = instrumentation.startSpan({
-    type: 'chat',
-    params: { model: 'claude-haiku-4-5' },
-  });
-
-  assert.ok(!('gen_ai.tool.definitions' in span.attributes));
-});
-
-test('uninstrument restores the original startSpan', () => {
-  const instrumentation = makeStubInstrumentation();
-  const original = instrumentation.startSpan;
-  const instrumentor = new AnthropicToolDefinitionsInstrumentor();
-  instrumentor.instrument(instrumentation);
-  assert.notEqual(instrumentation.startSpan, original);
-  instrumentor.uninstrument();
-  assert.equal(instrumentation.startSpan, original);
-});
-
-test('is a no-op when the instrumentor has no startSpan', () => {
-  const instrumentor = new AnthropicToolDefinitionsInstrumentor();
-  instrumentor.instrument({});
-  instrumentor.instrument(undefined);
-  instrumentor.uninstrument();
-});

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

@@ -1,107 +0,0 @@
-'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);
-});