opentelemetry-python-contrib-external-valkey 0.63b1__tar.gz → 0.65b0__tar.gz

{opentelemetry_python_contrib_external_valkey-0.63b1 → opentelemetry_python_contrib_external_valkey-0.65b0}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: opentelemetry-python-contrib-external-valkey
-Version: 0.63b1
+Version: 0.65b0
 Summary: OpenTelemetry Valkey instrumentation
 Author: Philip Meier
 Author-email: Philip Meier <github.pmeier@posteo.de>
 License-Expression: Apache-2.0
 License-File: LICENSE
 Requires-Dist: opentelemetry-api~=1.12
-Requires-Dist: opentelemetry-instrumentation==0.63b1
-Requires-Dist: opentelemetry-semantic-conventions==0.63b1
+Requires-Dist: opentelemetry-instrumentation==0.65b0
+Requires-Dist: opentelemetry-semantic-conventions==0.65b0
 Requires-Dist: wrapt>=1.12.1
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

opentelemetry_python_contrib_external_valkey-0.65b0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "opentelemetry-python-contrib-external-valkey"
+description = "OpenTelemetry Valkey instrumentation"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.10"
+version = "0.65b0"
+dependencies = [
+    "opentelemetry-api~=1.12",
+    "opentelemetry-instrumentation==0.65b0",
+    "opentelemetry-semantic-conventions==0.65b0",
+    "wrapt>=1.12.1",
+]
+
+[[project.authors]]
+name = "Philip Meier"
+email = "github.pmeier@posteo.de"
+
+[project.entry-points.opentelemetry_instrumentor]
+redis = "opentelemetry.instrumentation.valkey:ValkeyInstrumentor"
+
+[dependency-groups]
+instruments = ["valkey>=6.1.0"]
+dev = [
+    { include-group = "instruments" },
+    "fakeredis>=2.25",
+    "opentelemetry-test-utils==0.65b0",
+    "pytest>=7.4.4",
+    "pytest-asyncio>=1.2.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.11,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "opentelemetry.instrumentation.valkey"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra --tb=short"
+testpaths = ["tests"]

opentelemetry_python_contrib_external_valkey-0.63b1/pyproject.toml → opentelemetry_python_contrib_external_valkey-0.65b0/pyproject.toml.orig

@@ -8,12 +8,12 @@ authors = [
 ]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "0.63b1"
+version = "0.65b0"
 
 dependencies = [
     "opentelemetry-api~=1.12",
-    "opentelemetry-instrumentation==0.63b1",
-    "opentelemetry-semantic-conventions==0.63b1",
+    "opentelemetry-instrumentation==0.65b0",
+    "opentelemetry-semantic-conventions==0.65b0",
     "wrapt>=1.12.1",
 ]
 
@@ -22,7 +22,7 @@ instruments = ["valkey>=6.1.0"]
 dev = [
     {include-group = "instruments"},
     "fakeredis>=2.25",
-    "opentelemetry-test-utils==0.63b1",
+    "opentelemetry-test-utils==0.65b0",
     "pytest>=7.4.4",
     "pytest-asyncio>=1.2.0",
 ]

{opentelemetry_python_contrib_external_valkey-0.63b1 → opentelemetry_python_contrib_external_valkey-0.65b0}/src/opentelemetry/instrumentation/valkey/__init__.py

@@ -1,18 +1,7 @@
 # Copyright The OpenTelemetry Authors
 # Copyright 2025 Philip Meier
+# SPDX-License-Identifier: Apache-2.0
 #
-# 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.
-
 """
 Instrument `valkey`_ to report Valkey queries.
 
@@ -153,6 +142,13 @@ import valkey
 from wrapt import wrap_function_wrapper
 
 from opentelemetry import trace
+from opentelemetry.instrumentation._semconv import (
+    _get_schema_url_for_signal_types,
+    _get_semconv_opt_in_modes,
+    _OpenTelemetrySemanticConventionStability,
+    _OpenTelemetryStabilitySignalType,
+    _set_db_statement,
+)
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.valkey.package import _instruments
 from opentelemetry.instrumentation.valkey.util import (
@@ -168,9 +164,6 @@ from opentelemetry.instrumentation.utils import (
     is_instrumentation_enabled,
     unwrap,
 )
-from opentelemetry.semconv._incubating.attributes.db_attributes import (
-    DB_STATEMENT,
-)
 from opentelemetry.trace import (
     StatusCode,
     Tracer,
@@ -218,11 +211,32 @@ if _CLIENT_ASYNCIO_SUPPORT:
 _INSTRUMENTATION_ATTR = "_is_instrumented_by_opentelemetry"
 
 
+def _execute_hook(hook: Callable[..., None], *args: Any) -> None:
+    try:
+        hook(*args)
+    # pylint: disable-next=broad-exception-caught
+    except Exception:
+        _logger.warning("Exception raised by hook %r", hook, exc_info=True)
+
+
 def _traced_execute_factory(
     tracer: Tracer,
     request_hook: RequestHook | None = None,
     response_hook: ResponseHook | None = None,
 ):
+    sem_conv_opt_in_modes = _get_semconv_opt_in_modes(
+        (
+            _OpenTelemetryStabilitySignalType.DATABASE,
+            _OpenTelemetryStabilitySignalType.HTTP,
+        )
+    )
+    db_sem_conv_opt_in_mode = sem_conv_opt_in_modes[
+        _OpenTelemetryStabilitySignalType.DATABASE
+    ]
+    http_sem_conv_opt_in_mode = sem_conv_opt_in_modes[
+        _OpenTelemetryStabilitySignalType.HTTP
+    ]
+
     def _traced_execute_command(
         func: Callable[..., R],
         instance: ValkeyInstance,
@@ -238,19 +252,30 @@ def _traced_execute_factory(
             name, kind=trace.SpanKind.CLIENT
         ) as span:
             if span.is_recording():
-                span.set_attribute(DB_STATEMENT, query)
-                _set_connection_attributes(span, instance)
-                span.set_attribute("db.valkey.args_length", len(args))
+                span_attrs = {}
+                _set_db_statement(span_attrs, query, db_sem_conv_opt_in_mode)
+                span_attrs["db.valkey.args_length"] = len(args)
+
+                # Set all DB attributes
+                for key, value in span_attrs.items():
+                    span.set_attribute(key, value)
+
+                _set_connection_attributes(
+                    span,
+                    instance,
+                    db_sem_conv_opt_in_mode,
+                    http_sem_conv_opt_in_mode,
+                )
                 if span.name == "valkey.create_index":
                     _add_create_attributes(span, args)
             if callable(request_hook):
-                request_hook(span, instance, args, kwargs)
+                _execute_hook(request_hook, span, instance, args, kwargs)
             response = func(*args, **kwargs)
             if span.is_recording():
                 if span.name == "valkey.search":
                     _add_search_attributes(span, response, args)
             if callable(response_hook):
-                response_hook(span, instance, response)
+                _execute_hook(response_hook, span, instance, response)
             return response
 
     return _traced_execute_command
@@ -261,6 +286,19 @@ def _traced_execute_pipeline_factory(
     request_hook: RequestHook | None = None,
     response_hook: ResponseHook | None = None,
 ):
+    sem_conv_opt_in_modes = _get_semconv_opt_in_modes(
+        (
+            _OpenTelemetryStabilitySignalType.DATABASE,
+            _OpenTelemetryStabilitySignalType.HTTP,
+        )
+    )
+    db_sem_conv_opt_in_mode = sem_conv_opt_in_modes[
+        _OpenTelemetryStabilitySignalType.DATABASE
+    ]
+    http_sem_conv_opt_in_mode = sem_conv_opt_in_modes[
+        _OpenTelemetryStabilitySignalType.HTTP
+    ]
+
     def _traced_execute_pipeline(
         func: Callable[..., R],
         instance: PipelineInstance,
@@ -280,10 +318,21 @@ def _traced_execute_pipeline_factory(
             span_name, kind=trace.SpanKind.CLIENT
         ) as span:
             if span.is_recording():
-                span.set_attribute(DB_STATEMENT, resource)
-                _set_connection_attributes(span, instance)
-                span.set_attribute(
-                    "db.valkey.pipeline_length", len(command_stack)
+                span_attrs = {}
+                _set_db_statement(
+                    span_attrs, resource, db_sem_conv_opt_in_mode
+                )
+                span_attrs["db.valkey.pipeline_length"] = len(command_stack)
+
+                # Set all DB attributes
+                for key, value in span_attrs.items():
+                    span.set_attribute(key, value)
+
+                _set_connection_attributes(
+                    span,
+                    instance,
+                    db_sem_conv_opt_in_mode,
+                    http_sem_conv_opt_in_mode,
                 )
 
             response = None
@@ -294,7 +343,7 @@ def _traced_execute_pipeline_factory(
                 exception = watch_exception
 
             if callable(response_hook):
-                response_hook(span, instance, response)
+                _execute_hook(response_hook, span, instance, response)
 
         if exception:
             raise exception
@@ -309,6 +358,19 @@ def _async_traced_execute_factory(
     request_hook: RequestHook | None = None,
     response_hook: ResponseHook | None = None,
 ):
+    sem_conv_opt_in_modes = _get_semconv_opt_in_modes(
+        (
+            _OpenTelemetryStabilitySignalType.DATABASE,
+            _OpenTelemetryStabilitySignalType.HTTP,
+        )
+    )
+    db_sem_conv_opt_in_mode = sem_conv_opt_in_modes[
+        _OpenTelemetryStabilitySignalType.DATABASE
+    ]
+    http_sem_conv_opt_in_mode = sem_conv_opt_in_modes[
+        _OpenTelemetryStabilitySignalType.HTTP
+    ]
+
     async def _async_traced_execute_command(
         func: Callable[..., Awaitable[R]],
         instance: AsyncValkeyInstance,
@@ -325,14 +387,25 @@ def _async_traced_execute_factory(
             name, kind=trace.SpanKind.CLIENT
         ) as span:
             if span.is_recording():
-                span.set_attribute(DB_STATEMENT, query)
-                _set_connection_attributes(span, instance)
-                span.set_attribute("db.valkey.args_length", len(args))
+                span_attrs = {}
+                _set_db_statement(span_attrs, query, db_sem_conv_opt_in_mode)
+                span_attrs["db.valkey.args_length"] = len(args)
+
+                # Set all DB attributes
+                for key, value in span_attrs.items():
+                    span.set_attribute(key, value)
+
+                _set_connection_attributes(
+                    span,
+                    instance,
+                    db_sem_conv_opt_in_mode,
+                    http_sem_conv_opt_in_mode,
+                )
             if callable(request_hook):
-                request_hook(span, instance, args, kwargs)
+                _execute_hook(request_hook, span, instance, args, kwargs)
             response = await func(*args, **kwargs)
             if callable(response_hook):
-                response_hook(span, instance, response)
+                _execute_hook(response_hook, span, instance, response)
             return response
 
     return _async_traced_execute_command
@@ -343,6 +416,19 @@ def _async_traced_execute_pipeline_factory(
     request_hook: RequestHook | None = None,
     response_hook: ResponseHook | None = None,
 ):
+    sem_conv_opt_in_modes = _get_semconv_opt_in_modes(
+        (
+            _OpenTelemetryStabilitySignalType.DATABASE,
+            _OpenTelemetryStabilitySignalType.HTTP,
+        )
+    )
+    db_sem_conv_opt_in_mode = sem_conv_opt_in_modes[
+        _OpenTelemetryStabilitySignalType.DATABASE
+    ]
+    http_sem_conv_opt_in_mode = sem_conv_opt_in_modes[
+        _OpenTelemetryStabilitySignalType.HTTP
+    ]
+
     async def _async_traced_execute_pipeline(
         func: Callable[..., Awaitable[R]],
         instance: AsyncPipelineInstance,
@@ -364,10 +450,21 @@ def _async_traced_execute_pipeline_factory(
             span_name, kind=trace.SpanKind.CLIENT
         ) as span:
             if span.is_recording():
-                span.set_attribute(DB_STATEMENT, resource)
-                _set_connection_attributes(span, instance)
-                span.set_attribute(
-                    "db.valkey.pipeline_length", len(command_stack)
+                span_attrs = {}
+                _set_db_statement(
+                    span_attrs, resource, db_sem_conv_opt_in_mode
+                )
+                span_attrs["db.valkey.pipeline_length"] = len(command_stack)
+
+                # Set all DB attributes
+                for key, value in span_attrs.items():
+                    span.set_attribute(key, value)
+
+                _set_connection_attributes(
+                    span,
+                    instance,
+                    db_sem_conv_opt_in_mode,
+                    http_sem_conv_opt_in_mode,
                 )
 
             response = None
@@ -378,7 +475,7 @@ def _async_traced_execute_pipeline_factory(
                 exception = watch_exception
 
             if callable(response_hook):
-                response_hook(span, instance, response)
+                _execute_hook(response_hook, span, instance, response)
 
         if exception:
             raise exception
@@ -541,12 +638,20 @@ def _instrument_client(
 class ValkeyInstrumentor(BaseInstrumentor):
     @staticmethod
     def _get_tracer(**kwargs):
+        # Initialize semantic conventions opt-in if needed
+        _OpenTelemetrySemanticConventionStability._initialize()
+        # Valkey instrumentation supports both DATABASE and HTTP signal types
+        signal_types = [
+            _OpenTelemetryStabilitySignalType.DATABASE,
+            _OpenTelemetryStabilitySignalType.HTTP,
+        ]
+
         tracer_provider = kwargs.get("tracer_provider")
         return get_tracer(
             __name__,
             __version__,
             tracer_provider=tracer_provider,
-            schema_url="https://opentelemetry.io/schemas/1.11.0",
+            schema_url=_get_schema_url_for_signal_types(signal_types),
         )
 
     def instrument(
@@ -699,7 +804,6 @@ class ValkeyInstrumentor(BaseInstrumentor):
             _logger.warning(
                 "Attempting to un-instrument Valkey connection that wasn't instrumented"
             )
-            return
 
     def instrumentation_dependencies(self) -> Collection[str]:
         """Return a list of python packages with versions that the will be instrumented."""

{opentelemetry_python_contrib_external_valkey-0.63b1 → opentelemetry_python_contrib_external_valkey-0.65b0}/src/opentelemetry/instrumentation/valkey/custom_types.py

@@ -1,17 +1,6 @@
 # Copyright The OpenTelemetry Authors
 # Copyright 2025 Philip Meier
-#
-# 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.
+# SPDX-License-Identifier: Apache-2.0
 
 from __future__ import annotations
 

opentelemetry_python_contrib_external_valkey-0.65b0/src/opentelemetry/instrumentation/valkey/package.py

@@ -0,0 +1,8 @@
+# Copyright The OpenTelemetry Authors
+# Copyright 2025 Philip Meier
+# SPDX-License-Identifier: Apache-2.0
+
+
+_instruments = ("valkey >= 6.1.0",)
+
+_semconv_status = "migration"

{opentelemetry_python_contrib_external_valkey-0.63b1 → opentelemetry_python_contrib_external_valkey-0.65b0}/src/opentelemetry/instrumentation/valkey/util.py

@@ -1,18 +1,7 @@
 # Copyright The OpenTelemetry Authors
 # Copyright 2025 Philip Meier
+# SPDX-License-Identifier: Apache-2.0
 #
-# 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.
-
 """
 Some utils used by the valkey integration
 """
@@ -21,14 +10,15 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from opentelemetry.semconv._incubating.attributes.db_attributes import (
-    DB_REDIS_DATABASE_INDEX,
-    DB_SYSTEM,
+from opentelemetry.instrumentation._semconv import (
+    _set_db_redis_database_index,
+    _set_db_system,
+    _set_http_net_peer_name_client,
+    _set_http_peer_port_client,
+    _set_net_transport,
 )
-from opentelemetry.semconv._incubating.attributes.net_attributes import (
-    NET_PEER_NAME,
-    NET_PEER_PORT,
-    NET_TRANSPORT,
+from opentelemetry.semconv.attributes.network_attributes import (
+    NetworkTransportValues,
 )
 from opentelemetry.semconv.trace import (
     DbSystemValues,
@@ -47,20 +37,44 @@ if TYPE_CHECKING:
 _FIELD_TYPES = ["NUMERIC", "TEXT", "GEO", "TAG", "VECTOR"]
 
 
-def _extract_conn_attributes(conn_kwargs):
+def _extract_conn_attributes(
+    conn_kwargs, db_sem_conv_opt_in_mode, http_sem_conv_opt_in_mode
+):
     """Transform valkey conn info into dict"""
-    attributes = {
-        DB_SYSTEM: DbSystemValues.REDIS.value,
-    }
+    attributes = {}
+    _set_db_system(
+        attributes, DbSystemValues.REDIS.value, db_sem_conv_opt_in_mode
+    )
+
     db = conn_kwargs.get("db", 0)
-    attributes[DB_REDIS_DATABASE_INDEX] = db
+    _set_db_redis_database_index(attributes, db, db_sem_conv_opt_in_mode)
     if "path" in conn_kwargs:
-        attributes[NET_PEER_NAME] = conn_kwargs.get("path", "")
-        attributes[NET_TRANSPORT] = NetTransportValues.OTHER.value
+        _set_http_net_peer_name_client(
+            attributes, conn_kwargs.get("path", ""), http_sem_conv_opt_in_mode
+        )
+        _set_net_transport(
+            attributes,
+            NetTransportValues.OTHER.value,
+            NetworkTransportValues.UNIX.value,
+            http_sem_conv_opt_in_mode,
+        )
     else:
-        attributes[NET_PEER_NAME] = conn_kwargs.get("host", "localhost")
-        attributes[NET_PEER_PORT] = conn_kwargs.get("port", 6379)
-        attributes[NET_TRANSPORT] = NetTransportValues.IP_TCP.value
+        _set_http_net_peer_name_client(
+            attributes,
+            conn_kwargs.get("host", "localhost"),
+            http_sem_conv_opt_in_mode,
+        )
+        _set_http_peer_port_client(
+            attributes,
+            conn_kwargs.get("port", 6379),
+            http_sem_conv_opt_in_mode,
+        )
+        _set_net_transport(
+            attributes,
+            NetTransportValues.IP_TCP.value,
+            NetworkTransportValues.TCP.value,
+            http_sem_conv_opt_in_mode,
+        )
 
     return attributes
 
@@ -100,12 +114,21 @@ def _value_or_none(values, n):
 
 
 def _set_connection_attributes(
-    span: Span, conn: ValkeyInstance | AsyncValkeyInstance
+    span: Span,
+    conn: ValkeyInstance | AsyncValkeyInstance,
+    db_sem_conv_opt_in_mode,
+    http_sem_conv_opt_in_mode,
 ) -> None:
-    if not span.is_recording() or not hasattr(conn, "connection_pool"):
+    if (
+        not span.is_recording()
+        or not hasattr(conn, "connection_pool")
+        or not hasattr(conn.connection_pool, "connection_kwargs")
+    ):
         return
     for key, value in _extract_conn_attributes(
-        conn.connection_pool.connection_kwargs
+        conn.connection_pool.connection_kwargs,
+        db_sem_conv_opt_in_mode,
+        http_sem_conv_opt_in_mode,
     ).items():
         span.set_attribute(key, value)
 

opentelemetry_python_contrib_external_valkey-0.65b0/src/opentelemetry/instrumentation/valkey/version.py

@@ -0,0 +1,5 @@
+# Copyright The OpenTelemetry Authors
+# Copyright 2025 Philip Meier
+# SPDX-License-Identifier: Apache-2.0
+
+__version__ = "0.65b0"

opentelemetry_python_contrib_external_valkey-0.63b1/src/opentelemetry/instrumentation/valkey/package.py

@@ -1,16 +0,0 @@
-# Copyright The OpenTelemetry Authors
-# Copyright 2025 Philip Meier
-#
-# 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.
-
-_instruments = ("valkey >= 6.1.0",)

opentelemetry_python_contrib_external_valkey-0.63b1/src/opentelemetry/instrumentation/valkey/version.py

@@ -1,16 +0,0 @@
-# Copyright The OpenTelemetry Authors
-# Copyright 2025 Philip Meier
-#
-# 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.
-
-__version__ = "0.63b1"