opentelemetry-instrumentation 0.46b0__tar.gz → 0.48b0__tar.gz

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/.gitignore

@@ -58,3 +58,6 @@ _build/
 # mypy
 .mypy_cache/
 target
+
+# Benchmark result files
+*-benchmark.json

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opentelemetry-instrumentation
-Version: 0.46b0
+Version: 0.48b0
 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>
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 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

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/pyproject.toml

@@ -22,6 +22,7 @@ classifiers = [
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
   "opentelemetry-api ~= 1.4",

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/src/opentelemetry/instrumentation/_semconv.py

@@ -17,15 +17,37 @@ import threading
 from enum import Enum
 
 from opentelemetry.instrumentation.utils import http_status_to_status_code
+from opentelemetry.semconv.attributes.client_attributes import (
+    CLIENT_ADDRESS,
+    CLIENT_PORT,
+)
+from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
+from opentelemetry.semconv.attributes.http_attributes import (
+    HTTP_REQUEST_METHOD,
+    HTTP_REQUEST_METHOD_ORIGINAL,
+    HTTP_RESPONSE_STATUS_CODE,
+    HTTP_ROUTE,
+)
+from opentelemetry.semconv.attributes.network_attributes import (
+    NETWORK_PROTOCOL_VERSION,
+)
+from opentelemetry.semconv.attributes.server_attributes import (
+    SERVER_ADDRESS,
+    SERVER_PORT,
+)
+from opentelemetry.semconv.attributes.url_attributes import (
+    URL_FULL,
+    URL_PATH,
+    URL_QUERY,
+    URL_SCHEME,
+)
+from opentelemetry.semconv.attributes.user_agent_attributes import (
+    USER_AGENT_ORIGINAL,
+)
 from opentelemetry.semconv.trace import SpanAttributes
 from opentelemetry.trace.status import Status, StatusCode
 
-# 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"
-_METRIC_ATTRIBUTES_SERVER_DURATION_NAME = "http.server.request.duration"
+# These lists represent attributes for metrics that are currently supported
 
 _client_duration_attrs_old = [
     SpanAttributes.HTTP_STATUS_CODE,
@@ -38,14 +60,14 @@ _client_duration_attrs_old = [
 ]
 
 _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,
+    ERROR_TYPE,
+    HTTP_REQUEST_METHOD,
+    HTTP_RESPONSE_STATUS_CODE,
+    NETWORK_PROTOCOL_VERSION,
+    SERVER_ADDRESS,
+    SERVER_PORT,
     # TODO: Support opt-in for scheme in new semconv
-    # SpanAttributes.URL_SCHEME,
+    # URL_SCHEME,
 ]
 
 _server_duration_attrs_old = [
@@ -60,12 +82,12 @@ _server_duration_attrs_old = [
 ]
 
 _server_duration_attrs_new = [
-    _SPAN_ATTRIBUTES_ERROR_TYPE,
-    SpanAttributes.HTTP_REQUEST_METHOD,
-    SpanAttributes.HTTP_RESPONSE_STATUS_CODE,
-    SpanAttributes.HTTP_ROUTE,
-    SpanAttributes.NETWORK_PROTOCOL_VERSION,
-    SpanAttributes.URL_SCHEME,
+    ERROR_TYPE,
+    HTTP_REQUEST_METHOD,
+    HTTP_RESPONSE_STATUS_CODE,
+    HTTP_ROUTE,
+    NETWORK_PROTOCOL_VERSION,
+    URL_SCHEME,
 ]
 
 _server_active_requests_count_attrs_old = [
@@ -74,13 +96,12 @@ _server_active_requests_count_attrs_old = [
     SpanAttributes.HTTP_SCHEME,
     SpanAttributes.HTTP_FLAVOR,
     SpanAttributes.HTTP_SERVER_NAME,
-    SpanAttributes.NET_HOST_NAME,
-    SpanAttributes.NET_HOST_PORT,
 ]
 
 _server_active_requests_count_attrs_new = [
-    SpanAttributes.HTTP_REQUEST_METHOD,
-    SpanAttributes.URL_SCHEME,
+    HTTP_REQUEST_METHOD,
+    URL_SCHEME,
+    # TODO: Support SERVER_ADDRESS AND SERVER_PORT
 ]
 
 OTEL_SEMCONV_STABILITY_OPT_IN = "OTEL_SEMCONV_STABILITY_OPT_IN"
@@ -202,72 +223,80 @@ def _set_http_method(result, original, normalized, sem_conv_opt_in_mode):
     # 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
-        )
+        set_string_attribute(result, 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
-        )
+        set_string_attribute(result, HTTP_REQUEST_METHOD, normalized)
 
 
 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
-        )
+        set_int_attribute(result, HTTP_RESPONSE_STATUS_CODE, code)
 
 
 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)
+        set_string_attribute(result, 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)
     if _report_new(sem_conv_opt_in_mode):
-        set_string_attribute(result, SpanAttributes.URL_SCHEME, scheme)
+        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, SpanAttributes.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)
     if _report_new(sem_conv_opt_in_mode):
-        set_string_attribute(result, SpanAttributes.SERVER_ADDRESS, peer_name)
+        set_string_attribute(result, SERVER_ADDRESS, peer_name)
 
 
 def _set_http_peer_port_client(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)
+        set_int_attribute(result, SERVER_PORT, port)
 
 
 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
-        )
+        set_string_attribute(result, NETWORK_PROTOCOL_VERSION, version)
 
 
 # Server
@@ -277,14 +306,14 @@ def _set_http_net_host(result, host, sem_conv_opt_in_mode):
     if _report_old(sem_conv_opt_in_mode):
         set_string_attribute(result, SpanAttributes.NET_HOST_NAME, host)
     if _report_new(sem_conv_opt_in_mode):
-        set_string_attribute(result, SpanAttributes.SERVER_ADDRESS, host)
+        set_string_attribute(result, SERVER_ADDRESS, host)
 
 
 def _set_http_net_host_port(result, port, sem_conv_opt_in_mode):
     if _report_old(sem_conv_opt_in_mode):
         set_int_attribute(result, SpanAttributes.NET_HOST_PORT, port)
     if _report_new(sem_conv_opt_in_mode):
-        set_int_attribute(result, SpanAttributes.SERVER_PORT, port)
+        set_int_attribute(result, SERVER_PORT, port)
 
 
 def _set_http_target(result, target, path, query, sem_conv_opt_in_mode):
@@ -292,91 +321,86 @@ def _set_http_target(result, target, path, query, sem_conv_opt_in_mode):
         set_string_attribute(result, SpanAttributes.HTTP_TARGET, target)
     if _report_new(sem_conv_opt_in_mode):
         if path:
-            set_string_attribute(result, SpanAttributes.URL_PATH, path)
+            set_string_attribute(result, URL_PATH, path)
         if query:
-            set_string_attribute(result, SpanAttributes.URL_QUERY, query)
+            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, SpanAttributes.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, SpanAttributes.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, SpanAttributes.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):
     if _report_old(sem_conv_opt_in_mode):
         set_string_attribute(result, SpanAttributes.NET_PEER_NAME, name)
     if _report_new(sem_conv_opt_in_mode):
-        set_string_attribute(result, SpanAttributes.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, SpanAttributes.NETWORK_PROTOCOL_VERSION, version
-        )
+        set_string_attribute(result, CLIENT_ADDRESS, name)
 
 
 def _set_status(
     span,
-    metrics_attributes,
-    status_code_str,
-    status_code,
-    sem_conv_opt_in_mode,
+    metrics_attributes: dict,
+    status_code: int,
+    status_code_str: str,
+    server_span: bool = True,
+    sem_conv_opt_in_mode: _HTTPStabilityMode = _HTTPStabilityMode.DEFAULT,
 ):
     if status_code < 0:
-        if _report_new(sem_conv_opt_in_mode):
-            span.set_attribute(_SPAN_ATTRIBUTES_ERROR_TYPE, status_code_str)
-            metrics_attributes[_SPAN_ATTRIBUTES_ERROR_TYPE] = status_code_str
-
-        span.set_status(
-            Status(
-                StatusCode.ERROR,
-                "Non-integer HTTP status: " + status_code_str,
+        metrics_attributes[ERROR_TYPE] = status_code_str
+        if span.is_recording():
+            if _report_new(sem_conv_opt_in_mode):
+                span.set_attribute(ERROR_TYPE, status_code_str)
+            span.set_status(
+                Status(
+                    StatusCode.ERROR,
+                    "Non-integer HTTP status: " + status_code_str,
+                )
             )
-        )
     else:
-        status = http_status_to_status_code(status_code, server_span=True)
+        status = http_status_to_status_code(
+            status_code, server_span=server_span
+        )
 
         if _report_old(sem_conv_opt_in_mode):
-            span.set_attribute(SpanAttributes.HTTP_STATUS_CODE, status_code)
+            if span.is_recording():
+                span.set_attribute(
+                    SpanAttributes.HTTP_STATUS_CODE, status_code
+                )
             metrics_attributes[SpanAttributes.HTTP_STATUS_CODE] = status_code
         if _report_new(sem_conv_opt_in_mode):
-            span.set_attribute(
-                SpanAttributes.HTTP_RESPONSE_STATUS_CODE, status_code
-            )
-            metrics_attributes[SpanAttributes.HTTP_RESPONSE_STATUS_CODE] = (
-                status_code
-            )
+            if span.is_recording():
+                span.set_attribute(HTTP_RESPONSE_STATUS_CODE, status_code)
+            metrics_attributes[HTTP_RESPONSE_STATUS_CODE] = status_code
             if status == StatusCode.ERROR:
-                span.set_attribute(
-                    _SPAN_ATTRIBUTES_ERROR_TYPE, status_code_str
-                )
-                metrics_attributes[_SPAN_ATTRIBUTES_ERROR_TYPE] = (
-                    status_code_str
-                )
-        span.set_status(Status(status))
+                if span.is_recording():
+                    span.set_attribute(ERROR_TYPE, status_code_str)
+                metrics_attributes[ERROR_TYPE] = status_code_str
+        if span.is_recording():
+            span.set_status(Status(status))
 
 
 # Get schema version based off of opt-in mode

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/src/opentelemetry/instrumentation/bootstrap.py

@@ -119,7 +119,7 @@ def _find_installed_libraries():
 
 def _run_requirements():
     logger.setLevel(logging.ERROR)
-    print("\n".join(_find_installed_libraries()), end="")
+    print("\n".join(_find_installed_libraries()))
 
 
 def _run_install():

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/src/opentelemetry/instrumentation/bootstrap_gen.py

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

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/src/opentelemetry/instrumentation/utils.py

@@ -37,6 +37,10 @@ from opentelemetry.trace.propagation.tracecontext import (
 
 propagator = TraceContextTextMapPropagator()
 
+_SUPPRESS_INSTRUMENTATION_KEY_PLAIN = (
+    "suppress_instrumentation"  # Set for backward compatibility
+)
+
 
 def extract_attributes_from_object(
     obj: any, attributes: Sequence[str], existing: Dict[str, str] = None
@@ -161,9 +165,10 @@ def _python_path_without_directory(python_path, directory, path_separator):
 
 
 def is_instrumentation_enabled() -> bool:
-    if context.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
-        return False
-    return True
+    return not (
+        context.get_value(_SUPPRESS_INSTRUMENTATION_KEY)
+        or context.get_value(_SUPPRESS_INSTRUMENTATION_KEY_PLAIN)
+    )
 
 
 def is_http_instrumentation_enabled() -> bool:
@@ -188,7 +193,9 @@ def _suppress_instrumentation(*keys: str) -> Iterable[None]:
 @contextmanager
 def suppress_instrumentation() -> Iterable[None]:
     """Suppress instrumentation within the context."""
-    with _suppress_instrumentation(_SUPPRESS_INSTRUMENTATION_KEY):
+    with _suppress_instrumentation(
+        _SUPPRESS_INSTRUMENTATION_KEY, _SUPPRESS_INSTRUMENTATION_KEY_PLAIN
+    ):
         yield
 
 

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/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.46b0"
+__version__ = "0.48b0"

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/tests/auto_instrumentation/test_load.py

@@ -32,7 +32,9 @@ class TestLoad(TestCase):
     @patch(
         "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
     )
-    def test_load_configurators(self, iter_mock):
+    def test_load_configurators(
+        self, iter_mock
+    ):  # pylint: disable=no-self-use
         # Add multiple entry points but only specify the 2nd in the environment variable.
         ep_mock1 = Mock()
         ep_mock1.name = "custom_configurator1"
@@ -62,9 +64,8 @@ class TestLoad(TestCase):
         "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
     )
     def test_load_configurators_no_ep(
-        self,
-        iter_mock,
-    ):
+        self, iter_mock
+    ):  # pylint: disable=no-self-use
         iter_mock.return_value = ()
         # Confirm method does not crash if not entry points exist.
         _load._load_configurators()
@@ -214,6 +215,7 @@ class TestLoad(TestCase):
     )
     def test_load_instrumentors(self, iter_mock, dep_mock):
         # Mock opentelemetry_pre_instrument entry points
+        # pylint: disable=too-many-locals
         pre_ep_mock1 = Mock()
         pre_ep_mock1.name = "pre1"
         pre_mock1 = Mock()
@@ -285,7 +287,9 @@ class TestLoad(TestCase):
     @patch(
         "opentelemetry.instrumentation.auto_instrumentation._load.iter_entry_points"
     )
-    def test_load_instrumentors_dep_conflict(self, iter_mock, dep_mock):
+    def test_load_instrumentors_dep_conflict(
+        self, iter_mock, dep_mock
+    ):  # pylint: disable=no-self-use
         ep_mock1 = Mock()
         ep_mock1.name = "instr1"
 

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/tests/test_bootstrap.py

@@ -77,7 +77,7 @@ class TestBootstrap(TestCase):
             bootstrap.run()
             self.assertEqual(
                 fake_out.getvalue(),
-                "\n".join(self.installed_libraries),
+                "\n".join(self.installed_libraries) + "\n",
             )
 
     @patch("sys.argv", ["bootstrap", "-a", "install"])

{opentelemetry_instrumentation-0.46b0 → opentelemetry_instrumentation-0.48b0}/tests/test_utils.py

@@ -15,10 +15,20 @@
 import unittest
 from http import HTTPStatus
 
+from opentelemetry.context import (
+    _SUPPRESS_HTTP_INSTRUMENTATION_KEY,
+    _SUPPRESS_INSTRUMENTATION_KEY,
+    get_current,
+    get_value,
+)
 from opentelemetry.instrumentation.sqlcommenter_utils import _add_sql_comment
 from opentelemetry.instrumentation.utils import (
     _python_path_without_directory,
     http_status_to_status_code,
+    is_http_instrumentation_enabled,
+    is_instrumentation_enabled,
+    suppress_http_instrumentation,
+    suppress_instrumentation,
 )
 from opentelemetry.trace import StatusCode
 
@@ -186,3 +196,47 @@ class TestUtils(unittest.TestCase):
         )
 
         self.assertEqual(commented_sql_without_semicolon, "Select 1")
+
+    def test_is_instrumentation_enabled_by_default(self):
+        self.assertTrue(is_instrumentation_enabled())
+        self.assertTrue(is_http_instrumentation_enabled())
+
+    def test_suppress_instrumentation(self):
+        with suppress_instrumentation():
+            self.assertFalse(is_instrumentation_enabled())
+            self.assertFalse(is_http_instrumentation_enabled())
+
+        self.assertTrue(is_instrumentation_enabled())
+        self.assertTrue(is_http_instrumentation_enabled())
+
+    def test_suppress_http_instrumentation(self):
+        with suppress_http_instrumentation():
+            self.assertFalse(is_http_instrumentation_enabled())
+            self.assertTrue(is_instrumentation_enabled())
+
+        self.assertTrue(is_instrumentation_enabled())
+        self.assertTrue(is_http_instrumentation_enabled())
+
+    def test_suppress_instrumentation_key(self):
+        self.assertIsNone(get_value(_SUPPRESS_INSTRUMENTATION_KEY))
+        self.assertIsNone(get_value("suppress_instrumentation"))
+
+        with suppress_instrumentation():
+            ctx = get_current()
+            self.assertIn(_SUPPRESS_INSTRUMENTATION_KEY, ctx)
+            self.assertIn("suppress_instrumentation", ctx)
+            self.assertTrue(get_value(_SUPPRESS_INSTRUMENTATION_KEY))
+            self.assertTrue(get_value("suppress_instrumentation"))
+
+        self.assertIsNone(get_value(_SUPPRESS_INSTRUMENTATION_KEY))
+        self.assertIsNone(get_value("suppress_instrumentation"))
+
+    def test_suppress_http_instrumentation_key(self):
+        self.assertIsNone(get_value(_SUPPRESS_HTTP_INSTRUMENTATION_KEY))
+
+        with suppress_http_instrumentation():
+            ctx = get_current()
+            self.assertIn(_SUPPRESS_HTTP_INSTRUMENTATION_KEY, ctx)
+            self.assertTrue(get_value(_SUPPRESS_HTTP_INSTRUMENTATION_KEY))
+
+        self.assertIsNone(get_value(_SUPPRESS_HTTP_INSTRUMENTATION_KEY))