opentelemetry-instrumentation 0.47b0__py3-none-any.whl → 0.49b0__py3-none-any.whl

opentelemetry/instrumentation/_semconv.py

@@ -252,16 +252,32 @@ def _set_http_scheme(result, scheme, sem_conv_opt_in_mode):
         set_string_attribute(result, URL_SCHEME, scheme)
 
 
-def _set_http_host(result, host, sem_conv_opt_in_mode):
+def _set_http_flavor_version(result, version, sem_conv_opt_in_mode):
     if _report_old(sem_conv_opt_in_mode):
-        set_string_attribute(result, SpanAttributes.HTTP_HOST, host)
+        set_string_attribute(result, SpanAttributes.HTTP_FLAVOR, version)
     if _report_new(sem_conv_opt_in_mode):
-        set_string_attribute(result, SERVER_ADDRESS, host)
+        set_string_attribute(result, NETWORK_PROTOCOL_VERSION, version)
+
+
+def _set_http_user_agent(result, user_agent, sem_conv_opt_in_mode):
+    if _report_old(sem_conv_opt_in_mode):
+        set_string_attribute(
+            result, SpanAttributes.HTTP_USER_AGENT, user_agent
+        )
+    if _report_new(sem_conv_opt_in_mode):
+        set_string_attribute(result, USER_AGENT_ORIGINAL, user_agent)
 
 
 # Client
 
 
+def _set_http_host_client(result, host, sem_conv_opt_in_mode):
+    if _report_old(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.HTTP_HOST, host)
+    if _report_new(sem_conv_opt_in_mode):
+        set_string_attribute(result, SERVER_ADDRESS, host)
+
+
 def _set_http_net_peer_name_client(result, peer_name, sem_conv_opt_in_mode):
     if _report_old(sem_conv_opt_in_mode):
         set_string_attribute(result, SpanAttributes.NET_PEER_NAME, peer_name)
@@ -310,27 +326,32 @@ def _set_http_target(result, target, path, query, sem_conv_opt_in_mode):
             set_string_attribute(result, URL_QUERY, query)
 
 
-def _set_http_peer_ip(result, ip, sem_conv_opt_in_mode):
+def _set_http_host_server(result, host, sem_conv_opt_in_mode):
     if _report_old(sem_conv_opt_in_mode):
-        set_string_attribute(result, SpanAttributes.NET_PEER_IP, ip)
+        set_string_attribute(result, SpanAttributes.HTTP_HOST, host)
     if _report_new(sem_conv_opt_in_mode):
-        set_string_attribute(result, CLIENT_ADDRESS, ip)
+        set_string_attribute(result, CLIENT_ADDRESS, host)
 
 
-def _set_http_peer_port_server(result, port, sem_conv_opt_in_mode):
+# net.peer.ip -> net.sock.peer.addr
+# https://github.com/open-telemetry/semantic-conventions/blob/40db676ca0e735aa84f242b5a0fb14e49438b69b/schemas/1.15.0#L18
+# net.sock.peer.addr -> client.socket.address for server spans (TODO) AND client.address if missing
+# https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/CHANGELOG.md#v1210-2023-07-13
+# https://github.com/open-telemetry/semantic-conventions/blob/main/docs/non-normative/http-migration.md#common-attributes-across-http-client-and-server-spans
+def _set_http_peer_ip_server(result, ip, sem_conv_opt_in_mode):
     if _report_old(sem_conv_opt_in_mode):
-        set_int_attribute(result, SpanAttributes.NET_PEER_PORT, port)
+        set_string_attribute(result, SpanAttributes.NET_PEER_IP, ip)
     if _report_new(sem_conv_opt_in_mode):
-        set_int_attribute(result, CLIENT_PORT, port)
+        # Only populate if not already populated
+        if not result.get(CLIENT_ADDRESS):
+            set_string_attribute(result, CLIENT_ADDRESS, ip)
 
 
-def _set_http_user_agent(result, user_agent, sem_conv_opt_in_mode):
+def _set_http_peer_port_server(result, port, sem_conv_opt_in_mode):
     if _report_old(sem_conv_opt_in_mode):
-        set_string_attribute(
-            result, SpanAttributes.HTTP_USER_AGENT, user_agent
-        )
+        set_int_attribute(result, SpanAttributes.NET_PEER_PORT, port)
     if _report_new(sem_conv_opt_in_mode):
-        set_string_attribute(result, USER_AGENT_ORIGINAL, user_agent)
+        set_int_attribute(result, CLIENT_PORT, port)
 
 
 def _set_http_net_peer_name_server(result, name, sem_conv_opt_in_mode):
@@ -340,13 +361,6 @@ def _set_http_net_peer_name_server(result, name, sem_conv_opt_in_mode):
         set_string_attribute(result, CLIENT_ADDRESS, name)
 
 
-def _set_http_flavor_version(result, version, sem_conv_opt_in_mode):
-    if _report_old(sem_conv_opt_in_mode):
-        set_string_attribute(result, SpanAttributes.HTTP_FLAVOR, version)
-    if _report_new(sem_conv_opt_in_mode):
-        set_string_attribute(result, NETWORK_PROTOCOL_VERSION, version)
-
-
 def _set_status(
     span,
     metrics_attributes: dict,

opentelemetry/instrumentation/auto_instrumentation/__init__.py

@@ -19,9 +19,8 @@ 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__
+from opentelemetry.util._importlib_metadata import entry_points
 
 _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/auto_instrumentation/_load.py

@@ -12,11 +12,10 @@
 # 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 pkg_resources import iter_entry_points
-
 from opentelemetry.instrumentation.dependencies import (
     get_dist_dependency_conflicts,
 )
@@ -27,13 +26,39 @@ from opentelemetry.instrumentation.environment_variables import (
     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 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,15 +83,16 @@ 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
@@ -74,7 +100,8 @@ def _load_instrumentors(distro):
             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",
@@ -86,18 +113,29 @@ 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)
+        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 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",
@@ -110,7 +148,9 @@ def _load_configurators():
                 configurator_name is None
                 or configurator_name == entry_point.name
             ):
-                entry_point.load()().configure(auto_instrumentation_version=__version__)  # type: ignore
+                entry_point.load()().configure(
+                    auto_instrumentation_version=__version__
+                )  # type: ignore
                 configured = entry_point.name
             else:
                 _logger.warning(

opentelemetry/instrumentation/bootstrap.py

@@ -22,14 +22,21 @@ from subprocess import (
     SubprocessError,
     check_call,
 )
+from typing import Optional
 
-import pkg_resources
+from packaging.requirements import Requirement
 
 from opentelemetry.instrumentation.bootstrap_gen import (
-    default_instrumentations,
-    libraries,
+    default_instrumentations as gen_default_instrumentations,
+)
+from opentelemetry.instrumentation.bootstrap_gen import (
+    libraries as gen_libraries,
 )
 from opentelemetry.instrumentation.version import __version__
+from opentelemetry.util._importlib_metadata import (
+    PackageNotFoundError,
+    version,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -71,7 +78,7 @@ def _sys_pip_install(package):
         print(error)
 
 
-def _pip_check():
+def _pip_check(libraries):
     """Ensures none of the instrumentations have dependency conflicts.
     Clean check reported as:
     'No broken requirements found.'
@@ -91,24 +98,25 @@ 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
 
 
-def _find_installed_libraries():
+def _find_installed_libraries(default_instrumentations, libraries):
     for lib in default_instrumentations:
         yield lib
 
@@ -117,18 +125,25 @@ def _find_installed_libraries():
             yield lib["instrumentation"]
 
 
-def _run_requirements():
+def _run_requirements(default_instrumentations, libraries):
     logger.setLevel(logging.ERROR)
-    print("\n".join(_find_installed_libraries()), end="")
+    print(
+        "\n".join(
+            _find_installed_libraries(default_instrumentations, libraries)
+        )
+    )
 
 
-def _run_install():
-    for lib in _find_installed_libraries():
+def _run_install(default_instrumentations, libraries):
+    for lib in _find_installed_libraries(default_instrumentations, libraries):
         _sys_pip_install(lib)
-    _pip_check()
+    _pip_check(libraries)
 
 
-def run() -> None:
+def run(
+    default_instrumentations: Optional[list] = None,
+    libraries: Optional[list] = None,
+) -> None:
     action_install = "install"
     action_requirements = "requirements"
 
@@ -158,8 +173,14 @@ def run() -> None:
     )
     args = parser.parse_args()
 
+    if libraries is None:
+        libraries = gen_libraries
+
+    if default_instrumentations is None:
+        default_instrumentations = gen_default_instrumentations
+
     cmd = {
         action_install: _run_install,
         action_requirements: _run_requirements,
     }[args.action]
-    cmd()
+    cmd(default_instrumentations, libraries)

opentelemetry/instrumentation/bootstrap_gen.py

@@ -18,180 +18,184 @@
 libraries = [
     {
         "library": "aio_pika >= 7.2.0, < 10.0.0",
-        "instrumentation": "opentelemetry-instrumentation-aio-pika==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-aio-pika==0.49b0",
     },
     {
         "library": "aiohttp ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-aiohttp-client==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-aiohttp-client==0.49b0",
     },
     {
         "library": "aiohttp ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-aiohttp-server==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-aiohttp-server==0.49b0",
+    },
+    {
+        "library": "aiokafka >= 0.8, < 1.0",
+        "instrumentation": "opentelemetry-instrumentation-aiokafka==0.49b0",
     },
     {
         "library": "aiopg >= 0.13.0, < 2.0.0",
-        "instrumentation": "opentelemetry-instrumentation-aiopg==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-aiopg==0.49b0",
     },
     {
         "library": "asgiref ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-asgi==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-asgi==0.49b0",
     },
     {
         "library": "asyncpg >= 0.12.0",
-        "instrumentation": "opentelemetry-instrumentation-asyncpg==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-asyncpg==0.49b0",
     },
     {
         "library": "boto~=2.0",
-        "instrumentation": "opentelemetry-instrumentation-boto==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-boto==0.49b0",
     },
     {
         "library": "boto3 ~= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-boto3sqs==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-boto3sqs==0.49b0",
     },
     {
         "library": "botocore ~= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-botocore==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-botocore==0.49b0",
     },
     {
         "library": "cassandra-driver ~= 3.25",
-        "instrumentation": "opentelemetry-instrumentation-cassandra==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-cassandra==0.49b0",
     },
     {
         "library": "scylla-driver ~= 3.25",
-        "instrumentation": "opentelemetry-instrumentation-cassandra==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-cassandra==0.49b0",
     },
     {
         "library": "celery >= 4.0, < 6.0",
-        "instrumentation": "opentelemetry-instrumentation-celery==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-celery==0.49b0",
     },
     {
         "library": "confluent-kafka >= 1.8.2, <= 2.4.0",
-        "instrumentation": "opentelemetry-instrumentation-confluent-kafka==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-confluent-kafka==0.49b0",
     },
     {
         "library": "django >= 1.10",
-        "instrumentation": "opentelemetry-instrumentation-django==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-django==0.49b0",
     },
     {
         "library": "elasticsearch >= 6.0",
-        "instrumentation": "opentelemetry-instrumentation-elasticsearch==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-elasticsearch==0.49b0",
     },
     {
         "library": "falcon >= 1.4.1, < 3.1.2",
-        "instrumentation": "opentelemetry-instrumentation-falcon==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-falcon==0.49b0",
     },
     {
         "library": "fastapi ~= 0.58",
-        "instrumentation": "opentelemetry-instrumentation-fastapi==0.47b0",
-    },
-    {
-        "library": "fastapi-slim ~= 0.111.0",
-        "instrumentation": "opentelemetry-instrumentation-fastapi==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-fastapi==0.49b0",
     },
     {
         "library": "flask >= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-flask==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-flask==0.49b0",
     },
     {
-        "library": "grpcio ~= 1.27",
-        "instrumentation": "opentelemetry-instrumentation-grpc==0.47b0",
+        "library": "grpcio >= 1.42.0",
+        "instrumentation": "opentelemetry-instrumentation-grpc==0.49b0",
     },
     {
         "library": "httpx >= 0.18.0",
-        "instrumentation": "opentelemetry-instrumentation-httpx==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-httpx==0.49b0",
     },
     {
         "library": "jinja2 >= 2.7, < 4.0",
-        "instrumentation": "opentelemetry-instrumentation-jinja2==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-jinja2==0.49b0",
+    },
+    {
+        "library": "kafka-python >= 2.0, < 3.0",
+        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.49b0",
     },
     {
-        "library": "kafka-python >= 2.0",
-        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.47b0",
+        "library": "kafka-python-ng >= 2.0, < 3.0",
+        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.49b0",
     },
     {
-        "library": "mysql-connector-python ~= 8.0",
-        "instrumentation": "opentelemetry-instrumentation-mysql==0.47b0",
+        "library": "mysql-connector-python >= 8.0, < 10.0",
+        "instrumentation": "opentelemetry-instrumentation-mysql==0.49b0",
     },
     {
         "library": "mysqlclient < 3",
-        "instrumentation": "opentelemetry-instrumentation-mysqlclient==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-mysqlclient==0.49b0",
     },
     {
         "library": "pika >= 0.12.0",
-        "instrumentation": "opentelemetry-instrumentation-pika==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-pika==0.49b0",
     },
     {
         "library": "psycopg >= 3.1.0",
-        "instrumentation": "opentelemetry-instrumentation-psycopg==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-psycopg==0.49b0",
     },
     {
         "library": "psycopg2 >= 2.7.3.1",
-        "instrumentation": "opentelemetry-instrumentation-psycopg2==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-psycopg2==0.49b0",
     },
     {
         "library": "pymemcache >= 1.3.5, < 5",
-        "instrumentation": "opentelemetry-instrumentation-pymemcache==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-pymemcache==0.49b0",
     },
     {
         "library": "pymongo >= 3.1, < 5.0",
-        "instrumentation": "opentelemetry-instrumentation-pymongo==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-pymongo==0.49b0",
     },
     {
         "library": "PyMySQL < 2",
-        "instrumentation": "opentelemetry-instrumentation-pymysql==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-pymysql==0.49b0",
     },
     {
         "library": "pyramid >= 1.7",
-        "instrumentation": "opentelemetry-instrumentation-pyramid==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-pyramid==0.49b0",
     },
     {
         "library": "redis >= 2.6",
-        "instrumentation": "opentelemetry-instrumentation-redis==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-redis==0.49b0",
     },
     {
         "library": "remoulade >= 0.50",
-        "instrumentation": "opentelemetry-instrumentation-remoulade==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-remoulade==0.49b0",
     },
     {
         "library": "requests ~= 2.0",
-        "instrumentation": "opentelemetry-instrumentation-requests==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-requests==0.49b0",
     },
     {
         "library": "sqlalchemy",
-        "instrumentation": "opentelemetry-instrumentation-sqlalchemy==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-sqlalchemy==0.49b0",
     },
     {
         "library": "starlette ~= 0.13.0",
-        "instrumentation": "opentelemetry-instrumentation-starlette==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-starlette==0.49b0",
     },
     {
         "library": "psutil >= 5",
-        "instrumentation": "opentelemetry-instrumentation-system-metrics==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-system-metrics==0.49b0",
     },
     {
         "library": "tornado >= 5.1.1",
-        "instrumentation": "opentelemetry-instrumentation-tornado==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-tornado==0.49b0",
     },
     {
         "library": "tortoise-orm >= 0.17.0",
-        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.49b0",
     },
     {
         "library": "pydantic >= 1.10.2",
-        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.49b0",
     },
     {
         "library": "urllib3 >= 1.0.0, < 3.0.0",
-        "instrumentation": "opentelemetry-instrumentation-urllib3==0.47b0",
+        "instrumentation": "opentelemetry-instrumentation-urllib3==0.49b0",
     },
 ]
 default_instrumentations = [
-    "opentelemetry-instrumentation-asyncio==0.47b0",
-    "opentelemetry-instrumentation-aws-lambda==0.47b0",
-    "opentelemetry-instrumentation-dbapi==0.47b0",
-    "opentelemetry-instrumentation-logging==0.47b0",
-    "opentelemetry-instrumentation-sqlite3==0.47b0",
-    "opentelemetry-instrumentation-threading==0.47b0",
-    "opentelemetry-instrumentation-urllib==0.47b0",
-    "opentelemetry-instrumentation-wsgi==0.47b0",
+    "opentelemetry-instrumentation-asyncio==0.49b0",
+    "opentelemetry-instrumentation-dbapi==0.49b0",
+    "opentelemetry-instrumentation-logging==0.49b0",
+    "opentelemetry-instrumentation-sqlite3==0.49b0",
+    "opentelemetry-instrumentation-test==1.0.0b.dev",
+    "opentelemetry-instrumentation-threading==0.49b0",
+    "opentelemetry-instrumentation-urllib==0.49b0",
+    "opentelemetry-instrumentation-wsgi==0.49b0",
 ]

opentelemetry/instrumentation/dependencies.py

@@ -1,12 +1,26 @@
+# 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 typing import Collection, Optional
+from typing import Collection, Optional, Union
+
+from packaging.requirements import InvalidRequirement, Requirement
 
-from pkg_resources import (
+from opentelemetry.util._importlib_metadata import (
     Distribution,
-    DistributionNotFound,
-    RequirementParseError,
-    VersionConflict,
-    get_distribution,
+    PackageNotFoundError,
+    version,
 )
 
 logger = getLogger(__name__)
@@ -27,36 +41,43 @@ class DependencyConflict:
 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/distro.py

@@ -20,9 +20,8 @@ OpenTelemetry Base Distribution (Distro)
 from abc import ABC, abstractmethod
 from logging import getLogger
 
-from pkg_resources import EntryPoint
-
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.util._importlib_metadata import EntryPoint
 
 _LOG = getLogger(__name__)
 
@@ -33,7 +32,6 @@ class BaseDistro(ABC):
     _instance = None
 
     def __new__(cls, *args, **kwargs):
-
         if cls._instance is None:
             cls._instance = object.__new__(cls, *args, **kwargs)
 

opentelemetry/instrumentation/utils.py

@@ -14,8 +14,9 @@
 
 import urllib.parse
 from contextlib import contextmanager
+from importlib import import_module
 from re import escape, sub
-from typing import Dict, Iterable, Sequence
+from typing import Dict, Iterable, Sequence, Union
 
 from wrapt import ObjectProxy
 
@@ -80,13 +81,30 @@ def http_status_to_status_code(
     return StatusCode.ERROR
 
 
-def unwrap(obj, attr: str):
+def unwrap(obj: Union[object, str], attr: str):
     """Given a function that was wrapped by wrapt.wrap_function_wrapper, unwrap it
 
+    The object containing the function to unwrap may be passed as dotted module path string.
+
     Args:
-        obj: Object that holds a reference to the wrapped function
+        obj: Object that holds a reference to the wrapped function or dotted import path as string
         attr (str): Name of the wrapped function
     """
+    if isinstance(obj, str):
+        try:
+            module_path, class_name = obj.rsplit(".", 1)
+        except ValueError as exc:
+            raise ImportError(
+                f"Cannot parse '{obj}' as dotted import path"
+            ) from exc
+        module = import_module(module_path)
+        try:
+            obj = getattr(module, class_name)
+        except AttributeError as exc:
+            raise ImportError(
+                f"Cannot import '{class_name}' from '{module}'"
+            ) from exc
+
     func = getattr(obj, attr, None)
     if func and isinstance(func, ObjectProxy) and hasattr(func, "__wrapped__"):
         setattr(obj, attr, func.__wrapped__)

opentelemetry/instrumentation/version.py

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

{opentelemetry_instrumentation-0.47b0.dist-info → opentelemetry_instrumentation-0.49b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opentelemetry-instrumentation
-Version: 0.47b0
+Version: 0.49b0
 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>
@@ -18,7 +18,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Requires-Dist: opentelemetry-api~=1.4
-Requires-Dist: setuptools>=16.0
+Requires-Dist: opentelemetry-semantic-conventions==0.49b0
+Requires-Dist: packaging>=18.0
 Requires-Dist: wrapt<2.0.0,>=1.0.0
 Description-Content-Type: text/x-rst
 
@@ -64,7 +65,7 @@ to figure out which instrumentation packages the user might want to install. By
 prints out a list of the default and detected instrumentation packages that can be added to a
 requirements.txt file. It also supports installing the packages when run with
 :code:`--action=install` or :code:`-a install` flag. All default and detectable
-instrumentation packages are defined `here <https://github.com/flands/opentelemetry-python-contrib/blob/main/opentelemetry-instrumentation/src/opentelemetry/instrumentation/bootstrap_gen.py>`.
+instrumentation packages are defined `here <https://github.com/open-telemetry/opentelemetry-python-contrib/blob/main/opentelemetry-instrumentation/src/opentelemetry/instrumentation/bootstrap_gen.py>`.
 
 
 opentelemetry-instrument

opentelemetry_instrumentation-0.49b0.dist-info/RECORD

@@ -0,0 +1,20 @@
+opentelemetry/instrumentation/_semconv.py,sha256=eX7jtDvnLjCogil0SRZ4q_ftKWyJRNKiOkiuDRNVzgA,14582
+opentelemetry/instrumentation/bootstrap.py,sha256=Q-1j1G7QKXTTvH5xGGGRX3jCpTf_NuhBoy2X_MvM9sg,5428
+opentelemetry/instrumentation/bootstrap_gen.py,sha256=FXsAFLZ-XaIUiv-jFr_QvjzTE8st8DYaX6GqxXzxKP8,6865
+opentelemetry/instrumentation/dependencies.py,sha256=FcrMj6pudXBE70VhytIMc-JS-dVGDbtCNE2dviT4GBg,2527
+opentelemetry/instrumentation/distro.py,sha256=l7wjM9eR44X-Bk6w-b3_kW3_QgW82OiITRTOY48shZk,2168
+opentelemetry/instrumentation/environment_variables.py,sha256=oRcbNSSbnqJMQ3r4gBhK6jqtuI5WizapP962Z8DrVZ8,905
+opentelemetry/instrumentation/instrumentor.py,sha256=0r527qBsl-fPAVXPM3iu_k94omLN5MStOFmuAqpD_Zo,4509
+opentelemetry/instrumentation/propagators.py,sha256=hBkG70KlMUiTjxPeiyOhkb_eE96DRVzRyY4fEIzMqD4,4070
+opentelemetry/instrumentation/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opentelemetry/instrumentation/sqlcommenter_utils.py,sha256=yV_-hcwy_3ckP76_FC2dOrd8IKi9z_9s980ZMuGYkrE,1960
+opentelemetry/instrumentation/utils.py,sha256=4SvKC9Rg1tMcQe5SiAtbX82Xe5lXx1ltMdrCGLhmc3o,7037
+opentelemetry/instrumentation/version.py,sha256=feu1cU-5Mlc3KHErNko0hTd8PObq7lIudxaIp9B3L_8,608
+opentelemetry/instrumentation/auto_instrumentation/__init__.py,sha256=G3qhU-ZfdATzPdsZCvBZ2CT8kNZ1Wc8l7fETXKTPF2M,3800
+opentelemetry/instrumentation/auto_instrumentation/_load.py,sha256=e3IlquYKHgLuZXZ9pjMg76yxiM0Qa_-6qxgPFL-Vmh0,6301
+opentelemetry/instrumentation/auto_instrumentation/sitecustomize.py,sha256=p3cz9NlKNlnzxc7guFSPyztx8XMUteAxkN1NFYXSH-0,1449
+opentelemetry_instrumentation-0.49b0.dist-info/METADATA,sha256=cELamr_k3IkgMcm94h5mWlMiFildt8WgbxPt7waVdJk,6180
+opentelemetry_instrumentation-0.49b0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+opentelemetry_instrumentation-0.49b0.dist-info/entry_points.txt,sha256=iVv3t5REB0O58tFUEQQXYLrTCa1VVOFUXfrbvUk6_aU,279
+opentelemetry_instrumentation-0.49b0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+opentelemetry_instrumentation-0.49b0.dist-info/RECORD,,

opentelemetry_instrumentation-0.47b0.dist-info/RECORD

@@ -1,20 +0,0 @@
-opentelemetry/instrumentation/_semconv.py,sha256=zexTZwIY9qhUzmdMwVdvnP96B_L88CRZehl3SqbKyuc,13679
-opentelemetry/instrumentation/bootstrap.py,sha256=J_sUXmcnUGXXj0ySJ1KxGcr-nmfDP7-S_N3vHqjLecY,4725
-opentelemetry/instrumentation/bootstrap_gen.py,sha256=FFap1VKz1o1lq2SpkxPyRd8sJkXx32chqfXlVQ-L540,6704
-opentelemetry/instrumentation/dependencies.py,sha256=ljJ0nMK_vNZXOiCTLOT1nM3xpwmx7LVaW_S53jcRvIY,1798
-opentelemetry/instrumentation/distro.py,sha256=vCvt0pHLtL3OF1m7MVyPUkK4UfoZN6-Vj7JCc6XLbwc,2145
-opentelemetry/instrumentation/environment_variables.py,sha256=oRcbNSSbnqJMQ3r4gBhK6jqtuI5WizapP962Z8DrVZ8,905
-opentelemetry/instrumentation/instrumentor.py,sha256=0r527qBsl-fPAVXPM3iu_k94omLN5MStOFmuAqpD_Zo,4509
-opentelemetry/instrumentation/propagators.py,sha256=hBkG70KlMUiTjxPeiyOhkb_eE96DRVzRyY4fEIzMqD4,4070
-opentelemetry/instrumentation/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-opentelemetry/instrumentation/sqlcommenter_utils.py,sha256=yV_-hcwy_3ckP76_FC2dOrd8IKi9z_9s980ZMuGYkrE,1960
-opentelemetry/instrumentation/utils.py,sha256=5j6HYS00vpf5EeNHHYIpys1TZn9V-hnM6Hj2qQdPRG4,6339
-opentelemetry/instrumentation/version.py,sha256=6FmWdr2KRW0MGpqEO5NBzLrm6URCtz_6ixXi_ALh6JA,608
-opentelemetry/instrumentation/auto_instrumentation/__init__.py,sha256=en-gz8Qg6JlGR6XnFF0TYBElVUGMGNo3FtnB0GBJfA0,3780
-opentelemetry/instrumentation/auto_instrumentation/_load.py,sha256=RDFVxFJ2NR02i8_MFc2FJFxRQjsvjX8f1H2N7ZMF5V0,4794
-opentelemetry/instrumentation/auto_instrumentation/sitecustomize.py,sha256=p3cz9NlKNlnzxc7guFSPyztx8XMUteAxkN1NFYXSH-0,1449
-opentelemetry_instrumentation-0.47b0.dist-info/METADATA,sha256=GuxCSAJOongEM4JWciogmZYVmD5nFh7L347AKWo7wIQ,6115
-opentelemetry_instrumentation-0.47b0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-opentelemetry_instrumentation-0.47b0.dist-info/entry_points.txt,sha256=iVv3t5REB0O58tFUEQQXYLrTCa1VVOFUXfrbvUk6_aU,279
-opentelemetry_instrumentation-0.47b0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-opentelemetry_instrumentation-0.47b0.dist-info/RECORD,,