Remove pkg_resource and replace for importlib.metadata in autoinstrumentation

CHANGELOG.md

@@ -7,12 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Breaking changes
+
+- Deprecation of pkg_resource in favor of importlib.metadata
+  ([#2181](https://github.com/open-telemetry/opentelemetry-python-contrib/issues/2181))
+
 ## Version 1.27.0/0.48b0 ()
 
 ### Added
 
-- `opentelemetry-instrumentation-kafka-python` Instrument temporary fork, kafka-python-ng
-  inside kafka-python's instrumentation
+- `opentelemetry-instrumentation-kafka-python` Instrument temporary fork, kafka-python-ng inside kafka-python's instrumentation
   ([#2537](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/2537))
 
 ### Breaking changes

opentelemetry-instrumentation/pyproject.toml

@@ -26,8 +26,9 @@ classifiers = [
 ]
 dependencies = [
   "opentelemetry-api ~= 1.4",
-  "setuptools >= 16.0",
   "wrapt >= 1.0.0, < 2.0.0",
+  "importlib-metadata >= 6.0, < 8.0",
+  "packaging >= 18.0",
 ]
 
 [project.scripts]

opentelemetry-instrumentation/src/opentelemetry/instrumentation/auto_instrumentation/__init__.py

@@ -13,14 +13,13 @@
 # limitations under the License.
 
 from argparse import REMAINDER, ArgumentParser
+from importlib.metadata import entry_points
 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 pkg_resources import iter_entry_points
-
 from opentelemetry.instrumentation.version import __version__
 
 _logger = getLogger(__name__)
@@ -48,8 +47,8 @@ def run() -> None:
 
     argument_otel_environment_variable = {}
 
-    for entry_point in iter_entry_points(
-        "opentelemetry_environment_variables"
+    for entry_point in entry_points(
+        group="opentelemetry_environment_variables"
     ):
         environment_variable_module = entry_point.load()
 

opentelemetry-instrumentation/src/opentelemetry/instrumentation/auto_instrumentation/_load.py

@@ -12,11 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from importlib.metadata import EntryPoint, distributions, entry_points
 from logging import getLogger
 from os import environ
 
-from pkg_resources import iter_entry_points
-
 from opentelemetry.instrumentation.dependencies import (
     get_dist_dependency_conflicts,
 )
@@ -31,9 +30,32 @@
 _logger = getLogger(__name__)
 
 
+class _EntryPointDistFinder:
+    def __int__(self):
+        self._mapping = None
+
+    def dist_for(self, entry_point: EntryPoint):
+        dist = getattr(entry_point, "dist", None)
+        if dist:
+            return dist
+
+        if self._mapping is None:
+            self._mapping = {
+                self._key_for(ep): dist
+                for ep in dist.entry_points
+                for dist in distributions()
+            }
+
+        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 iter_entry_points("opentelemetry_distro"):
+    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:
@@ -58,23 +80,25 @@ def _load_distro() -> BaseDistro:
 
 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 iter_entry_points("opentelemetry_pre_instrument"):
+    for entry_point in entry_points(group="opentelemetry_pre_instrument"):
         entry_point.load()()
 
-    for entry_point in iter_entry_points("opentelemetry_instrumentor"):
+    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:
-            conflict = get_dist_dependency_conflicts(entry_point.dist)
+            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",
@@ -90,14 +114,14 @@ def _load_instrumentors(distro):
             _logger.exception("Instrumenting of %s failed", entry_point.name)
             raise exc
 
-    for entry_point in iter_entry_points("opentelemetry_post_instrument"):
+    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 iter_entry_points("opentelemetry_configurator"):
+    for entry_point in entry_points(group="opentelemetry_configurator"):
         if configured is not None:
             _logger.warning(
                 "Configuration of %s not loaded, %s already loaded",

opentelemetry-instrumentation/src/opentelemetry/instrumentation/bootstrap.py

@@ -15,6 +15,7 @@
 import argparse
 import logging
 import sys
+from importlib.metadata import PackageNotFoundError, version
 from subprocess import (
     PIPE,
     CalledProcessError,
@@ -23,7 +24,7 @@
     check_call,
 )
 
-import pkg_resources
+from packaging.requirements import Requirement
 
 from opentelemetry.instrumentation.bootstrap_gen import (
     default_instrumentations,
@@ -91,18 +92,19 @@ def _pip_check():
 
 
 def _is_installed(req):
-    if req in sys.modules:
-        return True
+    req = Requirement(req)
 
     try:
-        pkg_resources.get_distribution(req)
-    except pkg_resources.DistributionNotFound:
+        dist_version = version(req.name)
+    except PackageNotFoundError:
         return False
-    except pkg_resources.VersionConflict as exc:
+
+    if not req.specifier.filter(dist_version):
         logger.warning(
-            "instrumentation for package %s is available but version %s is installed. Skipping.",
-            exc.req,
-            exc.dist.as_requirement(),  # pylint: disable=no-member
+            "instrumentation for package %s is available"
+            " but version %s is installed. Skipping.",
+            req,
+            dist_version,
         )
         return False
     return True

opentelemetry-instrumentation/src/opentelemetry/instrumentation/dependencies.py

@@ -1,13 +1,8 @@
+from importlib.metadata import Distribution, PackageNotFoundError, version
 from logging import getLogger
-from typing import Collection, Optional
+from typing import Collection, Optional, Union
 
-from pkg_resources import (
-    Distribution,
-    DistributionNotFound,
-    RequirementParseError,
-    VersionConflict,
-    get_distribution,
-)
+from packaging.requirements import InvalidRequirement, Requirement
 
 logger = getLogger(__name__)
 
@@ -27,36 +22,43 @@ def __str__(self):
 def get_dist_dependency_conflicts(
     dist: Distribution,
 ) -> Optional[DependencyConflict]:
-    main_deps = dist.requires()
     instrumentation_deps = []
-    for dep in dist.requires(("instruments",)):
-        if dep not in main_deps:
-            # we set marker to none so string representation of the dependency looks like
-            #    requests ~= 1.0
-            # instead of
-            #    requests ~= 1.0; extra = "instruments"
-            # which does not work with `get_distribution()`
-            dep.marker = None
-            instrumentation_deps.append(str(dep))
+    extra = "extra"
+    instruments = "instruments"
+    instruments_marker = {extra: instruments}
+    for dep in dist.requires:
+        if extra not in dep or instruments not in dep:
+            continue
+
+        req = Requirement(dep)
+        if req.marker.evaluate(instruments_marker):
+            instrumentation_deps.append(req)
 
     return get_dependency_conflicts(instrumentation_deps)
 
 
 def get_dependency_conflicts(
-    deps: Collection[str],
+    deps: Collection[Union[str, Requirement]],
 ) -> Optional[DependencyConflict]:
     for dep in deps:
+        if isinstance(dep, Requirement):
+            req = dep
+        else:
+            try:
+                req = Requirement(dep)
+            except InvalidRequirement as exc:
+                logger.warning(
+                    'error parsing dependency, reporting as a conflict: "%s" - %s',
+                    dep,
+                    exc,
+                )
+                return DependencyConflict(dep)
+
         try:
-            get_distribution(dep)
-        except VersionConflict as exc:
-            return DependencyConflict(dep, exc.dist)
-        except DistributionNotFound:
-            return DependencyConflict(dep)
-        except RequirementParseError as exc:
-            logger.warning(
-                'error parsing dependency, reporting as a conflict: "%s" - %s',
-                dep,
-                exc,
-            )
+            dist_version = version(req.name)
+        except PackageNotFoundError:
             return DependencyConflict(dep)
+
+        if not req.specifier.contains(dist_version):
+            return DependencyConflict(dep, f"{req.name} {dist_version}")
     return None

opentelemetry-instrumentation/src/opentelemetry/instrumentation/distro.py

@@ -18,10 +18,9 @@
 """
 
 from abc import ABC, abstractmethod
+from importlib.metadata import EntryPoint
 from logging import getLogger
 
-from pkg_resources import EntryPoint
-
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 
 _LOG = getLogger(__name__)