opentelemetry-instrumentation 0.39b0__tar.gz → 0.41b0__tar.gz

{opentelemetry_instrumentation-0.39b0 → opentelemetry_instrumentation-0.41b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentelemetry-instrumentation
-Version: 0.39b0
+Version: 0.41b0
 Summary: Instrumentation Tools & Auto Instrumentation for OpenTelemetry Python
 Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/opentelemetry-instrumentation
 Author-email: OpenTelemetry Authors <cncf-opentelemetry-contributors@lists.cncf.io>
@@ -43,12 +43,15 @@ This package provides a couple of commands that help automatically instruments a
 
 .. note::
     You need to install a distro package to get auto instrumentation working. The ``opentelemetry-distro``
-    package contains the default distro and automatically configures some of the common options for users.
+    package contains the default distro and configurator and automatically configures some of the common options for users.
     For more info about ``opentelemetry-distro`` check `here <https://opentelemetry-python.readthedocs.io/en/latest/examples/distro/README.html>`__
     ::
 
         pip install opentelemetry-distro[otlp]
 
+    When creating a custom distro and/or configurator, be sure to add entry points for each under `opentelemetry_distro` and `opentelemetry_configurator` respectfully.
+    If you have entry points for multiple distros or configurators present in your environment, you should specify the entry point name of the distro and configurator you want to be used via the `OTEL_PYTHON_DISTRO` and `OTEL_PYTHON_CONFIGURATOR` environment variables.
+
 
 opentelemetry-bootstrap
 -----------------------
@@ -83,6 +86,8 @@ The command supports the following configuration options as CLI arguments and en
 
 * ``--traces_exporter`` or ``OTEL_TRACES_EXPORTER``
 * ``--metrics_exporter`` or ``OTEL_METRICS_EXPORTER``
+* ``--distro`` or ``OTEL_PYTHON_DISTRO``
+* ``--configurator`` or ``OTEL_PYTHON_CONFIGURATOR``
 
 Used to specify which trace exporter to use. Can be set to one or more of the well-known exporter
 names (see below).

{opentelemetry_instrumentation-0.39b0 → opentelemetry_instrumentation-0.41b0}/README.rst

@@ -18,12 +18,15 @@ This package provides a couple of commands that help automatically instruments a
 
 .. note::
     You need to install a distro package to get auto instrumentation working. The ``opentelemetry-distro``
-    package contains the default distro and automatically configures some of the common options for users.
+    package contains the default distro and configurator and automatically configures some of the common options for users.
     For more info about ``opentelemetry-distro`` check `here <https://opentelemetry-python.readthedocs.io/en/latest/examples/distro/README.html>`__
     ::
 
         pip install opentelemetry-distro[otlp]
 
+    When creating a custom distro and/or configurator, be sure to add entry points for each under `opentelemetry_distro` and `opentelemetry_configurator` respectfully.
+    If you have entry points for multiple distros or configurators present in your environment, you should specify the entry point name of the distro and configurator you want to be used via the `OTEL_PYTHON_DISTRO` and `OTEL_PYTHON_CONFIGURATOR` environment variables.
+
 
 opentelemetry-bootstrap
 -----------------------
@@ -58,6 +61,8 @@ The command supports the following configuration options as CLI arguments and en
 
 * ``--traces_exporter`` or ``OTEL_TRACES_EXPORTER``
 * ``--metrics_exporter`` or ``OTEL_METRICS_EXPORTER``
+* ``--distro`` or ``OTEL_PYTHON_DISTRO``
+* ``--configurator`` or ``OTEL_PYTHON_CONFIGURATOR``
 
 Used to specify which trace exporter to use. Can be set to one or more of the well-known exporter
 names (see below).

opentelemetry_instrumentation-0.39b0/src/opentelemetry/instrumentation/auto_instrumentation/sitecustomize.py → opentelemetry_instrumentation-0.41b0/src/opentelemetry/instrumentation/auto_instrumentation/_load.py

@@ -14,7 +14,6 @@
 
 from logging import getLogger
 from os import environ
-from os.path import abspath, dirname, pathsep
 
 from pkg_resources import iter_entry_points
 
@@ -23,30 +22,34 @@ from opentelemetry.instrumentation.dependencies import (
 )
 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.utils import _python_path_without_directory
 from opentelemetry.instrumentation.version import __version__
 
-logger = getLogger(__name__)
+_logger = getLogger(__name__)
 
 
-def _load_distros() -> BaseDistro:
+def _load_distro() -> BaseDistro:
+    distro_name = environ.get(OTEL_PYTHON_DISTRO, None)
     for entry_point in iter_entry_points("opentelemetry_distro"):
         try:
-            distro = entry_point.load()()
-            if not isinstance(distro, BaseDistro):
-                logger.debug(
-                    "%s is not an OpenTelemetry Distro. Skipping",
-                    entry_point.name,
+            # 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
                 )
-                continue
-            logger.debug(
-                "Distribution %s will be configured", entry_point.name
-            )
-            return distro
+                return distro
         except Exception as exc:  # pylint: disable=broad-except
-            logger.exception(
+            _logger.exception(
                 "Distribution %s configuration failed", entry_point.name
             )
             raise exc
@@ -65,7 +68,7 @@ def _load_instrumentors(distro):
 
     for entry_point in iter_entry_points("opentelemetry_instrumentor"):
         if entry_point.name in package_to_exclude:
-            logger.debug(
+            _logger.debug(
                 "Instrumentation skipped for library %s", entry_point.name
             )
             continue
@@ -73,7 +76,7 @@ def _load_instrumentors(distro):
         try:
             conflict = get_dist_dependency_conflicts(entry_point.dist)
             if conflict:
-                logger.debug(
+                _logger.debug(
                     "Skipping instrumentation %s: %s",
                     entry_point.name,
                     conflict,
@@ -82,9 +85,9 @@ def _load_instrumentors(distro):
 
             # 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)
+            _logger.debug("Instrumented %s", entry_point.name)
         except Exception as exc:  # pylint: disable=broad-except
-            logger.exception("Instrumenting of %s failed", entry_point.name)
+            _logger.exception("Instrumenting of %s failed", entry_point.name)
             raise exc
 
     for entry_point in iter_entry_points("opentelemetry_post_instrument"):
@@ -92,36 +95,30 @@ def _load_instrumentors(distro):
 
 
 def _load_configurators():
+    configurator_name = environ.get(OTEL_PYTHON_CONFIGURATOR, None)
     configured = None
     for entry_point in iter_entry_points("opentelemetry_configurator"):
         if configured is not None:
-            logger.warning(
+            _logger.warning(
                 "Configuration of %s not loaded, %s already loaded",
                 entry_point.name,
                 configured,
             )
             continue
         try:
-            entry_point.load()().configure(auto_instrumentation_version=__version__)  # type: ignore
-            configured = entry_point.name
+            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)
+            _logger.exception("Configuration of %s failed", entry_point.name)
             raise exc
-
-
-def initialize():
-    # prevents auto-instrumentation of subprocesses if code execs another python process
-    environ["PYTHONPATH"] = _python_path_without_directory(
-        environ["PYTHONPATH"], dirname(abspath(__file__)), pathsep
-    )
-
-    try:
-        distro = _load_distros()
-        distro.configure()
-        _load_configurators()
-        _load_instrumentors(distro)
-    except Exception:  # pylint: disable=broad-except
-        logger.exception("Failed to auto initialize opentelemetry")
-
-
-initialize()

opentelemetry_instrumentation-0.41b0/src/opentelemetry/instrumentation/auto_instrumentation/sitecustomize.py

@@ -0,0 +1,44 @@
+# 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 logging import getLogger
+from os import environ
+from os.path import abspath, dirname, pathsep
+
+from opentelemetry.instrumentation.auto_instrumentation._load import (
+    _load_configurators,
+    _load_distro,
+    _load_instrumentors,
+)
+from opentelemetry.instrumentation.utils import _python_path_without_directory
+
+logger = getLogger(__name__)
+
+
+def initialize():
+    # prevents auto-instrumentation of subprocesses if code execs another python process
+    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")
+
+
+initialize()

{opentelemetry_instrumentation-0.39b0 → opentelemetry_instrumentation-0.41b0}/src/opentelemetry/instrumentation/bootstrap_gen.py

@@ -18,158 +18,170 @@
 libraries = {
     "aio_pika": {
         "library": "aio_pika >= 7.2.0, < 10.0.0",
-        "instrumentation": "opentelemetry-instrumentation-aio-pika==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-aio-pika==0.41b0",
     },
     "aiohttp": {
         "library": "aiohttp ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-aiohttp-client==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-aiohttp-client==0.41b0",
     },
     "aiopg": {
         "library": "aiopg >= 0.13.0, < 2.0.0",
-        "instrumentation": "opentelemetry-instrumentation-aiopg==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-aiopg==0.41b0",
     },
     "asgiref": {
         "library": "asgiref ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-asgi==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-asgi==0.41b0",
     },
     "asyncpg": {
         "library": "asyncpg >= 0.12.0",
-        "instrumentation": "opentelemetry-instrumentation-asyncpg==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-asyncpg==0.41b0",
     },
     "boto": {
         "library": "boto~=2.0",
-        "instrumentation": "opentelemetry-instrumentation-boto==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-boto==0.41b0",
     },
     "boto3": {
         "library": "boto3 ~= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-boto3sqs==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-boto3sqs==0.41b0",
     },
     "botocore": {
         "library": "botocore ~= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-botocore==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-botocore==0.41b0",
+    },
+    "cassandra-driver": {
+        "library": "cassandra-driver ~= 3.25",
+        "instrumentation": "opentelemetry-instrumentation-cassandra==0.41b0",
+    },
+    "scylla-driver": {
+        "library": "scylla-driver ~= 3.25",
+        "instrumentation": "opentelemetry-instrumentation-cassandra==0.41b0",
     },
     "celery": {
         "library": "celery >= 4.0, < 6.0",
-        "instrumentation": "opentelemetry-instrumentation-celery==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-celery==0.41b0",
     },
     "confluent-kafka": {
-        "library": "confluent-kafka >= 1.8.2, < 2.0.0",
-        "instrumentation": "opentelemetry-instrumentation-confluent-kafka==0.39b0",
+        "library": "confluent-kafka >= 1.8.2, <= 2.2.0",
+        "instrumentation": "opentelemetry-instrumentation-confluent-kafka==0.41b0",
     },
     "django": {
         "library": "django >= 1.10",
-        "instrumentation": "opentelemetry-instrumentation-django==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-django==0.41b0",
     },
     "elasticsearch": {
         "library": "elasticsearch >= 2.0",
-        "instrumentation": "opentelemetry-instrumentation-elasticsearch==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-elasticsearch==0.41b0",
     },
     "falcon": {
         "library": "falcon >= 1.4.1, < 4.0.0",
-        "instrumentation": "opentelemetry-instrumentation-falcon==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-falcon==0.41b0",
     },
     "fastapi": {
         "library": "fastapi ~= 0.58",
-        "instrumentation": "opentelemetry-instrumentation-fastapi==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-fastapi==0.41b0",
     },
     "flask": {
         "library": "flask >= 1.0, < 3.0",
-        "instrumentation": "opentelemetry-instrumentation-flask==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-flask==0.41b0",
     },
     "grpcio": {
         "library": "grpcio ~= 1.27",
-        "instrumentation": "opentelemetry-instrumentation-grpc==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-grpc==0.41b0",
     },
     "httpx": {
-        "library": "httpx >= 0.18.0, <= 0.23.0",
-        "instrumentation": "opentelemetry-instrumentation-httpx==0.39b0",
+        "library": "httpx >= 0.18.0",
+        "instrumentation": "opentelemetry-instrumentation-httpx==0.41b0",
     },
     "jinja2": {
         "library": "jinja2 >= 2.7, < 4.0",
-        "instrumentation": "opentelemetry-instrumentation-jinja2==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-jinja2==0.41b0",
     },
     "kafka-python": {
         "library": "kafka-python >= 2.0",
-        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.41b0",
     },
     "mysql-connector-python": {
         "library": "mysql-connector-python ~= 8.0",
-        "instrumentation": "opentelemetry-instrumentation-mysql==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-mysql==0.41b0",
+    },
+    "mysqlclient": {
+        "library": "mysqlclient < 3",
+        "instrumentation": "opentelemetry-instrumentation-mysqlclient==0.41b0",
     },
     "pika": {
         "library": "pika >= 0.12.0",
-        "instrumentation": "opentelemetry-instrumentation-pika==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-pika==0.41b0",
     },
     "psycopg2": {
         "library": "psycopg2 >= 2.7.3.1",
-        "instrumentation": "opentelemetry-instrumentation-psycopg2==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-psycopg2==0.41b0",
     },
     "pymemcache": {
         "library": "pymemcache >= 1.3.5, < 5",
-        "instrumentation": "opentelemetry-instrumentation-pymemcache==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-pymemcache==0.41b0",
     },
     "pymongo": {
         "library": "pymongo >= 3.1, < 5.0",
-        "instrumentation": "opentelemetry-instrumentation-pymongo==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-pymongo==0.41b0",
     },
     "PyMySQL": {
         "library": "PyMySQL < 2",
-        "instrumentation": "opentelemetry-instrumentation-pymysql==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-pymysql==0.41b0",
     },
     "pyramid": {
         "library": "pyramid >= 1.7",
-        "instrumentation": "opentelemetry-instrumentation-pyramid==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-pyramid==0.41b0",
     },
     "redis": {
         "library": "redis >= 2.6",
-        "instrumentation": "opentelemetry-instrumentation-redis==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-redis==0.41b0",
     },
     "remoulade": {
         "library": "remoulade >= 0.50",
-        "instrumentation": "opentelemetry-instrumentation-remoulade==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-remoulade==0.41b0",
     },
     "requests": {
         "library": "requests ~= 2.0",
-        "instrumentation": "opentelemetry-instrumentation-requests==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-requests==0.41b0",
     },
     "scikit-learn": {
         "library": "scikit-learn ~= 0.24.0",
-        "instrumentation": "opentelemetry-instrumentation-sklearn==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-sklearn==0.41b0",
     },
     "sqlalchemy": {
         "library": "sqlalchemy",
-        "instrumentation": "opentelemetry-instrumentation-sqlalchemy==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-sqlalchemy==0.41b0",
     },
     "starlette": {
         "library": "starlette ~= 0.13.0",
-        "instrumentation": "opentelemetry-instrumentation-starlette==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-starlette==0.41b0",
     },
     "psutil": {
         "library": "psutil >= 5",
-        "instrumentation": "opentelemetry-instrumentation-system-metrics==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-system-metrics==0.41b0",
     },
     "tornado": {
         "library": "tornado >= 5.1.1",
-        "instrumentation": "opentelemetry-instrumentation-tornado==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-tornado==0.41b0",
     },
     "tortoise-orm": {
         "library": "tortoise-orm >= 0.17.0",
-        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.41b0",
     },
     "pydantic": {
         "library": "pydantic >= 1.10.2",
-        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.39b0",
+        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.41b0",
     },
     "urllib3": {
-        "library": "urllib3 >= 1.0.0, < 2.0.0",
-        "instrumentation": "opentelemetry-instrumentation-urllib3==0.39b0",
+        "library": "urllib3 >= 1.0.0, < 3.0.0",
+        "instrumentation": "opentelemetry-instrumentation-urllib3==0.41b0",
     },
 }
 default_instrumentations = [
-    "opentelemetry-instrumentation-aws-lambda==0.39b0",
-    "opentelemetry-instrumentation-dbapi==0.39b0",
-    "opentelemetry-instrumentation-logging==0.39b0",
-    "opentelemetry-instrumentation-sqlite3==0.39b0",
-    "opentelemetry-instrumentation-urllib==0.39b0",
-    "opentelemetry-instrumentation-wsgi==0.39b0",
+    "opentelemetry-instrumentation-aws-lambda==0.41b0",
+    "opentelemetry-instrumentation-dbapi==0.41b0",
+    "opentelemetry-instrumentation-logging==0.41b0",
+    "opentelemetry-instrumentation-sqlite3==0.41b0",
+    "opentelemetry-instrumentation-urllib==0.41b0",
+    "opentelemetry-instrumentation-wsgi==0.41b0",
 ]

{opentelemetry_instrumentation-0.39b0 → opentelemetry_instrumentation-0.41b0}/src/opentelemetry/instrumentation/environment_variables.py

@@ -16,3 +16,13 @@ OTEL_PYTHON_DISABLED_INSTRUMENTATIONS = "OTEL_PYTHON_DISABLED_INSTRUMENTATIONS"
 """
 .. envvar:: OTEL_PYTHON_DISABLED_INSTRUMENTATIONS
 """
+
+OTEL_PYTHON_DISTRO = "OTEL_PYTHON_DISTRO"
+"""
+.. envvar:: OTEL_PYTHON_DISTRO
+"""
+
+OTEL_PYTHON_CONFIGURATOR = "OTEL_PYTHON_CONFIGURATOR"
+"""
+.. envvar:: OTEL_PYTHON_CONFIGURATOR
+"""

{opentelemetry_instrumentation-0.39b0 → opentelemetry_instrumentation-0.41b0}/src/opentelemetry/instrumentation/utils.py

@@ -95,7 +95,7 @@ def _start_internal_or_server_span(
 
     Args:
         tracer : tracer in use by given instrumentation library
-        name (string): name of the span
+        span_name (string): name of the span
         start_time : start time of the span
         context_carrier : object which contains values that are
             used to construct a Context. This object

{opentelemetry_instrumentation-0.39b0 → opentelemetry_instrumentation-0.41b0}/src/opentelemetry/instrumentation/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.39b0"
+__version__ = "0.41b0"

opentelemetry_instrumentation-0.41b0/tests/auto_instrumentation/test_load.py

@@ -0,0 +1,312 @@
+# 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.
+# type: ignore
+
+from unittest import TestCase
+from unittest.mock import Mock, call, patch
+
+from opentelemetry.instrumentation.auto_instrumentation import _load
+from opentelemetry.instrumentation.environment_variables import (
+    OTEL_PYTHON_CONFIGURATOR,
+    OTEL_PYTHON_DISABLED_INSTRUMENTATIONS,
+    OTEL_PYTHON_DISTRO,
+)
+from opentelemetry.instrumentation.version import __version__
+
+
+class TestLoad(TestCase):
+    @patch.dict(
+        "os.environ", {OTEL_PYTHON_CONFIGURATOR: "custom_configurator2"}
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
+    )
+    def test_load_configurators(self, iter_mock):
+        # Add multiple entry points but only specify the 2nd in the environment variable.
+        ep_mock1 = Mock()
+        ep_mock1.name = "custom_configurator1"
+        configurator_mock1 = Mock()
+        ep_mock1.load.return_value = configurator_mock1
+        ep_mock2 = Mock()
+        ep_mock2.name = "custom_configurator2"
+        configurator_mock2 = Mock()
+        ep_mock2.load.return_value = configurator_mock2
+        ep_mock3 = Mock()
+        ep_mock3.name = "custom_configurator3"
+        configurator_mock3 = Mock()
+        ep_mock3.load.return_value = configurator_mock3
+
+        iter_mock.return_value = (ep_mock1, ep_mock2, ep_mock3)
+        _load._load_configurators()
+        configurator_mock1.assert_not_called()
+        configurator_mock2().configure.assert_called_once_with(
+            auto_instrumentation_version=__version__
+        )
+        configurator_mock3.assert_not_called()
+
+    @patch.dict(
+        "os.environ", {OTEL_PYTHON_CONFIGURATOR: "custom_configurator2"}
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
+    )
+    def test_load_configurators_no_ep(
+        self,
+        iter_mock,
+    ):
+        iter_mock.return_value = ()
+        # Confirm method does not crash if not entry points exist.
+        _load._load_configurators()
+
+    @patch.dict(
+        "os.environ", {OTEL_PYTHON_CONFIGURATOR: "custom_configurator2"}
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
+    )
+    def test_load_configurators_error(self, iter_mock):
+        # Add multiple entry points but only specify the 2nd in the environment variable.
+        ep_mock1 = Mock()
+        ep_mock1.name = "custom_configurator1"
+        configurator_mock1 = Mock()
+        ep_mock1.load.return_value = configurator_mock1
+        ep_mock2 = Mock()
+        ep_mock2.name = "custom_configurator2"
+        configurator_mock2 = Mock()
+        configurator_mock2().configure.side_effect = Exception()
+        ep_mock2.load.return_value = configurator_mock2
+        ep_mock3 = Mock()
+        ep_mock3.name = "custom_configurator3"
+        configurator_mock3 = Mock()
+        ep_mock3.load.return_value = configurator_mock3
+
+        iter_mock.return_value = (ep_mock1, ep_mock2, ep_mock3)
+        # Confirm failed configuration raises exception.
+        self.assertRaises(Exception, _load._load_configurators)
+
+    @patch.dict("os.environ", {OTEL_PYTHON_DISTRO: "custom_distro2"})
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.isinstance"
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
+    )
+    def test_load_distro(self, iter_mock, isinstance_mock):
+        # Add multiple entry points but only specify the 2nd in the environment variable.
+        ep_mock1 = Mock()
+        ep_mock1.name = "custom_distro1"
+        distro_mock1 = Mock()
+        ep_mock1.load.return_value = distro_mock1
+        ep_mock2 = Mock()
+        ep_mock2.name = "custom_distro2"
+        distro_mock2 = Mock()
+        ep_mock2.load.return_value = distro_mock2
+        ep_mock3 = Mock()
+        ep_mock3.name = "custom_distro3"
+        distro_mock3 = Mock()
+        ep_mock3.load.return_value = distro_mock3
+
+        iter_mock.return_value = (ep_mock1, ep_mock2, ep_mock3)
+        # Mock entry points to be instances of BaseDistro.
+        isinstance_mock.return_value = True
+        self.assertEqual(
+            _load._load_distro(),
+            distro_mock2(),
+        )
+
+    @patch.dict("os.environ", {OTEL_PYTHON_DISTRO: "custom_distro2"})
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.isinstance"
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.DefaultDistro"
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
+    )
+    def test_load_distro_not_distro(
+        self, iter_mock, default_distro_mock, isinstance_mock
+    ):
+        # Add multiple entry points but only specify the 2nd in the environment variable.
+        ep_mock1 = Mock()
+        ep_mock1.name = "custom_distro1"
+        distro_mock1 = Mock()
+        ep_mock1.load.return_value = distro_mock1
+        ep_mock2 = Mock()
+        ep_mock2.name = "custom_distro2"
+        distro_mock2 = Mock()
+        ep_mock2.load.return_value = distro_mock2
+        ep_mock3 = Mock()
+        ep_mock3.name = "custom_distro3"
+        distro_mock3 = Mock()
+        ep_mock3.load.return_value = distro_mock3
+
+        iter_mock.return_value = (ep_mock1, ep_mock2, ep_mock3)
+        # Confirm default distro is used if specified entry point is not a BaseDistro
+        isinstance_mock.return_value = False
+        self.assertEqual(
+            _load._load_distro(),
+            default_distro_mock(),
+        )
+
+    @patch.dict("os.environ", {OTEL_PYTHON_DISTRO: "custom_distro2"})
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.DefaultDistro"
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
+    )
+    def test_load_distro_no_ep(self, iter_mock, default_distro_mock):
+        iter_mock.return_value = ()
+        # Confirm default distro is used if there are no entry points.
+        self.assertEqual(
+            _load._load_distro(),
+            default_distro_mock(),
+        )
+
+    @patch.dict("os.environ", {OTEL_PYTHON_DISTRO: "custom_distro2"})
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.isinstance"
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
+    )
+    def test_load_distro_error(self, iter_mock, isinstance_mock):
+        ep_mock1 = Mock()
+        ep_mock1.name = "custom_distro1"
+        distro_mock1 = Mock()
+        ep_mock1.load.return_value = distro_mock1
+        ep_mock2 = Mock()
+        ep_mock2.name = "custom_distro2"
+        distro_mock2 = Mock()
+        distro_mock2.side_effect = Exception()
+        ep_mock2.load.return_value = distro_mock2
+        ep_mock3 = Mock()
+        ep_mock3.name = "custom_distro3"
+        distro_mock3 = Mock()
+        ep_mock3.load.return_value = distro_mock3
+
+        iter_mock.return_value = (ep_mock1, ep_mock2, ep_mock3)
+        isinstance_mock.return_value = True
+        # Confirm method raises exception if it fails to load a distro.
+        self.assertRaises(Exception, _load._load_distro)
+
+    @patch.dict(
+        "os.environ",
+        {OTEL_PYTHON_DISABLED_INSTRUMENTATIONS: " instr1 , instr3 "},
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.get_dist_dependency_conflicts"
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
+    )
+    def test_load_instrumentors(self, iter_mock, dep_mock):
+        # Mock opentelemetry_pre_instrument entry points
+        pre_ep_mock1 = Mock()
+        pre_ep_mock1.name = "pre1"
+        pre_mock1 = Mock()
+        pre_ep_mock1.load.return_value = pre_mock1
+
+        pre_ep_mock2 = Mock()
+        pre_ep_mock2.name = "pre2"
+        pre_mock2 = Mock()
+        pre_ep_mock2.load.return_value = pre_mock2
+
+        # Mock opentelemetry_instrumentor entry points
+        ep_mock1 = Mock()
+        ep_mock1.name = "instr1"
+
+        ep_mock2 = Mock()
+        ep_mock2.name = "instr2"
+
+        ep_mock3 = Mock()
+        ep_mock3.name = "instr3"
+
+        ep_mock4 = Mock()
+        ep_mock4.name = "instr4"
+
+        # Mock opentelemetry_instrumentor entry points
+        post_ep_mock1 = Mock()
+        post_ep_mock1.name = "post1"
+        post_mock1 = Mock()
+        post_ep_mock1.load.return_value = post_mock1
+
+        post_ep_mock2 = Mock()
+        post_ep_mock2.name = "post2"
+        post_mock2 = Mock()
+        post_ep_mock2.load.return_value = post_mock2
+
+        distro_mock = Mock()
+
+        # Mock entry points in order
+        iter_mock.side_effect = [
+            (pre_ep_mock1, pre_ep_mock2),
+            (ep_mock1, ep_mock2, ep_mock3, ep_mock4),
+            (post_ep_mock1, post_ep_mock2),
+        ]
+        # No dependency conflict
+        dep_mock.return_value = None
+        _load._load_instrumentors(distro_mock)
+        # All opentelemetry_pre_instrument entry points should be loaded
+        pre_mock1.assert_called_once()
+        pre_mock2.assert_called_once()
+        self.assertEqual(iter_mock.call_count, 3)
+        # Only non-disabled instrumentations should be loaded
+        distro_mock.load_instrumentor.assert_has_calls(
+            [
+                call(ep_mock2, skip_dep_check=True),
+                call(ep_mock4, skip_dep_check=True),
+            ]
+        )
+        self.assertEqual(distro_mock.load_instrumentor.call_count, 2)
+        # All opentelemetry_post_instrument entry points should be loaded
+        post_mock1.assert_called_once()
+        post_mock2.assert_called_once()
+
+    @patch.dict(
+        "os.environ",
+        {OTEL_PYTHON_DISABLED_INSTRUMENTATIONS: " instr1 , instr3 "},
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.get_dist_dependency_conflicts"
+    )
+    @patch(
+        "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
+    )
+    def test_load_instrumentors_dep_conflict(self, iter_mock, dep_mock):
+        ep_mock1 = Mock()
+        ep_mock1.name = "instr1"
+
+        ep_mock2 = Mock()
+        ep_mock2.name = "instr2"
+
+        ep_mock3 = Mock()
+        ep_mock3.name = "instr3"
+
+        ep_mock4 = Mock()
+        ep_mock4.name = "instr4"
+
+        distro_mock = Mock()
+
+        iter_mock.return_value = (ep_mock1, ep_mock2, ep_mock3, ep_mock4)
+        # If a dependency conflict is raised, that instrumentation should not be loaded, but others still should.
+        dep_mock.side_effect = [None, "DependencyConflict"]
+        _load._load_instrumentors(distro_mock)
+        distro_mock.load_instrumentor.assert_has_calls(
+            [
+                call(ep_mock2, skip_dep_check=True),
+            ]
+        )
+        distro_mock.load_instrumentor.assert_called_once()