weflayr 0.20.6 → 0.22.0

package/src/instrumentation/google/set_telemetry_attributes.js

@@ -0,0 +1,98 @@
+'use strict';
+
+/**
+ * Google GenAI (Gemini) telemetry complement — the registered orchestrator.
+ *
+ * Wires every weflayr-supplied patch the traceloop Google instrumentor misses:
+ *   - chat span enrichment (one wrap of generateContent{,Stream}Internal that
+ *     stamps provider name + audio tokens + cache tokens — see the get_*_telemetry
+ *     files), and
+ *   - the embeddings endpoint it doesn't cover at all.
+ *
+ * The public arrows delegate to these private prototype methods while the
+ * traceloop span is the active span, so enrichment lands on that span.
+ */
+
+const { trace } = require('@opentelemetry/api');
+
+const { getProviderName } = require('./get_provider_name');
+const { setAudioTelemetry } = require('./get_audio_telemetry');
+const { setCacheTelemetry } = require('./get_cache_telemetry');
+const { setReasoningTelemetry } = require('./get_reasoning_telemetry');
+const { instrumentEmbeddings } = require('./get_embeddings_telemetry');
+
+class GoogleTelemetryInstrumentor {
+  constructor() {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  instrument() {
+    let Models;
+    try {
+      ({ Models } = require('@google/genai'));
+    } catch (err) {
+      throw new Error(
+        'weflayr.autoInstrument(GOOGLE_GENAI): the @google/genai client is not installed. ' +
+          'Install it with: npm install @google/genai\n' +
+          `Underlying error: ${err.message}`
+      );
+    }
+
+    // Non-streaming: stamp provider up front, audio + cache tokens off the response.
+    this._wrapChat(Models.prototype, 'generateContentInternal', { stream: false });
+    // Streaming: stamp provider, then cache tokens off the final chunk's usageMetadata.
+    this._wrapChat(Models.prototype, 'generateContentStreamInternal', { stream: true });
+    // Embeddings: an endpoint the traceloop instrumentor doesn't cover at all.
+    instrumentEmbeddings(Models, this._patched);
+  }
+
+  _wrapChat(owner, methodName, { stream }) {
+    const original = owner[methodName];
+
+    function wrapper(...args) {
+      const span = trace.getActiveSpan();
+      if (!span || !span.isRecording || !span.isRecording()) {
+        return original.apply(this, args);
+      }
+      span.setAttribute('gen_ai.system', getProviderName(this));
+      if (!stream) {
+        return Promise.resolve(original.apply(this, args)).then((response) => {
+          setAudioTelemetry(span, response);
+          setCacheTelemetry(span, response);
+          setReasoningTelemetry(span, response);
+          return response;
+        });
+      }
+      // Streamed: usage (incl. cachedContentTokenCount) lands on the final chunk;
+      // observe the chunks as they pass through. The instrumentor keeps the span
+      // open until the stream is exhausted.
+      return Promise.resolve(original.apply(this, args)).then((stream_) => {
+        if (!stream_ || typeof stream_[Symbol.asyncIterator] !== 'function') return stream_;
+        return (async function* observeCache() {
+          for await (const chunk of stream_) {
+            try {
+              setCacheTelemetry(span, chunk);
+              setReasoningTelemetry(span, chunk);
+            } catch {
+              // Never break the caller's stream over an enrichment failure.
+            }
+            yield chunk;
+          }
+        })();
+      });
+    }
+
+    owner[methodName] = wrapper;
+    this._patched.push([owner, methodName, original]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { GoogleTelemetryInstrumentor };

package/src/instrumentation/openai/get_audio_telemetry.js

@@ -0,0 +1,149 @@
+'use strict';
+
+/**
+ * Hand-written OTel instrumentor for the OpenAI audio endpoints.
+ *
+ * The `@traceloop/instrumentation-openai` package wraps OpenAI's chat,
+ * completions, responses and image endpoints, but not the audio ones, so this
+ * ships inside weflayr to cover them. 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. It
+ * is registered alongside the traceloop instrumentor whenever
+ * `autoInstrument({ aiSdks: 'openai' })` runs.
+ *
+ * The billable unit differs by API, so each span records the one OpenAI 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`.
+ *
+ * Both endpoints are request/response (unary): `audio.speech.create` resolves to
+ * the full audio and `audio.transcriptions.create` to the transcription. The STT
+ * audio length is only present when the call requests `response_format: 'verbose_json'`.
+ */
+
+const { trace, SpanStatusCode } = require('@opentelemetry/api');
+
+const TRACER_NAME = 'weflayr.instrumentation.openai_audio';
+const TTS_OPERATION = 'text_to_speech';
+const STT_OPERATION = 'speech_to_text';
+
+// Return the gen_ai.system for this call, matching how the OpenAI chat
+// instrumentor attributes the vendor: Azure clients (reached via the same openai
+// SDK) report `azure.ai.openai`, everything else `openai`.
+function _detectSystem(instance) {
+  const baseURL = (instance && instance._client && instance._client.baseURL) || '';
+  return baseURL.toLowerCase().includes('openai.azure.com') ? 'azure.ai.openai' : 'openai';
+}
+
+function _startSpan(operation, body, system) {
+  const span = trace.getTracer(TRACER_NAME).startSpan(operation);
+  span.setAttribute('gen_ai.system', system);
+  span.setAttribute('gen_ai.operation.name', operation);
+  // `model` lives on the request body passed to both audio entrypoints.
+  const model = body && body.model;
+  if (model) {
+    span.setAttribute('gen_ai.request.model', model);
+  }
+  return span;
+}
+
+function _setInputCharacters(span, body) {
+  // `input` is the text passed to text_to_speech; the billable unit is its length.
+  span.setAttribute('gen_ai.usage.input_characters', ((body && body.input) || '').length);
+}
+
+function _setAudioDuration(span, response) {
+  // `duration` (seconds) is only present on a verbose transcription response;
+  // it is the billable unit for speech-to-text.
+  const durationSecs = response && response.duration;
+  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);
+}
+
+// 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 OpenAIAudioInstrumentor {
+  constructor() {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  instrument() {
+    let Speech;
+    let Transcriptions;
+    try {
+      ({ Speech } = require('openai/resources/audio/speech'));
+      ({ Transcriptions } = require('openai/resources/audio/transcriptions'));
+    } catch (err) {
+      throw new Error(
+        'weflayr.autoInstrument(OPENAI): the openai client is not installed. ' +
+          'Install it with: npm install openai\n' +
+          `Underlying error: ${err.message}`
+      );
+    }
+
+    // TTS — request body is the 1st arg; billed per character.
+    this._wrap(Speech.prototype, {
+      operation: TTS_OPERATION,
+      setRequestAttributes: _setInputCharacters,
+      setResponseAttributes: null,
+    });
+
+    // STT — request body is the 1st arg; billed per second of audio.
+    this._wrap(Transcriptions.prototype, {
+      operation: STT_OPERATION,
+      setRequestAttributes: null,
+      setResponseAttributes: _setAudioDuration,
+    });
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+
+  _wrap(owner, { operation, setRequestAttributes, setResponseAttributes }) {
+    const original = owner.create;
+
+    function wrapper(body, ...rest) {
+      const span = _startSpan(operation, body, _detectSystem(this));
+      if (setRequestAttributes) {
+        setRequestAttributes(span, body);
+      }
+      return _consumeUnary(
+        span,
+        Promise.resolve(original.call(this, body, ...rest)),
+        setResponseAttributes
+      );
+    }
+
+    owner.create = wrapper;
+    this._patched.push([owner, 'create', original]);
+  }
+}
+
+module.exports = { OpenAIAudioInstrumentor };

package/src/instrumentation/openai/get_cache_and_reasoning_telemetry.js

@@ -0,0 +1,71 @@
+'use strict';
+
+/**
+ * Cached-prompt token enrichment complement for the non-streamed OpenAI chat path.
+ *
+ * `@traceloop/instrumentation-openai` records `gen_ai.usage.{input,output}_tokens`
+ * for non-streamed calls but never reads `usage.prompt_tokens_details.cached_tokens`,
+ * so spans for prompt-cache hits carry no cached-token count. The Python
+ * OpenLLMetry instrumentor sets `gen_ai.usage.cache_read_input_tokens` from that
+ * field, so this brings the Node SDK to parity.
+ *
+ * It wraps the instrumentor instance's `_endSpan({ span, type, result })`, which
+ * finalizes the span after the response resolves, letting us stamp the
+ * cached-token count off `result.usage` while the span is still open. OpenAI has
+ * no separate cache-write count, so only `cache_read_input_tokens` is set.
+ *
+ * The same hook surfaces the reasoning-token count: reasoning models report it as
+ * `usage.completion_tokens_details.reasoning_tokens` (a subset of output_tokens)
+ * which the Node instrumentor drops, so this stamps the flat `reasoning_tokens`
+ * attribute (the form the Python instrumentor emits and the normalizer reads).
+ */
+
+const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
+const REASONING_TOKENS_ATTR = 'gen_ai.usage.reasoning_tokens';
+
+class OpenAIPromptCachingInstrumentor {
+  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 a missing cached-token count, never a crash.
+  instrument(instrumentation) {
+    const original = instrumentation && instrumentation._endSpan;
+    if (typeof original !== 'function') return;
+
+    instrumentation._endSpan = function endSpanWithCache(args) {
+      try {
+        const span = args && args.span;
+        const usage = args && args.result && args.result.usage;
+        const recording = span && span.isRecording && span.isRecording();
+        const cachedTokens =
+          usage && usage.prompt_tokens_details && usage.prompt_tokens_details.cached_tokens;
+        if (cachedTokens && recording) {
+          span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, cachedTokens);
+        }
+        const reasoningTokens =
+          usage &&
+          usage.completion_tokens_details &&
+          usage.completion_tokens_details.reasoning_tokens;
+        if (reasoningTokens && recording) {
+          span.setAttribute(REASONING_TOKENS_ATTR, reasoningTokens);
+        }
+      } catch {
+        // Never break span finalization over an enrichment failure.
+      }
+      return original.call(this, args);
+    };
+    this._patched.push([instrumentation, '_endSpan', original]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { OpenAIPromptCachingInstrumentor };

package/src/instrumentation/openai/get_embeddings_telemetry.js

@@ -0,0 +1,107 @@
+'use strict';
+
+/**
+ * Hand-written OTel instrumentor for the OpenAI embeddings endpoint.
+ *
+ * `@traceloop/instrumentation-openai` (the package weflayr uses for OpenAI on
+ * Node) does not wrap the embeddings endpoint, so this ships inside weflayr to
+ * cover it. The Python SDK gets embeddings for free from OpenLLMetry's
+ * instrumentor, so there is no Python counterpart to this file — but the span it
+ * emits is shaped to normalize identically. It is registered alongside the
+ * traceloop instrumentor whenever `autoInstrument({ aiSdks: 'openai' })` runs.
+ *
+ * Embeddings are billed per input token, so the span records the prompt tokens
+ * read off the response under `gen_ai.usage.input_tokens`; there is no completion.
+ */
+
+const { trace, SpanStatusCode } = require('@opentelemetry/api');
+
+const TRACER_NAME = 'weflayr.instrumentation.openai_embeddings';
+const EMBEDDINGS_OPERATION = 'embeddings';
+
+// Return the gen_ai.system for this call, matching how the OpenAI chat
+// instrumentor attributes the vendor: Azure clients (reached via the same openai
+// SDK) report `azure.ai.openai`, everything else `openai`.
+function _detectSystem(instance) {
+  const baseURL = (instance && instance._client && instance._client.baseURL) || '';
+  return baseURL.toLowerCase().includes('openai.azure.com') ? 'azure.ai.openai' : 'openai';
+}
+
+function _recordError(span, error) {
+  span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message ?? String(error) });
+  span.recordException(error);
+}
+
+class OpenAIEmbeddingsInstrumentor {
+  constructor() {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  instrument() {
+    let Embeddings;
+    try {
+      ({ Embeddings } = require('openai/resources/embeddings'));
+    } catch (err) {
+      throw new Error(
+        'weflayr.autoInstrument(OPENAI): the openai client is not installed. ' +
+          'Install it with: npm install openai\n' +
+          `Underlying error: ${err.message}`
+      );
+    }
+
+    const owner = Embeddings.prototype;
+    const original = owner.create;
+
+    function wrapper(body, ...rest) {
+      const span = trace.getTracer(TRACER_NAME).startSpan(EMBEDDINGS_OPERATION);
+      span.setAttribute('gen_ai.system', _detectSystem(this));
+      span.setAttribute('gen_ai.operation.name', EMBEDDINGS_OPERATION);
+      if (body && body.model) {
+        span.setAttribute('gen_ai.request.model', body.model);
+      }
+      // One user message per input element, matching the shape the chat
+      // instrumentors emit. The span processor strips it when message-content
+      // capture is disabled.
+      if (body && body.input != null) {
+        const inputs = Array.isArray(body.input) ? body.input : [body.input];
+        span.setAttribute(
+          'gen_ai.input.messages',
+          JSON.stringify(
+            inputs.map((content) => ({ role: 'user', parts: [{ type: 'text', content }] }))
+          )
+        );
+      }
+      return Promise.resolve(original.call(this, body, ...rest)).then(
+        (response) => {
+          if (response && response.model) {
+            span.setAttribute('gen_ai.response.model', response.model);
+          }
+          const promptTokens = response && response.usage && response.usage.prompt_tokens;
+          if (promptTokens != null) {
+            span.setAttribute('gen_ai.usage.input_tokens', promptTokens);
+          }
+          span.end();
+          return response;
+        },
+        (error) => {
+          _recordError(span, error);
+          span.end();
+          throw error;
+        }
+      );
+    }
+
+    owner.create = wrapper;
+    this._patched.push([owner, 'create', original]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { OpenAIEmbeddingsInstrumentor };

package/src/instrumentation/openai/get_streaming_usage.js

@@ -0,0 +1,81 @@
+'use strict';
+
+/**
+ * Streamed token-usage enrichment complement for the OpenAI chat path.
+ *
+ * `@traceloop/instrumentation-openai` does not record token usage for streamed
+ * calls: its stream handler accumulates `choices[].delta` but never reads the
+ * final usage chunk OpenAI sends when the request sets
+ * `stream_options: { include_usage: true }`. Non-streaming calls work because
+ * OpenAI returns `usage` in the response body, which the instrumentor reads
+ * directly. The Python OpenLLMetry instrumentor reads the streamed usage, so
+ * this gap is Node-only.
+ *
+ * It wraps the instrumentor instance's `_streamingWrapPromise`: that handler
+ * hands us the span and ends it only after its chunk loop, so when the usage
+ * chunk arrives the span is still open and we set the same `gen_ai.usage.*`
+ * attributes the instrumentor sets for non-streaming calls.
+ */
+
+const USAGE_INPUT_TOKENS_ATTR = 'gen_ai.usage.input_tokens';
+const USAGE_OUTPUT_TOKENS_ATTR = 'gen_ai.usage.output_tokens';
+const USAGE_TOTAL_TOKENS_ATTR = 'gen_ai.usage.total_tokens';
+const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
+
+function _setUsageAttributes(span, usage) {
+  if (typeof usage.prompt_tokens === 'number') {
+    span.setAttribute(USAGE_INPUT_TOKENS_ATTR, usage.prompt_tokens);
+  }
+  if (typeof usage.completion_tokens === 'number') {
+    span.setAttribute(USAGE_OUTPUT_TOKENS_ATTR, usage.completion_tokens);
+  }
+  if (typeof usage.total_tokens === 'number') {
+    span.setAttribute(USAGE_TOTAL_TOKENS_ATTR, usage.total_tokens);
+  }
+  // Cached-prompt tokens ride in the same streamed usage chunk; mirror the
+  // non-streamed cache backfill in get_cache_and_reasoning_telemetry.js.
+  const cachedTokens = usage.prompt_tokens_details && usage.prompt_tokens_details.cached_tokens;
+  if (cachedTokens) {
+    span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, cachedTokens);
+  }
+}
+
+class OpenAIStreamingUsageInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  // No-op if the instrumentor's internals have changed shape — the worst case is
+  // streamed spans without token counts, never a crash.
+  instrument(instrumentation) {
+    const original = instrumentation && instrumentation._streamingWrapPromise;
+    if (typeof original !== 'function') return;
+
+    instrumentation._streamingWrapPromise = function streamingWrapWithUsage(streamArgs) {
+      const span = streamArgs && streamArgs.span;
+      const wrappedStream = original.call(this, streamArgs);
+      if (!span) return wrappedStream;
+
+      return (async function* backfillUsage() {
+        for await (const chunk of wrappedStream) {
+          const usage = chunk && chunk.usage;
+          if (usage && span.isRecording()) {
+            _setUsageAttributes(span, usage);
+          }
+          yield chunk;
+        }
+      })();
+    };
+    this._patched.push([instrumentation, '_streamingWrapPromise', original]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { OpenAIStreamingUsageInstrumentor };

package/src/instrumentation/openai/set_telemetry_attributes.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * OpenAI telemetry complement — the registered orchestrator.
+ *
+ * Wires every weflayr-supplied patch the traceloop OpenAI instrumentor misses:
+ *   - the audio (TTS/STT) and embeddings endpoints it doesn't cover, and
+ *   - usage it drops on the chat endpoint it does cover: streamed token usage and
+ *     non-streamed cached-prompt tokens (these enrich the traceloop instrumentor
+ *     instance, hence the `instrumentation` argument).
+ */
+
+const { OpenAIAudioInstrumentor } = require('./get_audio_telemetry');
+const { OpenAIEmbeddingsInstrumentor } = require('./get_embeddings_telemetry');
+const { OpenAIStreamingUsageInstrumentor } = require('./get_streaming_usage');
+const { OpenAIPromptCachingInstrumentor } = require('./get_cache_and_reasoning_telemetry');
+
+class OpenAITelemetryInstrumentor {
+  constructor() {
+    this._subInstrumentors = [
+      new OpenAIAudioInstrumentor(),
+      new OpenAIEmbeddingsInstrumentor(),
+      new OpenAIStreamingUsageInstrumentor(),
+      new OpenAIPromptCachingInstrumentor(),
+    ];
+  }
+
+  // The endpoint complements ignore `instrumentation`; the streaming/cache ones
+  // patch its internal handlers.
+  instrument(instrumentation) {
+    for (const sub of this._subInstrumentors) sub.instrument(instrumentation);
+  }
+
+  uninstrument() {
+    for (const sub of this._subInstrumentors) sub.uninstrument();
+  }
+}
+
+module.exports = { OpenAITelemetryInstrumentor };

package/src/otel/exporter.js

@@ -77,7 +77,6 @@ function buildExporter({
   });
   const originalExport = exporter.export.bind(exporter);
   const wrappedExport = _exportWithRetry(originalExport, { maxRetries, maxRetryMs });
-  let warned = false;
   exporter.export = (spans, resultCallback) => {
     const start = Date.now();
     debug('exporter.export: posting count=%d', spans.length);
@@ -93,11 +92,7 @@ function buildExporter({
           result?.code,
           result?.error?.message || result?.error || '(none)'
         );
-        // Surface the first failure on stderr so users notice broken setups
-        // even without NODE_DEBUG=weflayr. Stay quiet after — repeated warns
-        // on a misconfigured key would just spam.
-        if (warnOnExportError && !warned) {
-          warned = true;
+        if (warnOnExportError) {
           // console.warn writes to stderr synchronously. process.emitWarning
           // is queued for the next tick, so a caller doing process.exit() from
           // their error handler races past it and the warning is lost.

package/src/otel/propagation.js

@@ -62,6 +62,11 @@ function _buildAttributes({ featureName, customerId, providerName, extraTags, sp
  * propagateMetadata call" contract.
  */
 function propagateMetadata(options, fn) {
+  const { featureName, customerId } = options ?? {};
+  if (featureName == null || customerId == null) {
+    throw new Error('propagateMetadata: `featureName` and `customerId` are required');
+  }
+
   if (typeof fn === 'function') {
     return _runWithMetadata(options, fn);
   }

package/src/otel/span-filter.js

@@ -27,18 +27,13 @@ const KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [
   'opentelemetry.instrumentation.google_generativeai',
   'opentelemetry.instrumentation.openai',
   'opentelemetry.instrumentation.openai_v2',
-  'opentelemetry.instrumentation.vertex_ai',
-  'opentelemetry.instrumentation.vertexai',
   'weflayr.instrumentation.elevenlabs',
   'strands-agents',
   'vllm',
   '@traceloop/instrumentation-openai',
   '@traceloop/instrumentation-anthropic',
   '@traceloop/instrumentation-bedrock',
-  '@traceloop/instrumentation-azure',
   '@traceloop/instrumentation-cohere',
-  '@traceloop/instrumentation-together',
-  '@traceloop/instrumentation-vertexai',
   '@traceloop/instrumentation-google-generativeai',
   '@traceloop/instrumentation-langchain',
   '@traceloop/instrumentation-llamaindex',

package/src/otel/span-processor.js

@@ -22,6 +22,29 @@ const { EXTRA_TAG_PREFIX, getMergedMetadataFromContext } = require('./propagatio
 const { isDefaultExportSpan, isKnownLLMInstrumentor } = require('./span-filter');
 const { debug } = require('../logger');
 
+// setup({captureMessageContent: ...}) records the choice in this env var (the
+// official OTel GenAI one). Instrumentors gate content on their own knobs
+// (openllmetry reads its own config and captures by default), so the processor
+// enforces the flag itself: when the env var is "false", message content is
+// stripped from every span before export.
+const CONTENT_CAPTURE_ENV = 'OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT';
+
+// The new-semconv JSON message attributes and the legacy indexed
+// `gen_ai.prompt.{i}.*` / `gen_ai.completion.{i}.*` attributes.
+const CONTENT_ATTRIBUTES = [
+  'gen_ai.input.messages',
+  'gen_ai.output.messages',
+  'gen_ai.system_instructions',
+];
+const CONTENT_ATTRIBUTE_PREFIXES = ['gen_ai.prompt.', 'gen_ai.completion.'];
+
+function _isContentAttribute(key) {
+  return (
+    CONTENT_ATTRIBUTES.includes(key) ||
+    CONTENT_ATTRIBUTE_PREFIXES.some((prefix) => key.startsWith(prefix))
+  );
+}
+
 class WeflayrSpanProcessor {
   constructor({ exporter, exportMode = 'batch', defaultTags = {}, mask, shouldExportSpan } = {}) {
     if (!exporter) {
@@ -77,6 +100,12 @@ class WeflayrSpanProcessor {
     }
     debug('span end: exporting name=%s scope=%s', span.name, span.instrumentationScope?.name);
 
+    if ((process.env[CONTENT_CAPTURE_ENV] || '').toLowerCase() === 'false') {
+      for (const key of Object.keys(span.attributes)) {
+        if (_isContentAttribute(key)) delete span.attributes[key];
+      }
+    }
+
     if (this._mask) {
       try {
         const masked = this._mask(span.attributes);
@@ -120,4 +149,4 @@ class WeflayrSpanProcessor {
   }
 }
 
-module.exports = { WeflayrSpanProcessor };
+module.exports = { CONTENT_CAPTURE_ENV, WeflayrSpanProcessor };

package/src/setup.js

@@ -5,13 +5,12 @@ const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
 const { resourceFromAttributes } = require('@opentelemetry/resources');
 
 const { buildExporter } = require('./otel/exporter');
-const { WeflayrSpanProcessor } = require('./otel/span-processor');
+const { CONTENT_CAPTURE_ENV, WeflayrSpanProcessor } = require('./otel/span-processor');
 const { debug } = require('./logger');
 const { version: SDK_VERSION } = require('../package.json');
 
 const SDK_LANGUAGE = 'javascript';
 const DEFAULT_BASE_URL = 'https://api.weflayr.com';
-const CONTENT_CAPTURE_ENV = 'OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT';
 
 const _state = {
   tracerProvider: null,