handle some edge cases

Author: RulaKhaled

packages/core/src/tracing/openai/index.ts

@@ -1,9 +1,11 @@
 import { getClient } from '../../currentScopes';
+import { DEBUG_BUILD } from '../../debug-build';
 import { captureException } from '../../exports';
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '../../semanticAttributes';
 import { SPAN_STATUS_ERROR } from '../../tracing';
 import { startSpan, startSpanManual } from '../../tracing/trace';
 import type { Span, SpanAttributeValue } from '../../types-hoist/span';
+import { debug } from '../../utils/debug-logger';
 import { isThenable } from '../../utils/is';
 import {
   GEN_AI_EMBEDDINGS_INPUT_ATTRIBUTE,
@@ -54,7 +56,16 @@ function extractAvailableTools(params: Record<string, unknown>): string | undefi
     : [];
 
   const availableTools = [...tools, ...webSearchOptions];
-  return availableTools.length > 0 ? JSON.stringify(availableTools) : undefined;
+  if (availableTools.length === 0) {
+    return undefined;
+  }
+
+  try {
+    return JSON.stringify(availableTools);
+  } catch (error) {
+    DEBUG_BUILD && debug.error('Failed to serialize OpenAI tools:', error);
+    return undefined;
+  }
 }
 
 /**
@@ -166,52 +177,50 @@ function addRequestAttributes(span: Span, params: Record<string, unknown>, opera
  * Creates a wrapped version of .withResponse() that replaces the data field
  * with the instrumented result while preserving metadata (response, request_id).
  */
-function createWithResponseWrapper<T>(
+async function createWithResponseWrapper<T>(
   originalWithResponse: Promise<unknown>,
   instrumentedPromise: Promise<T>,
 ): Promise<unknown> {
-  return instrumentedPromise.then(async instrumentedResult => {
-    try {
-      const originalWrapper = await originalWithResponse;
-
-      // If it's a wrapper object with data property, replace data with instrumented result
-      if (originalWrapper && typeof originalWrapper === 'object' && 'data' in originalWrapper) {
-        return {
-          ...originalWrapper,
-          data: instrumentedResult,
-        };
-      }
+  const instrumentedResult = await instrumentedPromise;
 
-      // Otherwise return the instrumented result as-is
-      return instrumentedResult;
-    } catch (error) {
-      // If getting the original wrapper fails, capture the error but still throw
-      // This ensures errors are visible while still being tracked in Sentry
-      captureException(error, {
-        mechanism: {
-          handled: false,
-          type: 'auto.ai.openai',
-        },
-      });
-      throw error;
+  try {
+    const originalWrapper = await originalWithResponse;
+
+    // Combine instrumented result with original metadata
+    if (originalWrapper && typeof originalWrapper === 'object' && 'data' in originalWrapper) {
+      return {
+        ...originalWrapper,
+        data: instrumentedResult,
+      };
     }
-  });
+    return instrumentedResult;
+  } catch (error) {
+    // originalWithResponse failed - capture and rethrow
+    captureException(error, {
+      mechanism: {
+        handled: false,
+        type: 'auto.ai.openai',
+      },
+    });
+    throw error;
+  }
 }
 
 /**
  * Wraps a promise-like object to preserve additional methods (like .withResponse())
  */
-function wrapPromiseWithMethods<T>(originalPromiseLike: T, instrumentedPromise: Promise<Awaited<T>>): T {
+function wrapPromiseWithMethods<R>(originalPromiseLike: Promise<R>, instrumentedPromise: Promise<R>): Promise<R> {
   // If the original result is not thenable, return the instrumented promise
+  // Should not happen with current OpenAI SDK instrumented methods, but just in case.
   if (!isThenable(originalPromiseLike)) {
-    return instrumentedPromise as T;
+    return instrumentedPromise;
   }
 
   // Create a proxy that forwards Promise methods to instrumentedPromise
   // and preserves additional methods from the original result
   return new Proxy(originalPromiseLike, {
     get(target: object, prop: string | symbol): unknown {
-      // For standard Promise methods (.then, .catch, .finally) and Symbol.toStringTag,
+      // For standard Promise methods (.then, .catch, .finally, Symbol.toStringTag),
       // use instrumentedPromise to preserve Sentry instrumentation.
       // For custom methods (like .withResponse()), use the original target.
       const useInstrumentedPromise = prop in Promise.prototype || prop === Symbol.toStringTag;
@@ -230,7 +239,7 @@ function wrapPromiseWithMethods<T>(originalPromiseLike: T, instrumentedPromise:
 
       return typeof value === 'function' ? value.bind(source) : value;
     },
-  }) as T;
+  }) as Promise<R>;
 }
 
 /**
@@ -252,21 +261,22 @@ function instrumentMethod<T extends unknown[], R>(
     const params = args[0] as Record<string, unknown> | undefined;
     const isStreamRequested = params && typeof params === 'object' && params.stream === true;
 
-    // Call the original method to get the result with all its methods
-    const originalResult = originalMethod.apply(context, args);
-
     const spanConfig = {
       name: `${operationName} ${model}${isStreamRequested ? ' stream-response' : ''}`,
       op: getSpanOperation(methodPath),
       attributes: requestAttributes as Record<string, SpanAttributeValue>,
     };
 
+    // Capture originalResult inside span callback to ensure HTTP request starts with active span
+    let originalResult!: Promise<R>;
     let instrumentedPromise: Promise<R>;
 
     if (isStreamRequested) {
       // For streaming responses, use manual span management to properly handle the async generator lifecycle
       instrumentedPromise = startSpanManual(spanConfig, async (span: Span) => {
         try {
+          originalResult = originalMethod.apply(context, args);
+
           if (options.recordInputs && params) {
             addRequestAttributes(span, params, operationName);
           }
@@ -296,6 +306,8 @@ function instrumentMethod<T extends unknown[], R>(
       // Non-streaming responses
       instrumentedPromise = startSpan(spanConfig, async (span: Span) => {
         try {
+          originalResult = originalMethod.apply(context, args);
+
           if (options.recordInputs && params) {
             addRequestAttributes(span, params, operationName);
           }