delete redundant comments

Author: galkleinman

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/v1/responses_wrappers.py

@@ -435,14 +435,12 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
     try:
         response = wrapped(*args, **kwargs)
         if isinstance(response, Stream):
-            # Create a span for the streaming response
             span = tracer.start_span(
                 SPAN_NAME,
                 kind=SpanKind.CLIENT,
                 start_time=start_time,
             )
 
-            # Wrap the stream with ResponseStream to capture telemetry
             return ResponseStream(
                 span=span,
                 response=response,
@@ -799,11 +797,9 @@ def __init__(
             response_reasoning_effort=None,
         )
 
-        # Accumulated response data
         self._complete_response_data = None
         self._output_text = ""
 
-        # Cleanup state tracking to prevent duplicate operations
         self._cleanup_completed = False
         self._cleanup_lock = threading.Lock()
 
@@ -862,22 +858,17 @@ async def __anext__(self):
 
     def _process_chunk(self, chunk):
         """Process a streaming chunk"""
-        # Handle response events based on type
         if hasattr(chunk, "type"):
-            # Handle text delta events
             if chunk.type == "response.output_text.delta":
                 if hasattr(chunk, "delta") and chunk.delta:
                     self._output_text += chunk.delta
-            # Handle completion event
             elif chunk.type == "response.completed" and hasattr(chunk, "response"):
                 self._complete_response_data = chunk.response
 
-        # Fallback: Extract text delta from chunk if it has a delta attribute with text
         if hasattr(chunk, "delta"):
             if hasattr(chunk.delta, "text") and chunk.delta.text:
                 self._output_text += chunk.delta.text
 
-        # Store the complete response when we get it
         if hasattr(chunk, "response") and chunk.response:
             self._complete_response_data = chunk.response
 
@@ -892,32 +883,26 @@ def _process_complete_response(self):
                 if self._complete_response_data:
                     parsed_response = parse_response(self._complete_response_data)
 
-                    # Update traced data with response information
                     self._traced_data.response_id = parsed_response.id
                     self._traced_data.response_model = parsed_response.model
                     self._traced_data.output_text = self._output_text
 
-                    # Update usage if available
                     if parsed_response.usage:
                         self._traced_data.usage = parsed_response.usage
 
-                    # Update output blocks
                     if parsed_response.output:
                         self._traced_data.output_blocks = {
                             block.id: block for block in parsed_response.output
                         }
 
-                    # Store in global responses dict
                     responses[parsed_response.id] = self._traced_data
 
-                # Set span attributes
                 set_data_attributes(self._traced_data, self._span)
                 self._span.set_status(StatusCode.OK)
                 self._span.end()
                 self._cleanup_completed = True
 
             except Exception as e:
-                # Log the error but don't fail
                 if self._span and self._span.is_recording():
                     self._span.set_attribute(ERROR_TYPE, e.__class__.__name__)
                     self._span.set_status(StatusCode.ERROR, str(e))
@@ -947,7 +932,6 @@ def _ensure_cleanup(self):
                 return
 
             try:
-                # Set whatever data we have so far
                 if self._span and self._span.is_recording():
                     set_data_attributes(self._traced_data, self._span)
                     self._span.set_status(StatusCode.OK)
@@ -956,5 +940,4 @@ def _ensure_cleanup(self):
                 self._cleanup_completed = True
 
             except Exception:
-                # Final fallback - just mark as completed
                 self._cleanup_completed = True

packages/opentelemetry-instrumentation-openai/tests/traces/test_responses.py

@@ -1,4 +1,3 @@
-
 import pytest
 
 from openai import OpenAI
@@ -7,7 +6,9 @@
 
 
 @pytest.mark.vcr
-def test_responses(instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI):
+def test_responses(
+    instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI
+):
     _ = openai_client.responses.create(
         model="gpt-4.1-nano",
         input="What is the capital of France?",
@@ -26,7 +27,9 @@ def test_responses(instrument_legacy, span_exporter: InMemorySpanExporter, opena
 
 
 @pytest.mark.vcr
-def test_responses_with_input_history(instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI):
+def test_responses_with_input_history(
+    instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI
+):
     user_message = "Come up with an adjective in English. Respond with just one word."
     first_response = openai_client.responses.create(
         model="gpt-4.1-nano",
@@ -79,7 +82,9 @@ def test_responses_with_input_history(instrument_legacy, span_exporter: InMemory
 
 
 @pytest.mark.vcr
-def test_responses_tool_calls(instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI):
+def test_responses_tool_calls(
+    instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI
+):
     tools = [
         {
             "type": "function",
@@ -90,11 +95,11 @@ def test_responses_tool_calls(instrument_legacy, span_exporter: InMemorySpanExpo
                 "properties": {
                     "location": {
                         "type": "string",
-                        "description": "The city and state, e.g. San Francisco, CA"
+                        "description": "The city and state, e.g. San Francisco, CA",
                     }
                 },
-                "required": ["location"]
-            }
+                "required": ["location"],
+            },
         }
     ]
     openai_client.responses.create(
@@ -103,11 +108,11 @@ def test_responses_tool_calls(instrument_legacy, span_exporter: InMemorySpanExpo
             {
                 "type": "message",
                 "role": "user",
-                "content": "What's the weather in London?"
+                "content": "What's the weather in London?",
             }
         ],
         tools=tools,
-        tool_choice="auto"
+        tool_choice="auto",
     )
 
     spans = span_exporter.get_finished_spans()
@@ -145,16 +150,17 @@ def test_responses_tool_calls(instrument_legacy, span_exporter: InMemorySpanExpo
 
 
 @pytest.mark.vcr
-@pytest.mark.skipif(not is_reasoning_supported(),
-                    reason="Reasoning is not supported in older OpenAI library versions")
-def test_responses_reasoning(instrument_legacy, span_exporter: InMemorySpanExporter,
-                             openai_client: OpenAI):
+@pytest.mark.skipif(
+    not is_reasoning_supported(),
+    reason="Reasoning is not supported in older OpenAI library versions",
+)
+def test_responses_reasoning(
+    instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI
+):
     openai_client.responses.create(
         model="gpt-5-nano",
         input="Count r's in strawberry",
-        reasoning={
-            "effort": "low", "summary": None
-        },
+        reasoning={"effort": "low", "summary": None},
     )
 
     spans = span_exporter.get_finished_spans()
@@ -172,18 +178,18 @@ def test_responses_reasoning(instrument_legacy, span_exporter: InMemorySpanExpor
 
 
 @pytest.mark.vcr
-@pytest.mark.skipif(not is_reasoning_supported(),
-                    reason="Reasoning is not supported in older OpenAI library versions")
-def test_responses_reasoning_dict_issue(instrument_legacy, span_exporter: InMemorySpanExporter,
-                                        openai_client: OpenAI):
+@pytest.mark.skipif(
+    not is_reasoning_supported(),
+    reason="Reasoning is not supported in older OpenAI library versions",
+)
+def test_responses_reasoning_dict_issue(
+    instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI
+):
     """Test for issue #3350 - reasoning dict causing invalid type warning"""
     openai_client.responses.create(
         model="gpt-5-nano",
         input="Explain why the sky is blue",
-        reasoning={
-            "effort": "medium",
-            "summary": "auto"
-        },
+        reasoning={"effort": "medium", "summary": "auto"},
     )
 
     spans = span_exporter.get_finished_spans()
@@ -205,7 +211,9 @@ def test_responses_reasoning_dict_issue(instrument_legacy, span_exporter: InMemo
 
 
 @pytest.mark.vcr
-def test_responses_streaming(instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI):
+def test_responses_streaming(
+    instrument_legacy, span_exporter: InMemorySpanExporter, openai_client: OpenAI
+):
     """Test for streaming responses.create() - reproduces customer issue"""
     stream = openai_client.responses.create(
         model="gpt-4.1-nano",
@@ -216,19 +224,13 @@ def test_responses_streaming(instrument_legacy, span_exporter: InMemorySpanExpor
     # Consume the stream
     full_text = ""
     for item in stream:
-        # Debug: print the structure of the item
-        # print(f"Item type: {type(item)}, Item: {item}")
-        # The response API streaming events have a different structure
-        # They have type="response.output_text.delta" with a "delta" field
         if hasattr(item, "type") and item.type == "response.output_text.delta":
             if hasattr(item, "delta") and item.delta:
                 full_text += item.delta
-        # Also handle if there's a delta attribute with text
         elif hasattr(item, "delta") and item.delta:
             if hasattr(item.delta, "text") and item.delta.text:
                 full_text += item.delta.text
 
-    # Check that spans were created
     spans = span_exporter.get_finished_spans()
     assert len(spans) == 1, f"Expected 1 span but got {len(spans)}"
 
@@ -241,28 +243,25 @@ def test_responses_streaming(instrument_legacy, span_exporter: InMemorySpanExpor
 
 @pytest.mark.vcr
 @pytest.mark.asyncio
-async def test_responses_streaming_async(instrument_legacy, span_exporter: InMemorySpanExporter, async_openai_client):
+async def test_responses_streaming_async(
+    instrument_legacy, span_exporter: InMemorySpanExporter, async_openai_client
+):
     """Test for async streaming responses.create() - reproduces customer issue"""
     stream = await async_openai_client.responses.create(
         model="gpt-4.1-nano",
         input="Tell me a three sentence bedtime story about a unicorn.",
         stream=True,
     )
 
-    # Consume the stream
     full_text = ""
     async for item in stream:
-        # The response API streaming events have a different structure
-        # They have type="response.output_text.delta" with a "delta" field
         if hasattr(item, "type") and item.type == "response.output_text.delta":
             if hasattr(item, "delta") and item.delta:
                 full_text += item.delta
-        # Also handle if there's a delta attribute with text
         elif hasattr(item, "delta") and item.delta:
             if hasattr(item.delta, "text") and item.delta.text:
                 full_text += item.delta.text
 
-    # Check that spans were created
     spans = span_exporter.get_finished_spans()
     assert len(spans) == 1, f"Expected 1 span but got {len(spans)}"