revert Python SDK related changes

Author: herin049

python/src/otel/otel_sdk/otel-instrument

@@ -146,18 +146,21 @@ else
     export OTEL_RESOURCE_ATTRIBUTES="$LAMBDA_RESOURCE_ATTRIBUTES,$OTEL_RESOURCE_ATTRIBUTES";
 fi
 
-# Redirect Lambda to load the `otel_wrapper.py` wrapper script instead of the
-# user's handler. The wrapper initializes OpenTelemetry instrumentation at module
-# load time and then delegates to the original handler.
+
+# - Uses the default `OTEL_PROPAGATORS` which is set to `tracecontext,baggage`
+
+# - Use a wrapper because AWS Lambda's `python3 /var/runtime/bootstrap.py` will
+#   use `imp.load_module` to load the function from the `_HANDLER` environment
+#   variable. This RELOADS the module and REMOVES any instrumentation patching
+#   done earlier. So we delay instrumentation until `bootstrap.py` imports
+#   `otel_wrapper.py` at which we know the patching will be picked up.
 #
-# _HANDLER is a reserved environment variable used by AWS Lambda containing the
-# application handler path (e.g., "mymodule.handler"). We save it to ORIG_HANDLER
-# to allow the `otel_wrapper.py` wrapper script to retrieve it later so it
-# can delegate to the original handler.
-# see: https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime
+#   See more:
+#   https://docs.python.org/3/library/imp.html#imp.load_module
+
 export ORIG_HANDLER=$_HANDLER;
 export _HANDLER="otel_wrapper.lambda_handler";
 
-# Handoff to the Lambda bootstrap process with _HANDLER set to
-# `otel_wrapper.lambda_handler`
-exec "$@"
+# - Call the upstream auto instrumentation script
+
+exec python3 $LAMBDA_LAYER_PKGS_DIR/bin/opentelemetry-instrument "$@"

python/src/otel/otel_sdk/otel_wrapper.py

@@ -13,83 +13,54 @@
 # limitations under the License.
 
 """
-OpenTelemetry Lambda Handler Wrapper
-
-This module wraps the user's Lambda function to enable automatic OpenTelemetry
-instrumentation. It acts as wrapper script that instruments the Lambda function
-before loading the module containing the user's handler.
-
-The instrumentation process works as follows:
-------------
-1. The `otel-instrument` shell script sets _HANDLER to point to this file's
-   `lambda_handler`, saving the original handler path to ORIG_HANDLER.
-
-2. When AWS Lambda imports this module, `auto_instrumentation.initialize()` runs
-   immediately, instrumenting the application before any user code executes.
-
-3. The module containing the user's handler is loaded by this script and the
-  `lambda_handler` variable is bound to the user's original handler function,
-   allowing Lambda invocations to be transparently forwarded to the original handler.
-
-Details on why the `opentelemetry-instrument` CLI wrapper is insufficient:
-------------------------------------------------
-The `opentelemetry-instrument` CLI wrapper only instruments the initial Python process.
-AWS Lambda may spawn fresh Python processes for new invocations (e.g. as is the case with
-lambda managed instances), which would bypass CLI based instrumentation. By
-calling `auto_instrumentation.initialize()` at module import time, we ensure every
-Lambda execution context is instrumented.
-
-Environment Variables
----------------------
-ORIG_HANDLER : str
-    The original Lambda handler path (e.g., "mymodule.handler"). Set by
-    `otel-instrument` before this module is loaded.
-"""
+`otel_wrapper.py`
+
+This file serves as a wrapper over the user's Lambda function.
+
+Usage
+-----
+Patch the reserved `_HANDLER` Lambda environment variable to point to this
+file's `otel_wrapper.lambda_handler` property. Do this having saved the original
+`_HANDLER` in the `ORIG_HANDLER` environment variable. Doing this makes it so
+that **on import of this file, the handler is instrumented**.
+
+Instrumenting any earlier will cause the instrumentation to be lost because the
+AWS Service uses `imp.load_module` to import the handler which RELOADS the
+module. This is why AwsLambdaInstrumentor cannot be instrumented with the
+`opentelemetry-instrument` script.
 
+See more:
+https://docs.python.org/3/library/imp.html#imp.load_module
+
+"""
 
 import os
 from importlib import import_module
 
-from opentelemetry.instrumentation import auto_instrumentation
-
-# Initialize OpenTelemetry instrumentation immediately on module import.
-# This must happen before the user's handler module is loaded (below) to ensure
-# all library patches are applied before any user code runs.
-auto_instrumentation.initialize()
+from opentelemetry.instrumentation.aws_lambda import AwsLambdaInstrumentor
 
 
-def _get_orig_handler():
-    """
-    Resolve and return the user's original Lambda handler function.
+def modify_module_name(module_name):
+    """Returns a valid modified module to get imported"""
+    return ".".join(module_name.split("/"))
 
-    Reads the handler path from the ORIG_HANDLER environment variable,
-    dynamically imports the handler's module and returns the handler
-    function.
-    """
 
-    handler_path = os.environ.get("ORIG_HANDLER")
+class HandlerError(Exception):
+    pass
 
-    if handler_path is None:
-        raise RuntimeError(
-            "ORIG_HANDLER is not defined."
-        )
 
-    # Split "module/path.handler_name" into module path and function name.
-    # The handler path uses the last "." as the separator between module and function.
-    try:
-        module_path, handler_name = handler_path.rsplit(".", 1)
-    except ValueError as e:
-        raise RuntimeError(
-            f"Invalid ORIG_HANDLER format '{handler_path}': expected "
-            f"'module.handler_name' or 'path/to/module.handler_name'. Error: {e}"
-        )
+AwsLambdaInstrumentor().instrument()
 
-    # Convert path separators to Python module notation
-    module_name = ".".join(module_path.split("/"))
+path = os.environ.get("ORIG_HANDLER")
 
-    handler_module = import_module(module_name)
-    return getattr(handler_module, handler_name)
+if path is None:
+    raise HandlerError("ORIG_HANDLER is not defined.")
 
+try:
+    (mod_name, handler_name) = path.rsplit(".", 1)
+except ValueError as e:
+    raise HandlerError("Bad path '{}' for ORIG_HANDLER: {}".format(path, str(e)))
 
-# Resolve to the user's handler at module load time.
-lambda_handler = _get_orig_handler()
+modified_mod_name = modify_module_name(mod_name)
+handler_module = import_module(modified_mod_name)
+lambda_handler = getattr(handler_module, handler_name)