opentelemetry-instrumentation 0.42b0__tar.gz → 0.43b0__tar.gz

{opentelemetry_instrumentation-0.42b0 → opentelemetry_instrumentation-0.43b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentelemetry-instrumentation
-Version: 0.42b0
+Version: 0.43b0
 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>

opentelemetry_instrumentation-0.43b0/src/opentelemetry/instrumentation/_semconv.py

@@ -0,0 +1,217 @@
+# 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.
+
+import os
+import threading
+from enum import Enum
+
+from opentelemetry.semconv.trace import SpanAttributes
+
+# TODO: will come through semconv package once updated
+_SPAN_ATTRIBUTES_ERROR_TYPE = "error.type"
+_SPAN_ATTRIBUTES_NETWORK_PEER_ADDRESS = "network.peer.address"
+_SPAN_ATTRIBUTES_NETWORK_PEER_PORT = "network.peer.port"
+_METRIC_ATTRIBUTES_CLIENT_DURATION_NAME = "http.client.request.duration"
+
+_client_duration_attrs_old = [
+    SpanAttributes.HTTP_STATUS_CODE,
+    SpanAttributes.HTTP_HOST,
+    SpanAttributes.NET_PEER_PORT,
+    SpanAttributes.NET_PEER_NAME,
+    SpanAttributes.HTTP_METHOD,
+    SpanAttributes.HTTP_FLAVOR,
+    SpanAttributes.HTTP_SCHEME,
+]
+
+_client_duration_attrs_new = [
+    _SPAN_ATTRIBUTES_ERROR_TYPE,
+    SpanAttributes.HTTP_REQUEST_METHOD,
+    SpanAttributes.HTTP_RESPONSE_STATUS_CODE,
+    SpanAttributes.NETWORK_PROTOCOL_VERSION,
+    SpanAttributes.SERVER_ADDRESS,
+    SpanAttributes.SERVER_PORT,
+    # TODO: Support opt-in for scheme in new semconv
+    # SpanAttributes.URL_SCHEME,
+]
+
+
+def _filter_duration_attrs(attrs, sem_conv_opt_in_mode):
+    filtered_attrs = {}
+    allowed_attributes = (
+        _client_duration_attrs_new
+        if sem_conv_opt_in_mode == _OpenTelemetryStabilityMode.HTTP
+        else _client_duration_attrs_old
+    )
+    for key, val in attrs.items():
+        if key in allowed_attributes:
+            filtered_attrs[key] = val
+    return filtered_attrs
+
+
+def set_string_attribute(result, key, value):
+    if value:
+        result[key] = value
+
+
+def set_int_attribute(result, key, value):
+    if value:
+        try:
+            result[key] = int(value)
+        except ValueError:
+            return
+
+
+def _set_http_method(result, original, normalized, sem_conv_opt_in_mode):
+    original = original.strip()
+    normalized = normalized.strip()
+    # See https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-spans.md#common-attributes
+    # Method is case sensitive. "http.request.method_original" should not be sanitized or automatically capitalized.
+    if original != normalized and _report_new(sem_conv_opt_in_mode):
+        set_string_attribute(
+            result, SpanAttributes.HTTP_REQUEST_METHOD_ORIGINAL, original
+        )
+
+    if _report_old(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.HTTP_METHOD, normalized)
+    if _report_new(sem_conv_opt_in_mode):
+        set_string_attribute(
+            result, SpanAttributes.HTTP_REQUEST_METHOD, normalized
+        )
+
+
+def _set_http_url(result, url, sem_conv_opt_in_mode):
+    if _report_old(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.HTTP_URL, url)
+    if _report_new(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.URL_FULL, url)
+
+
+def _set_http_scheme(result, scheme, sem_conv_opt_in_mode):
+    if _report_old(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.HTTP_SCHEME, scheme)
+    # TODO: Support opt-in for scheme in new semconv
+    # if _report_new(sem_conv_opt_in_mode):
+    #     set_string_attribute(result, SpanAttributes.URL_SCHEME, scheme)
+
+
+def _set_http_hostname(result, hostname, sem_conv_opt_in_mode):
+    if _report_old(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.HTTP_HOST, hostname)
+    if _report_new(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.SERVER_ADDRESS, hostname)
+
+
+def _set_http_net_peer_name(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)
+    if _report_new(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.SERVER_ADDRESS, peer_name)
+
+
+def _set_http_port(result, port, sem_conv_opt_in_mode):
+    if _report_old(sem_conv_opt_in_mode):
+        set_int_attribute(result, SpanAttributes.NET_PEER_PORT, port)
+    if _report_new(sem_conv_opt_in_mode):
+        set_int_attribute(result, SpanAttributes.SERVER_PORT, port)
+
+
+def _set_http_status_code(result, code, sem_conv_opt_in_mode):
+    if _report_old(sem_conv_opt_in_mode):
+        set_int_attribute(result, SpanAttributes.HTTP_STATUS_CODE, code)
+    if _report_new(sem_conv_opt_in_mode):
+        set_int_attribute(
+            result, SpanAttributes.HTTP_RESPONSE_STATUS_CODE, code
+        )
+
+
+def _set_http_network_protocol_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, SpanAttributes.NETWORK_PROTOCOL_VERSION, version
+        )
+
+
+_OTEL_SEMCONV_STABILITY_OPT_IN_KEY = "OTEL_SEMCONV_STABILITY_OPT_IN"
+
+
+class _OpenTelemetryStabilitySignalType:
+    HTTP = "http"
+
+
+class _OpenTelemetryStabilityMode(Enum):
+    # http - emit the new, stable HTTP and networking conventions ONLY
+    HTTP = "http"
+    # http/dup - emit both the old and the stable HTTP and networking conventions
+    HTTP_DUP = "http/dup"
+    # default - continue emitting old experimental HTTP and networking conventions
+    DEFAULT = "default"
+
+
+def _report_new(mode):
+    return mode.name != _OpenTelemetryStabilityMode.DEFAULT.name
+
+
+def _report_old(mode):
+    return mode.name != _OpenTelemetryStabilityMode.HTTP.name
+
+
+class _OpenTelemetrySemanticConventionStability:
+    _initialized = False
+    _lock = threading.Lock()
+    _OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING = {}
+
+    @classmethod
+    def _initialize(cls):
+        with _OpenTelemetrySemanticConventionStability._lock:
+            if not _OpenTelemetrySemanticConventionStability._initialized:
+                # Users can pass in comma delimited string for opt-in options
+                # Only values for http stability are supported for now
+                opt_in = os.environ.get(_OTEL_SEMCONV_STABILITY_OPT_IN_KEY, "")
+                opt_in_list = []
+                if opt_in:
+                    opt_in_list = [s.strip() for s in opt_in.split(",")]
+                http_opt_in = _OpenTelemetryStabilityMode.DEFAULT
+                if opt_in_list:
+                    # Process http opt-in
+                    # http/dup takes priority over http
+                    if (
+                        _OpenTelemetryStabilityMode.HTTP_DUP.value
+                        in opt_in_list
+                    ):
+                        http_opt_in = _OpenTelemetryStabilityMode.HTTP_DUP
+                    elif _OpenTelemetryStabilityMode.HTTP.value in opt_in_list:
+                        http_opt_in = _OpenTelemetryStabilityMode.HTTP
+                _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING[
+                    _OpenTelemetryStabilitySignalType.HTTP
+                ] = http_opt_in
+                _OpenTelemetrySemanticConventionStability._initialized = True
+
+    @classmethod
+    # Get OpenTelemetry opt-in mode based off of signal type (http, messaging, etc.)
+    def _get_opentelemetry_stability_opt_in_mode(
+        cls,
+        signal_type: _OpenTelemetryStabilitySignalType,
+    ) -> _OpenTelemetryStabilityMode:
+        return _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING.get(
+            signal_type, _OpenTelemetryStabilityMode.DEFAULT
+        )
+
+
+# Get schema version based off of opt-in mode
+def _get_schema_url(mode: _OpenTelemetryStabilityMode) -> str:
+    if mode is _OpenTelemetryStabilityMode.DEFAULT:
+        return "https://opentelemetry.io/schemas/1.11.0"
+    return SpanAttributes.SCHEMA_URL

{opentelemetry_instrumentation-0.42b0 → opentelemetry_instrumentation-0.43b0}/src/opentelemetry/instrumentation/bootstrap.py

@@ -77,7 +77,7 @@ def _pip_check():
     ) as check_pipe:
         pip_check = check_pipe.communicate()[0].decode()
         pip_check_lower = pip_check.lower()
-    for package_tup in libraries.values():
+    for package_tup in libraries:
         for package in package_tup:
             if package.lower() in pip_check_lower:
                 raise RuntimeError(f"Dependency conflict found: {pip_check}")
@@ -102,15 +102,12 @@ def _is_installed(req):
 
 
 def _find_installed_libraries():
-    libs = default_instrumentations[:]
-    libs.extend(
-        [
-            v["instrumentation"]
-            for _, v in libraries.items()
-            if _is_installed(v["library"])
-        ]
-    )
-    return libs
+    for lib in default_instrumentations:
+        yield lib
+
+    for lib in libraries:
+        if _is_installed(lib["library"]):
+            yield lib["instrumentation"]
 
 
 def _run_requirements():

{opentelemetry_instrumentation-0.42b0 → opentelemetry_instrumentation-0.43b0}/src/opentelemetry/instrumentation/bootstrap_gen.py

@@ -15,181 +15,181 @@
 # DO NOT EDIT. THIS FILE WAS AUTOGENERATED FROM INSTRUMENTATION PACKAGES.
 # RUN `python scripts/generate_instrumentation_bootstrap.py` TO REGENERATE.
 
-libraries = {
-    "aio_pika": {
+libraries = [
+    {
         "library": "aio_pika >= 7.2.0, < 10.0.0",
-        "instrumentation": "opentelemetry-instrumentation-aio-pika==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-aio-pika==0.43b0",
     },
-    "aiohttp": {
+    {
         "library": "aiohttp ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-aiohttp-client==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-aiohttp-client==0.43b0",
     },
-    "aiohttp": {
+    {
         "library": "aiohttp ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-aiohttp-server==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-aiohttp-server==0.43b0",
     },
-    "aiopg": {
+    {
         "library": "aiopg >= 0.13.0, < 2.0.0",
-        "instrumentation": "opentelemetry-instrumentation-aiopg==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-aiopg==0.43b0",
     },
-    "asgiref": {
+    {
         "library": "asgiref ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-asgi==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-asgi==0.43b0",
     },
-    "asyncpg": {
+    {
         "library": "asyncpg >= 0.12.0",
-        "instrumentation": "opentelemetry-instrumentation-asyncpg==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-asyncpg==0.43b0",
     },
-    "boto": {
+    {
         "library": "boto~=2.0",
-        "instrumentation": "opentelemetry-instrumentation-boto==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-boto==0.43b0",
     },
-    "boto3": {
+    {
         "library": "boto3 ~= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-boto3sqs==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-boto3sqs==0.43b0",
     },
-    "botocore": {
+    {
         "library": "botocore ~= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-botocore==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-botocore==0.43b0",
     },
-    "cassandra-driver": {
+    {
         "library": "cassandra-driver ~= 3.25",
-        "instrumentation": "opentelemetry-instrumentation-cassandra==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-cassandra==0.43b0",
     },
-    "scylla-driver": {
+    {
         "library": "scylla-driver ~= 3.25",
-        "instrumentation": "opentelemetry-instrumentation-cassandra==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-cassandra==0.43b0",
     },
-    "celery": {
+    {
         "library": "celery >= 4.0, < 6.0",
-        "instrumentation": "opentelemetry-instrumentation-celery==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-celery==0.43b0",
     },
-    "confluent-kafka": {
+    {
         "library": "confluent-kafka >= 1.8.2, <= 2.2.0",
-        "instrumentation": "opentelemetry-instrumentation-confluent-kafka==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-confluent-kafka==0.43b0",
     },
-    "django": {
+    {
         "library": "django >= 1.10",
-        "instrumentation": "opentelemetry-instrumentation-django==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-django==0.43b0",
     },
-    "elasticsearch": {
+    {
         "library": "elasticsearch >= 2.0",
-        "instrumentation": "opentelemetry-instrumentation-elasticsearch==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-elasticsearch==0.43b0",
     },
-    "falcon": {
-        "library": "falcon >= 1.4.1, < 4.0.0",
-        "instrumentation": "opentelemetry-instrumentation-falcon==0.42b0",
+    {
+        "library": "falcon >= 1.4.1, < 3.1.2",
+        "instrumentation": "opentelemetry-instrumentation-falcon==0.43b0",
     },
-    "fastapi": {
+    {
         "library": "fastapi ~= 0.58",
-        "instrumentation": "opentelemetry-instrumentation-fastapi==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-fastapi==0.43b0",
     },
-    "flask": {
+    {
         "library": "flask >= 1.0, < 3.0",
-        "instrumentation": "opentelemetry-instrumentation-flask==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-flask==0.43b0",
     },
-    "werkzeug": {
+    {
         "library": "werkzeug < 3.0.0",
-        "instrumentation": "opentelemetry-instrumentation-flask==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-flask==0.43b0",
     },
-    "grpcio": {
+    {
         "library": "grpcio ~= 1.27",
-        "instrumentation": "opentelemetry-instrumentation-grpc==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-grpc==0.43b0",
     },
-    "httpx": {
+    {
         "library": "httpx >= 0.18.0",
-        "instrumentation": "opentelemetry-instrumentation-httpx==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-httpx==0.43b0",
     },
-    "jinja2": {
+    {
         "library": "jinja2 >= 2.7, < 4.0",
-        "instrumentation": "opentelemetry-instrumentation-jinja2==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-jinja2==0.43b0",
     },
-    "kafka-python": {
+    {
         "library": "kafka-python >= 2.0",
-        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.43b0",
     },
-    "mysql-connector-python": {
+    {
         "library": "mysql-connector-python ~= 8.0",
-        "instrumentation": "opentelemetry-instrumentation-mysql==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-mysql==0.43b0",
     },
-    "mysqlclient": {
+    {
         "library": "mysqlclient < 3",
-        "instrumentation": "opentelemetry-instrumentation-mysqlclient==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-mysqlclient==0.43b0",
     },
-    "pika": {
+    {
         "library": "pika >= 0.12.0",
-        "instrumentation": "opentelemetry-instrumentation-pika==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-pika==0.43b0",
     },
-    "psycopg2": {
+    {
         "library": "psycopg2 >= 2.7.3.1",
-        "instrumentation": "opentelemetry-instrumentation-psycopg2==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-psycopg2==0.43b0",
     },
-    "pymemcache": {
+    {
         "library": "pymemcache >= 1.3.5, < 5",
-        "instrumentation": "opentelemetry-instrumentation-pymemcache==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-pymemcache==0.43b0",
     },
-    "pymongo": {
+    {
         "library": "pymongo >= 3.1, < 5.0",
-        "instrumentation": "opentelemetry-instrumentation-pymongo==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-pymongo==0.43b0",
     },
-    "PyMySQL": {
+    {
         "library": "PyMySQL < 2",
-        "instrumentation": "opentelemetry-instrumentation-pymysql==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-pymysql==0.43b0",
     },
-    "pyramid": {
+    {
         "library": "pyramid >= 1.7",
-        "instrumentation": "opentelemetry-instrumentation-pyramid==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-pyramid==0.43b0",
     },
-    "redis": {
+    {
         "library": "redis >= 2.6",
-        "instrumentation": "opentelemetry-instrumentation-redis==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-redis==0.43b0",
     },
-    "remoulade": {
+    {
         "library": "remoulade >= 0.50",
-        "instrumentation": "opentelemetry-instrumentation-remoulade==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-remoulade==0.43b0",
     },
-    "requests": {
+    {
         "library": "requests ~= 2.0",
-        "instrumentation": "opentelemetry-instrumentation-requests==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-requests==0.43b0",
     },
-    "scikit-learn": {
+    {
         "library": "scikit-learn ~= 0.24.0",
-        "instrumentation": "opentelemetry-instrumentation-sklearn==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-sklearn==0.43b0",
     },
-    "sqlalchemy": {
+    {
         "library": "sqlalchemy",
-        "instrumentation": "opentelemetry-instrumentation-sqlalchemy==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-sqlalchemy==0.43b0",
     },
-    "starlette": {
+    {
         "library": "starlette ~= 0.13.0",
-        "instrumentation": "opentelemetry-instrumentation-starlette==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-starlette==0.43b0",
     },
-    "psutil": {
+    {
         "library": "psutil >= 5",
-        "instrumentation": "opentelemetry-instrumentation-system-metrics==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-system-metrics==0.43b0",
     },
-    "tornado": {
+    {
         "library": "tornado >= 5.1.1",
-        "instrumentation": "opentelemetry-instrumentation-tornado==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-tornado==0.43b0",
     },
-    "tortoise-orm": {
+    {
         "library": "tortoise-orm >= 0.17.0",
-        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.43b0",
     },
-    "pydantic": {
+    {
         "library": "pydantic >= 1.10.2",
-        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.43b0",
     },
-    "urllib3": {
+    {
         "library": "urllib3 >= 1.0.0, < 3.0.0",
-        "instrumentation": "opentelemetry-instrumentation-urllib3==0.42b0",
+        "instrumentation": "opentelemetry-instrumentation-urllib3==0.43b0",
     },
-}
+]
 default_instrumentations = [
-    "opentelemetry-instrumentation-aws-lambda==0.42b0",
-    "opentelemetry-instrumentation-dbapi==0.42b0",
-    "opentelemetry-instrumentation-logging==0.42b0",
-    "opentelemetry-instrumentation-sqlite3==0.42b0",
-    "opentelemetry-instrumentation-urllib==0.42b0",
-    "opentelemetry-instrumentation-wsgi==0.42b0",
+    "opentelemetry-instrumentation-aws-lambda==0.43b0",
+    "opentelemetry-instrumentation-dbapi==0.43b0",
+    "opentelemetry-instrumentation-logging==0.43b0",
+    "opentelemetry-instrumentation-sqlite3==0.43b0",
+    "opentelemetry-instrumentation-urllib==0.43b0",
+    "opentelemetry-instrumentation-wsgi==0.43b0",
 ]

{opentelemetry_instrumentation-0.42b0 → opentelemetry_instrumentation-0.43b0}/src/opentelemetry/instrumentation/instrumentor.py

@@ -21,6 +21,9 @@ from abc import ABC, abstractmethod
 from logging import getLogger
 from typing import Collection, Optional
 
+from opentelemetry.instrumentation._semconv import (
+    _OpenTelemetrySemanticConventionStability,
+)
 from opentelemetry.instrumentation.dependencies import (
     DependencyConflict,
     get_dependency_conflicts,
@@ -105,6 +108,9 @@ class BaseInstrumentor(ABC):
                 _LOG.error(conflict)
                 return None
 
+        # initialize semantic conventions opt-in if needed
+        _OpenTelemetrySemanticConventionStability._initialize()
+
         result = self._instrument(  # pylint: disable=assignment-from-no-return
             **kwargs
         )

{opentelemetry_instrumentation-0.42b0 → opentelemetry_instrumentation-0.43b0}/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.42b0"
+__version__ = "0.43b0"

{opentelemetry_instrumentation-0.42b0 → opentelemetry_instrumentation-0.43b0}/tests/test_bootstrap.py

@@ -36,7 +36,7 @@ class TestBootstrap(TestCase):
     @classmethod
     def setUpClass(cls):
         cls.installed_libraries = sample_packages(
-            [lib["instrumentation"] for lib in libraries.values()], 0.6
+            [lib["instrumentation"] for lib in libraries], 0.6
         )
 
         # treat 50% of sampled packages as pre-installed