ioa-observe-sdk 1.0.15__py3-none-any.whl → 1.0.17__py3-none-any.whl

ioa_observe/sdk/tracing/tracing.py

@@ -38,6 +38,10 @@ from opentelemetry.semconv_ai import SpanAttributes
 from ioa_observe.sdk import Telemetry
 from ioa_observe.sdk.instruments import Instruments
 from ioa_observe.sdk.tracing.content_allow_list import ContentAllowList
+from ioa_observe.sdk.tracing.transform_span import (
+    transform_json_object_configurable,
+    validate_transformer_rules,
+)
 from ioa_observe.sdk.utils import is_notebook
 from ioa_observe.sdk.client import kv_store
 
@@ -106,8 +110,8 @@ def determine_reliability_score(span):
 class TracerWrapper(object):
     resource_attributes: dict = {}
     enable_content_tracing: bool = True
-    endpoint: str = (None,)
-    app_name: str = (None,)
+    endpoint: str = None
+    app_name: str = None
     headers: Dict[str, str] = {}
     __tracer_provider: TracerProvider = None
     __disabled: bool = False
@@ -129,7 +133,10 @@ class TracerWrapper(object):
                 return obj
 
             obj.__image_uploader = image_uploader
-            obj._agent_execution_counts = {}  # {(agent_name): [success_count, total_count]}
+            # {(agent_name): [success_count, total_count]}
+            obj._agent_execution_counts = {}
+            # Track spans that have been processed to avoid duplicates
+            obj._processed_spans = set()
             TracerWrapper.app_name = TracerWrapper.resource_attributes.get(
                 "service.name", "observe"
             )
@@ -139,6 +146,7 @@ class TracerWrapper(object):
                 Telemetry().capture("tracer:init", {"processor": "custom"})
                 obj.__spans_processor: SpanProcessor = processor
                 obj.__spans_processor_original_on_start = processor.on_start
+                obj.__spans_processor_original_on_end = processor.on_end
             else:
                 if exporter:
                     Telemetry().capture(
@@ -175,9 +183,10 @@ class TracerWrapper(object):
                         schedule_delay_millis=5000,
                     )
                 obj.__spans_processor_original_on_start = None
+                obj.__spans_processor_original_on_end = obj.__spans_processor.on_end
 
             obj.__spans_processor.on_start = obj._span_processor_on_start
-            # obj.__spans_processor.on_end = obj.span_processor_on_ending
+            obj.__spans_processor.on_end = obj.span_processor_on_ending
             obj.__tracer_provider.add_span_processor(obj.__spans_processor)
             # Custom metric, for example
             meter = get_meter("observe")
@@ -338,14 +347,114 @@ class TracerWrapper(object):
         self.number_active_agents.add(count, attributes=span.attributes)
 
     def span_processor_on_ending(self, span):
+        # Check if this span has already been processed to avoid duplicate processing
+        # Added for avoid duplicate on_ending with manual triggers
+        # from decorators (@tool, @workflow) in base.py
+        span_id = span.context.span_id
+        if span_id in self._processed_spans:
+            # This span was already processed, skip to avoid duplicates
+            return
+
+        # Mark this span as processed
+        self._processed_spans.add(span_id)
+
         determine_reliability_score(span)
         start_time = span.attributes.get("ioa_start_time")
-        # publish span to the exporter
+
+        # Apply transformations if enabled
+        apply_transform = get_value("apply_transform")
+        if apply_transform:
+            transformer_rules = get_value("transformer_rules")
+            if transformer_rules:
+                try:
+                    # Convert span to dict for transformation
+                    span_dict = self._span_to_dict(span)
+                    # Apply transformation
+                    transformed_span_dict = transform_json_object_configurable(
+                        span_dict, transformer_rules
+                    )
+                    # Update span with transformed data
+                    self._update_span_from_dict(span, transformed_span_dict)
+                except Exception as e:
+                    logging.error(f"Error applying span transformation: {e}")
 
         if start_time is not None:
             latency = (time.time() - start_time) * 1000
             self.response_latency_histogram.record(latency, attributes=span.attributes)
 
+        # Call original on_end method if it exists
+        if (
+            hasattr(self, "_TracerWrapper__spans_processor_original_on_end")
+            and self.__spans_processor_original_on_end
+        ):
+            self.__spans_processor_original_on_end(span)
+
+    def _span_to_dict(self, span):
+        """Convert span to dictionary for transformation."""
+        span_dict = {
+            "name": span.name,
+            "attributes": dict(span.attributes) if span.attributes else {},
+            "status": {
+                "status_code": span.status.status_code.name
+                if span.status and span.status.status_code
+                else None,
+                "description": span.status.description if span.status else None,
+            },
+        }
+        return span_dict
+
+    def _update_span_from_dict(self, span, span_dict):
+        """Update span with transformed data."""
+        # Update span name if it was transformed
+        if "name" in span_dict and span_dict["name"] != span.name:
+            # Directly modify the internal name attribute
+            if hasattr(span, "_name"):
+                span._name = span_dict["name"]
+
+        # Update attributes if they were transformed
+        if "attributes" in span_dict:
+            # Try multiple approaches to update span attributes
+            updated = False
+
+            # Method 1: Try using set_attribute if available and mutable
+            if (
+                hasattr(span, "set_attribute")
+                and hasattr(span, "_ended")
+                and not span._ended
+            ):
+                try:
+                    # Clear existing attributes by setting them to None
+                    if hasattr(span, "_attributes"):
+                        keys_to_remove = list(span._attributes.keys())
+                        for key in keys_to_remove:
+                            span.set_attribute(key, None)
+
+                    # Set new attributes
+                    for key, value in span_dict["attributes"].items():
+                        span.set_attribute(key, value)
+                    updated = True
+                except (AttributeError, TypeError):
+                    pass
+
+            # Method 2: Direct attribute manipulation
+            if not updated:
+                try:
+                    if hasattr(span, "_attributes"):
+                        span._attributes.clear()
+                        span._attributes.update(span_dict["attributes"])
+                        updated = True
+                    elif hasattr(span, "attributes") and hasattr(
+                        span.attributes, "clear"
+                    ):
+                        span.attributes.clear()
+                        span.attributes.update(span_dict["attributes"])
+                        updated = True
+                except (AttributeError, TypeError):
+                    pass
+
+            if not updated:
+                logging.warning("Cannot modify span attributes - span may be finalized")
+
     @staticmethod
     def set_static_params(
         resource_attributes: dict,
@@ -423,14 +532,101 @@ def set_workflow_name(workflow_name: str) -> None:
     attach(set_value("workflow_name", workflow_name))
 
 
-def session_start():
+def _parse_boolean_env(env_value: str) -> bool:
+    """
+    Parse boolean value from environment variable string.
+
+    Args:
+        env_value (str): Environment variable value to parse
+
+    Returns:
+        bool: Parsed boolean value
+
+    Accepts: "0", "1", "true", "false", "True", "False"
+    """
+    if env_value.lower() in ("true", "1"):
+        return True
+    elif env_value.lower() in ("false", "0"):
+        return False
+    else:
+        raise ValueError(f"Invalid boolean value: {env_value}")
+
+
+def session_start(apply_transform: bool = False):
     """
     Can be used as a context manager or a normal function.
     As a context manager, yields session metadata.
     As a normal function, just sets up the session.
+
+    Args:
+        apply_transform (bool): If True, enables span transformation based on
+                               rules loaded from SPAN_TRANSFORMER_RULES_FILE env.
+                               Can be overridden by
+                               SPAN_TRANSFORMER_RULES_ENABLED env var.
     """
-    session_id = TracerWrapper.app_name + "_" + str(uuid.uuid4())
+    session_id = (TracerWrapper.app_name or "observe") + "_" + str(uuid.uuid4())
     set_session_id(session_id)
+
+    # Check if environment variable overrides the apply_transform parameter
+    transformer_enabled_env = os.getenv("SPAN_TRANSFORMER_RULES_ENABLED")
+    if transformer_enabled_env:
+        try:
+            apply_transform = _parse_boolean_env(transformer_enabled_env)
+        except ValueError as e:
+            logging.error(
+                "Invalid SPAN_TRANSFORMER_RULES_ENABLED value: "
+                f"{e}. Using parameter value: {apply_transform}"
+            )
+
+    # Handle transformation flag
+    if apply_transform:
+        transformer_rules_file = os.getenv("SPAN_TRANSFORMER_RULES_FILE")
+        if not transformer_rules_file:
+            logging.error(
+                "SPAN_TRANSFORMER_RULES_FILE environment variable "
+                "not set. Disabling transformation."
+            )
+            apply_transform = False
+        elif not os.path.exists(transformer_rules_file):
+            logging.error(
+                "Transformer rules file not found: "
+                f"{transformer_rules_file}. Disabling "
+                "transformation."
+            )
+            apply_transform = False
+        else:
+            try:
+                with open(transformer_rules_file, "r") as f:
+                    transformer_rules = json.load(f)
+                # Validate structure and rules
+                validate_transformer_rules(transformer_rules)
+                attach(set_value("apply_transform", True))
+                attach(set_value("transformer_rules", transformer_rules))
+            except json.JSONDecodeError as e:
+                logging.error(
+                    "Failed to load transformer rules from "
+                    f"{transformer_rules_file}: {e}. Disabling "
+                    "transformation."
+                )
+                apply_transform = False
+            except ValueError:
+                logging.error(
+                    "Invalid transformer rules structure. "
+                    "Expected 'RULES' section. "
+                    "Disabling transformation."
+                )
+                apply_transform = False
+            except (json.JSONDecodeError, Exception) as e:
+                logging.error(
+                    "Failed to load transformer rules from "
+                    f"{transformer_rules_file}: {e}. "
+                    "Disabling transformation."
+                )
+                apply_transform = False
+
+    if not apply_transform:
+        attach(set_value("apply_transform", False))
+
     metadata = {
         "executionID": get_value("session.id") or session_id,
         "traceparentID": get_current_traceparent(),
@@ -581,14 +777,23 @@ def is_llm_span(span) -> bool:
 
 
 def init_spans_exporter(api_endpoint: str, headers: Dict[str, str]) -> SpanExporter:
-    if "http" in api_endpoint.lower() or "https" in api_endpoint.lower():
+    if api_endpoint and (
+        "http" in api_endpoint.lower() or "https" in api_endpoint.lower()
+    ):
         return HTTPExporter(
             endpoint=f"{api_endpoint}/v1/traces",
             headers=headers,
             compression=Compression.Gzip,
         )
-    else:
+    elif api_endpoint:
         return GRPCExporter(endpoint=f"{api_endpoint}", headers=headers)
+    else:
+        # Default to HTTP exporter with localhost when endpoint is None
+        return HTTPExporter(
+            endpoint="http://localhost:4318/v1/traces",
+            headers=headers,
+            compression=Compression.Gzip,
+        )
 
 
 def init_tracer_provider(resource: Resource) -> TracerProvider:

ioa_observe/sdk/tracing/transform_span.py

@@ -0,0 +1,210 @@
+# Copyright AGNTCY Contributors (https://github.com/agntcy)
+# SPDX-License-Identifier: Apache-2.0
+
+
+def validate_transformer_rules(config):
+    """
+    Validates the transformer rules configuration.
+
+    Args:
+        config (dict): The configuration dictionary to validate.
+
+    Raises:
+        ValueError: If the configuration is invalid.
+
+    Validation rules:
+    - Must have RULES section containing a list of transformation rules
+    - Each rule must have a 'path' field (list of strings)
+    - Path length = 1: Global transformation (e.g., ["old_key"])
+    - Path length > 1: Path-specific transformation
+      (e.g., ["attributes", "nested_key"])
+    - action_conflict must be one of: SKIP, REPLACE, DELETE
+    - DELETE action should not have a 'rename' field
+    """
+    if not isinstance(config, dict):
+        raise ValueError("Configuration must be a dictionary")
+
+    if "RULES" not in config:
+        raise ValueError("Configuration must contain 'RULES' section")
+
+    rules_section = config.get("RULES", [])
+    if not isinstance(rules_section, list):
+        raise ValueError("RULES section must be a list")
+
+    for i, rule in enumerate(rules_section):
+        if not isinstance(rule, dict):
+            raise ValueError(f"Rule {i} must be a dictionary")
+
+        # Check required fields
+        if "path" not in rule:
+            raise ValueError(f"Rule {i} must have 'path' field")
+
+        if not isinstance(rule["path"], list):
+            raise ValueError(f"Rule {i} 'path' must be a list")
+
+        if not rule["path"]:
+            raise ValueError(f"Rule {i} 'path' cannot be empty")
+
+        # Check action_conflict
+        action_conflict = rule.get("action_conflict", "REPLACE")
+        if action_conflict not in ["SKIP", "REPLACE", "DELETE"]:
+            raise ValueError(
+                f"Rule {i} action_conflict must be one of: SKIP, REPLACE, DELETE"
+            )
+
+        # Check rename field for non-DELETE actions
+        if action_conflict != "DELETE" and "rename" not in rule:
+            raise ValueError(
+                f"Rule {i} with {action_conflict} action must have 'rename' field"
+            )
+
+        # Check rename field for DELETE action
+        if action_conflict == "DELETE" and "rename" in rule:
+            raise ValueError(
+                f"Rule {i} with DELETE action should not have 'rename' field"
+            )
+
+
+def transform_json_object_configurable(data, config, current_path=()):
+    """
+    Recursively transforms a JSON object (dict or list) based on a unified
+    configuration that contains transformation rules for both global and
+    path-specific key renames, along with conflict resolution strategies.
+
+    Args:
+        data (dict or list or primitive): The JSON object or part of it
+                                          to transform.
+        config (dict): A dictionary containing transformation rules:
+                       {
+                           "RULES": [
+                               {
+                                   "path": ["old_key"],
+                                   "rename": "new_key",
+                                   "action_conflict": "SKIP"|"REPLACE"|"DELETE"
+                               },
+                               {
+                                   "path": ["attributes",
+                                           "traceloop.span.kind"],
+                                   "rename": "ioa_observe.span_kind",
+                                   "action_conflict": "REPLACE"
+                               },
+                               ...
+                           ]
+                       }
+        current_path (tuple): The current path (sequence of keys) from the
+                              root to the current data element.
+                              Used for path-specific lookups.
+
+    Returns:
+        dict or list or primitive: The transformed JSON object.
+    """
+    if isinstance(data, dict):
+        new_data = {}
+        for key, value in data.items():
+            full_key_path = current_path + (key,)
+
+            # Recursively transform the value first
+            transformed_value = transform_json_object_configurable(
+                value, config, full_key_path
+            )
+
+            # Default to no rename and 'REPLACE' conflict strategy
+            target_new_key = key
+            action_on_conflict = "REPLACE"
+            rule_applied = False
+
+            # Check for matching rules based on path
+            rules = config.get("RULES", [])
+            for rule in rules:
+                rule_path = tuple(rule["path"])
+
+                # Check if this rule applies to the current path
+                if len(rule_path) == 1:
+                    # Global rule: applies if the key matches
+                    if rule_path[0] == key:
+                        action_on_conflict = rule.get("action_conflict", "REPLACE")
+
+                        if action_on_conflict == "DELETE":
+                            # DELETE action: skip adding this key entirely
+                            rule_applied = True
+                            break
+                        elif "rename" in rule:
+                            target_new_key = rule["rename"]
+                            rule_applied = True
+                            break
+                else:
+                    # Path-specific rule: applies if full path matches
+                    if full_key_path == rule_path:
+                        action_on_conflict = rule.get("action_conflict", "REPLACE")
+
+                        if action_on_conflict == "DELETE":
+                            # DELETE action: skip adding this key entirely
+                            rule_applied = True
+                            break
+                        elif "rename" in rule:
+                            target_new_key = rule["rename"]
+                            rule_applied = True
+                            break
+
+            # Skip to next iteration if DELETE action was applied
+            if rule_applied and action_on_conflict == "DELETE":
+                continue
+
+            # Now, decide which key to use in new_data based on rules and
+            # conflict strategy
+            if rule_applied and target_new_key != key:
+                # A rename was proposed
+                if action_on_conflict == "SKIP" and (
+                    target_new_key in data or target_new_key in new_data
+                ):
+                    # If target key already exists in original data OR new_data
+                    # AND action is SKIP, keep the original key and its
+                    # transformed value. The rename is effectively "skipped".
+                    new_data[key] = transformed_value
+                else:
+                    # If action is REPLACE, or target key doesn't exist,
+                    # then perform the rename.
+                    # This will either add a new key or overwrite an
+                    # existing one.
+                    new_data[target_new_key] = transformed_value
+            else:
+                # No rule applied or DELETE handled above
+                new_data[key] = transformed_value
+
+        return new_data
+    elif isinstance(data, list):
+        new_list = []
+        for item in data:
+            # For list items, the path context usually doesn't change
+            # for the elements themselves
+            new_list.append(
+                transform_json_object_configurable(item, config, current_path)
+            )
+        return new_list
+    else:
+        # Base case: primitive types (str, int, float, bool, None)
+        # are returned as is
+        return data
+
+
+def transform_list_of_json_objects_configurable(json_objects_list, config):
+    """
+    Transforms a list of JSON objects by applying key replacements based on
+    the provided unified configuration.
+
+    Args:
+        json_objects_list (list): A list of Python dictionary objects
+                                  (parsed JSON).
+        config (dict): The unified configuration dictionary for
+                       transformations.
+
+    Returns:
+        list: A new list containing the transformed JSON objects.
+    """
+    if not isinstance(json_objects_list, list):
+        raise TypeError("Input must be a list of JSON objects.")
+
+    transformed_list = [
+        transform_json_object_configurable(obj, config) for obj in json_objects_list
+    ]
+    return transformed_list

ioa_observe/sdk/utils/const.py

@@ -21,6 +21,13 @@ OBSERVE_PROMPT_VERSION_HASH = "ioa_observe.prompt.version_hash"
 OBSERVE_PROMPT_TEMPLATE = "ioa_observe.prompt.template"
 OBSERVE_PROMPT_TEMPLATE_VARIABLES = "ioa_observe.prompt.template_variables"
 
+# MCP
+MCP_METHOD_NAME = "mcp.method.name"
+MCP_REQUEST_ARGUMENT = "mcp.request.argument"
+MCP_REQUEST_ID = "mcp.request.id"
+MCP_SESSION_INIT_OPTIONS = "mcp.session.init_options"
+MCP_RESPONSE_VALUE = "mcp.response.value"
+
 
 class ObserveSpanKindValues(Enum):
     WORKFLOW = "workflow"

{ioa_observe_sdk-1.0.15.dist-info → ioa_observe_sdk-1.0.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ioa-observe-sdk
-Version: 1.0.15
+Version: 1.0.17
 Summary: IOA Observability SDK
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -82,6 +82,8 @@ This schema is designed to provide comprehensive observability for Multi-Agent S
 
 Link: [AGNTCY Observability Schema](https://github.com/agntcy/observe/blob/main/schema/)
 
+An option is made available for transforming spans attributes exported by using options via env variables (SPAN_TRANSFORMER_RULES_ENABLED, SPAN_TRANSFORMER_RULES_FILE). Please read [transform](./sdk/tracing/transform_span.py).
+
 ## Dev
 
 Any Opentelemetry compatible backend can be used, but for this guide, we will use ClickhouseDB as the backend database.

{ioa_observe_sdk-1.0.15.dist-info → ioa_observe_sdk-1.0.17.dist-info}/RECORD

@@ -1,21 +1,22 @@
 ioa_observe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ioa_observe/sdk/__init__.py,sha256=h_dALthPo9HpUwNyEp7p9kTYlkaghx9ZY3b-YzVV2Vs,8824
+ioa_observe/sdk/__init__.py,sha256=GgEjiEhjqvbWh37FCrH1LQb-NROudJCZS4qa9j0Tyic,8845
 ioa_observe/sdk/instruments.py,sha256=cA5Yq1BYFovMrYUNYQXua-JXsMtMOa_YOn6yiJZNwLg,576
 ioa_observe/sdk/telemetry.py,sha256=6wwaOYhZMjAZ6dXDdBA2LUWo3LLptTcy93BJqDdbqBM,3103
 ioa_observe/sdk/version.py,sha256=oriNAY8huVDPw5N_rv5F_PehFrcGo37FSGBCfZCM81M,121
 ioa_observe/sdk/client/__init__.py,sha256=V4Rt-Z1EHlM12Lx3hGd0Ew70V1JKAQZXNb9ABtdWHEI,224
-ioa_observe/sdk/client/client.py,sha256=nGQoH2pGkc6QANrhfq7cgtgN0HlLxDeu6NrRaEbGHLE,2091
+ioa_observe/sdk/client/client.py,sha256=6TVOo_E1ulE3WO_CYG7oPgeucs-qegOA09uTO3yQiyk,2112
 ioa_observe/sdk/client/http.py,sha256=LdLYSQPFIhKN5BTB-N78jLO7ITl7jGjA0-qpewEIvO4,1724
 ioa_observe/sdk/config/__init__.py,sha256=8aVNaw0yRNLFPxlf97iOZLlJVcV81ivSDnudH2m1OIo,572
 ioa_observe/sdk/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ioa_observe/sdk/connectors/slim.py,sha256=NwbKEV7d5NIOqmG8zKqtgGigSJl7kf3QJ65z2gxpsY8,8498
-ioa_observe/sdk/decorators/__init__.py,sha256=c8gzCG-CASNI61RiTpNiTvMfguWvn4zc25fhBBgbHFA,3626
-ioa_observe/sdk/decorators/base.py,sha256=KbSxFUTP_qpZA0gzt_xe4pFTu9SLpAo1MbHskQ3BQ9A,30208
+ioa_observe/sdk/decorators/__init__.py,sha256=GUZs_HA57bQTLSgo7GAnaofAapk2Y-NuE6md0HPSH3s,3603
+ioa_observe/sdk/decorators/base.py,sha256=FLICXVOFzv6yuCQL99G5Do5h1WrKJNsegvfm5KHe9v8,30173
 ioa_observe/sdk/decorators/helpers.py,sha256=I9HXMBivkZpGDtPe9Ad_UU35p_m_wEPate4r_fU0oOA,2705
 ioa_observe/sdk/decorators/util.py,sha256=IebvH9gwZN1en3LblYJUh4bAV2STl6xmp8WpZzBDH2g,30068
 ioa_observe/sdk/instrumentations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ioa_observe/sdk/instrumentations/a2a.py,sha256=ov_9ckkymf_qFXG0iXVWfxlW-3kFcP-knrM_t-Cf72w,4414
-ioa_observe/sdk/instrumentations/slim.py,sha256=J5e6XeshH55xXaUiT9_j4R_n6VQELzBjgRAU-AgZGOg,11435
+ioa_observe/sdk/instrumentations/a2a.py,sha256=ZpqvPl4u-yheQzSdBfxnZhWFZ8ntbKni_uaW3IDyjqw,6309
+ioa_observe/sdk/instrumentations/mcp.py,sha256=vRM3ofnn7AMmry2RrfyZnZVPEutLWiDMghx2TSnm0Wk,18569
+ioa_observe/sdk/instrumentations/slim.py,sha256=9KS9slZKB7-oC-2SH2s2FKB2JHXXHt4_xPhLvxJD-fk,22456
 ioa_observe/sdk/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ioa_observe/sdk/logging/logging.py,sha256=HZxW9s8Due7jgiNkdI38cIjv5rC9D-Flta3RQMOnpow,2891
 ioa_observe/sdk/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -33,14 +34,15 @@ ioa_observe/sdk/tracing/content_allow_list.py,sha256=1fAkpIwUQ7vDwCTkIVrqeltWQtr
 ioa_observe/sdk/tracing/context_manager.py,sha256=O0JEXYa9h8anhW78R8KKBuqS0j4by1E1KXxNIMPnLr8,400
 ioa_observe/sdk/tracing/context_utils.py,sha256=-sYS9vPLI87davV9ubneq5xqbV583CC_c0SmOQS1TAs,2933
 ioa_observe/sdk/tracing/manual.py,sha256=KS6WN-zw9vAACzXYmnMoJm9d1fenYMfvzeK1GrGDPDE,1937
-ioa_observe/sdk/tracing/tracing.py,sha256=jU-qeIccoPUFms2uzYUHoBoACzkCqcdEW6PNzi8uz3M,38883
+ioa_observe/sdk/tracing/tracing.py,sha256=lwmatGwviSrf-hlBxRyxa0kv9AQdP302R3duBgNKsSU,47127
+ioa_observe/sdk/tracing/transform_span.py,sha256=XTApi_gJxum7ynvhtcoCfDyK8VVOj91Q1DT6hAeLHA8,8419
 ioa_observe/sdk/utils/__init__.py,sha256=UPn182U-UblF_XwXaFpx8F-TmQTbm1LYf9y89uSp5Hw,704
-ioa_observe/sdk/utils/const.py,sha256=GwbHakKPjBL4wLqAVkDrSoKB-8p18EUrbaqPuRuV_xg,1099
+ioa_observe/sdk/utils/const.py,sha256=d67dUTAH9UpWvUV9GLBUqn1Sc2knJ55dy-e6YoLrvSo,1318
 ioa_observe/sdk/utils/in_memory_span_exporter.py,sha256=H_4TRaThMO1H6vUQ0OpQvzJk_fZH0OOsRAM1iZQXsR8,2112
 ioa_observe/sdk/utils/json_encoder.py,sha256=g4NQ0tTqgWssY6I1D7r4zo0G6PiUo61jhofTAw5-jno,639
 ioa_observe/sdk/utils/package_check.py,sha256=1d1MjxhwoEZIx9dumirT2pRsEWgn-m-SI4npDeEalew,576
-ioa_observe_sdk-1.0.15.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
-ioa_observe_sdk-1.0.15.dist-info/METADATA,sha256=WwtaLg1AX6BXTs0ar7ru1rJ2GRKfoFMMpv8raR1FNLM,6799
-ioa_observe_sdk-1.0.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ioa_observe_sdk-1.0.15.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
-ioa_observe_sdk-1.0.15.dist-info/RECORD,,
+ioa_observe_sdk-1.0.17.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
+ioa_observe_sdk-1.0.17.dist-info/METADATA,sha256=jarZLIoRaEz4yKIwUHHKmAwL2e7hkKe_uhTTT6iwyiw,7027
+ioa_observe_sdk-1.0.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ioa_observe_sdk-1.0.17.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
+ioa_observe_sdk-1.0.17.dist-info/RECORD,,