opentelemetry-python-contrib-external-valkey 0.64b0__tar.gz → 0.66b0__tar.gz

{opentelemetry_python_contrib_external_valkey-0.64b0 → opentelemetry_python_contrib_external_valkey-0.66b0}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: opentelemetry-python-contrib-external-valkey
-Version: 0.64b0
+Version: 0.66b0
 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.64b0
-Requires-Dist: opentelemetry-semantic-conventions==0.64b0
+Requires-Dist: opentelemetry-instrumentation==0.66b0
+Requires-Dist: opentelemetry-semantic-conventions==0.66b0
 Requires-Dist: wrapt>=1.12.1
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

opentelemetry_python_contrib_external_valkey-0.66b0/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.66b0"
+dependencies = [
+    "opentelemetry-api~=1.12",
+    "opentelemetry-instrumentation==0.66b0",
+    "opentelemetry-semantic-conventions==0.66b0",
+    "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.66b0",
+    "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.64b0/pyproject.toml → opentelemetry_python_contrib_external_valkey-0.66b0/pyproject.toml.orig

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

{opentelemetry_python_contrib_external_valkey-0.64b0 → opentelemetry_python_contrib_external_valkey-0.66b0}/src/opentelemetry/instrumentation/valkey/__init__.py

@@ -136,7 +136,8 @@ API
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Callable, Collection
+from collections.abc import Callable, Collection
+from typing import TYPE_CHECKING, Any
 
 import valkey
 from wrapt import wrap_function_wrapper
@@ -172,7 +173,7 @@ from opentelemetry.trace import (
 )
 
 if TYPE_CHECKING:
-    from typing import Awaitable
+    from collections.abc import Awaitable
 
     import valkey.asyncio.client
     import valkey.asyncio.cluster
@@ -199,9 +200,7 @@ _REDIS_ASYNCIO_CLUSTER_VERSION = (4, 3, 2)
 
 
 _CLIENT_ASYNCIO_SUPPORT = valkey.VERSION >= _REDIS_ASYNCIO_VERSION
-_CLIENT_ASYNCIO_CLUSTER_SUPPORT = (
-    valkey.VERSION >= _REDIS_ASYNCIO_CLUSTER_VERSION
-)
+_CLIENT_ASYNCIO_CLUSTER_SUPPORT = valkey.VERSION >= _REDIS_ASYNCIO_CLUSTER_VERSION
 _CLIENT_CLUSTER_SUPPORT = valkey.VERSION >= _REDIS_CLUSTER_VERSION
 _CLIENT_BEFORE_V3 = valkey.VERSION < (3, 0, 0)
 
@@ -230,12 +229,8 @@ def _traced_execute_factory(
             _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
-    ]
+    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],
@@ -248,9 +243,7 @@ def _traced_execute_factory(
 
         query = _format_command_args(args)
         name = _build_span_name(instance, args)
-        with tracer.start_as_current_span(
-            name, kind=trace.SpanKind.CLIENT
-        ) as span:
+        with tracer.start_as_current_span(name, kind=trace.SpanKind.CLIENT) as span:
             if span.is_recording():
                 span_attrs = {}
                 _set_db_statement(span_attrs, query, db_sem_conv_opt_in_mode)
@@ -292,12 +285,8 @@ def _traced_execute_pipeline_factory(
             _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
-    ]
+    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],
@@ -314,14 +303,10 @@ def _traced_execute_pipeline_factory(
             span_name,
         ) = _build_span_meta_data_for_pipeline(instance)
         exception = None
-        with tracer.start_as_current_span(
-            span_name, kind=trace.SpanKind.CLIENT
-        ) as span:
+        with tracer.start_as_current_span(span_name, kind=trace.SpanKind.CLIENT) as span:
             if span.is_recording():
                 span_attrs = {}
-                _set_db_statement(
-                    span_attrs, resource, db_sem_conv_opt_in_mode
-                )
+                _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
@@ -364,12 +349,8 @@ def _async_traced_execute_factory(
             _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
-    ]
+    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]],
@@ -383,9 +364,7 @@ def _async_traced_execute_factory(
         query = _format_command_args(args)
         name = _build_span_name(instance, args)
 
-        with tracer.start_as_current_span(
-            name, kind=trace.SpanKind.CLIENT
-        ) as span:
+        with tracer.start_as_current_span(name, kind=trace.SpanKind.CLIENT) as span:
             if span.is_recording():
                 span_attrs = {}
                 _set_db_statement(span_attrs, query, db_sem_conv_opt_in_mode)
@@ -422,12 +401,8 @@ def _async_traced_execute_pipeline_factory(
             _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
-    ]
+    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]],
@@ -446,14 +421,10 @@ def _async_traced_execute_pipeline_factory(
 
         exception = None
 
-        with tracer.start_as_current_span(
-            span_name, kind=trace.SpanKind.CLIENT
-        ) as span:
+        with tracer.start_as_current_span(span_name, kind=trace.SpanKind.CLIENT) as span:
             if span.is_recording():
                 span_attrs = {}
-                _set_db_statement(
-                    span_attrs, resource, db_sem_conv_opt_in_mode
-                )
+                _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
@@ -491,18 +462,12 @@ def _instrument(
     request_hook: RequestHook | None = None,
     response_hook: ResponseHook | None = None,
 ):
-    _traced_execute_command = _traced_execute_factory(
-        tracer, request_hook, response_hook
-    )
-    _traced_execute_pipeline = _traced_execute_pipeline_factory(
-        tracer, request_hook, response_hook
-    )
+    _traced_execute_command = _traced_execute_factory(tracer, request_hook, response_hook)
+    _traced_execute_pipeline = _traced_execute_pipeline_factory(tracer, request_hook, response_hook)
     pipeline_class = "BasePipeline" if _CLIENT_BEFORE_V3 else "Pipeline"
     valkey_class = "StrictValkey" if _CLIENT_BEFORE_V3 else "Valkey"
 
-    wrap_function_wrapper(
-        "valkey", f"{valkey_class}.execute_command", _traced_execute_command
-    )
+    wrap_function_wrapper("valkey", f"{valkey_class}.execute_command", _traced_execute_command)
     wrap_function_wrapper(
         "valkey.client",
         f"{pipeline_class}.execute",
@@ -525,12 +490,8 @@ def _instrument(
             _traced_execute_pipeline,
         )
 
-    _async_traced_execute_command = _async_traced_execute_factory(
-        tracer, request_hook, response_hook
-    )
-    _async_traced_execute_pipeline = _async_traced_execute_pipeline_factory(
-        tracer, request_hook, response_hook
-    )
+    _async_traced_execute_command = _async_traced_execute_factory(tracer, request_hook, response_hook)
+    _async_traced_execute_pipeline = _async_traced_execute_pipeline_factory(tracer, request_hook, response_hook)
     if _CLIENT_ASYNCIO_SUPPORT:
         wrap_function_wrapper(
             "valkey.asyncio",
@@ -567,60 +528,40 @@ def _instrument_client(
     response_hook: ResponseHook | None = None,
 ):
     # first, handle async clients and cluster clients
-    _async_traced_execute = _async_traced_execute_factory(
-        tracer, request_hook, response_hook
-    )
-    _async_traced_execute_pipeline = _async_traced_execute_pipeline_factory(
-        tracer, request_hook, response_hook
-    )
+    _async_traced_execute = _async_traced_execute_factory(tracer, request_hook, response_hook)
+    _async_traced_execute_pipeline = _async_traced_execute_pipeline_factory(tracer, request_hook, response_hook)
 
     if _CLIENT_ASYNCIO_SUPPORT and isinstance(client, valkey.asyncio.Valkey):
 
         def _async_pipeline_wrapper(func, instance, args, kwargs):
             result = func(*args, **kwargs)
-            wrap_function_wrapper(
-                result, "execute", _async_traced_execute_pipeline
-            )
-            wrap_function_wrapper(
-                result, "immediate_execute_command", _async_traced_execute
-            )
+            wrap_function_wrapper(result, "execute", _async_traced_execute_pipeline)
+            wrap_function_wrapper(result, "immediate_execute_command", _async_traced_execute)
             return result
 
         wrap_function_wrapper(client, "execute_command", _async_traced_execute)
         wrap_function_wrapper(client, "pipeline", _async_pipeline_wrapper)
         return
 
-    if _CLIENT_ASYNCIO_CLUSTER_SUPPORT and isinstance(
-        client, valkey.asyncio.ValkeyCluster
-    ):
+    if _CLIENT_ASYNCIO_CLUSTER_SUPPORT and isinstance(client, valkey.asyncio.ValkeyCluster):
 
         def _async_cluster_pipeline_wrapper(func, instance, args, kwargs):
             result = func(*args, **kwargs)
-            wrap_function_wrapper(
-                result, "execute", _async_traced_execute_pipeline
-            )
+            wrap_function_wrapper(result, "execute", _async_traced_execute_pipeline)
             return result
 
         wrap_function_wrapper(client, "execute_command", _async_traced_execute)
-        wrap_function_wrapper(
-            client, "pipeline", _async_cluster_pipeline_wrapper
-        )
+        wrap_function_wrapper(client, "pipeline", _async_cluster_pipeline_wrapper)
         return
     # for valkey.client.Valkey, valkey.Cluster and v3.0.0 valkey.client.StrictValkey
     # the wrappers are the same
-    _traced_execute = _traced_execute_factory(
-        tracer, request_hook, response_hook
-    )
-    _traced_execute_pipeline = _traced_execute_pipeline_factory(
-        tracer, request_hook, response_hook
-    )
+    _traced_execute = _traced_execute_factory(tracer, request_hook, response_hook)
+    _traced_execute_pipeline = _traced_execute_pipeline_factory(tracer, request_hook, response_hook)
 
     def _pipeline_wrapper(func, instance, args, kwargs):
         result = func(*args, **kwargs)
         wrap_function_wrapper(result, "execute", _traced_execute_pipeline)
-        wrap_function_wrapper(
-            result, "immediate_execute_command", _traced_execute
-        )
+        wrap_function_wrapper(result, "immediate_execute_command", _traced_execute)
         return result
 
     wrap_function_wrapper(
@@ -776,9 +717,7 @@ class ValkeyInstrumentor(BaseInstrumentor):
             )
             setattr(client, _INSTRUMENTATION_ATTR, True)
         else:
-            _logger.warning(
-                "Attempting to instrument Valkey connection while already instrumented"
-            )
+            _logger.warning("Attempting to instrument Valkey connection while already instrumented")
 
     @staticmethod
     def uninstrument_client(
@@ -801,9 +740,7 @@ class ValkeyInstrumentor(BaseInstrumentor):
             # remain instrumented (pipelines should usually have a short span)
             unwrap(client, "pipeline")
         else:
-            _logger.warning(
-                "Attempting to un-instrument Valkey connection that wasn't instrumented"
-            )
+            _logger.warning("Attempting to un-instrument Valkey connection that wasn't instrumented")
 
     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.64b0 → opentelemetry_python_contrib_external_valkey-0.66b0}/src/opentelemetry/instrumentation/valkey/custom_types.py

@@ -4,7 +4,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 import valkey.asyncio.client
 import valkey.asyncio.cluster
@@ -14,9 +15,7 @@ import valkey.connection
 
 from opentelemetry.trace import Span
 
-RequestHook = Callable[
-    [Span, valkey.connection.Connection, list[Any], dict[str, Any]], None
-]
+RequestHook = Callable[[Span, valkey.connection.Connection, list[Any], dict[str, Any]], None]
 ResponseHook = Callable[[Span, valkey.connection.Connection, Any], None]
 
 AsyncPipelineInstance = TypeVar(
@@ -24,15 +23,11 @@ AsyncPipelineInstance = TypeVar(
     valkey.asyncio.client.Pipeline,
     valkey.asyncio.cluster.ClusterPipeline,
 )
-AsyncValkeyInstance = TypeVar(
-    "AsyncValkeyInstance", valkey.asyncio.Valkey, valkey.asyncio.ValkeyCluster
-)
+AsyncValkeyInstance = TypeVar("AsyncValkeyInstance", valkey.asyncio.Valkey, valkey.asyncio.ValkeyCluster)
 PipelineInstance = TypeVar(
     "PipelineInstance",
     valkey.client.Pipeline,
     valkey.cluster.ClusterPipeline,
 )
-ValkeyInstance = TypeVar(
-    "ValkeyInstance", valkey.client.Valkey, valkey.cluster.ValkeyCluster
-)
+ValkeyInstance = TypeVar("ValkeyInstance", valkey.client.Valkey, valkey.cluster.ValkeyCluster)
 R = TypeVar("R")

{opentelemetry_python_contrib_external_valkey-0.64b0 → opentelemetry_python_contrib_external_valkey-0.66b0}/src/opentelemetry/instrumentation/valkey/util.py

@@ -37,21 +37,18 @@ if TYPE_CHECKING:
 _FIELD_TYPES = ["NUMERIC", "TEXT", "GEO", "TAG", "VECTOR"]
 
 
-def _extract_conn_attributes(
-    conn_kwargs, db_sem_conv_opt_in_mode, http_sem_conv_opt_in_mode
-):
+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 = {}
-    _set_db_system(
-        attributes, DbSystemValues.REDIS.value, db_sem_conv_opt_in_mode
-    )
+    _set_db_system(attributes, DbSystemValues.REDIS.value, db_sem_conv_opt_in_mode)
 
-    db = conn_kwargs.get("db", 0)
+    # valkey-py may pass db=None explicitly (e.g. from_url); treat that as 0.
+    db = conn_kwargs.get("db")
+    if db is None:
+        db = 0
     _set_db_redis_database_index(attributes, db, db_sem_conv_opt_in_mode)
     if "path" in conn_kwargs:
-        _set_http_net_peer_name_client(
-            attributes, conn_kwargs.get("path", ""), http_sem_conv_opt_in_mode
-        )
+        _set_http_net_peer_name_client(attributes, conn_kwargs.get("path", ""), http_sem_conv_opt_in_mode)
         _set_net_transport(
             attributes,
             NetTransportValues.OTHER.value,
@@ -91,10 +88,7 @@ def _format_command_args(args: list[str]):
         out_str = " ".join(out)
 
         if len(out_str) > cmd_max_len:
-            out_str = (
-                out_str[: cmd_max_len - len(value_too_long_mark)]
-                + value_too_long_mark
-            )
+            out_str = out_str[: cmd_max_len - len(value_too_long_mark)] + value_too_long_mark
     else:
         out_str = ""
 
@@ -119,7 +113,11 @@ def _set_connection_attributes(
     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,
@@ -129,9 +127,7 @@ def _set_connection_attributes(
         span.set_attribute(key, value)
 
 
-def _build_span_name(
-    instance: ValkeyInstance | AsyncValkeyInstance, cmd_args: tuple[Any, ...]
-) -> str:
+def _build_span_name(instance: ValkeyInstance | AsyncValkeyInstance, cmd_args: tuple[Any, ...]) -> str:
     if len(cmd_args) > 0 and cmd_args[0]:
         if cmd_args[0] == "FT.SEARCH":
             name = "valkey.search"
@@ -140,14 +136,14 @@ def _build_span_name(
         else:
             name = cmd_args[0]
     else:
-        name = instance.connection_pool.connection_kwargs.get("db", 0)
-    return name
+        name = instance.connection_pool.connection_kwargs.get("db")
+        if name is None:
+            name = 0
+    return str(name)
 
 
 def _add_create_attributes(span: Span, args: tuple[Any, ...]):
-    _set_span_attribute_if_value(
-        span, "valkey.create_index.index", _value_or_none(args, 1)
-    )
+    _set_span_attribute_if_value(span, "valkey.create_index.index", _value_or_none(args, 1))
     # According to: https://github.com/valkey/valkey-py/blob/master/valkey/commands/search/commands.py#L155 schema is last argument for execute command
     try:
         schema_index = args.index("SCHEMA")
@@ -170,12 +166,8 @@ def _add_create_attributes(span: Span, args: tuple[Any, ...]):
 
 
 def _add_search_attributes(span: Span, response, args):
-    _set_span_attribute_if_value(
-        span, "valkey.search.index", _value_or_none(args, 1)
-    )
-    _set_span_attribute_if_value(
-        span, "valkey.search.query", _value_or_none(args, 2)
-    )
+    _set_span_attribute_if_value(span, "valkey.search.index", _value_or_none(args, 1))
+    _set_span_attribute_if_value(span, "valkey.search.query", _value_or_none(args, 2))
     # Parse response from search
     # https://valkey.io/docs/latest/commands/ft.search/
     # Response in format:
@@ -183,9 +175,7 @@ def _add_search_attributes(span: Span, response, args):
     # Returned documents in array format:
     # [first_field_name, first_field_value, second_field_name, second_field_value ...]
     number_of_returned_documents = _value_or_none(response, 0)
-    _set_span_attribute_if_value(
-        span, "valkey.search.total", number_of_returned_documents
-    )
+    _set_span_attribute_if_value(span, "valkey.search.total", number_of_returned_documents)
     if "NOCONTENT" in args or not number_of_returned_documents:
         return
     for document_number in range(number_of_returned_documents):
@@ -204,24 +194,26 @@ def _build_span_meta_data_for_pipeline(
     instance: PipelineInstance | AsyncPipelineInstance,
 ) -> tuple[list[Any], str, str]:
     try:
-        command_stack = (
-            instance.command_stack
-            if hasattr(instance, "command_stack")
-            else instance._command_stack
-        )
+        # valkey-py 6+ ClusterPipeline no longer updates ``command_stack``;
+        # queued commands are tracked on the execution strategy instead. The
+        # sync cluster strategy exposes them via a public ``command_queue``
+        # property, while the async cluster strategy only has the private
+        # ``_command_queue`` attribute. Fall back to ``command_stack`` /
+        # ``_command_stack`` for non-cluster pipelines and older valkey-py.
+        execution_strategy = getattr(instance, "_execution_strategy", None)
+        if execution_strategy is not None and hasattr(execution_strategy, "command_queue"):
+            command_stack = execution_strategy.command_queue
+        elif execution_strategy is not None and hasattr(execution_strategy, "_command_queue"):
+            command_stack = execution_strategy._command_queue
+        elif hasattr(instance, "command_stack"):
+            command_stack = instance.command_stack
+        else:
+            command_stack = instance._command_stack
 
-        cmds = [
-            _format_command_args(c.args if hasattr(c, "args") else c[0])
-            for c in command_stack
-        ]
+        cmds = [_format_command_args(c.args if hasattr(c, "args") else c[0]) for c in command_stack]
         resource = "\n".join(cmds)
 
-        span_name = " ".join(
-            [
-                (c.args[0] if hasattr(c, "args") else c[0][0])
-                for c in command_stack
-            ]
-        )
+        span_name = " ".join([(c.args[0] if hasattr(c, "args") else c[0][0]) for c in command_stack])
     except (AttributeError, IndexError):
         command_stack = []
         resource = ""

{opentelemetry_python_contrib_external_valkey-0.64b0 → opentelemetry_python_contrib_external_valkey-0.66b0}/src/opentelemetry/instrumentation/valkey/version.py

@@ -2,4 +2,4 @@
 # Copyright 2025 Philip Meier
 # SPDX-License-Identifier: Apache-2.0
 
-__version__ = "0.64b0"
+__version__ = "0.66b0"