Duplicate: add _semconv schem_url helper

Author: tammy-baylis-swi

opentelemetry-instrumentation/src/opentelemetry/instrumentation/_semconv.py

@@ -18,10 +18,14 @@
 import threading
 from enum import Enum
 from typing import Container, Mapping, MutableMapping
+from urllib.parse import urlparse
+
+from packaging import version as package_version
 
 from opentelemetry.instrumentation.utils import http_status_to_status_code
 from opentelemetry.semconv._incubating.attributes.db_attributes import (
     DB_NAME,
+    DB_OPERATION,
     DB_STATEMENT,
     DB_SYSTEM,
     DB_USER,
@@ -50,6 +54,7 @@
 )
 from opentelemetry.semconv.attributes.db_attributes import (
     DB_NAMESPACE,
+    DB_OPERATION_NAME,
     DB_QUERY_TEXT,
     DB_SYSTEM_NAME,
 )
@@ -177,6 +182,9 @@
 
 OTEL_SEMCONV_STABILITY_OPT_IN = "OTEL_SEMCONV_STABILITY_OPT_IN"
 
+# Legacy/default schema version when schema_url was first introduced
+_LEGACY_SCHEMA_VERSION = "1.11.0"
+
 
 class _OpenTelemetryStabilitySignalType(Enum):
     HTTP = "http"
@@ -590,6 +598,17 @@ def _set_db_user(
     # No new attribute - db.user was removed with no replacement
 
 
+def _set_db_operation(
+    result: MutableMapping[str, AttributeValue],
+    operation: str,
+    sem_conv_opt_in_mode: _StabilityMode,
+) -> None:
+    if _report_old(sem_conv_opt_in_mode):
+        set_string_attribute(result, DB_OPERATION, operation)
+    if _report_new(sem_conv_opt_in_mode):
+        set_string_attribute(result, DB_OPERATION_NAME, operation)
+
+
 # General
 
 
@@ -634,8 +653,63 @@ def _set_status(
             span.set_status(Status(status))
 
 
-# Get schema version based off of opt-in mode
 def _get_schema_url(mode: _StabilityMode) -> str:
+    """Get schema version URL for a single signal type's opt-in mode (backwards compatible).
+
+    For new instrumentations using multiple signal types, use
+    _get_schema_url_for_signal_types()
+    """
     if mode is _StabilityMode.DEFAULT:
-        return "https://opentelemetry.io/schemas/1.11.0"
+        return f"https://opentelemetry.io/schemas/{_LEGACY_SCHEMA_VERSION}"
     return Schemas.V1_21_0.value
+
+
+def _get_schema_version_for_opt_in_mode(
+    signal_type: _OpenTelemetryStabilitySignalType,
+    mode: _StabilityMode,
+) -> str:
+    """Get the schema version for a specific signal type and opt-in mode."""
+    if mode == _StabilityMode.DEFAULT:
+        return _LEGACY_SCHEMA_VERSION
+
+    signal_versions = {
+        _OpenTelemetryStabilitySignalType.HTTP: Schemas.V1_21_0.value,
+        _OpenTelemetryStabilitySignalType.DATABASE: Schemas.V1_25_0.value,
+        _OpenTelemetryStabilitySignalType.GEN_AI: Schemas.V1_26_0.value,
+    }
+    schema_url = signal_versions.get(signal_type)
+    if not schema_url:
+        return _LEGACY_SCHEMA_VERSION
+
+    path = urlparse(schema_url).path
+    schema_version = path.rstrip("/").split("/")[-1]
+    return schema_version or _LEGACY_SCHEMA_VERSION
+
+
+def _get_schema_url_for_signal_types(
+    signal_types: list[_OpenTelemetryStabilitySignalType],
+) -> str:
+    """Get the highest applicable schema URL for multiple signal types.
+
+    Note:
+        Instrumentors should call _OpenTelemetrySemanticConventionStability._initialize()
+        before using this function to ensure proper initialization of stability modes.
+
+    Args:
+        signal_types: List of signal types used by the instrumentation
+
+    Returns:
+        Schema URL string representing the highest applicable semconv version
+    """
+    highest_schema_version = _LEGACY_SCHEMA_VERSION
+    for signal_type in signal_types:
+        mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+            signal_type
+        )
+        schema_version = _get_schema_version_for_opt_in_mode(signal_type, mode)
+        # Keep the highest for all signals
+        if package_version.Version(schema_version) > package_version.Version(
+            highest_schema_version
+        ):
+            highest_schema_version = schema_version
+    return f"https://opentelemetry.io/schemas/{highest_schema_version}"

opentelemetry-instrumentation/tests/test_semconv.py

@@ -17,10 +17,14 @@
 from unittest.mock import Mock, patch
 
 from opentelemetry.instrumentation._semconv import (
+    _LEGACY_SCHEMA_VERSION,
     OTEL_SEMCONV_STABILITY_OPT_IN,
+    _get_schema_url_for_signal_types,
+    _get_schema_version_for_opt_in_mode,
     _OpenTelemetrySemanticConventionStability,
     _OpenTelemetryStabilitySignalType,
     _set_db_name,
+    _set_db_operation,
     _set_db_statement,
     _set_db_system,
     _set_db_user,
@@ -29,12 +33,14 @@
 )
 from opentelemetry.semconv._incubating.attributes.db_attributes import (
     DB_NAME,
+    DB_OPERATION,
     DB_STATEMENT,
     DB_SYSTEM,
     DB_USER,
 )
 from opentelemetry.semconv.attributes.db_attributes import (
     DB_NAMESPACE,
+    DB_OPERATION_NAME,
     DB_QUERY_TEXT,
     DB_SYSTEM_NAME,
 )
@@ -188,6 +194,134 @@ def test_stability_mode_dup_precedence(self):
         )
 
 
+class TestOpenTelemetrySemConvSchemaUrl(TestCase):
+    @stability_mode("")
+    def test_get_schema_version_for_opt_in_mode_default(self):
+        version = _get_schema_version_for_opt_in_mode(
+            _OpenTelemetryStabilitySignalType.HTTP, _StabilityMode.DEFAULT
+        )
+        self.assertEqual(version, _LEGACY_SCHEMA_VERSION)
+
+        version = _get_schema_version_for_opt_in_mode(
+            _OpenTelemetryStabilitySignalType.DATABASE, _StabilityMode.DEFAULT
+        )
+        self.assertEqual(version, _LEGACY_SCHEMA_VERSION)
+
+        version = _get_schema_version_for_opt_in_mode(
+            _OpenTelemetryStabilitySignalType.GEN_AI, _StabilityMode.DEFAULT
+        )
+        self.assertEqual(version, _LEGACY_SCHEMA_VERSION)
+
+    @stability_mode("")
+    def test_get_schema_version_for_opt_in_mode_http_stable(self):
+        version = _get_schema_version_for_opt_in_mode(
+            _OpenTelemetryStabilitySignalType.HTTP, _StabilityMode.HTTP
+        )
+        self.assertEqual(version, "1.21.0")
+
+    @stability_mode("")
+    def test_get_schema_version_for_opt_in_mode_database_stable(self):
+        version = _get_schema_version_for_opt_in_mode(
+            _OpenTelemetryStabilitySignalType.DATABASE, _StabilityMode.DATABASE
+        )
+        self.assertEqual(version, "1.25.0")
+
+    @stability_mode("")
+    def test_get_schema_version_for_opt_in_mode_gen_ai_stable(self):
+        version = _get_schema_version_for_opt_in_mode(
+            _OpenTelemetryStabilitySignalType.GEN_AI,
+            _StabilityMode.GEN_AI_LATEST_EXPERIMENTAL,
+        )
+        self.assertEqual(version, "1.26.0")
+
+    @stability_mode("")
+    def test_get_schema_url_for_signal_types_single_http_default(self):
+        url = _get_schema_url_for_signal_types(
+            [_OpenTelemetryStabilitySignalType.HTTP]
+        )
+        self.assertEqual(
+            url, f"https://opentelemetry.io/schemas/{_LEGACY_SCHEMA_VERSION}"
+        )
+
+    @stability_mode("http")
+    def test_get_schema_url_for_signal_types_single_http_stable(self):
+        url = _get_schema_url_for_signal_types(
+            [_OpenTelemetryStabilitySignalType.HTTP]
+        )
+        self.assertEqual(url, "https://opentelemetry.io/schemas/1.21.0")
+
+    @stability_mode("database")
+    def test_get_schema_url_for_signal_types_single_database_stable(self):
+        url = _get_schema_url_for_signal_types(
+            [_OpenTelemetryStabilitySignalType.DATABASE]
+        )
+        self.assertEqual(url, "https://opentelemetry.io/schemas/1.25.0")
+
+    @stability_mode("http,database")
+    def test_get_schema_url_for_signal_types_multiple_both_stable(self):
+        # DATABASE has higher version (1.25.0) than HTTP (1.21.0)
+        url = _get_schema_url_for_signal_types(
+            [
+                _OpenTelemetryStabilitySignalType.HTTP,
+                _OpenTelemetryStabilitySignalType.DATABASE,
+            ]
+        )
+        self.assertEqual(url, "https://opentelemetry.io/schemas/1.25.0")
+
+    @stability_mode("http")
+    def test_get_schema_url_for_signal_types_mixed_modes(self):
+        # HTTP is stable (1.21.0), DATABASE is default (1.11.0)
+        # Should return HTTP version as it's higher
+        url = _get_schema_url_for_signal_types(
+            [
+                _OpenTelemetryStabilitySignalType.HTTP,
+                _OpenTelemetryStabilitySignalType.DATABASE,
+            ]
+        )
+        self.assertEqual(url, "https://opentelemetry.io/schemas/1.21.0")
+
+    @stability_mode("database")
+    def test_get_schema_url_for_signal_types_database_only_stable(self):
+        # DATABASE is stable (1.25.0), HTTP is default (1.11.0)
+        # Should return DATABASE version as it's highest
+        url = _get_schema_url_for_signal_types(
+            [
+                _OpenTelemetryStabilitySignalType.HTTP,
+                _OpenTelemetryStabilitySignalType.DATABASE,
+            ]
+        )
+        self.assertEqual(url, "https://opentelemetry.io/schemas/1.25.0")
+
+    @stability_mode("")
+    def test_get_schema_url_for_signal_types_empty_list(self):
+        url = _get_schema_url_for_signal_types([])
+        self.assertEqual(
+            url, f"https://opentelemetry.io/schemas/{_LEGACY_SCHEMA_VERSION}"
+        )
+
+    @stability_mode("http/dup,database/dup")
+    def test_get_schema_url_for_signal_types_dup_modes(self):
+        url = _get_schema_url_for_signal_types(
+            [
+                _OpenTelemetryStabilitySignalType.HTTP,
+                _OpenTelemetryStabilitySignalType.DATABASE,
+            ]
+        )
+        self.assertEqual(url, "https://opentelemetry.io/schemas/1.25.0")
+
+    @stability_mode("http,database,gen_ai_latest_experimental")
+    def test_get_schema_url_for_signal_types_with_gen_ai(self):
+        # GEN_AI should be highest at 1.26.0
+        url = _get_schema_url_for_signal_types(
+            [
+                _OpenTelemetryStabilitySignalType.HTTP,
+                _OpenTelemetryStabilitySignalType.DATABASE,
+                _OpenTelemetryStabilitySignalType.GEN_AI,
+            ]
+        )
+        self.assertEqual(url, "https://opentelemetry.io/schemas/1.26.0")
+
+
 class TestOpenTelemetrySemConvStabilityHTTP(TestCase):
     def test_set_status_for_non_http_code_with_recording_span(self):
         span = Mock()
@@ -443,3 +577,45 @@ def test_db_user_none_value(self):
         result = {}
         _set_db_user(result, None, sem_conv_opt_in_mode=_StabilityMode.DEFAULT)
         self.assertNotIn(DB_USER, result)
+
+    def test_db_operation_default(self):
+        result = {}
+        _set_db_operation(
+            result,
+            "SELECT",
+            sem_conv_opt_in_mode=_StabilityMode.DEFAULT,
+        )
+        self.assertIn(DB_OPERATION, result)
+        self.assertEqual(result[DB_OPERATION], "SELECT")
+        self.assertNotIn(DB_OPERATION_NAME, result)
+
+    def test_db_operation_database_stable(self):
+        result = {}
+        _set_db_operation(
+            result,
+            "SELECT",
+            sem_conv_opt_in_mode=_StabilityMode.DATABASE,
+        )
+        self.assertNotIn(DB_OPERATION, result)
+        self.assertIn(DB_OPERATION_NAME, result)
+        self.assertEqual(result[DB_OPERATION_NAME], "SELECT")
+
+    def test_db_operation_database_dup(self):
+        result = {}
+        _set_db_operation(
+            result,
+            "SELECT",
+            sem_conv_opt_in_mode=_StabilityMode.DATABASE_DUP,
+        )
+        self.assertIn(DB_OPERATION, result)
+        self.assertEqual(result[DB_OPERATION], "SELECT")
+        self.assertIn(DB_OPERATION_NAME, result)
+        self.assertEqual(result[DB_OPERATION_NAME], "SELECT")
+
+    def test_db_operation_none_value(self):
+        result = {}
+        _set_db_operation(
+            result, None, sem_conv_opt_in_mode=_StabilityMode.DEFAULT
+        )
+        self.assertNotIn(DB_OPERATION, result)
+        self.assertNotIn(DB_OPERATION_NAME, result)