opentelemetry-instrumentation 0.49b2__tar.gz → 0.51b0__tar.gz

{opentelemetry_instrumentation-0.49b2 → opentelemetry_instrumentation-0.51b0}/PKG-INFO

@@ -1,10 +1,12 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: opentelemetry-instrumentation
-Version: 0.49b2
+Version: 0.51b0
 Summary: Instrumentation Tools & Auto Instrumentation for OpenTelemetry Python
 Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/opentelemetry-instrumentation
+Project-URL: Repository, https://github.com/open-telemetry/opentelemetry-python-contrib
 Author-email: OpenTelemetry Authors <cncf-opentelemetry-contributors@lists.cncf.io>
-License: Apache-2.0
+License-Expression: Apache-2.0
+License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -15,9 +17,10 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Requires-Dist: opentelemetry-api~=1.4
-Requires-Dist: opentelemetry-semantic-conventions==0.49b2
+Requires-Dist: opentelemetry-semantic-conventions==0.51b0
 Requires-Dist: packaging>=18.0
 Requires-Dist: wrapt<2.0.0,>=1.0.0
 Description-Content-Type: text/x-rst

{opentelemetry_instrumentation-0.49b2 → opentelemetry_instrumentation-0.51b0}/pyproject.toml

@@ -23,10 +23,11 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
   "opentelemetry-api ~= 1.4",
-  "opentelemetry-semantic-conventions == 0.49b2",
+  "opentelemetry-semantic-conventions == 0.51b0",
   "wrapt >= 1.0.0, < 2.0.0",
   "packaging >= 18.0",
 ]
@@ -40,6 +41,7 @@ instrumentation = "opentelemetry.instrumentation.environment_variables"
 
 [project.urls]
 Homepage = "https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/opentelemetry-instrumentation"
+Repository = "https://github.com/open-telemetry/opentelemetry-python-contrib"
 
 [tool.hatch.version]
 path = "src/opentelemetry/instrumentation/version.py"

{opentelemetry_instrumentation-0.49b2 → opentelemetry_instrumentation-0.51b0}/src/opentelemetry/instrumentation/_semconv.py

@@ -109,23 +109,23 @@ OTEL_SEMCONV_STABILITY_OPT_IN = "OTEL_SEMCONV_STABILITY_OPT_IN"
 
 class _OpenTelemetryStabilitySignalType:
     HTTP = "http"
+    DATABASE = "database"
 
 
-class _HTTPStabilityMode(Enum):
-    # http - emit the new, stable HTTP and networking conventions ONLY
+class _StabilityMode(Enum):
+    DEFAULT = "default"
     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"
+    DATABASE = "database"
+    DATABASE_DUP = "database/dup"
 
 
-def _report_new(mode):
-    return mode.name != _HTTPStabilityMode.DEFAULT.name
+def _report_new(mode: _StabilityMode):
+    return mode != _StabilityMode.DEFAULT
 
 
-def _report_old(mode):
-    return mode.name != _HTTPStabilityMode.HTTP.name
+def _report_old(mode: _StabilityMode):
+    return mode not in (_StabilityMode.HTTP, _StabilityMode.DATABASE)
 
 
 class _OpenTelemetrySemanticConventionStability:
@@ -135,35 +135,61 @@ class _OpenTelemetrySemanticConventionStability:
 
     @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
+        with cls._lock:
+            if cls._initialized:
+                return
+
+            # Users can pass in comma delimited string for opt-in options
+            # Only values for http and database stability are supported for now
+            opt_in = os.environ.get(OTEL_SEMCONV_STABILITY_OPT_IN)
+
+            if not opt_in:
+                # early return in case of default
+                cls._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING = {
+                    _OpenTelemetryStabilitySignalType.HTTP: _StabilityMode.DEFAULT,
+                    _OpenTelemetryStabilitySignalType.DATABASE: _StabilityMode.DEFAULT,
+                }
+                cls._initialized = True
+                return
+
+            opt_in_list = [s.strip() for s in opt_in.split(",")]
+
+            cls._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING[
+                _OpenTelemetryStabilitySignalType.HTTP
+            ] = cls._filter_mode(
+                opt_in_list, _StabilityMode.HTTP, _StabilityMode.HTTP_DUP
+            )
+
+            cls._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING[
+                _OpenTelemetryStabilitySignalType.DATABASE
+            ] = cls._filter_mode(
+                opt_in_list,
+                _StabilityMode.DATABASE,
+                _StabilityMode.DATABASE_DUP,
+            )
+
+            cls._initialized = True
+
+    @staticmethod
+    def _filter_mode(opt_in_list, stable_mode, dup_mode):
+        # Process semconv stability opt-in
+        # http/dup,database/dup has higher precedence over http,database
+        if dup_mode.value in opt_in_list:
+            return dup_mode
+
+        return (
+            stable_mode
+            if stable_mode.value in opt_in_list
+            else _StabilityMode.DEFAULT
+        )
 
     @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
+        cls, signal_type: _OpenTelemetryStabilitySignalType
+    ) -> _StabilityMode:
+        # Get OpenTelemetry opt-in mode based off of signal type (http, messaging, etc.)
+        return cls._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING.get(
+            signal_type, _StabilityMode.DEFAULT
         )
 
 
@@ -171,14 +197,12 @@ def _filter_semconv_duration_attrs(
     attrs,
     old_attrs,
     new_attrs,
-    sem_conv_opt_in_mode=_HTTPStabilityMode.DEFAULT,
+    sem_conv_opt_in_mode=_StabilityMode.DEFAULT,
 ):
     filtered_attrs = {}
     # duration is two different metrics depending on sem_conv_opt_in_mode, so no DUP attributes
     allowed_attributes = (
-        new_attrs
-        if sem_conv_opt_in_mode == _HTTPStabilityMode.HTTP
-        else old_attrs
+        new_attrs if sem_conv_opt_in_mode == _StabilityMode.HTTP else old_attrs
     )
     for key, val in attrs.items():
         if key in allowed_attributes:
@@ -190,7 +214,7 @@ def _filter_semconv_active_request_count_attr(
     attrs,
     old_attrs,
     new_attrs,
-    sem_conv_opt_in_mode=_HTTPStabilityMode.DEFAULT,
+    sem_conv_opt_in_mode=_StabilityMode.DEFAULT,
 ):
     filtered_attrs = {}
     if _report_old(sem_conv_opt_in_mode):
@@ -367,10 +391,11 @@ def _set_status(
     status_code: int,
     status_code_str: str,
     server_span: bool = True,
-    sem_conv_opt_in_mode: _HTTPStabilityMode = _HTTPStabilityMode.DEFAULT,
+    sem_conv_opt_in_mode: _StabilityMode = _StabilityMode.DEFAULT,
 ):
     if status_code < 0:
-        metrics_attributes[ERROR_TYPE] = status_code_str
+        if _report_new(sem_conv_opt_in_mode):
+            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)
@@ -404,7 +429,7 @@ def _set_status(
 
 
 # Get schema version based off of opt-in mode
-def _get_schema_url(mode: _HTTPStabilityMode) -> str:
-    if mode is _HTTPStabilityMode.DEFAULT:
+def _get_schema_url(mode: _StabilityMode) -> str:
+    if mode is _StabilityMode.DEFAULT:
         return "https://opentelemetry.io/schemas/1.11.0"
     return SpanAttributes.SCHEMA_URL

{opentelemetry_instrumentation-0.49b2 → opentelemetry_instrumentation-0.51b0}/src/opentelemetry/instrumentation/bootstrap_gen.py

@@ -18,187 +18,203 @@
 libraries = [
     {
         "library": "openai >= 1.26.0",
-        "instrumentation": "opentelemetry-instrumentation-openai-v2==2.0.0.dev",
+        "instrumentation": "opentelemetry-instrumentation-openai-v2==2.2b0.dev",
+    },
+    {
+        "library": "google-cloud-aiplatform >= 1.64",
+        "instrumentation": "opentelemetry-instrumentation-vertexai==2.1b0.dev",
     },
     {
         "library": "aio_pika >= 7.2.0, < 10.0.0",
-        "instrumentation": "opentelemetry-instrumentation-aio-pika==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-aio-pika==0.51b0",
     },
     {
         "library": "aiohttp ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-aiohttp-client==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-aiohttp-client==0.51b0",
     },
     {
         "library": "aiohttp ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-aiohttp-server==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-aiohttp-server==0.51b0",
     },
     {
         "library": "aiokafka >= 0.8, < 1.0",
-        "instrumentation": "opentelemetry-instrumentation-aiokafka==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-aiokafka==0.51b0",
     },
     {
         "library": "aiopg >= 0.13.0, < 2.0.0",
-        "instrumentation": "opentelemetry-instrumentation-aiopg==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-aiopg==0.51b0",
     },
     {
         "library": "asgiref ~= 3.0",
-        "instrumentation": "opentelemetry-instrumentation-asgi==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-asgi==0.51b0",
     },
     {
         "library": "asyncpg >= 0.12.0",
-        "instrumentation": "opentelemetry-instrumentation-asyncpg==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-asyncpg==0.51b0",
     },
     {
         "library": "boto~=2.0",
-        "instrumentation": "opentelemetry-instrumentation-boto==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-boto==0.51b0",
     },
     {
         "library": "boto3 ~= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-boto3sqs==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-boto3sqs==0.51b0",
     },
     {
         "library": "botocore ~= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-botocore==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-botocore==0.51b0",
     },
     {
         "library": "cassandra-driver ~= 3.25",
-        "instrumentation": "opentelemetry-instrumentation-cassandra==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-cassandra==0.51b0",
     },
     {
         "library": "scylla-driver ~= 3.25",
-        "instrumentation": "opentelemetry-instrumentation-cassandra==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-cassandra==0.51b0",
     },
     {
         "library": "celery >= 4.0, < 6.0",
-        "instrumentation": "opentelemetry-instrumentation-celery==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-celery==0.51b0",
+    },
+    {
+        "library": "click >= 8.1.3, < 9.0.0",
+        "instrumentation": "opentelemetry-instrumentation-click==0.51b0",
     },
     {
-        "library": "confluent-kafka >= 1.8.2, <= 2.4.0",
-        "instrumentation": "opentelemetry-instrumentation-confluent-kafka==0.49b2",
+        "library": "confluent-kafka >= 1.8.2, <= 2.7.0",
+        "instrumentation": "opentelemetry-instrumentation-confluent-kafka==0.51b0",
     },
     {
         "library": "django >= 1.10",
-        "instrumentation": "opentelemetry-instrumentation-django==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-django==0.51b0",
     },
     {
         "library": "elasticsearch >= 6.0",
-        "instrumentation": "opentelemetry-instrumentation-elasticsearch==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-elasticsearch==0.51b0",
     },
     {
-        "library": "falcon >= 1.4.1, < 3.1.2",
-        "instrumentation": "opentelemetry-instrumentation-falcon==0.49b2",
+        "library": "falcon >= 1.4.1, < 5.0.0",
+        "instrumentation": "opentelemetry-instrumentation-falcon==0.51b0",
     },
     {
         "library": "fastapi ~= 0.58",
-        "instrumentation": "opentelemetry-instrumentation-fastapi==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-fastapi==0.51b0",
     },
     {
         "library": "flask >= 1.0",
-        "instrumentation": "opentelemetry-instrumentation-flask==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-flask==0.51b0",
     },
     {
         "library": "grpcio >= 1.42.0",
-        "instrumentation": "opentelemetry-instrumentation-grpc==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-grpc==0.51b0",
     },
     {
         "library": "httpx >= 0.18.0",
-        "instrumentation": "opentelemetry-instrumentation-httpx==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-httpx==0.51b0",
     },
     {
         "library": "jinja2 >= 2.7, < 4.0",
-        "instrumentation": "opentelemetry-instrumentation-jinja2==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-jinja2==0.51b0",
     },
     {
         "library": "kafka-python >= 2.0, < 3.0",
-        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.51b0",
     },
     {
         "library": "kafka-python-ng >= 2.0, < 3.0",
-        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-kafka-python==0.51b0",
     },
     {
         "library": "mysql-connector-python >= 8.0, < 10.0",
-        "instrumentation": "opentelemetry-instrumentation-mysql==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-mysql==0.51b0",
     },
     {
         "library": "mysqlclient < 3",
-        "instrumentation": "opentelemetry-instrumentation-mysqlclient==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-mysqlclient==0.51b0",
     },
     {
         "library": "pika >= 0.12.0",
-        "instrumentation": "opentelemetry-instrumentation-pika==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-pika==0.51b0",
     },
     {
         "library": "psycopg >= 3.1.0",
-        "instrumentation": "opentelemetry-instrumentation-psycopg==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-psycopg==0.51b0",
     },
     {
         "library": "psycopg2 >= 2.7.3.1",
-        "instrumentation": "opentelemetry-instrumentation-psycopg2==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-psycopg2==0.51b0",
+    },
+    {
+        "library": "psycopg2-binary >= 2.7.3.1",
+        "instrumentation": "opentelemetry-instrumentation-psycopg2==0.51b0",
     },
     {
         "library": "pymemcache >= 1.3.5, < 5",
-        "instrumentation": "opentelemetry-instrumentation-pymemcache==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-pymemcache==0.51b0",
     },
     {
         "library": "pymongo >= 3.1, < 5.0",
-        "instrumentation": "opentelemetry-instrumentation-pymongo==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-pymongo==0.51b0",
+    },
+    {
+        "library": "pymssql >= 2.1.5, < 3",
+        "instrumentation": "opentelemetry-instrumentation-pymssql==0.51b0",
     },
     {
         "library": "PyMySQL < 2",
-        "instrumentation": "opentelemetry-instrumentation-pymysql==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-pymysql==0.51b0",
     },
     {
         "library": "pyramid >= 1.7",
-        "instrumentation": "opentelemetry-instrumentation-pyramid==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-pyramid==0.51b0",
     },
     {
         "library": "redis >= 2.6",
-        "instrumentation": "opentelemetry-instrumentation-redis==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-redis==0.51b0",
     },
     {
         "library": "remoulade >= 0.50",
-        "instrumentation": "opentelemetry-instrumentation-remoulade==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-remoulade==0.51b0",
     },
     {
         "library": "requests ~= 2.0",
-        "instrumentation": "opentelemetry-instrumentation-requests==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-requests==0.51b0",
     },
     {
         "library": "sqlalchemy >= 1.0.0, < 2.1.0",
-        "instrumentation": "opentelemetry-instrumentation-sqlalchemy==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-sqlalchemy==0.51b0",
     },
     {
         "library": "starlette ~= 0.13.0",
-        "instrumentation": "opentelemetry-instrumentation-starlette==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-starlette==0.51b0",
     },
     {
         "library": "psutil >= 5",
-        "instrumentation": "opentelemetry-instrumentation-system-metrics==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-system-metrics==0.51b0",
     },
     {
         "library": "tornado >= 5.1.1",
-        "instrumentation": "opentelemetry-instrumentation-tornado==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-tornado==0.51b0",
     },
     {
         "library": "tortoise-orm >= 0.17.0",
-        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.51b0",
     },
     {
         "library": "pydantic >= 1.10.2",
-        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-tortoiseorm==0.51b0",
     },
     {
         "library": "urllib3 >= 1.0.0, < 3.0.0",
-        "instrumentation": "opentelemetry-instrumentation-urllib3==0.49b2",
+        "instrumentation": "opentelemetry-instrumentation-urllib3==0.51b0",
     },
 ]
 default_instrumentations = [
-    "opentelemetry-instrumentation-asyncio==0.49b2",
-    "opentelemetry-instrumentation-dbapi==0.49b2",
-    "opentelemetry-instrumentation-logging==0.49b2",
-    "opentelemetry-instrumentation-sqlite3==0.49b2",
-    "opentelemetry-instrumentation-threading==0.49b2",
-    "opentelemetry-instrumentation-urllib==0.49b2",
-    "opentelemetry-instrumentation-wsgi==0.49b2",
+    "opentelemetry-instrumentation-asyncio==0.51b0",
+    "opentelemetry-instrumentation-dbapi==0.51b0",
+    "opentelemetry-instrumentation-logging==0.51b0",
+    "opentelemetry-instrumentation-sqlite3==0.51b0",
+    "opentelemetry-instrumentation-threading==0.51b0",
+    "opentelemetry-instrumentation-urllib==0.51b0",
+    "opentelemetry-instrumentation-wsgi==0.51b0",
 ]

{opentelemetry_instrumentation-0.49b2 → opentelemetry_instrumentation-0.51b0}/src/opentelemetry/instrumentation/dependencies.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from logging import getLogger
-from typing import Collection, Optional, Union
+from typing import Collection
 
 from packaging.requirements import InvalidRequirement, Requirement
 
@@ -27,10 +29,10 @@ logger = getLogger(__name__)
 
 
 class DependencyConflict:
-    required: str = None
-    found: Optional[str] = None
+    required: str | None = None
+    found: str | None = None
 
-    def __init__(self, required, found=None):
+    def __init__(self, required: str | None, found: str | None = None):
         self.required = required
         self.found = found
 
@@ -40,25 +42,26 @@ class DependencyConflict:
 
 def get_dist_dependency_conflicts(
     dist: Distribution,
-) -> Optional[DependencyConflict]:
+) -> DependencyConflict | None:
     instrumentation_deps = []
     extra = "extra"
     instruments = "instruments"
     instruments_marker = {extra: instruments}
-    for dep in dist.requires:
-        if extra not in dep or instruments not in dep:
-            continue
+    if dist.requires:
+        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)
+            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[Union[str, Requirement]],
-) -> Optional[DependencyConflict]:
+    deps: Collection[str | Requirement],
+) -> DependencyConflict | None:
     for dep in deps:
         if isinstance(dep, Requirement):
             req = dep

{opentelemetry_instrumentation-0.49b2 → opentelemetry_instrumentation-0.51b0}/src/opentelemetry/instrumentation/instrumentor.py

@@ -17,9 +17,11 @@
 OpenTelemetry Base Instrumentor
 """
 
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from logging import getLogger
-from typing import Collection, Optional
+from typing import Any, Collection
 
 from opentelemetry.instrumentation._semconv import (
     _OpenTelemetrySemanticConventionStability,
@@ -33,7 +35,7 @@ _LOG = getLogger(__name__)
 
 
 class BaseInstrumentor(ABC):
-    """An ABC for instrumentors
+    """An ABC for instrumentors.
 
     Child classes of this ABC should instrument specific third
     party libraries or frameworks either by using the
@@ -74,18 +76,18 @@ class BaseInstrumentor(ABC):
         is present in the environment.
         """
 
-    def _instrument(self, **kwargs):
+    def _instrument(self, **kwargs: Any):
         """Instrument the library"""
 
     @abstractmethod
-    def _uninstrument(self, **kwargs):
+    def _uninstrument(self, **kwargs: Any):
         """Uninstrument the library"""
 
-    def _check_dependency_conflicts(self) -> Optional[DependencyConflict]:
+    def _check_dependency_conflicts(self) -> DependencyConflict | None:
         dependencies = self.instrumentation_dependencies()
         return get_dependency_conflicts(dependencies)
 
-    def instrument(self, **kwargs):
+    def instrument(self, **kwargs: Any):
         """Instrument the library
 
         This method will be called without any optional arguments by the
@@ -117,7 +119,7 @@ class BaseInstrumentor(ABC):
         self._is_instrumented_by_opentelemetry = True
         return result
 
-    def uninstrument(self, **kwargs):
+    def uninstrument(self, **kwargs: Any):
         """Uninstrument the library
 
         See ``BaseInstrumentor.instrument`` for more information regarding the

{opentelemetry_instrumentation-0.49b2 → opentelemetry_instrumentation-0.51b0}/src/opentelemetry/instrumentation/utils.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import urllib.parse
 from contextlib import contextmanager
 from importlib import import_module
 from re import escape, sub
-from typing import Dict, Iterable, Sequence, Union
+from typing import Any, Dict, Generator, Sequence
 
 from wrapt import ObjectProxy
 
@@ -44,9 +46,9 @@ _SUPPRESS_INSTRUMENTATION_KEY_PLAIN = (
 
 
 def extract_attributes_from_object(
-    obj: any, attributes: Sequence[str], existing: Dict[str, str] = None
+    obj: Any, attributes: Sequence[str], existing: Dict[str, str] | None = None
 ) -> Dict[str, str]:
-    extracted = {}
+    extracted: dict[str, str] = {}
     if existing:
         extracted.update(existing)
     for attr in attributes:
@@ -81,7 +83,7 @@ def http_status_to_status_code(
     return StatusCode.ERROR
 
 
-def unwrap(obj: Union[object, str], attr: str):
+def unwrap(obj: object, 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.
@@ -152,7 +154,7 @@ def _start_internal_or_server_span(
     return span, token
 
 
-def _url_quote(s) -> str:  # pylint: disable=invalid-name
+def _url_quote(s: Any) -> str:  # pylint: disable=invalid-name
     if not isinstance(s, (str, bytes)):
         return s
     quoted = urllib.parse.quote(s)
@@ -163,13 +165,13 @@ def _url_quote(s) -> str:  # pylint: disable=invalid-name
     return quoted.replace("%", "%%")
 
 
-def _get_opentelemetry_values() -> dict:
+def _get_opentelemetry_values() -> dict[str, Any]:
     """
     Return the OpenTelemetry Trace and Span IDs if Span ID is set in the
     OpenTelemetry execution context.
     """
     # Insert the W3C TraceContext generated
-    _headers = {}
+    _headers: dict[str, Any] = {}
     propagator.inject(_headers)
     return _headers
 
@@ -196,7 +198,7 @@ def is_http_instrumentation_enabled() -> bool:
 
 
 @contextmanager
-def _suppress_instrumentation(*keys: str) -> Iterable[None]:
+def _suppress_instrumentation(*keys: str) -> Generator[None]:
     """Suppress instrumentation within the context."""
     ctx = context.get_current()
     for key in keys:
@@ -209,7 +211,7 @@ def _suppress_instrumentation(*keys: str) -> Iterable[None]:
 
 
 @contextmanager
-def suppress_instrumentation() -> Iterable[None]:
+def suppress_instrumentation() -> Generator[None]:
     """Suppress instrumentation within the context."""
     with _suppress_instrumentation(
         _SUPPRESS_INSTRUMENTATION_KEY, _SUPPRESS_INSTRUMENTATION_KEY_PLAIN
@@ -218,7 +220,7 @@ def suppress_instrumentation() -> Iterable[None]:
 
 
 @contextmanager
-def suppress_http_instrumentation() -> Iterable[None]:
+def suppress_http_instrumentation() -> Generator[None]:
     """Suppress instrumentation within the context."""
     with _suppress_instrumentation(_SUPPRESS_HTTP_INSTRUMENTATION_KEY):
         yield

{opentelemetry_instrumentation-0.49b2 → opentelemetry_instrumentation-0.51b0}/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.49b2"
+__version__ = "0.51b0"

{opentelemetry_instrumentation-0.49b2 → opentelemetry_instrumentation-0.51b0}/tests/test_dependencies.py

@@ -86,3 +86,19 @@ class TestDependencyConflicts(TestBase):
             str(conflict),
             'DependencyConflict: requested: "test-pkg~=1.0; extra == "instruments"" but found: "None"',
         )
+
+    def test_get_dist_dependency_conflicts_requires_none(self):
+        class MockDistribution(Distribution):
+            def locate_file(self, path):
+                pass
+
+            def read_text(self, filename):
+                pass
+
+            @property
+            def requires(self):
+                return None
+
+        dist = MockDistribution()
+        conflict = get_dist_dependency_conflicts(dist)
+        self.assertTrue(conflict is None)

opentelemetry_instrumentation-0.51b0/tests/test_semconv.py

@@ -0,0 +1,258 @@
+# 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
+from unittest import TestCase
+from unittest.mock import Mock, patch
+
+from opentelemetry.instrumentation._semconv import (
+    OTEL_SEMCONV_STABILITY_OPT_IN,
+    _OpenTelemetrySemanticConventionStability,
+    _OpenTelemetryStabilitySignalType,
+    _set_status,
+    _StabilityMode,
+)
+from opentelemetry.trace.status import StatusCode
+
+
+def stability_mode(mode):
+    def decorator(test_case):
+        @patch.dict(os.environ, {OTEL_SEMCONV_STABILITY_OPT_IN: mode})
+        def wrapper(*args, **kwargs):
+            _OpenTelemetrySemanticConventionStability._initialized = False
+            _OpenTelemetrySemanticConventionStability._initialize()
+            return test_case(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+class TestOpenTelemetrySemConvStability(TestCase):
+    @stability_mode("")
+    def test_default_mode(self):
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.HTTP
+            ),
+            _StabilityMode.DEFAULT,
+        )
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.DATABASE
+            ),
+            _StabilityMode.DEFAULT,
+        )
+
+    @stability_mode("http")
+    def test_http_stable_mode(self):
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.HTTP
+            ),
+            _StabilityMode.HTTP,
+        )
+
+    @stability_mode("http/dup")
+    def test_http_dup_mode(self):
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.HTTP
+            ),
+            _StabilityMode.HTTP_DUP,
+        )
+
+    @stability_mode("database")
+    def test_database_stable_mode(self):
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.DATABASE
+            ),
+            _StabilityMode.DATABASE,
+        )
+
+    @stability_mode("database/dup")
+    def test_database_dup_mode(self):
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.DATABASE
+            ),
+            _StabilityMode.DATABASE_DUP,
+        )
+
+    @stability_mode("database,http")
+    def test_multiple_stability_database_http_modes(self):
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.DATABASE
+            ),
+            _StabilityMode.DATABASE,
+        )
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.HTTP
+            ),
+            _StabilityMode.HTTP,
+        )
+
+    @stability_mode("database,http/dup")
+    def test_multiple_stability_database_http_dup_modes(self):
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.DATABASE
+            ),
+            _StabilityMode.DATABASE,
+        )
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.HTTP
+            ),
+            _StabilityMode.HTTP_DUP,
+        )
+
+    @stability_mode("database/dup,http")
+    def test_multiple_stability_database_dup_http_stable_modes(self):
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.DATABASE
+            ),
+            _StabilityMode.DATABASE_DUP,
+        )
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.HTTP
+            ),
+            _StabilityMode.HTTP,
+        )
+
+    @stability_mode("database,database/dup,http,http/dup")
+    def test_stability_mode_dup_precedence(self):
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.DATABASE
+            ),
+            _StabilityMode.DATABASE_DUP,
+        )
+        self.assertEqual(
+            _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+                _OpenTelemetryStabilitySignalType.HTTP
+            ),
+            _StabilityMode.HTTP_DUP,
+        )
+
+
+class TestOpenTelemetrySemConvStabilityHTTP(TestCase):
+    def test_set_status_for_non_http_code_with_recording_span(self):
+        span = Mock()
+        span.is_recording.return_value = True
+        metric_attributes = {}
+        _set_status(
+            span,
+            metric_attributes,
+            -1,
+            "Exception",
+            sem_conv_opt_in_mode=_StabilityMode.DEFAULT,
+        )
+
+        self.assertIsNone(metric_attributes.get("error.type"))
+        span.set_attribute.assert_not_called()
+        status_call = span.set_status.call_args[0][0]
+        self.assertEqual(status_call.status_code, StatusCode.ERROR)
+        self.assertEqual(
+            status_call.description, "Non-integer HTTP status: " + "Exception"
+        )
+
+    def test_status_code_http_default(self):
+        span = Mock()
+        metrics_attributes = {}
+        _set_status(
+            span=span,
+            metrics_attributes=metrics_attributes,
+            status_code=404,
+            status_code_str="404",
+            server_span=True,
+            sem_conv_opt_in_mode=_StabilityMode.DEFAULT,
+        )
+        # Verify only old conventions are emitted
+        span.set_attribute.assert_called_with("http.status_code", 404)
+        self.assertIn("http.status_code", metrics_attributes)
+        self.assertNotIn("http.response_status_code", metrics_attributes)
+
+    def test_status_code_http_stable(self):
+        span = Mock()
+        metrics_attributes = {}
+        _set_status(
+            span=span,
+            metrics_attributes=metrics_attributes,
+            status_code=200,
+            status_code_str="200",
+            server_span=True,
+            sem_conv_opt_in_mode=_StabilityMode.HTTP,
+        )
+        # Verify only new conventions are emitted
+        span.set_attribute.assert_called_with("http.response.status_code", 200)
+        self.assertIn("http.response.status_code", metrics_attributes)
+        self.assertNotIn("http.status_code", metrics_attributes)
+
+    def test_status_code_http_dup(self):
+        span = Mock()
+        metrics_attributes = {}
+        _set_status(
+            span=span,
+            metrics_attributes=metrics_attributes,
+            status_code=500,
+            status_code_str="500",
+            server_span=True,
+            sem_conv_opt_in_mode=_StabilityMode.HTTP_DUP,
+        )
+        # Verify both old and new conventions are emitted
+        span.set_attribute.assert_any_call("http.status_code", 500)
+        span.set_attribute.assert_any_call("http.response.status_code", 500)
+        self.assertIn("http.status_code", metrics_attributes)
+        self.assertIn("http.response.status_code", metrics_attributes)
+
+    def test_error_status_code_new_mode(self):
+        span = Mock()
+        metrics_attributes = {}
+        _set_status(
+            span=span,
+            metrics_attributes=metrics_attributes,
+            status_code=500,
+            status_code_str="500",
+            server_span=True,
+            sem_conv_opt_in_mode=_StabilityMode.HTTP,
+        )
+        # Verify error type is set for new conventions
+        span.set_attribute.assert_any_call("error.type", "500")
+        self.assertIn("error.type", metrics_attributes)
+        self.assertEqual(metrics_attributes["error.type"], "500")
+
+    def test_non_recording_span(self):
+        span = Mock()
+        span.is_recording.return_value = False
+        metrics_attributes = {}
+        _set_status(
+            span=span,
+            metrics_attributes=metrics_attributes,
+            status_code=200,
+            status_code_str="200",
+            server_span=True,
+            sem_conv_opt_in_mode=_StabilityMode.HTTP_DUP,
+        )
+        # Verify no span attributes are set if not recording
+        span.set_attribute.assert_not_called()
+        span.set_status.assert_not_called()
+        # Verify status code set for metrics independent of tracing decision
+        self.assertIn("http.status_code", metrics_attributes)
+        self.assertIn("http.response.status_code", metrics_attributes)