Merge branch 'main' into bedrock-agentcore-resource-support

Author: liustve

.pylintrc

@@ -7,7 +7,7 @@ extension-pkg-whitelist=cassandra
 
 # Add list of files or directories to be excluded. They should be base names, not
 # paths.
-ignore=CVS,gen,Dockerfile,docker-compose.yml,README.md,requirements.txt,mock_collector_service_pb2.py,mock_collector_service_pb2.pyi,mock_collector_service_pb2_grpc.py
+ignore=CVS,gen,Dockerfile,docker-compose.yml,README.md,requirements.txt,mock_collector_service_pb2.py,mock_collector_service_pb2.pyi,mock_collector_service_pb2_grpc.py,pyproject.toml,db.sqlite3
 
 # Add files or directories matching the regex patterns to be excluded. The
 # regex matches against base names, not paths.

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/aws_opentelemetry_configurator.py

@@ -616,7 +616,7 @@ def _is_application_signals_runtime_enabled():
     )
 
 
-def _get_code_correlation_enabled_status() -> Optional[bool]:
+def get_code_correlation_enabled_status() -> Optional[bool]:
     """
     Get the code correlation enabled status from environment variable.
 

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/code_correlation/__init__.py

@@ -7,6 +7,7 @@
 This module provides functionality for correlating code execution with telemetry data.
 """
 
+import inspect
 from functools import wraps
 from typing import Any, Callable
 
@@ -21,7 +22,7 @@
 CODE_LINE_NUMBER = "code.line.number"
 
 
-def _add_code_attributes_to_span(span, func: Callable[..., Any]) -> None:
+def add_code_attributes_to_span(span, func_or_class: Callable[..., Any]) -> None:
     """
     Add code-related attributes to a span based on a Python function.
 
@@ -39,36 +40,27 @@ def _add_code_attributes_to_span(span, func: Callable[..., Any]) -> None:
         return
 
     try:
-        # Get function name
-        function_name = getattr(func, "__name__", str(func))
-        span.set_attribute(CODE_FUNCTION_NAME, function_name)
-
-        # Get function source file from code object
-        try:
-            if hasattr(func, "__code__"):
-                source_file = func.__code__.co_filename
-                span.set_attribute(CODE_FILE_PATH, source_file)
-        except (AttributeError, TypeError):
-            # Handle cases where code object is not available
-            # (e.g., built-in functions, C extensions)
-            pass
-
-        # Get function line number from code object
+        # Check if it's a class first, with proper exception handling
         try:
-            if hasattr(func, "__code__"):
-                line_number = func.__code__.co_firstlineno
-                span.set_attribute(CODE_LINE_NUMBER, line_number)
-        except (AttributeError, TypeError):
-            # Handle cases where code object is not available
-            pass
-
+            is_class = inspect.isclass(func_or_class)
+        except Exception:  # pylint: disable=broad-exception-caught
+            # If inspect.isclass fails, we can't safely determine the type, so return early
+            return
+
+        if is_class:
+            span.set_attribute(CODE_FUNCTION_NAME, f"{func_or_class.__module__}.{func_or_class.__qualname__}")
+            span.set_attribute(CODE_FILE_PATH, inspect.getfile(func_or_class))
+        else:
+            code = getattr(func_or_class, "__code__", None)
+            if code:
+                span.set_attribute(CODE_FUNCTION_NAME, f"{func_or_class.__module__}.{func_or_class.__qualname__}")
+                span.set_attribute(CODE_FILE_PATH, code.co_filename)
+                span.set_attribute(CODE_LINE_NUMBER, code.co_firstlineno)
     except Exception:  # pylint: disable=broad-exception-caught
-        # Silently handle any unexpected errors to avoid breaking
-        # the instrumentation flow
         pass
 
 
-def add_code_attributes_to_span(func: Callable[..., Any]) -> Callable[..., Any]:
+def record_code_attributes(func: Callable[..., Any]) -> Callable[..., Any]:
     """
     Decorator to automatically add code attributes to the current OpenTelemetry span.
 
@@ -81,12 +73,12 @@ def add_code_attributes_to_span(func: Callable[..., Any]) -> Callable[..., Any]:
     This decorator supports both synchronous and asynchronous functions.
 
     Usage:
-        @add_code_attributes_to_span
+        @record_code_attributes
         def my_sync_function():
             # Sync function implementation
             pass
 
-        @add_code_attributes_to_span
+        @record_code_attributes
         async def my_async_function():
             # Async function implementation
             pass
@@ -97,9 +89,8 @@ async def my_async_function():
     Returns:
         The wrapped function with current span code attributes tracing
     """
-    # Detect async functions: check function code object flags or special attributes
-    # CO_ITERABLE_COROUTINE = 0x80, async functions will have this flag set
-    is_async = (hasattr(func, "__code__") and func.__code__.co_flags & 0x80) or hasattr(func, "_is_coroutine")
+    # Detect async functions
+    is_async = inspect.iscoroutinefunction(func)
 
     if is_async:
         # Async function wrapper
@@ -109,7 +100,7 @@ async def async_wrapper(*args, **kwargs):
             try:
                 current_span = trace.get_current_span()
                 if current_span:
-                    _add_code_attributes_to_span(current_span, func)
+                    add_code_attributes_to_span(current_span, func)
             except Exception:  # pylint: disable=broad-exception-caught
                 # Silently handle any unexpected errors
                 pass
@@ -126,7 +117,7 @@ def sync_wrapper(*args, **kwargs):
         try:
             current_span = trace.get_current_span()
             if current_span:
-                _add_code_attributes_to_span(current_span, func)
+                add_code_attributes_to_span(current_span, func)
         except Exception:  # pylint: disable=broad-exception-caught
             # Silently handle any unexpected errors
             pass

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/patches/_django_patches.py

@@ -0,0 +1,140 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Modifications Copyright The OpenTelemetry Authors. Licensed under the Apache License 2.0 License.
+
+from logging import getLogger
+
+from amazon.opentelemetry.distro.aws_opentelemetry_configurator import get_code_correlation_enabled_status
+
+_logger = getLogger(__name__)
+
+
+def _apply_django_instrumentation_patches() -> None:
+    """Django instrumentation patches
+
+    Applies patches to provide code attributes support for Django instrumentation.
+    This patches the Django instrumentation to automatically add code attributes
+    to spans by modifying the process_view method of the Django middleware.
+    Also patches Django's path/re_path functions for URL pattern instrumentation.
+    """
+    if get_code_correlation_enabled_status() is True:
+        _apply_django_code_attributes_patch()
+
+
+def _apply_django_code_attributes_patch() -> None:  # pylint: disable=too-many-statements
+    """Django instrumentation patch for code attributes
+
+    This patch modifies the Django middleware's process_view method to automatically add
+    code attributes to the current span when a view function is about to be executed.
+
+    The patch includes:
+    1. Support for class-based views by extracting the actual HTTP method handler
+    2. Automatic addition of code.function.name, code.file.path, and code.line.number
+    3. Graceful error handling and cleanup during uninstrument
+    """
+    try:
+        # Import Django instrumentation classes and AWS code correlation function
+        from amazon.opentelemetry.distro.code_correlation import (  # pylint: disable=import-outside-toplevel
+            add_code_attributes_to_span,
+        )
+        from opentelemetry.instrumentation.django import DjangoInstrumentor  # pylint: disable=import-outside-toplevel
+
+        # Store the original _instrument and _uninstrument methods
+        original_instrument = DjangoInstrumentor._instrument
+        original_uninstrument = DjangoInstrumentor._uninstrument
+
+        # Store reference to original Django middleware process_view method
+        original_process_view = None
+
+        def _patch_django_middleware():
+            """Patch Django middleware's process_view method to add code attributes."""
+            try:
+                # Import Django middleware class
+                # pylint: disable=import-outside-toplevel
+                from opentelemetry.instrumentation.django.middleware.otel_middleware import _DjangoMiddleware
+
+                nonlocal original_process_view
+                if original_process_view is None:
+                    original_process_view = _DjangoMiddleware.process_view
+
+                def patched_process_view(
+                    self, request, view_func, *args, **kwargs
+                ):  # pylint: disable=too-many-locals,too-many-nested-blocks,too-many-branches
+                    """Patched process_view method to add code attributes to the span."""
+                    # First call the original process_view method
+                    result = original_process_view(self, request, view_func, *args, **kwargs)
+
+                    # Add code attributes if we have a span and view function
+                    try:
+                        if (
+                            self._environ_activation_key in request.META.keys()
+                            and self._environ_span_key in request.META.keys()
+                        ):
+                            span = request.META[self._environ_span_key]
+                            if span and view_func and span.is_recording():
+                                # Determine the target function/method to analyze
+                                target = view_func
+
+                                # If it's a class-based view, get the corresponding HTTP method handler
+                                view_class = getattr(view_func, "view_class", None)
+                                if view_class:
+                                    method_name = request.method.lower()
+                                    handler = getattr(view_class, method_name, None) or view_class
+                                    target = handler
+
+                                # Call the existing add_code_attributes_to_span function
+                                add_code_attributes_to_span(span, target)
+                                _logger.debug(
+                                    "Added code attributes to span for Django view: %s",
+                                    getattr(target, "__name__", str(target)),
+                                )
+                    except Exception as exc:  # pylint: disable=broad-exception-caught
+                        # Don't let code attributes addition break the request processing
+                        _logger.warning("Failed to add code attributes to Django span: %s", exc)
+
+                    return result
+
+                # Apply the patch
+                _DjangoMiddleware.process_view = patched_process_view
+                _logger.debug("Django middleware process_view patched successfully for code attributes")
+
+            except Exception as exc:  # pylint: disable=broad-exception-caught
+                _logger.warning("Failed to patch Django middleware process_view: %s", exc)
+
+        def _unpatch_django_middleware():
+            """Restore original Django middleware process_view method."""
+            try:
+                # pylint: disable=import-outside-toplevel
+                from opentelemetry.instrumentation.django.middleware.otel_middleware import _DjangoMiddleware
+
+                if original_process_view is not None:
+                    _DjangoMiddleware.process_view = original_process_view
+                    _logger.debug("Django middleware process_view restored successfully")
+
+            except Exception as exc:  # pylint: disable=broad-exception-caught
+                _logger.warning("Failed to restore Django middleware process_view: %s", exc)
+
+        def patched_instrument(self, **kwargs):
+            """Patched _instrument method with Django middleware patching"""
+            # Apply Django middleware patches
+            _patch_django_middleware()
+
+            # Call the original _instrument method
+            original_instrument(self, **kwargs)
+
+        def patched_uninstrument(self, **kwargs):
+            """Patched _uninstrument method with Django middleware patch restoration"""
+            # Call the original _uninstrument method first
+            original_uninstrument(self, **kwargs)
+
+            # Restore original Django middleware
+            _unpatch_django_middleware()
+
+        # Apply the patches to DjangoInstrumentor
+        DjangoInstrumentor._instrument = patched_instrument
+        DjangoInstrumentor._uninstrument = patched_uninstrument
+
+        _logger.debug("Django instrumentation code attributes patch applied successfully")
+
+    except Exception as exc:  # pylint: disable=broad-exception-caught
+        _logger.warning("Failed to apply Django code attributes patch: %s", exc)

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/patches/_fastapi_patches.py

@@ -0,0 +1,119 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Modifications Copyright The OpenTelemetry Authors. Licensed under the Apache License 2.0 License.
+
+from logging import getLogger
+
+from amazon.opentelemetry.distro.aws_opentelemetry_configurator import get_code_correlation_enabled_status
+
+_logger = getLogger(__name__)
+
+
+def _apply_fastapi_instrumentation_patches() -> None:
+    """FastAPI instrumentation patches
+
+    Applies patches to provide code attributes support for FastAPI instrumentation.
+    This patches the FastAPI instrumentation to automatically add code attributes
+    to spans by decorating view functions with record_code_attributes.
+    """
+    if get_code_correlation_enabled_status() is True:
+        _apply_fastapi_code_attributes_patch()
+
+
+def _apply_fastapi_code_attributes_patch() -> None:
+    """FastAPI instrumentation patch for code attributes
+
+    This patch modifies the FastAPI instrumentation to automatically apply
+    the current_span_code_attributes decorator to all endpoint functions when
+    the FastAPI app is instrumented.
+
+    The patch:
+    1. Imports current_span_code_attributes decorator from AWS distro utils
+    2. Hooks FastAPI's APIRouter.add_api_route method during instrumentation
+    3. Automatically decorates endpoint functions as they are registered
+    4. Adds code.function.name, code.file.path, and code.line.number to spans
+    5. Provides cleanup during uninstrumentation
+    """
+    try:
+        # Import FastAPI instrumentation classes and AWS decorator
+        from fastapi import routing  # pylint: disable=import-outside-toplevel
+
+        from amazon.opentelemetry.distro.code_correlation import (  # pylint: disable=import-outside-toplevel
+            record_code_attributes,
+        )
+        from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor  # pylint: disable=import-outside-toplevel
+
+        # Store the original _instrument and _uninstrument methods
+        original_instrument = FastAPIInstrumentor._instrument
+        original_uninstrument = FastAPIInstrumentor._uninstrument
+
+        def _wrapped_add_api_route(original_add_api_route_method):
+            """Wrapper for APIRouter.add_api_route method."""
+
+            def wrapper(self, *args, **kwargs):
+                # Apply current_span_code_attributes decorator to endpoint function
+                try:
+                    # Get endpoint function from args or kwargs
+                    endpoint = None
+                    if len(args) >= 2:
+                        endpoint = args[1]
+                    else:
+                        endpoint = kwargs.get("endpoint")
+
+                    if endpoint and callable(endpoint):
+                        # Check if function is already decorated (avoid double decoration)
+                        if not hasattr(endpoint, "_current_span_code_attributes_decorated"):
+                            # Apply decorator
+                            decorated_endpoint = record_code_attributes(endpoint)
+                            # Mark as decorated to avoid double decoration
+                            decorated_endpoint._current_span_code_attributes_decorated = True
+                            decorated_endpoint._original_endpoint = endpoint
+
+                            # Replace endpoint in args or kwargs
+                            if len(args) >= 2:
+                                args = list(args)
+                                args[1] = decorated_endpoint
+                                args = tuple(args)
+                            elif "endpoint" in kwargs:
+                                kwargs["endpoint"] = decorated_endpoint
+
+                except Exception as exc:  # pylint: disable=broad-exception-caught
+                    _logger.warning("Failed to apply code attributes decorator to endpoint: %s", exc)
+
+                return original_add_api_route_method(self, *args, **kwargs)
+
+            return wrapper
+
+        def patched_instrument(self, **kwargs):
+            """Patched _instrument method with APIRouter.add_api_route wrapping"""
+            # Store original add_api_route method if not already stored
+            if not hasattr(self, "_original_apirouter"):
+                self._original_apirouter = routing.APIRouter.add_api_route
+
+            # Wrap APIRouter.add_api_route with code attributes decoration
+            routing.APIRouter.add_api_route = _wrapped_add_api_route(self._original_apirouter)
+
+            # Call the original _instrument method
+            original_instrument(self, **kwargs)
+
+        def patched_uninstrument(self, **kwargs):
+            """Patched _uninstrument method with APIRouter.add_api_route restoration"""
+            # Call the original _uninstrument method first
+            original_uninstrument(self, **kwargs)
+
+            # Restore original APIRouter.add_api_route method if it exists
+            if hasattr(self, "_original_apirouter"):
+                try:
+                    routing.APIRouter.add_api_route = self._original_apirouter
+                    delattr(self, "_original_apirouter")
+                except Exception as exc:  # pylint: disable=broad-exception-caught
+                    _logger.warning("Failed to restore original APIRouter.add_api_route method: %s", exc)
+
+        # Apply the patches to FastAPIInstrumentor
+        FastAPIInstrumentor._instrument = patched_instrument
+        FastAPIInstrumentor._uninstrument = patched_uninstrument
+
+        _logger.debug("FastAPI instrumentation code attributes patch applied successfully")
+
+    except Exception as exc:  # pylint: disable=broad-exception-caught
+        _logger.warning("Failed to apply FastAPI code attributes patch: %s", exc)