feat(opentracing-shim): Map OpenTracing span.kind tag to OTel SpanKind

The OpenTracing shim was not translating the span.kind tag to the
OpenTelemetry SpanKind argument. This change extracts the span.kind
tag from OpenTracing spans and maps it to the corresponding OTel
SpanKind (CLIENT, SERVER, CONSUMER, PRODUCER, or INTERNAL).

The span.kind tag is preserved in the span attributes to avoid
modifying user data within the shim.

Fixes open-telemetry#2549

Made-with: Cursor

Author: cabaret-pro

CHANGELOG.md

@@ -12,15 +12,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+- `opentelemetry-opentracing-shim`: Map OpenTracing `span.kind` tag to OpenTelemetry SpanKind
+  ([#2549](https://github.com/open-telemetry/opentelemetry-python/issues/2549))
 - `opentelemetry-sdk`: fix type annotations on `MetricReader` and related types
   ([#4938](https://github.com/open-telemetry/opentelemetry-python/pull/4938/))
 
 ## Version 1.40.0/0.61b0 (2026-03-04)
 
 - `opentelemetry-sdk`: deprecate `LoggingHandler` in favor of `opentelemetry-instrumentation-logging`, see `opentelemetry-instrumentation-logging` documentation
   ([#4919](https://github.com/open-telemetry/opentelemetry-python/pull/4919))
-- `opentelemetry-sdk`: Clarify log processor error handling expectations in documentation
-  ([#4915](https://github.com/open-telemetry/opentelemetry-python/pull/4915))
 - bump semantic-conventions to v1.40.0
   ([#4941](https://github.com/open-telemetry/opentelemetry-python/pull/4941))
 - Add stale PR GitHub Action

shim/opentelemetry-opentracing-shim/src/opentelemetry/shim/opentracing_shim/__init__.py

@@ -99,6 +99,7 @@
     Tracer,
     UnsupportedFormatException,
 )
+from opentracing import tags as ot_tags
 from typing_extensions import deprecated
 
 from opentelemetry.baggage import get_baggage, set_baggage
@@ -674,13 +675,21 @@ def start_span(
         if start_time_ns is not None:
             start_time_ns = util.time_seconds_to_ns(start_time)
 
-        span = self._otel_tracer.start_span(
-            operation_name,
-            context=parent_span_context,
-            links=valid_links,
-            attributes=tags,
-            start_time=start_time_ns,
-        )
+        # Extract span kind from OpenTracing tags if present.
+        # OpenTracing uses the "span.kind" tag to indicate span kind, while
+        # OpenTelemetry uses a dedicated kind argument.
+        span_kwargs: dict = {
+            "context": parent_span_context,
+            "links": valid_links,
+            "attributes": tags,
+            "start_time": start_time_ns,
+        }
+        if tags is not None and ot_tags.SPAN_KIND in tags:
+            span_kwargs["kind"] = util.opentracing_kind_to_otel_kind(
+                tags[ot_tags.SPAN_KIND]
+            )
+
+        span = self._otel_tracer.start_span(operation_name, **span_kwargs)
 
         context = SpanContextShim(span.get_span_context())
         return SpanShim(self, context, span)

shim/opentelemetry-opentracing-shim/src/opentelemetry/shim/opentracing_shim/util.py

@@ -12,10 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from opentracing import tags as ot_tags
+
+from opentelemetry.trace import SpanKind
+
 # A default event name to be used for logging events when a better event name
 # can't be derived from the event's key-value pairs.
 DEFAULT_EVENT_NAME = "log"
 
+# Mapping from OpenTracing span kind tag values to OpenTelemetry SpanKind.
+_OPENTRACING_TO_OTEL_KIND = {
+    ot_tags.SPAN_KIND_RPC_CLIENT: SpanKind.CLIENT,
+    ot_tags.SPAN_KIND_RPC_SERVER: SpanKind.SERVER,
+    ot_tags.SPAN_KIND_CONSUMER: SpanKind.CONSUMER,
+    ot_tags.SPAN_KIND_PRODUCER: SpanKind.PRODUCER,
+}
+
 
 def time_seconds_to_ns(time_seconds):
     """Converts a time value in seconds to a time value in nanoseconds.
@@ -52,3 +64,19 @@ def event_name_from_kv(key_values):
         return DEFAULT_EVENT_NAME
 
     return key_values["event"]
+
+
+def opentracing_kind_to_otel_kind(opentracing_kind: str) -> SpanKind:
+    """Converts an OpenTracing span kind tag value to an OpenTelemetry SpanKind.
+
+    Args:
+        opentracing_kind: The value of the OpenTracing ``span.kind`` tag.
+            Expected values are ``client``, ``server``, ``consumer``, or
+            ``producer``.
+
+    Returns:
+        The corresponding :class:`opentelemetry.trace.SpanKind`. Returns
+        ``SpanKind.INTERNAL`` if the input is not a recognized OpenTracing
+        span kind.
+    """
+    return _OPENTRACING_TO_OTEL_KIND.get(opentracing_kind, SpanKind.INTERNAL)

shim/opentelemetry-opentracing-shim/tests/test_shim.py

@@ -668,3 +668,61 @@ def test_mixed_mode(self):
                     scope.span.unwrap().parent,
                     opentelemetry_span.context,
                 )
+
+    def test_span_kind_from_tags(self):
+        """Test that span.kind OpenTracing tag is converted to OTel SpanKind."""
+
+        # Test consumer kind
+        with self.shim.start_active_span(
+            "TestSpanKind1", tags={"span.kind": "consumer"}
+        ) as scope:
+            self.assertEqual(scope.span.unwrap().kind, trace.SpanKind.CONSUMER)
+
+        # Test producer kind
+        with self.shim.start_active_span(
+            "TestSpanKind2", tags={"span.kind": "producer"}
+        ) as scope:
+            self.assertEqual(scope.span.unwrap().kind, trace.SpanKind.PRODUCER)
+
+        # Test client kind
+        with self.shim.start_active_span(
+            "TestSpanKind3", tags={"span.kind": "client"}
+        ) as scope:
+            self.assertEqual(scope.span.unwrap().kind, trace.SpanKind.CLIENT)
+
+        # Test server kind
+        with self.shim.start_active_span(
+            "TestSpanKind4", tags={"span.kind": "server"}
+        ) as scope:
+            self.assertEqual(scope.span.unwrap().kind, trace.SpanKind.SERVER)
+
+        # Test unknown kind defaults to INTERNAL
+        with self.shim.start_active_span(
+            "TestSpanKind5", tags={"span.kind": "unknown"}
+        ) as scope:
+            self.assertEqual(scope.span.unwrap().kind, trace.SpanKind.INTERNAL)
+
+        # Test no span.kind tag defaults to INTERNAL
+        with self.shim.start_active_span(
+            "TestSpanKind6", tags={"foo": "bar"}
+        ) as scope:
+            self.assertEqual(scope.span.unwrap().kind, trace.SpanKind.INTERNAL)
+
+        # Test no tags at all defaults to INTERNAL
+        with self.shim.start_active_span("TestSpanKind7") as scope:
+            self.assertEqual(scope.span.unwrap().kind, trace.SpanKind.INTERNAL)
+
+    def test_span_kind_tag_preserved_in_attributes(self):
+        """Test that span.kind tag is also preserved as an attribute."""
+
+        with self.shim.start_active_span(
+            "TestSpanKindAttr", tags={"span.kind": "consumer", "foo": "bar"}
+        ) as scope:
+            # Verify the span kind is correctly set
+            self.assertEqual(scope.span.unwrap().kind, trace.SpanKind.CONSUMER)
+            # Verify the span.kind tag is preserved as an attribute
+            self.assertEqual(
+                scope.span.unwrap().attributes.get("span.kind"), "consumer"
+            )
+            # Verify other attributes are also preserved
+            self.assertEqual(scope.span.unwrap().attributes.get("foo"), "bar")

shim/opentelemetry-opentracing-shim/tests/test_util.py

@@ -15,12 +15,16 @@
 from time import time, time_ns
 from unittest import TestCase
 
+from opentracing import tags as ot_tags
+
 from opentelemetry.shim.opentracing_shim.util import (
     DEFAULT_EVENT_NAME,
     event_name_from_kv,
+    opentracing_kind_to_otel_kind,
     time_seconds_from_ns,
     time_seconds_to_ns,
 )
+from opentelemetry.trace import SpanKind
 
 
 class TestUtil(TestCase):
@@ -68,3 +72,36 @@ def test_time_conversion_precision(self):
         # TODO: This seems to work consistently, but we should find out the
         # biggest possible loss of precision.
         self.assertAlmostEqual(result, time_seconds, places=6)
+
+    def test_opentracing_kind_to_otel_kind(self):
+        """Test conversion from OpenTracing span.kind tag values to OTel SpanKind."""
+
+        # Test all valid OpenTracing span kinds
+        self.assertEqual(
+            opentracing_kind_to_otel_kind(ot_tags.SPAN_KIND_RPC_CLIENT),
+            SpanKind.CLIENT,
+        )
+        self.assertEqual(
+            opentracing_kind_to_otel_kind(ot_tags.SPAN_KIND_RPC_SERVER),
+            SpanKind.SERVER,
+        )
+        self.assertEqual(
+            opentracing_kind_to_otel_kind(ot_tags.SPAN_KIND_CONSUMER),
+            SpanKind.CONSUMER,
+        )
+        self.assertEqual(
+            opentracing_kind_to_otel_kind(ot_tags.SPAN_KIND_PRODUCER),
+            SpanKind.PRODUCER,
+        )
+
+        # Test unknown span kind defaults to INTERNAL
+        self.assertEqual(
+            opentracing_kind_to_otel_kind("unknown"),
+            SpanKind.INTERNAL,
+        )
+
+        # Test empty string defaults to INTERNAL
+        self.assertEqual(
+            opentracing_kind_to_otel_kind(""),
+            SpanKind.INTERNAL,
+        )