weflayr 0.24.0 → 0.26.0

package/tests/instrumentation/elevenlabs/full_instrumentation.test.js

@@ -1,258 +0,0 @@
-'use strict';
-
-// Tests for the bundled ElevenLabs audio instrumentor.
-//
-// The real `@elevenlabs/elevenlabs-js` clients are stubbed with methods that
-// mirror the SDK's shapes — the streaming TTS entrypoints (`convert` / `stream`)
-// resolve to a ReadableStream, `streamWithTimestamps` to an async-iterable, and
-// the unary `convertWithTimestamps` and Speech-to-Text `convert` to a response
-// object — 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 {
-  ElevenLabsInstrumentor,
-} = require('../../../src/instrumentation/elevenlabs/full_instrumentation');
-
-const TTS_CLIENT_MODULE = '@elevenlabs/elevenlabs-js/api/resources/textToSpeech/client/Client';
-const STT_CLIENT_MODULE = '@elevenlabs/elevenlabs-js/api/resources/speechToText/client/Client';
-
-// The instrumentor emits via the global tracer provider. node's test runner
-// isolates each test file in its own process, so registering one provider +
-// in-memory exporter for the whole file is safe.
-const exporter = new InMemorySpanExporter();
-trace.setGlobalTracerProvider(
-  new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
-);
-
-// The exact chunk objects the streaming stubs yield. Shared so the passthrough
-// assertions can compare object identity — proof our proxies re-emit the user's
-// chunks without copying or mutating them.
-const TTS_BYTE_CHUNKS = [Buffer.from('a'), Buffer.from('b')];
-const TTS_OBJECT_CHUNKS = [{ audioBase64: 'eA==' }, { audioBase64: 'YmI=' }];
-
-function readableOf(chunks) {
-  let index = 0;
-  return new ReadableStream({
-    pull(controller) {
-      if (index < chunks.length) controller.enqueue(chunks[index++]);
-      else controller.close();
-    },
-  });
-}
-
-function failingReadable(error) {
-  return new ReadableStream({
-    pull() {
-      throw error;
-    },
-  });
-}
-
-function asyncIterableOf(chunks) {
-  return {
-    async *[Symbol.asyncIterator]() {
-      for (const chunk of chunks) yield chunk;
-    },
-  };
-}
-
-class StubTextToSpeechClient {
-  convert(_voiceId, request = {}) {
-    if (request.text === 'boom') return Promise.resolve(failingReadable(new Error('api error')));
-    return Promise.resolve(readableOf(TTS_BYTE_CHUNKS));
-  }
-
-  stream(_voiceId, _request = {}) {
-    return Promise.resolve(readableOf([Buffer.from('x')]));
-  }
-
-  streamWithTimestamps(_voiceId, _request = {}) {
-    return Promise.resolve(asyncIterableOf(TTS_OBJECT_CHUNKS));
-  }
-
-  convertWithTimestamps(_voiceId, _request = {}) {
-    return Promise.resolve({ audioBase64: 'YQ==' });
-  }
-}
-
-class StubSpeechToTextClient {
-  convert(request = {}) {
-    if (request.modelId === 'boom') return Promise.reject(new Error('api error'));
-    return Promise.resolve({ audioDurationSecs: 12.4, text: 'hello' });
-  }
-}
-
-async function drain(stream) {
-  const reader = stream.getReader();
-  const chunks = [];
-  for (;;) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    chunks.push(value);
-  }
-  return chunks;
-}
-
-async function drainIterable(iterable) {
-  const chunks = [];
-  for await (const chunk of iterable) chunks.push(chunk);
-  return chunks;
-}
-
-// Stub the elevenlabs client modules, install the instrumentor + the in-memory
-// exporter, and return a teardown that restores everything.
-function instrumented() {
-  const stubs = {
-    [TTS_CLIENT_MODULE]: { TextToSpeechClient: StubTextToSpeechClient },
-    [STT_CLIENT_MODULE]: { SpeechToTextClient: StubSpeechToTextClient },
-  };
-  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 ElevenLabsInstrumentor();
-  instrumentor.instrument();
-
-  return () => {
-    instrumentor.uninstrument();
-    Module._resolveFilename = origResolve;
-    for (const moduleId of Object.keys(stubs)) delete require.cache[moduleId];
-    exporter.reset();
-  };
-}
-
-test('convert emits genai span with char count', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubTextToSpeechClient();
-    const stream = await client.convert('voice', { text: 'hello world', modelId: 'eleven_v2' });
-    // Same count, order, and object identity: the byte-stream proxy re-emits each
-    // chunk by reference — no telemetry collision with the caller's audio.
-    const collected = await drain(stream);
-    assert.equal(collected.length, TTS_BYTE_CHUNKS.length);
-    collected.forEach((chunk, index) => assert.equal(chunk, TTS_BYTE_CHUNKS[index]));
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.name, 'text_to_speech');
-    assert.equal(span.attributes['gen_ai.system'], 'elevenlabs');
-    assert.equal(span.attributes['gen_ai.operation.name'], 'text_to_speech');
-    assert.equal(span.attributes['gen_ai.request.model'], 'eleven_v2');
-    assert.equal(span.attributes['gen_ai.usage.input_characters'], 'hello world'.length);
-    assert.equal(span.status.code, SpanStatusCode.UNSET);
-  } finally {
-    teardown();
-  }
-});
-
-test('convert records error status on failure', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubTextToSpeechClient();
-    const stream = await client.convert('voice', { text: 'boom', modelId: 'm' });
-    await assert.rejects(() => drain(stream), /api error/);
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.status.code, SpanStatusCode.ERROR);
-  } finally {
-    teardown();
-  }
-});
-
-test('convert with timestamps emits span with char count', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubTextToSpeechClient();
-    // The unary timestamp variant resolves to a single response, not a stream.
-    const result = await client.convertWithTimestamps('voice', { text: 'hello', modelId: 'm' });
-    assert.equal(result.audioBase64, 'YQ==');
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.name, 'text_to_speech');
-    assert.equal(span.attributes['gen_ai.usage.input_characters'], 'hello'.length);
-    assert.equal(span.attributes['gen_ai.usage.input_seconds'], undefined);
-  } finally {
-    teardown();
-  }
-});
-
-test('stream with timestamps emits span with char count', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubTextToSpeechClient();
-    const stream = await client.streamWithTimestamps('voice', { text: 'hello', modelId: 'm' });
-    // Same count, order, and object identity: the object-stream proxy re-yields
-    // each chunk by reference — no telemetry collision with the caller's payload.
-    const collected = await drainIterable(stream);
-    assert.equal(collected.length, TTS_OBJECT_CHUNKS.length);
-    collected.forEach((chunk, index) => assert.equal(chunk, TTS_OBJECT_CHUNKS[index]));
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.name, 'text_to_speech');
-    assert.equal(span.attributes['gen_ai.usage.input_characters'], 'hello'.length);
-  } finally {
-    teardown();
-  }
-});
-
-test('uninstrument restores original methods', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubTextToSpeechClient();
-    assert.deepEqual(await drain(await client.stream('voice', { text: 'x' })), [Buffer.from('x')]);
-    assert.equal(exporter.getFinishedSpans().length, 1);
-  } finally {
-    teardown();
-  }
-});
-
-test('speech to text emits span with audio duration', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubSpeechToTextClient();
-    const result = await client.convert({ modelId: 'scribe_v1', file: Buffer.from('audio') });
-    assert.equal(result.audioDurationSecs, 12.4);
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.name, 'speech_to_text');
-    assert.equal(span.attributes['gen_ai.system'], 'elevenlabs');
-    assert.equal(span.attributes['gen_ai.operation.name'], 'speech_to_text');
-    assert.equal(span.attributes['gen_ai.request.model'], 'scribe_v1');
-    assert.equal(span.attributes['gen_ai.usage.input_seconds'], 12.4);
-    assert.equal(span.attributes['gen_ai.usage.input_characters'], undefined);
-    assert.equal(span.status.code, SpanStatusCode.UNSET);
-  } finally {
-    teardown();
-  }
-});
-
-test('speech to text records error status on failure', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubSpeechToTextClient();
-    await assert.rejects(
-      () => client.convert({ modelId: 'boom', file: Buffer.from('audio') }),
-      /api error/
-    );
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.status.code, SpanStatusCode.ERROR);
-  } finally {
-    teardown();
-  }
-});

package/tests/instrumentation/google/get_cache_operations_telemetry.test.js

@@ -1,130 +0,0 @@
-'use strict';
-
-// Tests for the Google GenAI explicit-cache lifecycle telemetry.
-//
-// The @google/genai `Caches` class is stubbed with prototype
-// create/update/delete methods mirroring the SDK shape.
-// `instrumentCacheOperations(Caches, patched)` wraps them and pushes the
-// restore tuples onto `patched`.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const { trace, SpanStatusCode } = require('@opentelemetry/api');
-const {
-  BasicTracerProvider,
-  InMemorySpanExporter,
-  SimpleSpanProcessor,
-} = require('@opentelemetry/sdk-trace-base');
-
-const {
-  instrumentCacheOperations,
-} = require('../../../src/instrumentation/google/get_cache_operations_telemetry');
-
-const exporter = new InMemorySpanExporter();
-trace.setGlobalTracerProvider(
-  new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
-);
-
-const CACHED_CONTENT = {
-  name: 'cachedContents/abc123',
-  expireTime: '2026-07-16T14:00:00Z',
-  usageMetadata: { totalTokenCount: 5300 },
-};
-
-class StubCaches {
-  create(params = {}) {
-    if (params.model === 'boom') return Promise.reject(new Error('api error'));
-    return Promise.resolve(CACHED_CONTENT);
-  }
-
-  update() {
-    return Promise.resolve(CACHED_CONTENT);
-  }
-
-  delete() {
-    return Promise.resolve({});
-  }
-}
-
-function instrumented() {
-  const patched = [];
-  instrumentCacheOperations(StubCaches, patched);
-  return () => {
-    for (const [owner, methodName, original] of patched) owner[methodName] = original;
-    exporter.reset();
-  };
-}
-
-test('create span carries cache facts and content', async () => {
-  const teardown = instrumented();
-  try {
-    await new StubCaches().create({
-      model: 'models/gemini-2.5-flash',
-      config: {
-        contents: ['a very large document to cache'],
-        systemInstruction: 'Answer from the document.',
-        ttl: '3600s',
-      },
-    });
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.name, 'cache_create');
-    assert.equal(span.attributes['gen_ai.system'], 'gemini');
-    assert.equal(span.attributes['gen_ai.request.model'], 'gemini-2.5-flash');
-    assert.equal(span.attributes['weflayr.cache.operation'], 'create');
-    assert.equal(span.attributes['weflayr.cache.cached_content_id'], 'cachedContents/abc123');
-    assert.equal(span.attributes['weflayr.cache.expire_time'], '2026-07-16T14:00:00Z');
-    assert.equal(span.attributes['gen_ai.usage.input_tokens'], 5300);
-    assert.deepEqual(JSON.parse(span.attributes['gen_ai.input.messages']), [
-      { role: 'user', parts: [{ type: 'text', content: 'a very large document to cache' }] },
-    ]);
-    assert.deepEqual(JSON.parse(span.attributes['gen_ai.system_instructions']), [
-      { type: 'text', content: 'Answer from the document.' },
-    ]);
-  } finally {
-    teardown();
-  }
-});
-
-test('update span carries the new expiry but no token count', async () => {
-  const teardown = instrumented();
-  try {
-    await new StubCaches().update({ name: 'cachedContents/abc123', config: { ttl: '180s' } });
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.name, 'cache_update');
-    assert.equal(span.attributes['weflayr.cache.operation'], 'update');
-    assert.equal(span.attributes['weflayr.cache.expire_time'], '2026-07-16T14:00:00Z');
-    assert.ok(!('gen_ai.usage.input_tokens' in span.attributes));
-  } finally {
-    teardown();
-  }
-});
-
-test('delete span carries operation and cache id', async () => {
-  const teardown = instrumented();
-  try {
-    await new StubCaches().delete({ name: 'cachedContents/abc123' });
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.name, 'cache_delete');
-    assert.equal(span.attributes['weflayr.cache.operation'], 'delete');
-    assert.equal(span.attributes['weflayr.cache.cached_content_id'], 'cachedContents/abc123');
-    assert.ok(!('gen_ai.usage.input_tokens' in span.attributes));
-  } finally {
-    teardown();
-  }
-});
-
-test('error span records status', async () => {
-  const teardown = instrumented();
-  try {
-    await assert.rejects(new StubCaches().create({ model: 'boom' }));
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.status.code, SpanStatusCode.ERROR);
-  } finally {
-    teardown();
-  }
-});

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

@@ -1,128 +0,0 @@
-'use strict';
-
-// Tests for the bundled Google GenAI (Gemini) embeddings telemetry.
-//
-// The @google/genai `Models` class is stubbed with the prototype method
-// `embedContentInternal` (the stable patch point that the public `embedContent`
-// arrow delegates to). The Gemini Developer API returns no token usage, so the
-// billable unit is the input character count. `instrumentEmbeddings(Models,
-// patched)` wraps the method and pushes its restore tuple onto `patched`.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const { trace, SpanStatusCode } = require('@opentelemetry/api');
-const {
-  BasicTracerProvider,
-  InMemorySpanExporter,
-  SimpleSpanProcessor,
-} = require('@opentelemetry/sdk-trace-base');
-
-const {
-  instrumentEmbeddings,
-} = require('../../../src/instrumentation/google/get_embeddings_telemetry');
-
-const exporter = new InMemorySpanExporter();
-trace.setGlobalTracerProvider(
-  new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
-);
-
-class StubModels {
-  embedContentInternal(params = {}) {
-    if (params.model === 'boom') return Promise.reject(new Error('api error'));
-    return Promise.resolve({ embeddings: [{ values: [0.1] }] });
-  }
-}
-
-function instrumented() {
-  const patched = [];
-  instrumentEmbeddings(StubModels, patched);
-  return () => {
-    for (const [owner, methodName, original] of patched) owner[methodName] = original;
-    exporter.reset();
-  };
-}
-
-test('embeddings emits genai span with character count and stripped model', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubModels();
-    await client.embedContentInternal({
-      model: 'models/text-embedding-004',
-      contents: 'hello world',
-    });
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.name, 'embeddings');
-    // No apiClient on the stub → Gemini Developer API.
-    assert.equal(span.attributes['gen_ai.system'], 'gemini');
-    assert.equal(span.attributes['gen_ai.operation.name'], 'embeddings');
-    // The "models/" prefix is stripped to match the chat path.
-    assert.equal(span.attributes['gen_ai.request.model'], 'text-embedding-004');
-    assert.equal(span.attributes['gen_ai.usage.input_characters'], 'hello world'.length);
-    assert.deepEqual(JSON.parse(span.attributes['gen_ai.input.messages']), [
-      { role: 'user', parts: [{ type: 'text', content: 'hello world' }] },
-    ]);
-    assert.equal(span.status.code, SpanStatusCode.UNSET);
-  } finally {
-    teardown();
-  }
-});
-
-test('embeddings counts characters across list/part contents', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubModels();
-    await client.embedContentInternal({
-      model: 'text-embedding-004',
-      contents: ['ab', { text: 'cde' }, { parts: [{ text: 'fg' }] }],
-    });
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.attributes['gen_ai.usage.input_characters'], 7);
-  } finally {
-    teardown();
-  }
-});
-
-test('embeddings system is vertex_ai when client targets vertex', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubModels();
-    // The Vertex backend is read off the api client.
-    client.apiClient = { isVertexAI: () => true };
-    await client.embedContentInternal({ model: 'text-embedding-004', contents: 'hi' });
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.attributes['gen_ai.system'], 'vertex_ai');
-  } finally {
-    teardown();
-  }
-});
-
-test('embeddings records error status on failure', async () => {
-  const teardown = instrumented();
-  try {
-    const client = new StubModels();
-    await assert.rejects(
-      () => client.embedContentInternal({ model: 'boom', contents: 'x' }),
-      /api error/
-    );
-
-    const [span] = exporter.getFinishedSpans();
-    assert.equal(span.status.code, SpanStatusCode.ERROR);
-  } finally {
-    teardown();
-  }
-});
-
-test('uninstrument restores the original method', async () => {
-  const teardown = instrumented();
-  const client = new StubModels();
-  await client.embedContentInternal({ model: 'text-embedding-004', contents: 'x' });
-  assert.equal(exporter.getFinishedSpans().length, 1);
-  teardown();
-  // After teardown the prototype method is restored (no new span is recorded).
-  await client.embedContentInternal({ model: 'text-embedding-004', contents: 'y' });
-  assert.equal(exporter.getFinishedSpans().length, 0);
-});

package/tests/instrumentation/google/get_reasoning_telemetry.test.js

@@ -1,41 +0,0 @@
-'use strict';
-
-// Tests for the Gemini reasoning (thinking) token complement. It stamps
-// usageMetadata.thoughtsTokenCount onto the chat span as
-// gen_ai.usage.thoughts_token_count so the normalizer can fold the
-// (separately-reported) thinking tokens into the completion count.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const {
-  setReasoningTelemetry,
-} = require('../../../src/instrumentation/google/get_reasoning_telemetry');
-
-function fakeSpan() {
-  const attrs = {};
-  return {
-    attrs,
-    setAttribute(key, value) {
-      attrs[key] = value;
-    },
-  };
-}
-
-test('stamps thoughts token count', () => {
-  const span = fakeSpan();
-  setReasoningTelemetry(span, { usageMetadata: { thoughtsTokenCount: 369 } });
-  assert.equal(span.attrs['gen_ai.usage.thoughts_token_count'], 369);
-});
-
-test('sets nothing when thoughts is zero', () => {
-  const span = fakeSpan();
-  setReasoningTelemetry(span, { usageMetadata: { thoughtsTokenCount: 0 } });
-  assert.equal(span.attrs['gen_ai.usage.thoughts_token_count'], undefined);
-});
-
-test('is a no-op without usageMetadata', () => {
-  const span = fakeSpan();
-  setReasoningTelemetry(span, {});
-  assert.equal(Object.keys(span.attrs).length, 0);
-});