opentelemetry-instrumentation 0.44b0__py3-none-any.whl → 0.46b0__py3-none-any.whl

opentelemetry/instrumentation/_semconv.py

@@ -16,13 +16,16 @@ import os
 import threading
 from enum import Enum
 
+from opentelemetry.instrumentation.utils import http_status_to_status_code
 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"
 
 _client_duration_attrs_old = [
     SpanAttributes.HTTP_STATUS_CODE,
@@ -45,13 +48,116 @@ _client_duration_attrs_new = [
     # SpanAttributes.URL_SCHEME,
 ]
 
+_server_duration_attrs_old = [
+    SpanAttributes.HTTP_METHOD,
+    SpanAttributes.HTTP_HOST,
+    SpanAttributes.HTTP_SCHEME,
+    SpanAttributes.HTTP_STATUS_CODE,
+    SpanAttributes.HTTP_FLAVOR,
+    SpanAttributes.HTTP_SERVER_NAME,
+    SpanAttributes.NET_HOST_NAME,
+    SpanAttributes.NET_HOST_PORT,
+]
+
+_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,
+]
+
+_server_active_requests_count_attrs_old = [
+    SpanAttributes.HTTP_METHOD,
+    SpanAttributes.HTTP_HOST,
+    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,
+]
+
+OTEL_SEMCONV_STABILITY_OPT_IN = "OTEL_SEMCONV_STABILITY_OPT_IN"
+
+
+class _OpenTelemetryStabilitySignalType:
+    HTTP = "http"
+
+
+class _HTTPStabilityMode(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 != _HTTPStabilityMode.DEFAULT.name
+
+
+def _report_old(mode):
+    return mode.name != _HTTPStabilityMode.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, "")
+                opt_in_list = []
+                if opt_in:
+                    opt_in_list = [s.strip() for s in opt_in.split(",")]
+                http_opt_in = _HTTPStabilityMode.DEFAULT
+                if opt_in_list:
+                    # Process http opt-in
+                    # http/dup takes priority over http
+                    if _HTTPStabilityMode.HTTP_DUP.value in opt_in_list:
+                        http_opt_in = _HTTPStabilityMode.HTTP_DUP
+                    elif _HTTPStabilityMode.HTTP.value in opt_in_list:
+                        http_opt_in = _HTTPStabilityMode.HTTP
+                _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING[
+                    _OpenTelemetryStabilitySignalType.HTTP
+                ] = http_opt_in
+                _OpenTelemetrySemanticConventionStability._initialized = True
 
-def _filter_duration_attrs(attrs, sem_conv_opt_in_mode):
+    @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,
+    ) -> _HTTPStabilityMode:
+        return _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING.get(
+            signal_type, _HTTPStabilityMode.DEFAULT
+        )
+
+
+def _filter_semconv_duration_attrs(
+    attrs,
+    old_attrs,
+    new_attrs,
+    sem_conv_opt_in_mode=_HTTPStabilityMode.DEFAULT,
+):
     filtered_attrs = {}
+    # duration is two different metrics depending on sem_conv_opt_in_mode, so no DUP attributes
     allowed_attributes = (
-        _client_duration_attrs_new
-        if sem_conv_opt_in_mode == _OpenTelemetryStabilityMode.HTTP
-        else _client_duration_attrs_old
+        new_attrs
+        if sem_conv_opt_in_mode == _HTTPStabilityMode.HTTP
+        else old_attrs
     )
     for key, val in attrs.items():
         if key in allowed_attributes:
@@ -59,6 +165,24 @@ def _filter_duration_attrs(attrs, sem_conv_opt_in_mode):
     return filtered_attrs
 
 
+def _filter_semconv_active_request_count_attr(
+    attrs,
+    old_attrs,
+    new_attrs,
+    sem_conv_opt_in_mode=_HTTPStabilityMode.DEFAULT,
+):
+    filtered_attrs = {}
+    if _report_old(sem_conv_opt_in_mode):
+        for key, val in attrs.items():
+            if key in old_attrs:
+                filtered_attrs[key] = val
+    if _report_new(sem_conv_opt_in_mode):
+        for key, val in attrs.items():
+            if key in new_attrs:
+                filtered_attrs[key] = val
+    return filtered_attrs
+
+
 def set_string_attribute(result, key, value):
     if value:
         result[key] = value
@@ -90,6 +214,15 @@ def _set_http_method(result, original, normalized, sem_conv_opt_in_mode):
         )
 
 
+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_url(result, url, sem_conv_opt_in_mode):
     if _report_old(sem_conv_opt_in_mode):
         set_string_attribute(result, SpanAttributes.HTTP_URL, url)
@@ -100,41 +233,34 @@ def _set_http_url(result, url, sem_conv_opt_in_mode):
 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)
+    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):
+def _set_http_host(result, host, sem_conv_opt_in_mode):
     if _report_old(sem_conv_opt_in_mode):
-        set_string_attribute(result, SpanAttributes.HTTP_HOST, hostname)
+        set_string_attribute(result, SpanAttributes.HTTP_HOST, host)
     if _report_new(sem_conv_opt_in_mode):
-        set_string_attribute(result, SpanAttributes.SERVER_ADDRESS, hostname)
+        set_string_attribute(result, SpanAttributes.SERVER_ADDRESS, host)
+
 
+# Client
 
-def _set_http_net_peer_name(result, peer_name, sem_conv_opt_in_mode):
+
+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)
 
 
-def _set_http_port(result, port, sem_conv_opt_in_mode):
+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)
 
 
-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)
@@ -144,74 +270,117 @@ def _set_http_network_protocol_version(result, version, sem_conv_opt_in_mode):
         )
 
 
-_OTEL_SEMCONV_STABILITY_OPT_IN_KEY = "OTEL_SEMCONV_STABILITY_OPT_IN"
+# Server
 
 
-class _OpenTelemetryStabilitySignalType:
-    HTTP = "http"
+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)
 
 
-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 _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)
 
 
-def _report_new(mode):
-    return mode.name != _OpenTelemetryStabilityMode.DEFAULT.name
+def _set_http_target(result, target, path, query, sem_conv_opt_in_mode):
+    if _report_old(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)
+        if query:
+            set_string_attribute(result, SpanAttributes.URL_QUERY, query)
 
 
-def _report_old(mode):
-    return mode.name != _OpenTelemetryStabilityMode.HTTP.name
+def _set_http_peer_ip(result, ip, sem_conv_opt_in_mode):
+    if _report_old(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.NET_PEER_IP, ip)
+    if _report_new(sem_conv_opt_in_mode):
+        set_string_attribute(result, SpanAttributes.CLIENT_ADDRESS, ip)
 
 
-class _OpenTelemetrySemanticConventionStability:
-    _initialized = False
-    _lock = threading.Lock()
-    _OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING = {}
+def _set_http_peer_port_server(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.CLIENT_PORT, port)
 
-    @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
+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, SpanAttributes.USER_AGENT_ORIGINAL, user_agent
+        )
+
+
+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
+        )
+
+
+def _set_status(
+    span,
+    metrics_attributes,
+    status_code_str,
+    status_code,
+    sem_conv_opt_in_mode,
+):
+    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,
+            )
         )
+    else:
+        status = http_status_to_status_code(status_code, server_span=True)
+
+        if _report_old(sem_conv_opt_in_mode):
+            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 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))
 
 
 # Get schema version based off of opt-in mode
-def _get_schema_url(mode: _OpenTelemetryStabilityMode) -> str:
-    if mode is _OpenTelemetryStabilityMode.DEFAULT:
+def _get_schema_url(mode: _HTTPStabilityMode) -> str:
+    if mode is _HTTPStabilityMode.DEFAULT:
         return "https://opentelemetry.io/schemas/1.11.0"
     return SpanAttributes.SCHEMA_URL

opentelemetry/instrumentation/bootstrap.py

@@ -14,8 +14,14 @@
 
 import argparse
 import logging
-import subprocess
 import sys
+from subprocess import (
+    PIPE,
+    CalledProcessError,
+    Popen,
+    SubprocessError,
+    check_call,
+)
 
 import pkg_resources
 
@@ -34,7 +40,7 @@ def _syscall(func):
             if package:
                 return func(package)
             return func()
-        except subprocess.SubprocessError as exp:
+        except SubprocessError as exp:
             cmd = getattr(exp, "cmd", None)
             if cmd:
                 msg = f'Error calling system command "{" ".join(cmd)}"'
@@ -48,18 +54,21 @@ def _syscall(func):
 @_syscall
 def _sys_pip_install(package):
     # explicit upgrade strategy to override potential pip config
-    subprocess.check_call(
-        [
-            sys.executable,
-            "-m",
-            "pip",
-            "install",
-            "-U",
-            "--upgrade-strategy",
-            "only-if-needed",
-            package,
-        ]
-    )
+    try:
+        check_call(
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                "-U",
+                "--upgrade-strategy",
+                "only-if-needed",
+                package,
+            ]
+        )
+    except CalledProcessError as error:
+        print(error)
 
 
 def _pip_check():
@@ -70,8 +79,8 @@ def _pip_check():
     'opentelemetry-instrumentation-flask 1.0.1 has requirement opentelemetry-sdk<2.0,>=1.0, but you have opentelemetry-sdk 0.5.'
     To not be too restrictive, we'll only check for relevant packages.
     """
-    with subprocess.Popen(
-        [sys.executable, "-m", "pip", "check"], stdout=subprocess.PIPE
+    with Popen(
+        [sys.executable, "-m", "pip", "check"], stdout=PIPE
     ) as check_pipe:
         pip_check = check_pipe.communicate()[0].decode()
         pip_check_lower = pip_check.lower()

opentelemetry/instrumentation/bootstrap_gen.py

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

@@ -50,9 +50,10 @@ class BaseDistro(ABC):
     def load_instrumentor(  # pylint: disable=no-self-use
         self, entry_point: EntryPoint, **kwargs
     ):
-        """Takes a collection of instrumentation entry points
-        and activates them by instantiating and calling instrument()
-        on each one.
+        """Takes an instrumentation entry point and activates it by instantiating
+        and calling instrument() on it.
+        This is called for each opentelemetry_instrumentor entry point by auto
+        instrumentation.
 
         Distros can override this method to customize the behavior by
         inspecting each entry point and configuring them in special ways,

opentelemetry/instrumentation/version.py

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

{opentelemetry_instrumentation-0.44b0.dist-info → opentelemetry_instrumentation-0.46b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: opentelemetry-instrumentation
-Version: 0.44b0
+Version: 0.46b0
 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>
@@ -19,7 +19,6 @@ Requires-Python: >=3.8
 Requires-Dist: opentelemetry-api~=1.4
 Requires-Dist: setuptools>=16.0
 Requires-Dist: wrapt<2.0.0,>=1.0.0
-Provides-Extra: test
 Description-Content-Type: text/x-rst
 
 OpenTelemetry Instrumentation

{opentelemetry_instrumentation-0.44b0.dist-info → opentelemetry_instrumentation-0.46b0.dist-info}/RECORD

@@ -1,20 +1,20 @@
-opentelemetry/instrumentation/_semconv.py,sha256=0vCrUperS-ixS3fAH0_sauYhsoVhIc5E2cuOPx6RNtE,8143
-opentelemetry/instrumentation/bootstrap.py,sha256=dNW-ZC7SgGo6VPCear4Le0Oq3bNrX1Tao2QIz1bIn0c,4560
-opentelemetry/instrumentation/bootstrap_gen.py,sha256=Ct_p04nS9vJcamL0s8dnMKsIwZshHD9tWdjMdcH_Psg,6520
+opentelemetry/instrumentation/_semconv.py,sha256=dDNGU4I5r6UvLHWIpwW1eblSGKQCSNghCjsCBwEFsoA,13703
+opentelemetry/instrumentation/bootstrap.py,sha256=J_sUXmcnUGXXj0ySJ1KxGcr-nmfDP7-S_N3vHqjLecY,4725
+opentelemetry/instrumentation/bootstrap_gen.py,sha256=6t_k5Hwfgb-MNvusKaOUfNrt90I0ULrEexfcq3znypM,6703
 opentelemetry/instrumentation/dependencies.py,sha256=ljJ0nMK_vNZXOiCTLOT1nM3xpwmx7LVaW_S53jcRvIY,1798
-opentelemetry/instrumentation/distro.py,sha256=4TCMpJY169TiYXfaD-9suGv6310_ir_rVuMljC7CVOY,2071
+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=REjbeQl1wE6A4ByCKxOH5xdEjov2FHeO_WEUmGw6wqk,6128
-opentelemetry/instrumentation/version.py,sha256=19mImFBLq6Vm8J2PHjFLnLCfNeBJuW5hSl2zbot4J5I,608
+opentelemetry/instrumentation/version.py,sha256=asa7q2ly73330-K1Q7vujpvZk7hfhasEZUzSFDPu1N8,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.44b0.dist-info/METADATA,sha256=Lw0A_fDo43_fxB3N5Xb5Sr9KraDlXRpMhLj3ZMU1WmM,6085
-opentelemetry_instrumentation-0.44b0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-opentelemetry_instrumentation-0.44b0.dist-info/entry_points.txt,sha256=iVv3t5REB0O58tFUEQQXYLrTCa1VVOFUXfrbvUk6_aU,279
-opentelemetry_instrumentation-0.44b0.dist-info/licenses/LICENSE,sha256=h8jwqxShIeVkc8vOo9ynxGYW16f4fVPxLhZKZs0H5U8,11350
-opentelemetry_instrumentation-0.44b0.dist-info/RECORD,,
+opentelemetry_instrumentation-0.46b0.dist-info/METADATA,sha256=HnyH6uUKDWtwFtY55DFfAiuhGfmSVd238C_4afzyQoI,6064
+opentelemetry_instrumentation-0.46b0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+opentelemetry_instrumentation-0.46b0.dist-info/entry_points.txt,sha256=iVv3t5REB0O58tFUEQQXYLrTCa1VVOFUXfrbvUk6_aU,279
+opentelemetry_instrumentation-0.46b0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+opentelemetry_instrumentation-0.46b0.dist-info/RECORD,,

{opentelemetry_instrumentation-0.44b0.dist-info → opentelemetry_instrumentation-0.46b0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.21.1
+Generator: hatchling 1.24.2
 Root-Is-Purelib: true
 Tag: py3-none-any

{opentelemetry_instrumentation-0.44b0.dist-info → opentelemetry_instrumentation-0.46b0.dist-info}/licenses/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright The OpenTelemetry Authors
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.