weflayr 0.22.2 → 0.24.0

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

@@ -0,0 +1,130 @@
+'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/openai/get_cache_config_telemetry.test.js

@@ -0,0 +1,83 @@
+'use strict';
+
+// Tests for the OpenAI request-side prompt-cache param 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 {
+  OpenAICacheConfigInstrumentor,
+} = require('../../../src/instrumentation/openai/get_cache_config_telemetry');
+
+function makeFakeSpan() {
+  const attributes = {};
+  return {
+    attributes,
+    setAttribute(key, value) {
+      attributes[key] = value;
+    },
+  };
+}
+
+function makeStubInstrumentation() {
+  return {
+    startSpan() {
+      return makeFakeSpan();
+    },
+  };
+}
+
+test('stamps prompt cache key and retention from the request params', () => {
+  const instrumentation = makeStubInstrumentation();
+  new OpenAICacheConfigInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation.startSpan({
+    type: 'chat',
+    params: {
+      model: 'gpt-4o-mini',
+      prompt_cache_key: 'session-42',
+      prompt_cache_retention: '24h',
+    },
+  });
+
+  assert.equal(span.attributes['weflayr.cache.key'], 'session-42');
+  assert.equal(span.attributes['weflayr.cache.retention'], '24h');
+});
+
+test('stamps prompt cache options ttl as the retention', () => {
+  const instrumentation = makeStubInstrumentation();
+  new OpenAICacheConfigInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation.startSpan({
+    type: 'chat',
+    params: {
+      model: 'gpt-5.6',
+      prompt_cache_options: { ttl: '30m' },
+    },
+  });
+
+  assert.equal(span.attributes['weflayr.cache.retention'], '30m');
+});
+
+test('no attributes without cache params', () => {
+  const instrumentation = makeStubInstrumentation();
+  new OpenAICacheConfigInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation.startSpan({ type: 'chat', params: { model: 'gpt-4o-mini' } });
+
+  assert.ok(!('weflayr.cache.key' in span.attributes));
+  assert.ok(!('weflayr.cache.retention' in span.attributes));
+});
+
+test('uninstrument restores the original startSpan', () => {
+  const instrumentation = makeStubInstrumentation();
+  const original = instrumentation.startSpan;
+  const instrumentor = new OpenAICacheConfigInstrumentor();
+  instrumentor.instrument(instrumentation);
+  assert.notEqual(instrumentation.startSpan, original);
+  instrumentor.uninstrument();
+  assert.equal(instrumentation.startSpan, original);
+});

package/tests/instrumentation/vercel/get_cache_creation_telemetry.test.js

@@ -0,0 +1,96 @@
+'use strict';
+
+// Tests for the ai >= 7 cache-write capture: the telemetry dispatcher's
+// onLanguageModelCallEnd reads the raw `usage.cache_creation` off the event's
+// raw provider usage and stamps it verbatim on the still-open model-call span
+// (reached through the integration's call state) before ending it.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  VercelCacheCreationInstrumentor,
+  cacheCreationFromRawUsage,
+} = require('../../../src/instrumentation/vercel/get_cache_creation_telemetry');
+
+const RAW_ANTHROPIC_USAGE = {
+  input_tokens: 7,
+  cache_creation_input_tokens: 6053,
+  cache_creation: { ephemeral_5m_input_tokens: 6053, ephemeral_1h_input_tokens: 0 },
+};
+
+function makeFakeSpan() {
+  const attributes = {};
+  return {
+    attributes,
+    setAttribute(key, value) {
+      attributes[key] = value;
+    },
+  };
+}
+
+function makeInstrumentedDispatcher() {
+  const span = makeFakeSpan();
+  const endedEvents = [];
+  const dispatcher = {
+    onLanguageModelCallEnd(event) {
+      endedEvents.push(event);
+    },
+    getCallState(callId) {
+      return callId === 'call-1' ? { inferenceSpan: span } : undefined;
+    },
+  };
+  const instrumentor = new VercelCacheCreationInstrumentor();
+  instrumentor.instrument(dispatcher);
+  return { dispatcher, span, endedEvents, instrumentor };
+}
+
+test('stamps the raw cache_creation from the provider usage on the model-call span', () => {
+  const { dispatcher, span, endedEvents } = makeInstrumentedDispatcher();
+
+  dispatcher.onLanguageModelCallEnd({
+    callId: 'call-1',
+    usage: { inputTokens: 6060, outputTokens: 5, raw: RAW_ANTHROPIC_USAGE },
+  });
+
+  assert.deepEqual(
+    JSON.parse(span.attributes['weflayr.cache.creation']),
+    RAW_ANTHROPIC_USAGE.cache_creation
+  );
+  // The original handler still runs (it ends the span).
+  assert.equal(endedEvents.length, 1);
+});
+
+test('stamps nothing without a cache_creation in the raw usage', () => {
+  const { dispatcher, span } = makeInstrumentedDispatcher();
+
+  dispatcher.onLanguageModelCallEnd({
+    callId: 'call-1',
+    usage: { inputTokens: 13, outputTokens: 5, raw: { input_tokens: 13 } },
+  });
+
+  assert.ok(!('weflayr.cache.creation' in span.attributes));
+});
+
+test('cacheCreationFromRawUsage drops an all-zero cache_creation', () => {
+  assert.deepEqual(
+    cacheCreationFromRawUsage({
+      cache_creation: { ephemeral_5m_input_tokens: 4000, ephemeral_1h_input_tokens: 1300 },
+    }),
+    { ephemeral_5m_input_tokens: 4000, ephemeral_1h_input_tokens: 1300 }
+  );
+  assert.equal(
+    cacheCreationFromRawUsage({
+      cache_creation: { ephemeral_5m_input_tokens: 0, ephemeral_1h_input_tokens: 0 },
+    }),
+    undefined
+  );
+  assert.equal(cacheCreationFromRawUsage(undefined), undefined);
+});
+
+test('uninstrument restores the original handler', () => {
+  const { dispatcher, instrumentor } = makeInstrumentedDispatcher();
+  assert.equal(dispatcher.onLanguageModelCallEnd.name, 'onLanguageModelCallEndWithCacheCreation');
+  instrumentor.uninstrument();
+  assert.equal(dispatcher.onLanguageModelCallEnd.name, 'onLanguageModelCallEnd');
+});