weflayr 0.23.0 → 0.26.0

package/src/instrumentation/bedrock/get_input_message_content_telemetry.js

@@ -1,94 +0,0 @@
-'use strict';
-
-/**
- * Input message content for Bedrock invoke_model spans the instrumentor misses.
- *
- * `@traceloop/instrumentation-bedrock` parses the request body per model vendor,
- * so a call whose model id has no recognizable vendor (e.g. an invalid model —
- * exactly the error spans) gets no `gen_ai.input.messages`. Wrap the
- * instrumentor's `_startSpan({ params })` to stamp the input messages from the
- * request body whenever the instrumentor did not. The span processor strips the
- * attribute when message-content capture is disabled.
- */
-
-function _contentToParts(content) {
-  if (typeof content === 'string') {
-    return [{ type: 'text', content }];
-  }
-  if (Array.isArray(content)) {
-    return content
-      .filter((block) => block && typeof block.text === 'string')
-      .map((block) => ({ type: 'text', content: block.text }));
-  }
-  return [];
-}
-
-// Messages in the role+parts shape from an InvokeModel JSON body — the
-// `messages` schema (Nova, Anthropic-on-Bedrock) or the flat `inputText` /
-// `prompt` schemas (Titan, legacy).
-function _inputMessagesFromRequestBody(rawBody) {
-  if (typeof rawBody !== 'string') return [];
-  let body;
-  try {
-    body = JSON.parse(rawBody);
-  } catch {
-    return [];
-  }
-  if (!body || typeof body !== 'object') return [];
-  if (Array.isArray(body.messages)) {
-    return body.messages
-      .filter((message) => message && typeof message === 'object')
-      .map((message) => ({
-        role: String(message.role || ''),
-        parts: _contentToParts(message.content),
-      }));
-  }
-  const prompt = body.inputText || body.prompt;
-  if (typeof prompt === 'string') {
-    return [{ role: 'user', parts: [{ type: 'text', content: prompt }] }];
-  }
-  return [];
-}
-
-class BedrockInputMessageContentInstrumentor {
-  constructor() {
-    // [instrumentation, methodName, originalFunction] for uninstrument().
-    this._patched = [];
-  }
-
-  // No-op (and never throws) if the instrumentor's internals have changed shape —
-  // the worst case is missing input messages, never a crash.
-  instrument(instrumentation) {
-    if (!instrumentation) return;
-    const original = instrumentation._startSpan;
-    if (typeof original !== 'function') return;
-
-    instrumentation._startSpan = function startSpanWithInputMessages(request) {
-      const span = original.call(this, request);
-      try {
-        const attributes = span && span.attributes;
-        if (attributes && attributes['gen_ai.input.messages'] == null) {
-          const body =
-            request && request.params && request.params.input && request.params.input.body;
-          const messages = _inputMessagesFromRequestBody(body);
-          if (messages.length) {
-            span.setAttribute('gen_ai.input.messages', JSON.stringify(messages));
-          }
-        }
-      } catch {
-        // Never break span creation over an enrichment failure.
-      }
-      return span;
-    };
-    this._patched.push([instrumentation, '_startSpan', original]);
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-}
-
-module.exports = { BedrockInputMessageContentInstrumentor };

package/src/instrumentation/bedrock/get_streaming_output_message_telemetry.js

@@ -1,87 +0,0 @@
-'use strict';
-
-/**
- * Streamed-output message content for the Bedrock invoke_model stream span.
- *
- * `@traceloop/instrumentation-bedrock` accumulates the streamed text but formats
- * the final `gen_ai.output.messages` by passing that string through its chat
- * block mapper, which only accepts block arrays — so streamed Nova spans end up
- * with an assistant message whose `parts` is empty. This complement wraps the
- * instrumentor's per-chunk `_handleNovaStreamingMetadata(span, parsedResponse)`
- * hook: it accumulates the `contentBlockDelta` text and the `messageStop` stop
- * reason itself, and re-stamps a correct output message when the trailing
- * `metadata` chunk (always last in a Nova stream) arrives — after the
- * instrumentor has written its empty-parts message. The span processor strips
- * the attribute when message-content capture is disabled.
- */
-
-// Nova stop reasons mapped to the OTel finish_reason values the instrumentor
-// uses on non-streamed spans, so streamed and non-streamed rows normalize alike.
-const FINISH_REASON_BY_STOP_REASON = {
-  end_turn: 'stop',
-  stop_sequence: 'stop',
-  max_tokens: 'length',
-  tool_use: 'tool_call',
-};
-
-class BedrockStreamingOutputMessageInstrumentor {
-  constructor() {
-    // [instrumentation, methodName, originalFunction] for uninstrument().
-    this._patched = [];
-    // span -> {text, stopReason} accumulated across the stream's chunks.
-    this._streamStateBySpan = new WeakMap();
-  }
-
-  // No-op (and never throws) if the instrumentor's internals have changed shape —
-  // the worst case is an empty streamed output message, never a crash.
-  instrument(instrumentation) {
-    if (!instrumentation) return;
-    const original = instrumentation._handleNovaStreamingMetadata;
-    if (typeof original !== 'function') return;
-
-    const streamStateBySpan = this._streamStateBySpan;
-    instrumentation._handleNovaStreamingMetadata = function handleWithOutputMessage(
-      span,
-      parsedResponse
-    ) {
-      try {
-        const state = streamStateBySpan.get(span) || { text: '', stopReason: null };
-        const delta =
-          parsedResponse &&
-          parsedResponse.contentBlockDelta &&
-          parsedResponse.contentBlockDelta.delta &&
-          parsedResponse.contentBlockDelta.delta.text;
-        if (typeof delta === 'string') state.text += delta;
-        const stopReason =
-          parsedResponse && parsedResponse.messageStop && parsedResponse.messageStop.stopReason;
-        if (stopReason != null) state.stopReason = stopReason;
-        streamStateBySpan.set(span, state);
-
-        if (parsedResponse && parsedResponse.metadata && state.text) {
-          const message = {
-            role: 'assistant',
-            parts: [{ type: 'text', content: state.text }],
-          };
-          if (state.stopReason != null) {
-            message.finish_reason =
-              FINISH_REASON_BY_STOP_REASON[state.stopReason] || state.stopReason;
-          }
-          span.setAttribute('gen_ai.output.messages', JSON.stringify([message]));
-        }
-      } catch {
-        // Never break the caller's stream over an enrichment failure.
-      }
-      return original.call(this, span, parsedResponse);
-    };
-    this._patched.push([instrumentation, '_handleNovaStreamingMetadata', original]);
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-}
-
-module.exports = { BedrockStreamingOutputMessageInstrumentor };

package/src/instrumentation/bedrock/set_telemetry_attributes.js

@@ -1,36 +0,0 @@
-'use strict';
-
-/**
- * Bedrock telemetry complement — the registered orchestrator.
- *
- * Wires the weflayr-supplied patches the traceloop Bedrock instrumentor misses:
- * cached-prompt token counts on the invoke_model span (Nova returns them in the
- * response body but traceloop never reads them) and the streamed output message
- * content (its stream path formats an empty-parts message).
- */
-
-const { BedrockPromptCachingInstrumentor } = require('./get_cache_telemetry');
-const { BedrockInputMessageContentInstrumentor } = require('./get_input_message_content_telemetry');
-const {
-  BedrockStreamingOutputMessageInstrumentor,
-} = require('./get_streaming_output_message_telemetry');
-
-class BedrockTelemetryInstrumentor {
-  constructor() {
-    this._subInstrumentors = [
-      new BedrockPromptCachingInstrumentor(),
-      new BedrockInputMessageContentInstrumentor(),
-      new BedrockStreamingOutputMessageInstrumentor(),
-    ];
-  }
-
-  instrument(instrumentation) {
-    for (const sub of this._subInstrumentors) sub.instrument(instrumentation);
-  }
-
-  uninstrument() {
-    for (const sub of this._subInstrumentors) sub.uninstrument();
-  }
-}
-
-module.exports = { BedrockTelemetryInstrumentor };

package/src/instrumentation/cohere/get_chat_telemetry.js

@@ -1,88 +0,0 @@
-'use strict';
-
-/**
- * Chat token-usage enrichment complement for the Cohere v1 chat path.
- *
- * `@traceloop/instrumentation-cohere` creates the `cohere.chat` span but reads
- * token usage from the obsolete `result.token_count.{prompt,response}_tokens`
- * shape; modern cohere-ai returns usage under `meta.billedUnits` instead, so the
- * traceloop span ends up with zero chat tokens. This thin complement backfills
- * `gen_ai.usage.{input,output}_tokens` from `meta.billedUnits`, the same source
- * traceloop already uses for the `generate` endpoint — bringing Node chat tokens
- * to parity with the Python SDK (OpenLLMetry captures them natively, so there is
- * no Python counterpart).
- *
- * It hooks the internal `CohereClient.prototype.__chat` (which the public `chat`
- * delegates to synchronously) rather than the public `chat`: traceloop wraps
- * `chat` and opens the span around it, so `__chat` runs while that span is the
- * active span — letting this complement enrich it regardless of patch order.
- */
-
-const { trace } = require('@opentelemetry/api');
-
-function _billedUnits(result) {
-  // Public `chat` resolves to the response body, but `__chat` resolves to the
-  // Fern wrapper `{ data, rawResponse }`; read billedUnits off either shape.
-  const response = result && result.data ? result.data : result;
-  return response && response.meta ? response.meta.billedUnits : undefined;
-}
-
-function _setChatTokenUsage(span, result) {
-  const billedUnits = _billedUnits(result);
-  if (!billedUnits) return;
-  if (typeof billedUnits.inputTokens === 'number') {
-    span.setAttribute('gen_ai.usage.input_tokens', billedUnits.inputTokens);
-  }
-  if (typeof billedUnits.outputTokens === 'number') {
-    span.setAttribute('gen_ai.usage.output_tokens', billedUnits.outputTokens);
-  }
-}
-
-class CohereChatTokenUsageInstrumentor {
-  constructor() {
-    // [ownerPrototype, methodName, originalFunction] for uninstrument().
-    this._patched = [];
-  }
-
-  instrument() {
-    let CohereClient;
-    try {
-      ({ CohereClient } = require('cohere-ai/Client'));
-    } catch (err) {
-      throw new Error(
-        'weflayr.autoInstrument(COHERE): the cohere-ai client is not installed. ' +
-          'Install it with: npm install cohere-ai\n' +
-          `Underlying error: ${err.message}`
-      );
-    }
-
-    this._wrap(CohereClient.prototype, '__chat');
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-
-  _wrap(owner, methodName) {
-    const original = owner[methodName];
-
-    function wrapper(...args) {
-      // Captured synchronously, while traceloop's chat span is still active.
-      const span = trace.getActiveSpan();
-      const result = original.apply(this, args);
-      if (!span || !span.isRecording || !span.isRecording()) return result;
-      return Promise.resolve(result).then((response) => {
-        _setChatTokenUsage(span, response);
-        return response;
-      });
-    }
-
-    owner[methodName] = wrapper;
-    this._patched.push([owner, methodName, original]);
-  }
-}
-
-module.exports = { CohereChatTokenUsageInstrumentor };

package/src/instrumentation/cohere/get_embeddings_telemetry.js

@@ -1,107 +0,0 @@
-'use strict';
-
-/**
- * Hand-written OTel instrumentor for the Cohere embeddings endpoint.
- *
- * `@traceloop/instrumentation-cohere` (the package weflayr uses for Cohere on
- * Node) wraps chat/generate/rerank but not `embed`, so this ships inside weflayr
- * to cover it. OpenLLMetry's cohere instrumentor doesn't cover `embed` either, so
- * the Python SDK has a mirror complement (`cohere_embeddings.py`) shaped to
- * normalize identically. It is registered alongside the traceloop instrumentor
- * whenever `autoInstrument({ aiSdks: 'cohere' })` runs.
- *
- * Embeddings are billed per input token, so the span records the input tokens
- * Cohere returns under `gen_ai.usage.input_tokens`; there is no completion.
- */
-
-const { trace, SpanStatusCode } = require('@opentelemetry/api');
-
-const TRACER_NAME = 'weflayr.instrumentation.cohere_embeddings';
-// Matches the gen_ai.system the cohere chat instrumentors set (Python + Node).
-const SYSTEM = 'Cohere';
-const EMBEDDINGS_OPERATION = 'embeddings';
-
-function _recordError(span, error) {
-  span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message ?? String(error) });
-  span.recordException(error);
-}
-
-function _wrapEmbed(owner, patched) {
-  const original = owner.embed;
-
-  function wrapper(request, ...rest) {
-    const span = trace.getTracer(TRACER_NAME).startSpan(EMBEDDINGS_OPERATION);
-    span.setAttribute('gen_ai.system', SYSTEM);
-    span.setAttribute('gen_ai.operation.name', EMBEDDINGS_OPERATION);
-    if (request && request.model) {
-      span.setAttribute('gen_ai.request.model', request.model);
-    }
-    // The embedded texts are the prompt; stamp one user message per text, like
-    // the chat path. The span processor strips it when content capture is off.
-    if (request && Array.isArray(request.texts) && request.texts.length) {
-      span.setAttribute(
-        'gen_ai.input.messages',
-        JSON.stringify(
-          request.texts.map((text) => ({ role: 'user', parts: [{ type: 'text', content: text }] }))
-        )
-      );
-    }
-    return Promise.resolve(original.call(this, request, ...rest)).then(
-      (response) => {
-        // Node SDK reports the billed input tokens under camelCase keys.
-        const inputTokens =
-          response?.meta?.billedUnits?.inputTokens ?? response?.meta?.tokens?.inputTokens;
-        if (inputTokens != null) {
-          span.setAttribute('gen_ai.usage.input_tokens', inputTokens);
-        }
-        span.end();
-        return response;
-      },
-      (error) => {
-        _recordError(span, error);
-        span.end();
-        throw error;
-      }
-    );
-  }
-
-  owner.embed = wrapper;
-  patched.push([owner, 'embed', original]);
-}
-
-class CohereEmbeddingsInstrumentor {
-  constructor() {
-    // [ownerPrototype, methodName, originalFunction] for uninstrument().
-    this._patched = [];
-  }
-
-  instrument() {
-    let CohereClient;
-    let V2Client;
-    try {
-      // v1 `embed` is a prototype method on CohereClient; v2 `embed` lives on
-      // V2Client.prototype (CohereClientV2 binds it as an instance property, so
-      // it must be patched on the underlying V2Client class instead).
-      ({ CohereClient } = require('cohere-ai/Client'));
-      ({ V2Client } = require('cohere-ai/api/resources/v2/client/Client'));
-    } catch (err) {
-      throw new Error(
-        'weflayr.autoInstrument(COHERE): the cohere-ai client is not installed. ' +
-          'Install it with: npm install cohere-ai\n' +
-          `Underlying error: ${err.message}`
-      );
-    }
-
-    _wrapEmbed(CohereClient.prototype, this._patched);
-    _wrapEmbed(V2Client.prototype, this._patched);
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-}
-
-module.exports = { CohereEmbeddingsInstrumentor };

package/src/instrumentation/cohere/set_telemetry_attributes.js

@@ -1,32 +0,0 @@
-'use strict';
-
-/**
- * Cohere telemetry complement — the registered orchestrator.
- *
- * Wires the weflayr-supplied patches the traceloop Cohere instrumentor misses:
- *   - chat token usage (traceloop reads the obsolete usage shape and records
- *     zero chat tokens), and
- *   - the embeddings endpoint it doesn't cover.
- */
-
-const { CohereChatTokenUsageInstrumentor } = require('./get_chat_telemetry');
-const { CohereEmbeddingsInstrumentor } = require('./get_embeddings_telemetry');
-
-class CohereTelemetryInstrumentor {
-  constructor() {
-    this._subInstrumentors = [
-      new CohereChatTokenUsageInstrumentor(),
-      new CohereEmbeddingsInstrumentor(),
-    ];
-  }
-
-  instrument(instrumentation) {
-    for (const sub of this._subInstrumentors) sub.instrument(instrumentation);
-  }
-
-  uninstrument() {
-    for (const sub of this._subInstrumentors) sub.uninstrument();
-  }
-}
-
-module.exports = { CohereTelemetryInstrumentor };

package/src/instrumentation/elevenlabs/full_instrumentation.js

@@ -1,236 +0,0 @@
-'use strict';
-
-/**
- * Hand-written OTel instrumentor for the ElevenLabs audio clients.
- *
- * No official OpenTelemetry instrumentor exists for the ElevenLabs SDK (it's
- * audio, not an LLM), so this ships inside weflayr. It wraps the Text-to-Speech
- * and Speech-to-Text entrypoints to emit one `gen_ai.*` span per call, which
- * flows through the standard span processor -> exporter with no new transport code.
- *
- * The billable unit differs by API, so each span records the one ElevenLabs bills:
- *   - Text-to-Speech is billed per input character -> `gen_ai.usage.input_characters`.
- *   - Speech-to-Text is billed per second of audio  -> `gen_ai.usage.input_seconds`.
- *
- * Entrypoints come in three result shapes, independent of which API they belong to:
- *   - *byte stream* methods resolve to a `ReadableStream` of audio chunks;
- *   - *object stream* methods resolve to an async-iterable of chunk objects;
- *   - *unary* methods resolve to the full response.
- * The HTTP request -- plus any error -- only happens while a stream is awaited
- * and consumed, so the span is started eagerly (to capture the
- * `propagateMetadata` context active at the call site) and ended once the result
- * is exhausted (streams) or returned (unary), giving an `elapsed_ms` that covers
- * the whole call. The per-second billable unit is read off the STT response.
- */
-
-const { trace, SpanStatusCode } = require('@opentelemetry/api');
-
-const TRACER_NAME = 'weflayr.instrumentation.elevenlabs';
-const SYSTEM = 'elevenlabs';
-const TTS_OPERATION = 'text_to_speech';
-const STT_OPERATION = 'speech_to_text';
-
-function _startSpan(operation, request) {
-  const span = trace.getTracer(TRACER_NAME).startSpan(operation);
-  span.setAttribute('gen_ai.system', SYSTEM);
-  span.setAttribute('gen_ai.operation.name', operation);
-  // `modelId` lives on the request body passed to every audio entrypoint.
-  const modelId = request && request.modelId;
-  if (modelId) {
-    span.setAttribute('gen_ai.request.model', modelId);
-  }
-  return span;
-}
-
-function _setInputCharacters(span, request) {
-  // `text` lives on the request body of every TTS entrypoint; the billable unit
-  // is its length.
-  span.setAttribute('gen_ai.usage.input_characters', ((request && request.text) || '').length);
-}
-
-function _setAudioDuration(span, response) {
-  // The transcription response exposes the transcribed audio length in seconds.
-  const durationSecs = response && response.audioDurationSecs;
-  if (durationSecs != null) {
-    span.setAttribute('gen_ai.usage.input_seconds', durationSecs);
-  }
-}
-
-function _recordError(span, error) {
-  span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message ?? String(error) });
-  span.recordException(error);
-}
-
-// Proxy a `ReadableStream` of audio bytes so the span ends -- and any error is
-// recorded -- once the whole stream has been consumed (or the consumer cancels).
-// The span ends exactly once across every exit path.
-function _consumeByteStream(span, responsePromise) {
-  let ended = false;
-  const end = () => {
-    if (ended) return;
-    ended = true;
-    span.end();
-  };
-
-  return responsePromise.then(
-    (audioStream) => {
-      const reader = audioStream.getReader();
-      return new ReadableStream({
-        async pull(controller) {
-          try {
-            const { done, value } = await reader.read();
-            if (done) {
-              end();
-              controller.close();
-              return;
-            }
-            controller.enqueue(value);
-          } catch (error) {
-            _recordError(span, error);
-            end();
-            controller.error(error);
-          }
-        },
-        cancel(reason) {
-          end();
-          return reader.cancel(reason);
-        },
-      });
-    },
-    (error) => {
-      _recordError(span, error);
-      end();
-      throw error;
-    }
-  );
-}
-
-// Proxy an async-iterable of chunk objects (the streaming "with timestamps"
-// variant) so the span ends once iteration completes.
-function _consumeObjectStream(span, responsePromise) {
-  async function* iterate(stream) {
-    try {
-      for await (const chunk of stream) {
-        yield chunk;
-      }
-    } catch (error) {
-      _recordError(span, error);
-      throw error;
-    } finally {
-      span.end();
-    }
-  }
-
-  return responsePromise.then(
-    (stream) => iterate(stream),
-    (error) => {
-      _recordError(span, error);
-      span.end();
-      throw error;
-    }
-  );
-}
-
-// Wrap a request/response entrypoint: the span spans the single call, and any
-// response-derived billable unit is read off the result.
-function _consumeUnary(span, responsePromise, setResponseAttributes) {
-  return responsePromise.then(
-    (response) => {
-      if (setResponseAttributes) {
-        setResponseAttributes(span, response);
-      }
-      span.end();
-      return response;
-    },
-    (error) => {
-      _recordError(span, error);
-      span.end();
-      throw error;
-    }
-  );
-}
-
-class ElevenLabsInstrumentor {
-  constructor() {
-    // [ownerPrototype, methodName, originalFunction] for uninstrument().
-    this._patched = [];
-  }
-
-  instrument() {
-    let TextToSpeechClient;
-    let SpeechToTextClient;
-    try {
-      ({
-        TextToSpeechClient,
-      } = require('@elevenlabs/elevenlabs-js/api/resources/textToSpeech/client/Client'));
-      ({
-        SpeechToTextClient,
-      } = require('@elevenlabs/elevenlabs-js/api/resources/speechToText/client/Client'));
-    } catch (err) {
-      throw new Error(
-        'weflayr.autoInstrument(ELEVENLABS): the @elevenlabs/elevenlabs-js client is not ' +
-          'installed. Install it with: npm install @elevenlabs/elevenlabs-js\n' +
-          `Underlying error: ${err.message}`
-      );
-    }
-
-    // TTS — request body is the 2nd arg (after voice_id); billed per character.
-    this._wrap(TextToSpeechClient.prototype, 'convert', {
-      operation: TTS_OPERATION,
-      requestArgIndex: 1,
-      setRequestAttributes: _setInputCharacters,
-      consume: _consumeByteStream,
-    });
-    this._wrap(TextToSpeechClient.prototype, 'stream', {
-      operation: TTS_OPERATION,
-      requestArgIndex: 1,
-      setRequestAttributes: _setInputCharacters,
-      consume: _consumeByteStream,
-    });
-    this._wrap(TextToSpeechClient.prototype, 'streamWithTimestamps', {
-      operation: TTS_OPERATION,
-      requestArgIndex: 1,
-      setRequestAttributes: _setInputCharacters,
-      consume: _consumeObjectStream,
-    });
-    this._wrap(TextToSpeechClient.prototype, 'convertWithTimestamps', {
-      operation: TTS_OPERATION,
-      requestArgIndex: 1,
-      setRequestAttributes: _setInputCharacters,
-      consume: (span, responsePromise) => _consumeUnary(span, responsePromise, null),
-    });
-
-    // STT — request body is the 1st arg; billed per second of audio.
-    this._wrap(SpeechToTextClient.prototype, 'convert', {
-      operation: STT_OPERATION,
-      requestArgIndex: 0,
-      setRequestAttributes: null,
-      consume: (span, responsePromise) => _consumeUnary(span, responsePromise, _setAudioDuration),
-    });
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-
-  _wrap(owner, methodName, { operation, requestArgIndex, setRequestAttributes, consume }) {
-    const original = owner[methodName];
-
-    function wrapper(...args) {
-      const request = args[requestArgIndex];
-      const span = _startSpan(operation, request);
-      if (setRequestAttributes) {
-        setRequestAttributes(span, request);
-      }
-      return consume(span, original.apply(this, args));
-    }
-
-    owner[methodName] = wrapper;
-    this._patched.push([owner, methodName, original]);
-  }
-}
-
-module.exports = { ElevenLabsInstrumentor };