two version of R2R are hereHEADmaster

3 files changed, 316 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/instrumentation/auto_instrumentation/__init__.py b/.venv/lib/python3.12/site-packages/opentelemetry/instrumentation/auto_instrumentation/__init__.py
new file mode 100644
index 00000000..69af0b4c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/opentelemetry/instrumentation/auto_instrumentation/__init__.py
@@ -0,0 +1,135 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from argparse import REMAINDER, ArgumentParser
+from logging import getLogger
+from os import environ, execl, getcwd
+from os.path import abspath, dirname, pathsep
+from re import sub
+from shutil import which
+
+from opentelemetry.instrumentation.auto_instrumentation._load import (
+    _load_configurators,
+    _load_distro,
+    _load_instrumentors,
+)
+from opentelemetry.instrumentation.utils import _python_path_without_directory
+from opentelemetry.instrumentation.version import __version__
+from opentelemetry.util._importlib_metadata import entry_points
+
+_logger = getLogger(__name__)
+
+
+def run() -> None:
+    parser = ArgumentParser(
+        description="""
+        opentelemetry-instrument automatically instruments a Python
+        program and its dependencies and then runs the program.
+        """,
+        epilog="""
+        Optional arguments (except for --help and --version) for opentelemetry-instrument
+        directly correspond with OpenTelemetry environment variables. The
+        corresponding optional argument is formed by removing the OTEL_ or
+        OTEL_PYTHON_ prefix from the environment variable and lower casing the
+        rest. For example, the optional argument --attribute_value_length_limit
+        corresponds with the environment variable
+        OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT.
+
+        These optional arguments will override the current value of the
+        corresponding environment variable during the execution of the command.
+        """,
+    )
+
+    argument_otel_environment_variable = {}
+
+    for entry_point in entry_points(
+        group="opentelemetry_environment_variables"
+    ):
+        environment_variable_module = entry_point.load()
+
+        for attribute in dir(environment_variable_module):
+            if attribute.startswith("OTEL_"):
+                argument = sub(r"OTEL_(PYTHON_)?", "", attribute).lower()
+
+                parser.add_argument(
+                    f"--{argument}",
+                    required=False,
+                )
+                argument_otel_environment_variable[argument] = attribute
+
+    parser.add_argument(
+        "--version",
+        help="print version information",
+        action="version",
+        version="%(prog)s " + __version__,
+    )
+    parser.add_argument("command", help="Your Python application.")
+    parser.add_argument(
+        "command_args",
+        help="Arguments for your application.",
+        nargs=REMAINDER,
+    )
+
+    args = parser.parse_args()
+
+    for argument, otel_environment_variable in (
+        argument_otel_environment_variable
+    ).items():
+        value = getattr(args, argument)
+        if value is not None:
+            environ[otel_environment_variable] = value
+
+    python_path = environ.get("PYTHONPATH")
+
+    if not python_path:
+        python_path = []
+
+    else:
+        python_path = python_path.split(pathsep)
+
+    cwd_path = getcwd()
+
+    # This is being added to support applications that are being run from their
+    # own executable, like Django.
+    # FIXME investigate if there is another way to achieve this
+    if cwd_path not in python_path:
+        python_path.insert(0, cwd_path)
+
+    filedir_path = dirname(abspath(__file__))
+
+    python_path = [path for path in python_path if path != filedir_path]
+
+    python_path.insert(0, filedir_path)
+
+    environ["PYTHONPATH"] = pathsep.join(python_path)
+
+    executable = which(args.command)
+    execl(executable, executable, *args.command_args)
+
+
+def initialize():
+    """Setup auto-instrumentation, called by the sitecustomize module"""
+    # prevents auto-instrumentation of subprocesses if code execs another python process
+    if "PYTHONPATH" in environ:
+        environ["PYTHONPATH"] = _python_path_without_directory(
+            environ["PYTHONPATH"], dirname(abspath(__file__)), pathsep
+        )
+
+    try:
+        distro = _load_distro()
+        distro.configure()
+        _load_configurators()
+        _load_instrumentors(distro)
+    except Exception:  # pylint: disable=broad-except
+        _logger.exception("Failed to auto initialize OpenTelemetry")
diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/instrumentation/auto_instrumentation/_load.py b/.venv/lib/python3.12/site-packages/opentelemetry/instrumentation/auto_instrumentation/_load.py
new file mode 100644
index 00000000..3d602b2a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/opentelemetry/instrumentation/auto_instrumentation/_load.py
@@ -0,0 +1,164 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from functools import cached_property
+from logging import getLogger
+from os import environ
+
+from opentelemetry.instrumentation.dependencies import (
+    get_dist_dependency_conflicts,
+)
+from opentelemetry.instrumentation.distro import BaseDistro, DefaultDistro
+from opentelemetry.instrumentation.environment_variables import (
+    OTEL_PYTHON_CONFIGURATOR,
+    OTEL_PYTHON_DISABLED_INSTRUMENTATIONS,
+    OTEL_PYTHON_DISTRO,
+)
+from opentelemetry.instrumentation.version import __version__
+from opentelemetry.util._importlib_metadata import (
+    EntryPoint,
+    distributions,
+    entry_points,
+)
+
+_logger = getLogger(__name__)
+
+
+class _EntryPointDistFinder:
+    @cached_property
+    def _mapping(self):
+        return {
+            self._key_for(ep): dist
+            for dist in distributions()
+            for ep in dist.entry_points
+        }
+
+    def dist_for(self, entry_point: EntryPoint):
+        dist = getattr(entry_point, "dist", None)
+        if dist:
+            return dist
+
+        return self._mapping.get(self._key_for(entry_point))
+
+    @staticmethod
+    def _key_for(entry_point: EntryPoint):
+        return f"{entry_point.group}:{entry_point.name}:{entry_point.value}"
+
+
+def _load_distro() -> BaseDistro:
+    distro_name = environ.get(OTEL_PYTHON_DISTRO, None)
+    for entry_point in entry_points(group="opentelemetry_distro"):
+        try:
+            # If no distro is specified, use first to come up.
+            if distro_name is None or distro_name == entry_point.name:
+                distro = entry_point.load()()
+                if not isinstance(distro, BaseDistro):
+                    _logger.debug(
+                        "%s is not an OpenTelemetry Distro. Skipping",
+                        entry_point.name,
+                    )
+                    continue
+                _logger.debug(
+                    "Distribution %s will be configured", entry_point.name
+                )
+                return distro
+        except Exception as exc:  # pylint: disable=broad-except
+            _logger.exception(
+                "Distribution %s configuration failed", entry_point.name
+            )
+            raise exc
+    return DefaultDistro()
+
+
+def _load_instrumentors(distro):
+    package_to_exclude = environ.get(OTEL_PYTHON_DISABLED_INSTRUMENTATIONS, [])
+    entry_point_finder = _EntryPointDistFinder()
+    if isinstance(package_to_exclude, str):
+        package_to_exclude = package_to_exclude.split(",")
+        # to handle users entering "requests , flask" or "requests, flask" with spaces
+        package_to_exclude = [x.strip() for x in package_to_exclude]
+
+    for entry_point in entry_points(group="opentelemetry_pre_instrument"):
+        entry_point.load()()
+
+    for entry_point in entry_points(group="opentelemetry_instrumentor"):
+        if entry_point.name in package_to_exclude:
+            _logger.debug(
+                "Instrumentation skipped for library %s", entry_point.name
+            )
+            continue
+
+        try:
+            entry_point_dist = entry_point_finder.dist_for(entry_point)
+            conflict = get_dist_dependency_conflicts(entry_point_dist)
+            if conflict:
+                _logger.debug(
+                    "Skipping instrumentation %s: %s",
+                    entry_point.name,
+                    conflict,
+                )
+                continue
+
+            # tell instrumentation to not run dep checks again as we already did it above
+            distro.load_instrumentor(entry_point, skip_dep_check=True)
+            _logger.debug("Instrumented %s", entry_point.name)
+        except ImportError:
+            # in scenarios using the kubernetes operator to do autoinstrumentation some
+            # instrumentors (usually requiring binary extensions) may fail to load
+            # because the injected autoinstrumentation code does not match the application
+            # environment regarding python version, libc, etc... In this case it's better
+            # to skip the single instrumentation rather than failing to load everything
+            # so treat differently ImportError than the rest of exceptions
+            _logger.exception(
+                "Importing of %s failed, skipping it", entry_point.name
+            )
+            continue
+        except Exception as exc:  # pylint: disable=broad-except
+            _logger.exception("Instrumenting of %s failed", entry_point.name)
+            raise exc
+
+    for entry_point in entry_points(group="opentelemetry_post_instrument"):
+        entry_point.load()()
+
+
+def _load_configurators():
+    configurator_name = environ.get(OTEL_PYTHON_CONFIGURATOR, None)
+    configured = None
+    for entry_point in entry_points(group="opentelemetry_configurator"):
+        if configured is not None:
+            _logger.warning(
+                "Configuration of %s not loaded, %s already loaded",
+                entry_point.name,
+                configured,
+            )
+            continue
+        try:
+            if (
+                configurator_name is None
+                or configurator_name == entry_point.name
+            ):
+                entry_point.load()().configure(
+                    auto_instrumentation_version=__version__
+                )  # type: ignore
+                configured = entry_point.name
+            else:
+                _logger.warning(
+                    "Configuration of %s not loaded because %s is set by %s",
+                    entry_point.name,
+                    configurator_name,
+                    OTEL_PYTHON_CONFIGURATOR,
+                )
+        except Exception as exc:  # pylint: disable=broad-except
+            _logger.exception("Configuration of %s failed", entry_point.name)
+            raise exc
diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/instrumentation/auto_instrumentation/sitecustomize.py b/.venv/lib/python3.12/site-packages/opentelemetry/instrumentation/auto_instrumentation/sitecustomize.py
new file mode 100644
index 00000000..c126b873
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/opentelemetry/instrumentation/auto_instrumentation/sitecustomize.py
@@ -0,0 +1,17 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opentelemetry.instrumentation.auto_instrumentation import initialize
+
+initialize()