weflayr 0.24.0 → 0.26.1

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

@@ -1,118 +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 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);
-
-  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, {});
-});

package/tests/instrumentation/cohere/get_chat_telemetry.test.js

@@ -1,148 +0,0 @@
-'use strict';
-
-// Tests for the Cohere chat token-usage enrichment complement.
-//
-// The cohere-ai v1 `CohereClient` is stubbed with an internal `__chat` method
-// that mirrors the SDK shape — resolving to `{ data: { meta: { billedUnits } } }`
-// — so the complement can be exercised without network access or the dependency
-// installed. The complement enriches whichever span is active when `__chat` runs
-// (in production, the span traceloop opens around the public `chat`), so the
-// tests start a span and make it active before invoking `__chat`.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const Module = require('node:module');
-
-const { trace, context } = require('@opentelemetry/api');
-const {
-  BasicTracerProvider,
-  InMemorySpanExporter,
-  SimpleSpanProcessor,
-} = require('@opentelemetry/sdk-trace-base');
-const { AsyncLocalStorageContextManager } = require('@opentelemetry/context-async-hooks');
-
-const {
-  CohereChatTokenUsageInstrumentor,
-} = require('../../../src/instrumentation/cohere/get_chat_telemetry');
-
-const CLIENT_MODULE = 'cohere-ai/Client';
-
-const exporter = new InMemorySpanExporter();
-trace.setGlobalTracerProvider(
-  new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
-);
-context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
-const tracer = trace.getTracer('test');
-
-class StubCohereClient {
-  __chat(request = {}) {
-    if (request.model === 'boom') return Promise.reject(new Error('api error'));
-    return Promise.resolve({
-      data: { text: 'hi', meta: { billedUnits: { inputTokens: 7, outputTokens: 3 } } },
-    });
-  }
-}
-
-function instrumented() {
-  const stubs = { [CLIENT_MODULE]: { CohereClient: StubCohereClient } };
-  const origResolve = Module._resolveFilename;
-  Module._resolveFilename = function patched(request, ...rest) {
-    if (request in stubs) return request;
-    return origResolve.call(this, request, ...rest);
-  };
-  for (const [moduleId, exports] of Object.entries(stubs)) {
-    require.cache[moduleId] = { id: moduleId, filename: moduleId, loaded: true, exports };
-  }
-
-  const instrumentor = new CohereChatTokenUsageInstrumentor();
-  instrumentor.instrument();
-
-  return () => {
-    instrumentor.uninstrument();
-    Module._resolveFilename = origResolve;
-    for (const moduleId of Object.keys(stubs)) delete require.cache[moduleId];
-    exporter.reset();
-  };
-}
-
-// Runs `__chat` inside an active span, mirroring the context traceloop sets up
-// around the public `chat`, and returns the finished span.
-async function callChatWithinSpan(client, request) {
-  const span = tracer.startSpan('cohere.chat');
-  await context.with(trace.setSpan(context.active(), span), () => client.__chat(request));
-  span.end();
-  return exporter.getFinishedSpans().find((finished) => finished.name === 'cohere.chat');
-}
-
-test('enriches the active chat span with input and output tokens', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubCohereClient();
-    const span = await callChatWithinSpan(client, { model: 'command-r-08-2024', message: 'hi' });
-
-    assert.equal(span.attributes['gen_ai.usage.input_tokens'], 7);
-    assert.equal(span.attributes['gen_ai.usage.output_tokens'], 3);
-  } finally {
-    teardown();
-  }
-});
-
-test('leaves the response unchanged', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubCohereClient();
-    let result;
-    const span = tracer.startSpan('cohere.chat');
-    await context.with(trace.setSpan(context.active(), span), async () => {
-      result = await client.__chat({ model: 'command-r-08-2024', message: 'hi' });
-    });
-    span.end();
-
-    assert.equal(result.data.text, 'hi');
-    assert.equal(result.data.meta.billedUnits.inputTokens, 7);
-  } finally {
-    teardown();
-  }
-});
-
-test('does nothing when no span is active', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubCohereClient();
-    // No active span — must not throw, just pass the response through.
-    const result = await client.__chat({ model: 'command-r-08-2024', message: 'hi' });
-    assert.equal(result.data.meta.billedUnits.outputTokens, 3);
-    assert.equal(exporter.getFinishedSpans().length, 0);
-  } finally {
-    teardown();
-  }
-});
-
-test('propagates errors without enriching the span', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubCohereClient();
-    const span = tracer.startSpan('cohere.chat');
-    await assert.rejects(
-      () =>
-        context.with(trace.setSpan(context.active(), span), () =>
-          client.__chat({ model: 'boom', message: 'x' })
-        ),
-      /api error/
-    );
-    span.end();
-
-    const finished = exporter.getFinishedSpans().find((each) => each.name === 'cohere.chat');
-    assert.equal(finished.attributes['gen_ai.usage.input_tokens'], undefined);
-  } finally {
-    teardown();
-  }
-});
-
-test('uninstrument restores the original method', async () => {
-  const teardown = instrumented();
-  const { CohereClient } = require(CLIENT_MODULE);
-  const wrapped = CohereClient.prototype.__chat;
-  teardown();
-  assert.notEqual(CohereClient.prototype.__chat, wrapped);
-});

package/tests/instrumentation/cohere/get_embeddings_telemetry.test.js

@@ -1,132 +0,0 @@
-'use strict';
-
-// Tests for the bundled Cohere embeddings instrumentor.
-//
-// The cohere-ai v1 `CohereClient` and v2 `V2Client` classes are stubbed with an
-// `embed` method that mirrors the SDK shape — resolving to a response carrying
-// `meta.billedUnits.inputTokens` — so the instrumentor can be exercised without
-// network access or the dependency installed.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const Module = require('node:module');
-
-const { trace, SpanStatusCode } = require('@opentelemetry/api');
-const {
-  BasicTracerProvider,
-  InMemorySpanExporter,
-  SimpleSpanProcessor,
-} = require('@opentelemetry/sdk-trace-base');
-
-const {
-  CohereEmbeddingsInstrumentor,
-} = require('../../../src/instrumentation/cohere/get_embeddings_telemetry');
-
-const V1_MODULE = 'cohere-ai/Client';
-const V2_MODULE = 'cohere-ai/api/resources/v2/client/Client';
-
-const exporter = new InMemorySpanExporter();
-trace.setGlobalTracerProvider(
-  new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
-);
-
-class StubCohereClient {
-  embed(request = {}) {
-    if (request.model === 'boom') return Promise.reject(new Error('api error'));
-    return Promise.resolve({ embeddings: [[0.1]], meta: { billedUnits: { inputTokens: 8 } } });
-  }
-}
-
-class StubV2Client {
-  embed(_request = {}) {
-    return Promise.resolve({
-      embeddings: { float: [[0.2]] },
-      meta: { billedUnits: { inputTokens: 5 } },
-    });
-  }
-}
-
-function instrumented() {
-  const stubs = {
-    [V1_MODULE]: { CohereClient: StubCohereClient },
-    [V2_MODULE]: { V2Client: StubV2Client },
-  };
-  const origResolve = Module._resolveFilename;
-  Module._resolveFilename = function patched(request, ...rest) {
-    if (request in stubs) return request;
-    return origResolve.call(this, request, ...rest);
-  };
-  for (const [moduleId, exports] of Object.entries(stubs)) {
-    require.cache[moduleId] = { id: moduleId, filename: moduleId, loaded: true, exports };
-  }
-
-  const instrumentor = new CohereEmbeddingsInstrumentor();
-  instrumentor.instrument();
-
-  return () => {
-    instrumentor.uninstrument();
-    Module._resolveFilename = origResolve;
-    for (const moduleId of Object.keys(stubs)) delete require.cache[moduleId];
-    exporter.reset();
-  };
-}
-
-test('v1 embed emits genai span with input tokens', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubCohereClient();
-    const result = await client.embed({ model: 'embed-english-v3.0', texts: ['hi'] });
-    assert.equal(result.meta.billedUnits.inputTokens, 8);
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.name, 'embeddings');
-    assert.equal(span.attributes['gen_ai.system'], 'Cohere');
-    assert.equal(span.attributes['gen_ai.operation.name'], 'embeddings');
-    assert.equal(span.attributes['gen_ai.request.model'], 'embed-english-v3.0');
-    assert.equal(span.attributes['gen_ai.usage.input_tokens'], 8);
-    assert.deepEqual(JSON.parse(span.attributes['gen_ai.input.messages']), [
-      { role: 'user', parts: [{ type: 'text', content: 'hi' }] },
-    ]);
-    assert.equal(span.status.code, SpanStatusCode.UNSET);
-  } finally {
-    teardown();
-  }
-});
-
-test('v2 embed emits genai span with input tokens', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubV2Client();
-    await client.embed({ model: 'embed-v4.0', texts: ['hi'] });
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.attributes['gen_ai.request.model'], 'embed-v4.0');
-    assert.equal(span.attributes['gen_ai.usage.input_tokens'], 5);
-  } finally {
-    teardown();
-  }
-});
-
-test('embed records error status on failure', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubCohereClient();
-    await assert.rejects(() => client.embed({ model: 'boom', texts: ['x'] }), /api error/);
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.status.code, SpanStatusCode.ERROR);
-  } finally {
-    teardown();
-  }
-});
-
-test('uninstrument restores original methods', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubCohereClient();
-    await client.embed({ model: 'embed-english-v3.0', texts: ['x'] });
-    assert.equal(exporter.getFinishedSpans().length, 1);
-  } finally {
-    teardown();
-  }
-});