weflayr 0.20.6 → 0.22.0

package/tests/index.test.js

@@ -14,7 +14,6 @@ const { _state } = require('../src/setup');
 const { isDefaultExportSpan } = require('../src/otel/span-filter');
 const { WeflayrSpanProcessor } = require('../src/otel/span-processor');
 const { buildExporter, _exportWithRetry } = require('../src/otel/exporter');
-const { patchOpenAIStreamingUsage } = require('../src/otel/openai-streaming-usage');
 
 const contextManager = new AsyncHooksContextManager();
 contextManager.enable();
@@ -185,6 +184,54 @@ test('buildExporter strips trailing slash on baseUrl', () => {
   assert.equal(_exporterParams(exporter).url, 'https://api.weflayr.com/');
 });
 
+test('buildExporter warns on every export error when warnOnExportError is true', async () => {
+  const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
+  const origExport = OTLPTraceExporter.prototype.export;
+  OTLPTraceExporter.prototype.export = function (spans, cb) {
+    cb({ code: 1, error: { code: 401, message: 'Unauthorized' } });
+  };
+  const warnings = [];
+  const origWarn = console.warn;
+  console.warn = (...args) => warnings.push(args.join(' '));
+  try {
+    const exporter = buildExporter({
+      baseUrl: 'https://api.weflayr.com',
+      apiKey: 'bad',
+      warnOnExportError: true,
+    });
+    await new Promise((resolve) => exporter.export([], resolve));
+    await new Promise((resolve) => exporter.export([], resolve));
+    assert.equal(warnings.filter((w) => w.includes('[weflayr]')).length, 2);
+  } finally {
+    OTLPTraceExporter.prototype.export = origExport;
+    console.warn = origWarn;
+  }
+});
+
+test('buildExporter does not warn when warnOnExportError is false', async () => {
+  const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
+  const origExport = OTLPTraceExporter.prototype.export;
+  OTLPTraceExporter.prototype.export = function (spans, cb) {
+    cb({ code: 1, error: { code: 401, message: 'Unauthorized' } });
+  };
+  const warnings = [];
+  const origWarn = console.warn;
+  console.warn = (...args) => warnings.push(args.join(' '));
+  try {
+    const exporter = buildExporter({
+      baseUrl: 'https://api.weflayr.com',
+      apiKey: 'bad',
+      warnOnExportError: false,
+    });
+    await new Promise((resolve) => exporter.export([], resolve));
+    await new Promise((resolve) => exporter.export([], resolve));
+    assert.equal(warnings.filter((w) => w.includes('[weflayr]')).length, 0);
+  } finally {
+    OTLPTraceExporter.prototype.export = origExport;
+    console.warn = origWarn;
+  }
+});
+
 // ── span-filter ───────────────────────────────────────────────────────────────
 
 test('isDefaultExportSpan accepts spans with gen_ai.* attributes', () => {
@@ -288,6 +335,60 @@ test('WeflayrSpanProcessor applies mask before export', async () => {
   assert.equal(span.attributes['gen_ai.prompt'], '[REDACTED]');
 });
 
+test('WeflayrSpanProcessor strips message content when capture disabled', async () => {
+  // Instrumentors gate content on their own env vars (openllmetry captures by
+  // default), so the processor itself must drop message content when
+  // captureMessageContent=false recorded "false" in the env var.
+  process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = 'false';
+  try {
+    const exporter = makeExporterStub();
+    const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
+    const span = makeFakeSpan({
+      attributes: {
+        'gen_ai.system': 'openai',
+        'gen_ai.input.messages': '[{"role": "user"}]',
+        'gen_ai.output.messages': '[{"role": "assistant"}]',
+        'gen_ai.system_instructions': '[{"type": "text"}]',
+        'gen_ai.prompt.0.content': 'Hi Noe',
+        'gen_ai.completion.0.content': 'Hello!',
+        'gen_ai.usage.input_tokens': 12,
+      },
+    });
+    proc.onEnd(span);
+    await proc.forceFlush();
+    assert.equal(span.attributes['gen_ai.system'], 'openai');
+    assert.equal(span.attributes['gen_ai.usage.input_tokens'], 12);
+    for (const key of Object.keys(span.attributes)) {
+      assert.ok(!key.startsWith('gen_ai.prompt'), `unexpected ${key}`);
+      assert.ok(!key.startsWith('gen_ai.completion'), `unexpected ${key}`);
+    }
+    assert.ok(!('gen_ai.input.messages' in span.attributes));
+    assert.ok(!('gen_ai.output.messages' in span.attributes));
+    assert.ok(!('gen_ai.system_instructions' in span.attributes));
+  } finally {
+    delete process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT;
+  }
+});
+
+test('WeflayrSpanProcessor keeps message content when capture enabled', async () => {
+  process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = 'true';
+  try {
+    const exporter = makeExporterStub();
+    const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
+    const span = makeFakeSpan({
+      attributes: {
+        'gen_ai.system': 'openai',
+        'gen_ai.input.messages': '[{"role": "user"}]',
+      },
+    });
+    proc.onEnd(span);
+    await proc.forceFlush();
+    assert.equal(span.attributes['gen_ai.input.messages'], '[{"role": "user"}]');
+  } finally {
+    delete process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT;
+  }
+});
+
 // ── propagateMetadata ────────────────────────────────────────────────────────
 
 function _makeMetadataHarness() {
@@ -478,12 +579,48 @@ test('propagateMetadata providerName writes attribute', async () => {
   await provider.shutdown();
 });
 
+test('propagateMetadata requires featureName and customerId', () => {
+  assert.throws(() => weflayr.propagateMetadata({}), /featureName.*customerId.*required/);
+  assert.throws(() => weflayr.propagateMetadata({ featureName: 'f' }), /required/);
+  assert.throws(() => weflayr.propagateMetadata({ customerId: 'c' }), /required/);
+});
+
 // ── autoInstrument ────────────────────────────────────────────────────────────
 
 function _ensureSetupDone() {
   if (!_state.processor) weflayr.setup({ apiKey: 'test-key' });
 }
 
+// Instrumenting OPENAI also runs the bundled audio + embeddings instrumentors,
+// which eagerly require the openai resource modules. Stub them so autoInstrument
+// tests don't need the real `openai` dependency installed.
+const OPENAI_RESOURCE_STUBS = {
+  'openai/resources/audio/speech': {
+    Speech: class {
+      create() {}
+    },
+  },
+  'openai/resources/audio/transcriptions': {
+    Transcriptions: class {
+      create() {}
+    },
+  },
+  'openai/resources/embeddings': {
+    Embeddings: class {
+      create() {}
+    },
+  },
+};
+
+function _stubOpenAIResources() {
+  for (const [id, exports] of Object.entries(OPENAI_RESOURCE_STUBS)) {
+    require.cache[id] = { id, filename: id, loaded: true, exports };
+  }
+  return () => {
+    for (const id of Object.keys(OPENAI_RESOURCE_STUBS)) delete require.cache[id];
+  };
+}
+
 test('autoInstrument throws "install package X" when the dep is missing', async () => {
   _ensureSetupDone();
   await assert.rejects(
@@ -517,7 +654,7 @@ test('autoInstrument loads a stubbed Traceloop package', async () => {
   }
   const origResolve = Module._resolveFilename;
   Module._resolveFilename = function patched(req, ...rest) {
-    if (req === '@traceloop/instrumentation-openai') return req;
+    if (req === '@traceloop/instrumentation-openai' || req in OPENAI_RESOURCE_STUBS) return req;
     return origResolve.call(this, req, ...rest);
   };
   require.cache['@traceloop/instrumentation-openai'] = {
@@ -526,12 +663,14 @@ test('autoInstrument loads a stubbed Traceloop package', async () => {
     loaded: true,
     exports: { OpenAIInstrumentation: FakeOpenAIInstrumentation },
   };
+  const cleanupOpenAI = _stubOpenAIResources();
   try {
     await weflayr.autoInstrument({ aiSdks: weflayr.AiSdk.OPENAI });
     assert.equal(constructed, true);
   } finally {
     Module._resolveFilename = origResolve;
     delete require.cache['@traceloop/instrumentation-openai'];
+    cleanupOpenAI();
   }
 });
 
@@ -564,7 +703,7 @@ test('autoInstrument runs setup when apiKey passed', async () => {
   }
   const origResolve = Module._resolveFilename;
   Module._resolveFilename = function patched(req, ...rest) {
-    if (req === '@traceloop/instrumentation-openai') return req;
+    if (req === '@traceloop/instrumentation-openai' || req in OPENAI_RESOURCE_STUBS) return req;
     return origResolve.call(this, req, ...rest);
   };
   require.cache['@traceloop/instrumentation-openai'] = {
@@ -573,6 +712,7 @@ test('autoInstrument runs setup when apiKey passed', async () => {
     loaded: true,
     exports: { OpenAIInstrumentation: FakeOpenAIInstrumentation },
   };
+  const cleanupOpenAI = _stubOpenAIResources();
   try {
     await weflayr.autoInstrument({
       aiSdks: weflayr.AiSdk.OPENAI,
@@ -582,6 +722,7 @@ test('autoInstrument runs setup when apiKey passed', async () => {
   } finally {
     Module._resolveFilename = origResolve;
     delete require.cache['@traceloop/instrumentation-openai'];
+    cleanupOpenAI();
   }
 });
 
@@ -641,47 +782,6 @@ test('exporter gives up after maxRetries on persistent 503', async () => {
   assert.equal(calls, 3);
 });
 
-// ── OpenAI streaming usage backfill ─────────────────────────────────────────────
-
-// Build a fake OpenAI instrumentor whose streaming handler mimics traceloop's:
-// it yields content chunks, then a final usage chunk (as OpenAI sends when
-// `stream_options.include_usage` is set) without recording usage itself. The
-// patch should read the usage chunk and set the token attributes on the span.
-function makeFakeOpenAIInstrumentation() {
-  return {
-    _streamingWrapPromise() {
-      return (async function* originalStream() {
-        yield { id: 'chatcmpl-1', model: 'gpt-4o-mini', choices: [{ delta: { content: 'Hi' } }] };
-        yield {
-          id: 'chatcmpl-1',
-          model: 'gpt-4o-mini',
-          choices: [],
-          usage: { prompt_tokens: 13, completion_tokens: 2, total_tokens: 15 },
-        };
-      })();
-    },
-  };
-}
-
-test('patchOpenAIStreamingUsage sets token attributes from the streamed usage chunk', async () => {
-  const span = makeFakeSpan();
-  const instrumentation = makeFakeOpenAIInstrumentation();
-  patchOpenAIStreamingUsage(instrumentation);
-
-  const stream = instrumentation._streamingWrapPromise({ span });
-  for await (const chunk of stream) void chunk;
-
-  assert.equal(span.attributes['gen_ai.usage.input_tokens'], 13);
-  assert.equal(span.attributes['gen_ai.usage.output_tokens'], 2);
-  assert.equal(span.attributes['gen_ai.usage.total_tokens'], 15);
-});
-
-test('patchOpenAIStreamingUsage is a no-op when the streaming handler is absent', () => {
-  const instrumentation = {};
-  patchOpenAIStreamingUsage(instrumentation);
-  assert.equal(instrumentation._streamingWrapPromise, undefined);
-});
-
 // ── flush ─────────────────────────────────────────────────────────────────────
 
 test('flush does not throw', async () => {

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

@@ -0,0 +1,158 @@
+'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

@@ -0,0 +1,117 @@
+'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

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