packages/sample-app/sample_app/google_genai_image_example.py (1)

35-44: Simplify and harden MIME-type detection

You already call .lower() on the path, so listing uppercase variants is redundant. Also, using the stdlib mimetypes avoids manual extension lists and supports more formats out of the box.

Apply this diff:

-        # Determine mime type from file extension
-        if image_path.lower().endswith(('.png', '.PNG')):
-            mime_type = "image/png"
-        elif image_path.lower().endswith(('.jpg', '.jpeg', '.JPG', '.JPEG')):
-            mime_type = "image/jpeg"
-        elif image_path.lower().endswith(('.gif', '.GIF')):
-            mime_type = "image/gif" 
-        elif image_path.lower().endswith(('.webp', '.WEBP')):
-            mime_type = "image/webp"
-        else:
-            mime_type = "image/jpeg"  # Default fallback
+        # Determine mime type from filename using stdlib
+        import mimetypes
+        mime_type, _ = mimetypes.guess_type(image_path)
+        if not mime_type or not mime_type.startswith("image/"):
+            mime_type = "image/jpeg"  # Default fallback

packages/sample-app/sample_app/vertex_gemini_vision_example.py (1)

29-34: Optional: detect MIME type dynamically

Right now every local image is sent as image/jpeg. If the sample may handle PNG/GIF/WebP, consider detecting from filename or bytes.

Example using stdlib mimetypes:

-    image_part = Part.from_data(
-        data=image_data,
-        mime_type="image/jpeg"
-    )
+    import mimetypes
+    mime_type, _ = mimetypes.guess_type(image_path)
+    if not mime_type or not mime_type.startswith("image/"):
+        mime_type = "image/jpeg"
+    image_part = Part.from_data(data=image_data, mime_type=mime_type)

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/__init__.py (2)

282-288: Outdated comment: code does perform image processing in sync path

The comment says “avoid image processing for now,” but set_input_attributes_sync includes image processing and upload hook usage. This can confuse future maintainers.

Apply this diff:

-    # Use sync version for non-async wrapper to avoid image processing for now
+    # Use the synchronous attribute path for non-async wrappers

---

310-316: Type-hint the new constructor arg and document behavior

For clarity and IDE help, add a precise type hint to upload_base64_image, matching Config. Also briefly document that, if provided, it overrides the global Config uploader.

Apply this diff:

-    def __init__(self, exception_logger=None, use_legacy_attributes=True, upload_base64_image=None):
+    def __init__(
+        self,
+        exception_logger=None,
+        use_legacy_attributes: bool = True,
+        upload_base64_image: "Callable[[str, str, str, str], str]" = None,
+    ):

Note: using a forward string reference avoids adding a new import in this file. Alternatively, import Callable locally.

packages/traceloop-sdk/traceloop/sdk/tracing/tracing.py (2)

680-693: Match Gemini init signature to widened callable type.

Stay consistent with the Optional async callable; avoids typing noise and future adapters.

-def init_google_generativeai_instrumentor(
-    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], str]
-):
+def init_google_generativeai_instrumentor(
+    should_enrich_metrics: bool, base64_image_uploader: Optional[Callable[..., Awaitable[str]]] = None
+):

---

943-955: Match Vertex init signature to widened callable type.

Same rationale as for Gemini.

-def init_vertexai_instrumentor(
-    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], str]
-):
+def init_vertexai_instrumentor(
+    should_enrich_metrics: bool, base64_image_uploader: Optional[Callable[..., Awaitable[str]]] = None
+):

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/span_utils.py (3)

70-101: Same fixes for sync processing; avoid losing uploads under running event loop.

Currently asyncio.run() under an active loop will raise and force a fallback URL. Consider a safer bridge and stringified IDs.

-        image_format = item.mime_type.split('/')[1] if item.mime_type else 'unknown'
+        mime = getattr(getattr(item, "inline_data", None), "mime_type", None) or getattr(item, "mime_type", None)
+        image_format = mime.split('/')[1] if mime else 'unknown'
@@
-        try:
-            url = asyncio.run(Config.upload_base64_image(trace_id, span_id, image_name, base64_string))
+        tid, sid = str(trace_id), str(span_id)
+        try:
+            # Prefer running in a new loop when one is already active to avoid RuntimeError
+            loop = None
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                pass
+            if loop and loop.is_running():
+                # Run in a worker thread to avoid interfering with the existing loop
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:
+                    url = ex.submit(lambda: asyncio.run(Config.upload_base64_image(tid, sid, image_name, base64_string))).result()
+            else:
+                url = asyncio.run(Config.upload_base64_image(tid, sid, image_name, base64_string))
         except Exception as upload_error:
             logger.warning(f"Failed to upload image: {upload_error}")
             url = f"/image/{image_name}"  # Fallback URL

If adding concurrent.futures is undesirable, at minimum stringify IDs:

-            url = asyncio.run(Config.upload_base64_image(trace_id, span_id, image_name, base64_string))
+            url = asyncio.run(Config.upload_base64_image(str(trace_id), str(span_id), image_name, base64_string))

---

105-153: Set role attribute alongside content for consistency with OpenAI/GenAI paths.

You build content but never set f"{prefix}.role". GenAI and OpenAI code sets role="user". Aligning improves downstream parsing consistency.

-                _set_span_attribute(span, f"{prefix}.content", json.dumps(processed_content))
+                _set_span_attribute(span, f"{prefix}.content", json.dumps(processed_content))
+                _set_span_attribute(span, f"{prefix}.role", "user")

---

21-35: Flake8: avoid bare except (E722).

Addressed in the detection function change above. If you keep any bare excepts, switch to except Exception:.

packages/opentelemetry-instrumentation-google-generativeai/opentelemetry/instrumentation/google_generativeai/span_utils.py (3)

19-23: Micro: simplify guard.

Combine nested checks.

-def _set_span_attribute(span, name, value):
-    if value is not None:
-        if value != "":
-            span.set_attribute(name, value)
+def _set_span_attribute(span, name, value):
+    if value is not None and value != "":
+        span.set_attribute(name, value)

---

26-41: Tighten detector and exceptions.

Good structure; minor simplification and explicit Exception.

-    try:
-        # Check if it has the Part attributes we expect for new Google GenAI SDK
-        if hasattr(item, 'inline_data') and item.inline_data is not None:
-            # Check if it's an image mime type and has data
-            if (hasattr(item.inline_data, 'mime_type') and
-                    item.inline_data.mime_type and
-                    'image/' in item.inline_data.mime_type and
-                    hasattr(item.inline_data, 'data') and
-                    item.inline_data.data):
-                return True
-        return False
-    except Exception:
+    try:
+        inline = getattr(item, "inline_data", None)
+        mime = getattr(inline, "mime_type", None)
+        has_data = hasattr(inline, "data") and bool(inline.data)
+        return bool(mime and mime.startswith("image/") and has_data)
+    except Exception:
         return False

---

74-106: Safer sync upload under running event loops; stringify IDs.

asyncio.run inside a running loop raises RuntimeError leading to fallback URL.

-        try:
-            url = asyncio.run(Config.upload_base64_image(trace_id, span_id, image_name, base64_string))
+        tid, sid = str(trace_id), str(span_id)
+        try:
+            loop = None
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                pass
+            if loop and loop.is_running():
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:
+                    url = ex.submit(lambda: asyncio.run(Config.upload_base64_image(tid, sid, image_name, base64_string))).result()
+            else:
+                url = asyncio.run(Config.upload_base64_image(tid, sid, image_name, base64_string))

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

packages/sample-app/sample_app/google_genai_image_example.py (1)

24-25: Verify model and location values for your environment

Using location="global" and the model ID gemini-2.0-flash-exp may vary by region and SDK version. If the target Vertex/GenAI endpoint in your project doesn’t expose this model or accept global, requests will fail.

Would you like me to check the latest supported model IDs and regions for the google-genai SDK and Vertex endpoints you’re using?

Also applies to: 65-68

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/__init__.py (1)

181-188: Good: request handling is now truly async

Making _handle_request async and awaiting it in _awrap ensures image-part processing (which may await uploads) happens before the model call and keeps the async path consistent with the new span_utils behavior.

Also applies to: 238-238

packages/traceloop-sdk/traceloop/sdk/tracing/tracing.py (1)

461-463: OK to forward uploader to Gemini instrumentor (post-type fix).

Once the callable type is widened to Optional[Callable[..., Awaitable[str]]], this pass-through looks good.

packages/opentelemetry-instrumentation-google-generativeai/opentelemetry/instrumentation/google_generativeai/__init__.py (3)

16-20: Import switch to set_input_attributes_sync looks good.

Keeps sync flow consistent with event-less path.

---

252-258: Config wiring for upload_base64_image is sound.

Passing the callable through the constructor and assigning to Config is consistent with other instrumentors.

---

106-106: OK to route non-event path through sync attribute setter.

Matches the synchronous wrapping being used here.

packages/opentelemetry-instrumentation-google-generativeai/opentelemetry/instrumentation/google_generativeai/span_utils.py (2)

117-172: LGTM: mixed-content handling for contents[] with text and image Parts.

The per-item JSON payload with role defaulting to "user" aligns with OpenAI-compatible formatting.

---

173-216: LGTM: args[] path mirrors contents[]; role set to "user".

Consistent with the new content structure.

packages/opentelemetry-instrumentation-google-generativeai/opentelemetry/instrumentation/google_generativeai/span_utils.py (2)

57-59: Normalize OTel IDs to strings before upload (matches Config type and uploader expectations)

span.context.trace_id and span.context.span_id are integers in OTel. Config.upload_base64_image is typed to receive strings. Normalize IDs to strings to avoid type surprises.

Apply:

         # Upload the base64 data
-        url = await Config.upload_base64_image(trace_id, span_id, image_name, base64_string)
+        tid, sid = str(trace_id), str(span_id)
+        url = await Config.upload_base64_image(tid, sid, image_name, base64_string)

-        url = asyncio.run(Config.upload_base64_image(trace_id, span_id, image_name, base64_string))
+        tid, sid = str(trace_id), str(span_id)
+        url = asyncio.run(Config.upload_base64_image(tid, sid, image_name, base64_string))

Also applies to: 85-87

---

85-87: Guard asyncio.run in sync path to avoid RuntimeError when an event loop is already running; provide fallback

Calling asyncio.run inside an already-running event loop raises RuntimeError. Add a guard and graceful fallback URL.

-        # Use asyncio.run to call the async upload function in sync context
-        url = asyncio.run(Config.upload_base64_image(trace_id, span_id, image_name, base64_string))
+        # Use asyncio.run to call the async upload function in sync context
+        try:
+            url = asyncio.run(Config.upload_base64_image(tid, sid, image_name, base64_string))
+        except RuntimeError:
+            # Event loop is already running (e.g., notebooks, async frameworks)
+            logger.warning("Event loop already running; cannot use asyncio.run in sync path, using fallback URL.")
+            fallback_url = getattr(
+                Config,
+                "fallback_sync_image_url",
+                getattr(Config, "fallback_image_url", None),
+            )
+            if fallback_url:
+                return {"type": "image_url", "image_url": {"url": fallback_url}}
+            return None

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/span_utils.py (2)

21-36: Fix Vertex Part detection; prefer inline_data.mime_type and check data presence.

As implemented, this will miss valid Parts where mime_type lives under inline_data (common in Vertex). Also retains unnecessary nesting. This causes image parts to be skipped entirely.

 def _is_base64_image_part(item):
     """Check if item is a VertexAI Part object containing image data"""
     try:
-        # Check if it has the Part attributes we expect
-        if not hasattr(item, 'inline_data') or not hasattr(item, 'mime_type'):
-            return False
-
-        # Check if it's an image mime type and has inline data
-        if item.mime_type and 'image/' in item.mime_type and item.inline_data:
-            # Check if the inline_data has actual data
-            if hasattr(item.inline_data, 'data') and item.inline_data.data:
-                return True
-
-        return False
+        inline = getattr(item, "inline_data", None)
+        mime = getattr(inline, "mime_type", None) or getattr(item, "mime_type", None)
+        has_data = hasattr(inline, "data") and bool(inline.data)
+        return bool(mime and mime.startswith("image/") and has_data)
     except Exception:
         return False

If you want to restrict formats to PNG, JPEG/JPG, GIF, WebP as per PR goal, add this near the top of the module (optional) and gate on it:

ALLOWED_IMAGE_MIME_TYPES = {"image/png", "image/jpeg", "image/jpg", "image/webp", "image/gif"}

and then:

return bool(mime in ALLOWED_IMAGE_MIME_TYPES and has_data)

---

45-55: Normalize IDs to strings and use robust mime extraction.

Prefer inline_data.mime_type, split defensively, and pass string IDs to the uploader to match its signature.

-        # Extract format from mime type (e.g., 'image/jpeg' -> 'jpeg')
-        image_format = item.mime_type.split('/')[1] if item.mime_type else 'unknown'
+        # Extract format from mime type (prefer inline_data.mime_type)
+        mime = (
+            getattr(getattr(item, "inline_data", None), "mime_type", None)
+            or getattr(item, "mime_type", None)
+        )
+        image_format = mime.split('/')[1] if (mime and '/' in mime) else 'unknown'
         image_name = f"content_{content_index}.{image_format}"
@@
-        # Upload the base64 data
-        url = await Config.upload_base64_image(trace_id, span_id, image_name, base64_string)
+        # Upload the base64 data
+        tid, sid = str(trace_id), str(span_id)
+        url = await Config.upload_base64_image(tid, sid, image_name, base64_string)

packages/opentelemetry-instrumentation-google-generativeai/opentelemetry/instrumentation/google_generativeai/span_utils.py (3)

26-41: Tighten and simplify image-part detection; flatten nested conditionals

Flatten the nested checks per SIM102 and avoid attribute chains that can raise if intermediates are None. Optionally restrict to the supported set of mime types.

-def _is_image_part(item):
-    """Check if item is a Google GenAI Part object containing image data"""
-    try:
-        # Check if it has the Part attributes we expect for new Google GenAI SDK
-        if hasattr(item, 'inline_data') and item.inline_data is not None:
-            # Check if it's an image mime type and has data
-            if (hasattr(item.inline_data, 'mime_type') and
-                    item.inline_data.mime_type and
-                    'image/' in item.inline_data.mime_type and
-                    hasattr(item.inline_data, 'data') and
-                    item.inline_data.data):
-                return True
-        return False
-    except Exception:
-        return False
+def _is_image_part(item):
+    """Check if item is a Google GenAI Part object containing image data"""
+    try:
+        inline = getattr(item, "inline_data", None)
+        mime = getattr(inline, "mime_type", None)
+        data = getattr(inline, "data", None)
+        return bool(inline and mime and mime.startswith("image/") and data)
+    except Exception:
+        return False

If you want to strictly align with “PNG/JPEG/GIF/WebP only”, you can add:

ALLOWED_MIME = {"image/png","image/jpeg","image/jpg","image/gif","image/webp"}
return bool(inline and mime in ALLOWED_MIME and data)

---

43-69: Reduce duplication between async and sync image-processing paths

The async/sync functions duplicate extraction, naming, encoding, and return-shape logic. Factor out common pieces to reduce maintenance risk.

Sketch:

def _extract_image_name_and_b64(item, content_index):
    image_format = item.inline_data.mime_type.split("/")[1] if item.inline_data.mime_type else "unknown"
    image_name = f"content_{content_index}.{image_format}"
    base64_string = base64.b64encode(item.inline_data.data).decode("utf-8")
    return image_name, base64_string

def _as_image_url(url):
    return {"type": "image_url", "image_url": {"url": url}}

Then each path only differs at the “upload” line (await vs sync or fallback).

Also applies to: 71-96

---

48-56: Minor: avoid repeating base64 encode/name creation logic; precompute once

Precompute image_name and base64_string via a helper to keep both paths in lockstep and reduce drift.

Also applies to: 76-84

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/span_utils.py (10)

14-18: Simplify guard; avoid nested if (Ruff SIM102).

Current nested checks are equivalent to a single guard; keeps intent while reducing branches.

 def _set_span_attribute(span, name, value):
-    if value is not None:
-        if value != "":
-            span.set_attribute(name, value)
-    return
+    if value is None or value == "":
+        return
+    span.set_attribute(name, value)

---

61-64: Add a graceful fallback URL when upload fails (PR objective).

The PR summary mentions “graceful fallback URLs when uploads fail,” but this path currently returns None, dropping the image. Consider returning a small, deterministic placeholder URL (e.g., an app-handled openllmetry: scheme) or a configurable fallback.

For example:

-        # Return None to skip adding this image to the span
-        return None
+        # Graceful fallback: keep content shape even if upload fails
+        fallback = getattr(Config, "fallback_image_url", None)
+        if callable(fallback):
+            try:
+                return {"type": "image_url", "image_url": {"url": fallback()}}
+            except Exception:
+                logger.debug("fallback_image_url failed; skipping image.")
+        return None

Would you like me to wire a simple Config.fallback_image_url with a default like "openllmetry:upload_failed"?

---

101-107: Set explicit role for prompt entries ("user") to align with semconv usage.

Adds parity with other instrumentations that emit role alongside content.

         for i, arg in enumerate(args):
             prefix = f"{SpanAttributes.LLM_PROMPTS}.{i}"
+            _set_span_attribute(span, f"{prefix}.role", "user")
@@
         for i, arg in enumerate(args):
             prefix = f"{SpanAttributes.LLM_PROMPTS}.{i}"
+            _set_span_attribute(span, f"{prefix}.role", "user")

Also applies to: 155-161

---

108-114: Avoid unnecessary deepcopy; iterate read-only and drop import.

Deep copying Part objects is costly and may fail. We don't mutate; iterate directly. Then remove the copy import.

-                # List of mixed content (text strings and Part objects) - deep copy and process
-                content = copy.deepcopy(arg)
-
-                # Process each item in the content list using OpenAI-compatible format
-                processed_content = []
-                for j, item in enumerate(content):
+                # List of mixed content (text strings and Part objects) - process read-only
+                processed_content = []
+                for j, item in enumerate(arg):

-                # List of mixed content (text strings and Part objects) - deep copy and process
-                content = copy.deepcopy(arg)
-
-                # Process each item in the content list using OpenAI-compatible format
-                processed_content = []
-                for j, item in enumerate(content):
+                # List of mixed content (text strings and Part objects) - process read-only
+                processed_content = []
+                for j, item in enumerate(arg):

Outside-range cleanup:

-import copy

Also applies to: 162-167, 1-1

---

118-124: Defensive: skip empty/failed image uploads before appending.

Ensure we don't append placeholders when uploader returns falsy URL.

-                        if processed_item is not None:
+                        if processed_item and processed_item.get("image_url", {}).get("url"):
                             processed_content.append(processed_item)

Apply similarly in the sync branch.

Also applies to: 188-195

---

39-60: Optional: validate image mime types against allowed set.

If strict validation is desired, reject unsupported images early to protect attributes from unexpected content types.

 async def _process_image_part(item, trace_id, span_id, content_index):
@@
-        # Convert binary data to base64 string for upload
+        # Validate mime type if policy is configured
+        allowed = globals().get("ALLOWED_IMAGE_MIME_TYPES")
+        if allowed is not None and mime not in allowed:
+            logger.debug("Skipping image with unsupported mime type: %s", mime)
+            return None
+
+        # Convert binary data to base64 string for upload
         binary_data = item.inline_data.data

Repeat the same check in the sync variant.

Also applies to: 67-92

---

39-60: Telemetry hygiene: avoid embedding large data URLs in attributes.

If you implement a fallback using data: URLs, cap base64 length (e.g., 8–16KB) to respect typical exporter limits and avoid bloating spans.

I can add a small helper to truncate base64 for any data-URL fallback and document the attribute size trade-offs.

Also applies to: 67-92

---

41-43: Early-exit condition should also handle empty uploader callable.

Guard for a misconfigured Config where upload_base64_image is set but falsy/non-callable.

-    if not Config.upload_base64_image:
+    if not getattr(Config, "upload_base64_image", None):
         return None

Also applies to: 69-71

---

95-145: End-to-end check: inputs with only images can yield empty content arrays.

If every image fails to upload, we set an empty JSON list. Consider skipping attribute in that case to reduce noise.

-                _set_span_attribute(span, f"{prefix}.content", json.dumps(processed_content))
+                if processed_content:
+                    _set_span_attribute(span, f"{prefix}.content", json.dumps(processed_content))

Apply in both async and sync paths.

Also applies to: 149-199

---

39-60: Unit-test request: add coverage for inline_data mime vs. item mime, and sync path in running loop.

These code paths are fragile across SDK versions. Add tests to lock behavior.

I can contribute tests that:

• Assert _is_base64_image_part accepts Parts where mime lives on inline_data.
• Verify async uploader is called with str IDs.
• Validate sync path returns None (or placeholder) when a loop is already running.

Would you like me to draft these?

Also applies to: 67-92

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

packages/opentelemetry-instrumentation-google-generativeai/opentelemetry/instrumentation/google_generativeai/span_utils.py (3)

44-69: Normalize IDs to strings and use configurable fallbacks for missing/failed uploads (async path)

Two issues:

• OTel IDs are often ints; normalize to str before handing to uploaders. This was raised earlier.
• When uploads are disabled or fail, return a configurable fallback URL instead of dropping the image. This matches the PR’s “graceful fallback” promise and prior feedback.

 async def _process_image_part(item, trace_id, span_id, content_index):
     """Process a Google GenAI Part object containing image data"""
-    if not Config.upload_base64_image:
-        return None
+    if not Config.upload_base64_image:
+        fallback_url = getattr(
+            Config, "fallback_async_image_url", getattr(Config, "fallback_image_url", None)
+        )
+        if fallback_url:
+            return {"type": "image_url", "image_url": {"url": fallback_url}}
+        return None
 
     try:
         # Extract format from mime type (e.g., 'image/jpeg' -> 'jpeg')
         image_format = item.inline_data.mime_type.split('/')[1] if item.inline_data.mime_type else 'unknown'
         image_name = f"content_{content_index}.{image_format}"
 
         # Convert binary data to base64 string for upload
         binary_data = item.inline_data.data
         base64_string = base64.b64encode(binary_data).decode('utf-8')
 
         # Upload the base64 data
-        url = await Config.upload_base64_image(trace_id, span_id, image_name, base64_string)
+        # Normalize IDs to strings (OTel may provide ints)
+        tid, sid = str(trace_id), str(span_id)
+        url = await Config.upload_base64_image(tid, sid, image_name, base64_string)
+        if not url:
+            fallback_url = getattr(
+                Config, "fallback_async_image_url", getattr(Config, "fallback_image_url", None)
+            )
+            if fallback_url:
+                return {"type": "image_url", "image_url": {"url": fallback_url}}
+            return None
 
         # Return OpenAI-compatible format for consistency across LLM providers
         return {
             "type": "image_url",
             "image_url": {"url": url}
         }
     except Exception as e:
-        logger.warning(f"Failed to process image part: {e}")
-        # Return None to skip adding this image to the span
-        return None
+        logger.warning("Failed to process image part; using fallback if configured: %s", e)
+        fallback_url = getattr(
+            Config, "fallback_async_image_url", getattr(Config, "fallback_image_url", None)
+        )
+        if fallback_url:
+            return {"type": "image_url", "image_url": {"url": fallback_url}}
+        return None

---

87-118: Sync image processing: use run_async return value, normalize IDs, and honor fallbacks

Currently, exceptions in the spawned thread aren’t surfaced and may yield url=None. Also, IDs aren’t normalized and missing/failed uploads don’t use fallbacks.

 def _process_image_part_sync(item, trace_id, span_id, content_index):
     """Synchronous version of image part processing using OpenAI's pattern"""
-    if not Config.upload_base64_image:
-        return None
+    if not Config.upload_base64_image:
+        fallback_url = getattr(
+            Config, "fallback_sync_image_url", getattr(Config, "fallback_image_url", None)
+        )
+        if fallback_url:
+            return {"type": "image_url", "image_url": {"url": fallback_url}}
+        return None
 
     try:
         # Extract format from mime type (e.g., 'image/jpeg' -> 'jpeg')
         image_format = item.inline_data.mime_type.split('/')[1] if item.inline_data.mime_type else 'unknown'
         image_name = f"content_{content_index}.{image_format}"
 
         # Convert binary data to base64 string for upload
         binary_data = item.inline_data.data
         base64_string = base64.b64encode(binary_data).decode('utf-8')
 
-        # Use OpenAI's run_async pattern to handle the async upload function
-        url = None
-
-        async def upload_task():
-            nonlocal url
-            url = await Config.upload_base64_image(trace_id, span_id, image_name, base64_string)
-
-        run_async(upload_task())
+        # Normalize IDs to strings and run async uploader from sync code
+        tid, sid = str(trace_id), str(span_id)
+        async def upload_task():
+            return await Config.upload_base64_image(tid, sid, image_name, base64_string)
+        url = run_async(upload_task())
 
-        return {
+        if not url:
+            fallback_url = getattr(
+                Config, "fallback_sync_image_url", getattr(Config, "fallback_image_url", None)
+            )
+            if fallback_url:
+                return {"type": "image_url", "image_url": {"url": fallback_url}}
+            return None
+
+        return {
             "type": "image_url",
             "image_url": {"url": url}
         }
     except Exception as e:
-        logger.warning(f"Failed to process image part sync: {e}")
-        # Return None to skip adding this image to the span
-        return None
+        logger.warning("Failed to process image part sync; using fallback if configured: %s", e)
+        fallback_url = getattr(
+            Config, "fallback_sync_image_url", getattr(Config, "fallback_image_url", None)
+        )
+        if fallback_url:
+            return {"type": "image_url", "image_url": {"url": fallback_url}}
+        return None

---

120-123: dont_throw likely won’t catch exceptions in async function — update decorator or handle locally

Per prior review, the decorator is synchronous and won’t catch exceptions inside this async def. Either upgrade dont_throw to wrap coroutine functions or remove the decorator here and add a try/except in the function.

Option A (preferred): update the decorator (in utils.py) to detect coroutine functions and return an async wrapper using inspect.iscoroutinefunction and await (see earlier suggestion).

Option B (local change here): drop @dont_throw and wrap the body in try/except.

Would you like me to generate a focused patch for Option B in this file, or a utils.py patch for Option A?

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/span_utils.py (3)

83-109: Sync upload: robust MIME parsing, normalize IDs to strings, and support both async and sync uploaders

Mirror the async improvements and allow a synchronous uploader without forcing a thread-hopping coroutine.

-    try:
-        # Extract format from mime type (e.g., 'image/jpeg' -> 'jpeg')
-        image_format = item.mime_type.split('/')[1] if item.mime_type else 'unknown'
+    try:
+        # Extract format from mime type (prefer inline_data.mime_type)
+        mime = (
+            getattr(getattr(item, "inline_data", None), "mime_type", None)
+            or getattr(item, "mime_type", None)
+        ) or ""
+        image_format = mime.split("/", 1)[1].lower() if "/" in mime else "unknown"
         image_name = f"content_{content_index}.{image_format}"
@@
-        # Use OpenAI's run_async pattern to handle the async upload function
-        url = None
-
-        async def upload_task():
-            nonlocal url
-            url = await Config.upload_base64_image(trace_id, span_id, image_name, base64_string)
-
-        run_async(upload_task())
+        # Support both async and sync uploaders
+        uploader = Config.upload_base64_image
+        tid, sid = str(trace_id), str(span_id)
+        if asyncio.iscoroutinefunction(uploader):
+            url = run_async(uploader(tid, sid, image_name, base64_string))
+        else:
+            url = uploader(tid, sid, image_name, base64_string)

---

22-37: Fix VertexAI Part image detection: prefer inline_data.mime_type and simplify checks

Current logic relies on item.mime_type and nested conditions, which misses the common inline_data.mime_type path and can fail to detect valid image Parts.

-def _is_base64_image_part(item):
-    """Check if item is a VertexAI Part object containing image data"""
-    try:
-        # Check if it has the Part attributes we expect
-        if not hasattr(item, 'inline_data') or not hasattr(item, 'mime_type'):
-            return False
-
-        # Check if it's an image mime type and has inline data
-        if item.mime_type and 'image/' in item.mime_type and item.inline_data:
-            # Check if the inline_data has actual data
-            if hasattr(item.inline_data, 'data') and item.inline_data.data:
-                return True
-
-        return False
-    except Exception:
-        return False
+def _is_base64_image_part(item):
+    """Return True when `item` is a VertexAI Part with inline image bytes."""
+    try:
+        inline = getattr(item, "inline_data", None)
+        mime = getattr(inline, "mime_type", None) or getattr(item, "mime_type", None)
+        data = getattr(inline, "data", None)
+        return bool(mime and mime.startswith("image/") and data)
+    except Exception:
+        return False

---

45-61: Async upload: robust MIME parsing and normalize IDs to strings; support sync uploaders via to_thread

Use inline_data.mime_type when present, split safely, and cast trace/span IDs to strings. If a synchronous uploader is configured, offload it with asyncio.to_thread to avoid blocking the loop.

-        # Extract format from mime type (e.g., 'image/jpeg' -> 'jpeg')
-        image_format = item.mime_type.split('/')[1] if item.mime_type else 'unknown'
+        # Extract format from mime type (prefer inline_data.mime_type)
+        mime = (
+            getattr(getattr(item, "inline_data", None), "mime_type", None)
+            or getattr(item, "mime_type", None)
+        ) or ""
+        image_format = mime.split("/", 1)[1].lower() if "/" in mime else "unknown"
         image_name = f"content_{content_index}.{image_format}"
@@
-        # Upload the base64 data
-        url = await Config.upload_base64_image(trace_id, span_id, image_name, base64_string)
+        # Upload the base64 data (support async or sync uploader)
+        uploader = Config.upload_base64_image
+        tid, sid = str(trace_id), str(span_id)
+        if asyncio.iscoroutinefunction(uploader):
+            url = await uploader(tid, sid, image_name, base64_string)
+        else:
+            url = await asyncio.to_thread(uploader, tid, sid, image_name, base64_string)

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/span_utils.py (6)

62-66: Log full traceback on upload failure

Use logger.exception to retain stack traces for support/debuggability.

-    except Exception as e:
-        logger.warning(f"Failed to process image part: {e}")
-        # Return None to skip adding this image to the span
-        return None
+    except Exception:
+        logger.exception("Failed to process image part")
+        return None

---

68-81: Return the coroutine result from run_async

Returning the result simplifies callers and avoids reliance on outer nonlocal variables.

-def run_async(method):
-    """Handle async method in sync context, following OpenAI's battle-tested approach"""
+def run_async(coro):
+    """Run an async coroutine from sync code and return its result."""
     try:
         loop = asyncio.get_running_loop()
     except RuntimeError:
         loop = None
 
-    if loop and loop.is_running():
-        thread = threading.Thread(target=lambda: asyncio.run(method))
+    if loop and loop.is_running():
+        result = None
+        def _runner():
+            nonlocal result
+            result = asyncio.run(coro)
+        thread = threading.Thread(target=_runner)
         thread.start()
         thread.join()
-    else:
-        asyncio.run(method)
+        return result
+    else:
+        return asyncio.run(coro)

---

110-113: Log full traceback on sync upload failure

Same rationale as async path.

-    except Exception as e:
-        logger.warning(f"Failed to process image part sync: {e}")
-        # Return None to skip adding this image to the span
-        return None
+    except Exception:
+        logger.exception("Failed to process image part sync")
+        return None

---

130-136: Avoid deepcopy of content lists

Deep copying provider objects is unnecessary (we don’t mutate items), can be expensive, and may fail on non-serializable Parts. Iterate the original list.

-                # List of mixed content (text strings and Part objects) - deep copy and process
-                content = copy.deepcopy(arg)
+                # List of mixed content (text strings and Part objects)
+                content = arg

Also remove the now-unused import:

-import copy

Also applies to: 187-193

---

15-19: Simplify nested conditionals per Ruff SIM102

No functional change; reduces nesting.

-def _set_span_attribute(span, name, value):
-    if value is not None:
-        if value != "":
-            span.set_attribute(name, value)
-    return
+def _set_span_attribute(span, name, value):
+    if value is not None and value != "":
+        span.set_attribute(name, value)

---

62-66: Confirm fallback behavior when uploads fail

PR objective mentions “graceful fallback URLs when uploads fail,” but both paths return None on failure, which drops the image entirely. If fallback is expected at this layer, consider a configurable placeholder (e.g., Config.fallback_image_url) or a data: URL stub to preserve structure.

Also applies to: 110-113

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

packages/opentelemetry-instrumentation-google-generativeai/opentelemetry/instrumentation/google_generativeai/span_utils.py (5)

148-174: Mixed-content processing (text + images) looks correct and resilient

Accurately iterates content.parts, preserves text, processes images, and stringifies other parts. Good use of role defaulting later.

---

176-186: Span attribute construction for per-item JSON payloads is coherent

Using JSON with explicit types aligns with your OpenAI-compatible shape and keeps attributes uniform across providers.

---

187-226: Args-path handling mirrors contents-path semantics

Symmetry between args and contents handling is good; indices are stable and image parts go through the same pipeline.

---

226-232: Prompt kwarg path is straightforward and consistent

Single-string prompt is correctly wrapped into the JSON content format and tagged with role "user".

---

234-341: Sync and async attribute setters correctly separated

I’ve confirmed that:

• All async wrappers invoke the async setter with await set_input_attributes(span, args) (e.g. in vertexai/__init__.py at line 187).
• All sync wrappers call the sync setter set_input_attributes_sync(span, …) (e.g. in vertexai/__init__.py at line 287 and in google_generativeai/__init__.py at line 106).

The sync version remains available for backward compatibility, and no async contexts call the sync setter—avoiding nested event‐loop issues.

packages/opentelemetry-instrumentation-google-generativeai/opentelemetry/instrumentation/google_generativeai/span_utils.py (1)

61-65: Ensure URL is not None and return a configurable fallback on upload failures

Today, if the upload coroutine fails in the background thread (sync path) or raises (async path), we can end up returning {"image_url":{"url": None}} or drop the image entirely by returning None. The PR summary promises “graceful fallback URLs when uploads fail”; make this behavior explicit and avoid emitting invalid URLs.

Apply these diffs:

@@
-        # Return OpenAI-compatible format for consistency across LLM providers
-        return {
-            "type": "image_url",
-            "image_url": {"url": url}
-        }
+        # Return OpenAI-compatible format for consistency across LLM providers
+        if not url:
+            logger.debug("Image upload returned empty URL; using fallback (async)")
+            fallback_url = getattr(
+                Config, "fallback_async_image_url",
+                getattr(Config, "fallback_image_url", None),
+            )
+            if fallback_url:
+                return {"type": "image_url", "image_url": {"url": fallback_url}}
+            return None
+        return {"type": "image_url", "image_url": {"url": url}}
@@
-    except Exception as e:
-        logger.warning(f"Failed to process image part: {e}")
-        # Return None to skip adding this image to the span
-        return None
+    except Exception as e:
+        logger.warning(f"Failed to process image part: {e}")
+        # Graceful fallback
+        fallback_url = getattr(
+            Config, "fallback_async_image_url",
+            getattr(Config, "fallback_image_url", None),
+        )
+        if fallback_url:
+            return {"type": "image_url", "image_url": {"url": fallback_url}}
+        return None
@@
-        return {
-            "type": "image_url",
-            "image_url": {"url": url}
-        }
+        if not url:
+            logger.debug("Image upload returned empty URL; using fallback (sync)")
+            fallback_url = getattr(
+                Config, "fallback_sync_image_url",
+                getattr(Config, "fallback_image_url", None),
+            )
+            if fallback_url:
+                return {"type": "image_url", "image_url": {"url": fallback_url}}
+            return None
+        return {"type": "image_url", "image_url": {"url": url}}
@@
-    except Exception as e:
-        logger.warning(f"Failed to process image part sync: {e}")
-        # Return None to skip adding this image to the span
-        return None
+    except Exception as e:
+        logger.warning(f"Failed to process image part sync: {e}")
+        # Graceful fallback
+        fallback_url = getattr(
+            Config, "fallback_sync_image_url",
+            getattr(Config, "fallback_image_url", None),
+        )
+        if fallback_url:
+            return {"type": "image_url", "image_url": {"url": fallback_url}}
+        return None

Note: You may want to add the optional fallback_*_image_url fields to the relevant Config class (or a single fallback_image_url) if not already present.

Also applies to: 110-113, 66-69, 114-117

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/span_utils.py (1)

22-37: Fix Vertex Part image detection: prefer inline_data.mime_type and tighten checks.

Current logic incorrectly requires item.mime_type on the Part, which will miss images because Vertex places mime_type on inline_data. Also collapse nested ifs. This was raised previously; applying here ensures images are actually detected.

-def _is_base64_image_part(item):
-    """Check if item is a VertexAI Part object containing image data"""
-    try:
-        # Check if it has the Part attributes we expect
-        if not hasattr(item, 'inline_data') or not hasattr(item, 'mime_type'):
-            return False
-
-        # Check if it's an image mime type and has inline data
-        if item.mime_type and 'image/' in item.mime_type and item.inline_data:
-            # Check if the inline_data has actual data
-            if hasattr(item.inline_data, 'data') and item.inline_data.data:
-                return True
-
-        return False
-    except Exception:
-        return False
+def _is_base64_image_part(item):
+    """Check if item is a VertexAI Part object containing image data"""
+    try:
+        inline = getattr(item, "inline_data", None)
+        mime = getattr(inline, "mime_type", None) or getattr(item, "mime_type", None)
+        has_data = hasattr(inline, "data") and bool(inline.data)
+        return bool(mime and mime.startswith("image/") and has_data)
+    except Exception:
+        return False

packages/opentelemetry-instrumentation-google-generativeai/opentelemetry/instrumentation/google_generativeai/span_utils.py (1)

27-41: Constrain image detection to supported MIME types and simplify nested conditionals

The current _is_image_part accepts any image/* and uses deeply nested checks. Tighten to the formats you intend to support (PNG/JPEG/GIF/WebP) and flatten the predicate for readability and correctness (SIM102).

Apply within this range:

-def _is_image_part(item):
-    """Check if item is a Google GenAI Part object containing image data"""
-    try:
-        # Check if it has the Part attributes we expect for new Google GenAI SDK
-        if hasattr(item, 'inline_data') and item.inline_data is not None:
-            # Check if it's an image mime type and has data
-            if (hasattr(item.inline_data, 'mime_type') and
-                    item.inline_data.mime_type and
-                    'image/' in item.inline_data.mime_type and
-                    hasattr(item.inline_data, 'data') and
-                    item.inline_data.data):
-                return True
-        return False
-    except Exception:
-        return False
+def _is_image_part(item):
+    """Check if item is a Google GenAI Part object containing supported image data"""
+    try:
+        inline = getattr(item, "inline_data", None)
+        mime = getattr(inline, "mime_type", None)
+        data = getattr(inline, "data", None)
+        return bool(
+            inline
+            and isinstance(mime, str)
+            and mime in ALLOWED_IMAGE_MIME_TYPES
+            and data
+        )
+    except Exception:
+        return False

Add near the logger (outside this hunk) to centralize the allowlist:

# Supported image MIME types (align with PR scope)
ALLOWED_IMAGE_MIME_TYPES = {"image/png", "image/jpeg", "image/gif", "image/webp"}

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/__init__.py (1)

318-326: Minor typo in class docstring

“VertextAI” → “VertexAI”.

No functional impact, but worth fixing for polish.

packages/traceloop-sdk/traceloop/sdk/tracing/tracing.py (4)

424-429: Type hints: uploader is awaited downstream; annotate as awaitable

Across instrumentors, upload_base64_image is awaited. Update the type to an awaitable to reflect reality and help static analysis.

-def init_instrumentations(
-    should_enrich_metrics: bool,
-    base64_image_uploader: Callable[[str, str, str, str], str],
+from typing import Awaitable
+def init_instrumentations(
+    should_enrich_metrics: bool,
+    base64_image_uploader: Callable[[str, str, str, str], Awaitable[str]],

Remember to import Awaitable at the top (with the other typing imports).

---

561-563: Align OpenAI/Anthropic initializers with awaitable uploader signature

Propagate the awaitable type to these initializers to maintain consistency.

-def init_openai_instrumentor(
-    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], str]
+def init_openai_instrumentor(
+    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], Awaitable[str]]
@@
-def init_anthropic_instrumentor(
-    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], str]
+def init_anthropic_instrumentor(
+    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], Awaitable[str]]

Also applies to: 585-587

---

680-682: Gemini initializer: annotate uploader as awaitable

Same rationale as above for consistency and tooling.

-def init_google_generativeai_instrumentor(
-    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], str]
+def init_google_generativeai_instrumentor(
+    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], Awaitable[str]]
@@
             instrumentor = GoogleGenerativeAiInstrumentor(
                 exception_logger=lambda e: Telemetry().log_exception(e),
-                upload_base64_image=base64_image_uploader,
+                upload_base64_image=base64_image_uploader,
             )

Also applies to: 690-693

---

943-945: Vertex initializer: annotate uploader as awaitable

Mirror the awaitable type here as well.

-def init_vertexai_instrumentor(
-    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], str]
+def init_vertexai_instrumentor(
+    should_enrich_metrics: bool, base64_image_uploader: Callable[[str, str, str, str], Awaitable[str]]
@@
             instrumentor = VertexAIInstrumentor(
                 exception_logger=lambda e: Telemetry().log_exception(e),
-                upload_base64_image=base64_image_uploader,
+                upload_base64_image=base64_image_uploader,
             )

Also applies to: 951-954

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/span_utils.py (7)

16-18: Consolidate nested conditionals in _set_span_attribute for clarity.

Simplify to a single guard; keeps behavior identical and satisfies SIM102.

-    if value is not None:
-        if value != "":
-            span.set_attribute(name, value)
+    if value not in (None, ""):
+        span.set_attribute(name, value)

---

75-78: Harden run_async: log coroutine exceptions and avoid non-daemon thread.

Capture and log exceptions inside the worker; mark the helper thread as daemon to avoid shutdown hangs.

-        thread = threading.Thread(target=lambda: asyncio.run(method))
-        thread.start()
-        thread.join()
+        def _runner():
+            try:
+                asyncio.run(method)
+            except Exception as e:
+                logger.debug("run_async coroutine failed: %s", e)
+        thread = threading.Thread(target=_runner, daemon=True)
+        thread.start()
+        thread.join()

---

122-132: Avoid deepcopy for argument lists; iterate directly or take a shallow copy.

We don’t mutate items; deepcopy adds avoidable CPU and memory overhead for large prompt payloads.

-        # List of mixed content (text strings and Part objects) - deep copy and process
-        content_list = copy.deepcopy(argument)
+        # List of mixed content (text strings and Part objects) - no mutation required
+        content_list = list(argument)

---

156-158: Restrict fallback text size to prevent leaking huge object reprs.

Serializing arbitrary objects via str(content_item) risks very large attributes and inadvertent PII. Truncate defensively.

-        return {"type": "text", "text": str(content_item)}
+        text = str(content_item)
+        return {"type": "text", "text": text[:1000]}

---

167-178: Mirror shallow-copy optimization in sync path.

Same rationale as async path: avoid deepcopy.

-        # List of mixed content (text strings and Part objects) - deep copy and process
-        content_list = copy.deepcopy(argument)
+        # List of mixed content (text strings and Part objects) - no mutation required
+        content_list = list(argument)

---

201-203: Truncate fallback text in sync path as well.

Keep consistency and avoid oversized attributes.

-        return {"type": "text", "text": str(content_item)}
+        text = str(content_item)
+        return {"type": "text", "text": text[:1000]}

---

243-265: Mixed “.content” vs legacy “.user” prompt attributes—confirm intended dual format.

You now store JSON content at gen_ai.prompt.{i}.content while still setting gen_ai.prompt.0.user. If both are meant to coexist for back-compat, consider gating legacy fields behind Config.use_legacy_attributes to avoid duplication.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.