weflayr 0.23.0 → 0.26.0

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

@@ -1,158 +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('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_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,82 +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('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_telemetry.test.js

@@ -1,102 +0,0 @@
-'use strict';
-
-// Tests for the Bedrock cached-prompt token complement. It wraps the primary
-// instrumentor's `_wrapPromise(span, promise, modelId)` to read Nova's cache-token
-// counts off the decoded InvokeModel response body and stamp them as
-// gen_ai.usage.cache_* attributes.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const {
-  BedrockPromptCachingInstrumentor,
-} = require('../../../src/instrumentation/bedrock/get_cache_telemetry');
-
-function fakeSpan() {
-  const attrs = {};
-  return {
-    attrs,
-    isRecording: () => true,
-    setAttribute(key, value) {
-      attrs[key] = value;
-    },
-  };
-}
-
-function encode(obj) {
-  return new TextEncoder().encode(JSON.stringify(obj));
-}
-
-// Pass-through original: resolve to whatever promise it was handed.
-function passthroughInstrumentation() {
-  return { _wrapPromise: (_span, promise) => Promise.resolve(promise) };
-}
-
-test('stamps cache read/write from a buffered InvokeModel body', async () => {
-  const instrumentation = passthroughInstrumentation();
-  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
-
-  const span = fakeSpan();
-  const body = encode({
-    usage: { cacheReadInputTokenCount: 100, cacheWriteInputTokenCount: 1300 },
-  });
-  await instrumentation._wrapPromise(span, Promise.resolve({ body }), 'amazon.nova-micro-v1:0');
-
-  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], 100);
-  assert.equal(span.attrs['gen_ai.usage.cache_creation_input_tokens'], 1300);
-});
-
-test('sets nothing when cache counts are zero', async () => {
-  const instrumentation = passthroughInstrumentation();
-  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
-
-  const span = fakeSpan();
-  const body = encode({ usage: { cacheReadInputTokenCount: 0, cacheWriteInputTokenCount: 0 } });
-  await instrumentation._wrapPromise(span, Promise.resolve({ body }), 'm');
-
-  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('skips a streamed (async-iterable) body without consuming it', async () => {
-  const instrumentation = passthroughInstrumentation();
-  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
-
-  const span = fakeSpan();
-  let consumed = false;
-  const body = (async function* () {
-    consumed = true;
-    yield {};
-  })();
-  await instrumentation._wrapPromise(span, Promise.resolve({ body }), 'm');
-
-  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], undefined);
-  assert.equal(consumed, false);
-});
-
-test('stamps cache from the streamed metadata chunk and calls the original', () => {
-  const calls = [];
-  const instrumentation = {
-    _handleNovaStreamingMetadata(span, parsed) {
-      calls.push(parsed);
-    },
-  };
-  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
-
-  const span = fakeSpan();
-  instrumentation._handleNovaStreamingMetadata(span, {
-    metadata: {
-      usage: { inputTokens: 3, cacheReadInputTokenCount: 1458, cacheWriteInputTokenCount: 0 },
-    },
-  });
-
-  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], 1458);
-  assert.equal(span.attrs['gen_ai.usage.cache_creation_input_tokens'], undefined);
-  assert.equal(calls.length, 1);
-});
-
-test('is a no-op when the instrumentor has no _wrapPromise', () => {
-  const instrumentation = {};
-  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
-  assert.equal(instrumentation._wrapPromise, undefined);
-});

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

@@ -1,89 +0,0 @@
-'use strict';
-
-// Tests for the Bedrock input-message-content complement.
-//
-// The traceloop instrumentation instance is stubbed with a `_startSpan` that
-// returns a fake span — with or without instrumentor-set input messages — so
-// the wrap's "only when missing" behaviour can be exercised.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const {
-  BedrockInputMessageContentInstrumentor,
-} = require('../../../src/instrumentation/bedrock/get_input_message_content_telemetry');
-
-function makeFakeSpan(attributes = {}) {
-  return {
-    attributes,
-    setAttribute(key, value) {
-      attributes[key] = value;
-    },
-  };
-}
-
-function makeStubInstrumentation(spanAttributes) {
-  return {
-    _startSpan() {
-      return makeFakeSpan(spanAttributes);
-    },
-  };
-}
-
-function request(body) {
-  return { params: { input: { modelId: 'model-that-does-not-exist', body } } };
-}
-
-test('stamps input messages when the instrumentor set none', () => {
-  const instrumentation = makeStubInstrumentation({});
-  new BedrockInputMessageContentInstrumentor().instrument(instrumentation);
-
-  const span = instrumentation._startSpan(
-    request(JSON.stringify({ messages: [{ role: 'user', content: [{ text: 'Hello' }] }] }))
-  );
-
-  assert.deepEqual(JSON.parse(span.attributes['gen_ai.input.messages']), [
-    { role: 'user', parts: [{ type: 'text', content: 'Hello' }] },
-  ]);
-});
-
-test('supports the flat inputText schema', () => {
-  const instrumentation = makeStubInstrumentation({});
-  new BedrockInputMessageContentInstrumentor().instrument(instrumentation);
-
-  const span = instrumentation._startSpan(request(JSON.stringify({ inputText: 'Hello' })));
-
-  assert.deepEqual(JSON.parse(span.attributes['gen_ai.input.messages']), [
-    { role: 'user', parts: [{ type: 'text', content: 'Hello' }] },
-  ]);
-});
-
-test('leaves instrumentor-set input messages untouched', () => {
-  const existing = '[{"role":"user","parts":[{"type":"text","content":"from-traceloop"}]}]';
-  const instrumentation = makeStubInstrumentation({ 'gen_ai.input.messages': existing });
-  new BedrockInputMessageContentInstrumentor().instrument(instrumentation);
-
-  const span = instrumentation._startSpan(
-    request(JSON.stringify({ messages: [{ role: 'user', content: [{ text: 'other' }] }] }))
-  );
-
-  assert.equal(span.attributes['gen_ai.input.messages'], existing);
-});
-
-test('no attribute for an unparseable or empty body', () => {
-  const instrumentation = makeStubInstrumentation({});
-  new BedrockInputMessageContentInstrumentor().instrument(instrumentation);
-
-  assert.ok(
-    !('gen_ai.input.messages' in instrumentation._startSpan(request('not-json')).attributes)
-  );
-});
-
-test('uninstrument restores the original startSpan', () => {
-  const instrumentation = makeStubInstrumentation({});
-  const original = instrumentation._startSpan;
-  const instrumentor = new BedrockInputMessageContentInstrumentor();
-  instrumentor.instrument(instrumentation);
-  instrumentor.uninstrument();
-  assert.equal(instrumentation._startSpan, original);
-});

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

@@ -1,87 +0,0 @@
-'use strict';
-
-// Tests for the Bedrock streamed-output message complement.
-//
-// The traceloop instrumentation instance is stubbed with a
-// `_handleNovaStreamingMetadata` no-op; chunks are replayed through the wrap the
-// way the instrumentation's stream loop calls it.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const {
-  BedrockStreamingOutputMessageInstrumentor,
-} = require('../../../src/instrumentation/bedrock/get_streaming_output_message_telemetry');
-
-function makeFakeSpan() {
-  const attributes = {};
-  return {
-    attributes,
-    setAttribute(key, value) {
-      attributes[key] = value;
-    },
-  };
-}
-
-function instrumented() {
-  const instrumentation = { _handleNovaStreamingMetadata() {} };
-  const instrumentor = new BedrockStreamingOutputMessageInstrumentor();
-  instrumentor.instrument(instrumentation);
-  return { instrumentation, instrumentor };
-}
-
-test('re-stamps the output message from accumulated stream chunks', () => {
-  const { instrumentation } = instrumented();
-  const span = makeFakeSpan();
-
-  instrumentation._handleNovaStreamingMetadata(span, {
-    contentBlockDelta: { delta: { text: 'Hel' } },
-  });
-  instrumentation._handleNovaStreamingMetadata(span, {
-    contentBlockDelta: { delta: { text: 'lo!' } },
-  });
-  instrumentation._handleNovaStreamingMetadata(span, {
-    messageStop: { stopReason: 'end_turn' },
-  });
-  assert.ok(!('gen_ai.output.messages' in span.attributes), 'set only on the metadata chunk');
-
-  instrumentation._handleNovaStreamingMetadata(span, { metadata: { usage: {} } });
-  assert.deepEqual(JSON.parse(span.attributes['gen_ai.output.messages']), [
-    {
-      role: 'assistant',
-      parts: [{ type: 'text', content: 'Hello!' }],
-      finish_reason: 'stop',
-    },
-  ]);
-});
-
-test('maps max_tokens to length', () => {
-  const { instrumentation } = instrumented();
-  const span = makeFakeSpan();
-  instrumentation._handleNovaStreamingMetadata(span, {
-    contentBlockDelta: { delta: { text: 'OK' } },
-  });
-  instrumentation._handleNovaStreamingMetadata(span, {
-    messageStop: { stopReason: 'max_tokens' },
-  });
-  instrumentation._handleNovaStreamingMetadata(span, { metadata: {} });
-  assert.equal(JSON.parse(span.attributes['gen_ai.output.messages'])[0].finish_reason, 'length');
-});
-
-test('no attribute when no text was streamed', () => {
-  const { instrumentation } = instrumented();
-  const span = makeFakeSpan();
-  instrumentation._handleNovaStreamingMetadata(span, {
-    messageStop: { stopReason: 'end_turn' },
-  });
-  instrumentation._handleNovaStreamingMetadata(span, { metadata: {} });
-  assert.ok(!('gen_ai.output.messages' in span.attributes));
-});
-
-test('uninstrument restores the original handler', () => {
-  const { instrumentation, instrumentor } = instrumented();
-  instrumentor.uninstrument();
-  const span = makeFakeSpan();
-  instrumentation._handleNovaStreamingMetadata(span, { metadata: {} });
-  assert.deepEqual(span.attributes, {});
-});