openinference-instrumentation-beeai 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

{openinference_instrumentation_beeai-0.1.5.dist-info → openinference_instrumentation_beeai-0.1.7.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: openinference-instrumentation-beeai
-Version: 0.1.5
+Version: 0.1.7
 Summary: OpenInference BeeAI Instrumentation
 Project-URL: Homepage, https://github.com/Arize-ai/openinference/tree/main/python/instrumentation/openinference-instrumentation-beeai
-Author-email: Milan Gallas <gallas.milan@gmail.com>
+Author: IBM Corp.
+Maintainer-email: Tomas Dvorak <toomas2d@gmail.com>
 License-Expression: Apache-2.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -14,16 +15,18 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.14,>=3.11
-Requires-Dist: openinference-instrumentation>=0.1.27
-Requires-Dist: openinference-semantic-conventions>=0.1.17
-Requires-Dist: opentelemetry-api>=1.31.1
-Requires-Dist: opentelemetry-instrumentation>=0.52b1
-Requires-Dist: opentelemetry-semantic-conventions>=0.52b1
+Requires-Dist: beeai-framework<0.2.0,>=0.1.32
+Requires-Dist: openinference-instrumentation>=0.1.36
+Requires-Dist: openinference-semantic-conventions>=0.1.21
+Requires-Dist: opentelemetry-api>=1.36.0
+Requires-Dist: opentelemetry-instrumentation>=0.57b0
+Requires-Dist: opentelemetry-semantic-conventions>=0.57b0
 Requires-Dist: wrapt>=1.17.2
 Provides-Extra: instruments
-Requires-Dist: beeai-framework[duckduckgo,wikipedia]==0.1.18; extra == 'instruments'
+Requires-Dist: beeai-framework>=0.1.32; extra == 'instruments'
 Provides-Extra: test
-Requires-Dist: beeai-framework[duckduckgo,wikipedia]==0.1.18; extra == 'test'
+Requires-Dist: beeai-framework>=0.1.32; extra == 'test'
+Requires-Dist: opentelemetry-exporter-otlp; extra == 'test'
 Requires-Dist: opentelemetry-sdk; extra == 'test'
 Description-Content-Type: text/markdown
 

openinference_instrumentation_beeai-0.1.7.dist-info/RECORD

@@ -0,0 +1,21 @@
+openinference/instrumentation/beeai/__init__.py,sha256=5_bUn-XMonUXUgbbqU_PrGyW2ojiWQD7LUvjB7B-g0A,4467
+openinference/instrumentation/beeai/_span.py,sha256=VZfoQHDUlAeyHxI7MnQ6QGq2LwhHiI1AQ2Uw_4Dn5Zw,2750
+openinference/instrumentation/beeai/_utils.py,sha256=nZQkVv1QTNVYu23EqEaRkYtncmpE4LLqEH_xCoHzM3c,2247
+openinference/instrumentation/beeai/version.py,sha256=YpKDcdV7CqL8n45u267wKtyloM13FSVbOdrqgNZnSLM,22
+openinference/instrumentation/beeai/processors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openinference/instrumentation/beeai/processors/base.py,sha256=akaQCsZmbapEC5tctD_VXWiBOu2pYHFRJRZ_pynpApc,2176
+openinference/instrumentation/beeai/processors/chat.py,sha256=yyNjoG3AY2XPNHr6t2JJEwmx5NCibc3ThsWBL8lIuTU,9082
+openinference/instrumentation/beeai/processors/embedding.py,sha256=T9fZs2M7qEs4SnLYbSXRbhe3P7rCNch-snRQBDSC9Es,2598
+openinference/instrumentation/beeai/processors/locator.py,sha256=G9TFW_HgXM1TrOVdvtRU2Eq3D-atHLAET4fSo4F02X8,3635
+openinference/instrumentation/beeai/processors/requirement.py,sha256=Q9DgHDd-5rmP88Fe00d7cNKQg5zQ7ILuRzVAej5xfmk,2666
+openinference/instrumentation/beeai/processors/tool.py,sha256=LmYD9Oj9l_jRZEXoTyfMSykZQum0EHdBZOW6AtiPoHE,2720
+openinference/instrumentation/beeai/processors/workflow.py,sha256=OMwFFHv3mp4M4hFvH7utYd_fiSkTnBcl2oUVaMEdy-A,3815
+openinference/instrumentation/beeai/processors/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openinference/instrumentation/beeai/processors/agents/base.py,sha256=3fidrUoU9pVixq9YN_y1jkNMozNMX-YG2CMuh855cLk,1244
+openinference/instrumentation/beeai/processors/agents/react.py,sha256=rS3xlvgyZ5G6MyDMeSh4xFLT_66h7GVAYEYlwZCpIdY,3022
+openinference/instrumentation/beeai/processors/agents/requirement_agent.py,sha256=HpleY8pNWojuUqcae2PZgat7Xq2edU9C-uz0YjZQUyc,2774
+openinference/instrumentation/beeai/processors/agents/tool_calling.py,sha256=yaWP5JmGuvZIha9iUSKgv0MJgI0QSbuiJLLQFnbqUZw,1223
+openinference_instrumentation_beeai-0.1.7.dist-info/METADATA,sha256=j0D1RjhUiFGl8lZ8vzgQzt_yGWaZO1-2eQVDe6maZdI,5491
+openinference_instrumentation_beeai-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+openinference_instrumentation_beeai-0.1.7.dist-info/entry_points.txt,sha256=ee7EUhbWv-XK1dxhPXuFVy9qstzj-lc-265Phe2Ml9s,183
+openinference_instrumentation_beeai-0.1.7.dist-info/RECORD,,

openinference/instrumentation/beeai/middleware.py

@@ -1,291 +0,0 @@
-# Copyright 2025 IBM Corp.
-#
-# 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.
-
-import logging
-import time
-from datetime import datetime, timezone
-from importlib.metadata import PackageNotFoundError, version
-from typing import Any, Callable, Dict, Optional, cast
-
-from beeai_framework.agents.base import BaseAgent
-from beeai_framework.agents.react.agent import ReActAgent
-from beeai_framework.agents.react.events import ReActAgentSuccessEvent
-from beeai_framework.agents.tool_calling.agent import ToolCallingAgent
-from beeai_framework.agents.tool_calling.events import ToolCallingAgentSuccessEvent
-from beeai_framework.backend import Role
-from beeai_framework.context import RunContext
-from beeai_framework.emitter import EventMeta
-from beeai_framework.errors import FrameworkError
-
-from openinference.instrumentation import OITracer
-from openinference.semconv.trace import OpenInferenceSpanKindValues, SpanAttributes
-
-from .utils.build_trace_tree import build_trace_tree
-from .utils.create_span import FrameworkSpan, create_span
-from .utils.get_serialized_object_safe import get_serialized_object_safe
-from .utils.id_name_manager import IdNameManager
-
-try:
-    Version = version("beeai-framework")
-except PackageNotFoundError:
-    Version = "unknown"
-
-id_name_manager = IdNameManager()
-active_traces_map: Dict[str, str] = {}
-
-logger = logging.getLogger(__name__)
-
-
-def create_telemetry_middleware(
-    tracer: OITracer, main_span_kind: str
-) -> Callable[[RunContext], None]:
-    def middleware(context: RunContext) -> None:
-        trace_obj = getattr(context.emitter, "trace", None)
-        trace_id = getattr(trace_obj, "id", None)
-        if not trace_id:
-            raise FrameworkError("Fatal error. Missing traceId", context=context.__dict__)
-
-        emitter = context.emitter
-        run_params = context.run_params
-        instance = context.instance
-
-        if trace_id in active_traces_map:
-            return
-        active_traces_map[trace_id] = type(instance).__name__
-        base_path = ".".join(emitter.namespace)
-        prompt = None
-        if isinstance(instance, BaseAgent):
-            prompt = run_params.get("prompt") if isinstance(run_params, dict) else None
-
-        spans_map: Dict[str, FrameworkSpan] = {}
-        parent_ids_map: dict[str, int] = {}
-        spans_to_delete_map: set[str] = set()
-        events_iterations_map: dict[str, dict[str, str]] = {}
-
-        def clean_span_sources(span_id: str) -> None:
-            span = spans_map.get(span_id)
-            parent_id = span.get("parent_id") if span else None
-            if not parent_id:
-                return
-
-            span_count = parent_ids_map.get(parent_id)
-            if not span_count:
-                return
-
-            if span_count > 1:
-                parent_ids_map[parent_id] = span_count - 1
-            elif span_count == 1:
-                parent_ids_map.pop(parent_id)
-                if parent_id in spans_to_delete_map:
-                    spans_map.pop(parent_id, None)
-                    spans_to_delete_map.discard(parent_id)
-
-        history: list[dict[str, Any]] = []
-        generated_message: Optional[dict[str, Any]] = None
-        group_iterations = []
-
-        start_time_perf = time.time_ns()
-
-        def datetime_to_ns(dt: datetime) -> int:
-            epoch = datetime(1970, 1, 1, tzinfo=timezone.utc)
-            return int((dt - epoch).total_seconds() * 1e9)
-
-        def on_finish(_data: Any, _meta: EventMeta) -> None:
-            nonlocal prompt
-            try:
-                if not prompt and isinstance(instance, BaseAgent):
-                    prompt = next(
-                        (m.text for m in reversed(instance.memory.messages) if m.role == Role.USER),
-                        None,
-                    )
-                    if not prompt:
-                        raise FrameworkError("The prompt must be defined", context=context.__dict__)
-
-                ## This would call your tree-building logic
-                build_trace_tree(
-                    tracer=tracer,
-                    main_span_kind=main_span_kind,
-                    data={
-                        "prompt": prompt,
-                        "history": history,
-                        "generatedMessage": generated_message,
-                        "spans": list(spans_map.values()),
-                        "traceId": trace_id,
-                        "version": Version,
-                        "startTime": start_time_perf,
-                        "endTime": time.time_ns(),
-                        "source": active_traces_map.get(trace_id),
-                        "run_error_span_key": f"run.{base_path}.error",
-                    },
-                )
-            except Exception as e:
-                logger.error("Instrumentation send data error", exc_info=e)
-            finally:
-                del active_traces_map[trace_id]
-
-        emitter.match(f"run.{base_path}.finish", on_finish)
-
-        def on_any_event(data: Any, meta: EventMeta) -> None:
-            nonlocal context
-            if meta.path.startswith("run.") and meta.name != "run.error":
-                return
-
-            if meta.name == "new_token":
-                return
-
-            if not getattr(meta.trace, "run_id", None):
-                raise FrameworkError(
-                    f"Fatal error. Missing run_id for event: {meta.path}", context=context.__dict__
-                )
-
-            try:
-                iteration_event_name = meta.group_id.strip("`") if meta.group_id else meta.group_id
-                if (
-                    iteration_event_name
-                    and not getattr(meta.trace, "parent_run_id", None)
-                    and iteration_event_name not in group_iterations
-                ):
-                    spans_map[iteration_event_name] = create_span(
-                        id=iteration_event_name,
-                        name=iteration_event_name,
-                        target="groupId",
-                        data={
-                            SpanAttributes.OPENINFERENCE_SPAN_KIND: OpenInferenceSpanKindValues.CHAIN.value  # noqa: E501
-                        },
-                        started_at=datetime_to_ns(meta.created_at),
-                    )
-                    group_iterations.append(iteration_event_name)
-
-                ids = id_name_manager.get_ids(
-                    path=meta.path,
-                    id=meta.id,
-                    run_id=meta.trace.run_id,  # type: ignore
-                    parent_run_id=getattr(meta.trace, "parent_run_id", None),
-                    group_id=iteration_event_name,
-                )
-
-                span_id = ids["spanId"]
-                parent_span_id = ids["parentSpanId"]
-
-                serialized_data = get_serialized_object_safe(data, meta)
-                # Skip partialUpdate events with no data
-                if meta.name == "partial_update" and not serialized_data:
-                    return
-
-                span = create_span(
-                    id=span_id,
-                    name=meta.name,
-                    target=meta.path,
-                    parent={"id": parent_span_id} if parent_span_id else None,
-                    ctx=getattr(meta, "context", None),
-                    data=serialized_data,
-                    started_at=datetime_to_ns(meta.created_at),
-                )
-                spans_map[span["context"]["span_id"]] = span
-
-                last_iteration = group_iterations[-1] if group_iterations else None
-
-                # Clean up `partial_update` event if no nested spans
-                last_iteration_event_span_id: Optional[str] = (
-                    events_iterations_map.get(last_iteration, {}).get(meta.name)
-                    if last_iteration is not None
-                    else None
-                )
-
-                if (
-                    last_iteration_event_span_id
-                    and meta.name == "partial_update"
-                    and last_iteration_event_span_id in spans_map
-                ):
-                    if span_id and span_id in parent_ids_map:
-                        spans_to_delete_map.add(last_iteration_event_span_id)
-                    else:
-                        clean_span_sources(last_iteration_event_span_id)
-                        spans_map.pop(last_iteration_event_span_id, None)
-
-                # Create new span
-                spans_map[span["context"]["span_id"]] = span
-
-                # Update parent count
-                if span.get("parent_id"):
-                    parent_id = span["parent_id"]
-                    if parent_id is not None:
-                        parent_ids_map[parent_id] = parent_ids_map.get(parent_id, 0) + 1
-
-                # Save the last event for each iteration
-                if group_iterations:
-                    if last_iteration in events_iterations_map:
-                        events_iterations_map[last_iteration][meta.name] = span["context"][
-                            "span_id"
-                        ]
-                    elif last_iteration is not None:
-                        events_iterations_map[last_iteration] = {
-                            meta.name: span["context"]["span_id"]
-                        }
-
-            except Exception as e:
-                logger.error("Instrumentation build data error", exc_info=e)
-
-        emitter.match("*.*", on_any_event)
-
-        def is_success_event(event: Any) -> bool:
-            return getattr(event, "name", None) == "success" and isinstance(
-                getattr(event, "creator", None), BaseAgent
-            )
-
-        def on_success(data: Any, meta: EventMeta) -> None:
-            nonlocal generated_message, history
-            try:
-                if isinstance(meta.creator, ToolCallingAgent):
-                    tool_calling_typed_data = cast(ToolCallingAgentSuccessEvent, data)
-                    history = [
-                        {
-                            "text": m.text,
-                            "role": m.role.value if hasattr(m.role, "value") else m.role,
-                        }
-                        for m in tool_calling_typed_data.state.memory.messages
-                    ]
-                    if (
-                        hasattr(tool_calling_typed_data.state, "result")
-                        and tool_calling_typed_data.state.result is not None
-                    ):
-                        result_role = tool_calling_typed_data.state.result.role
-                        generated_message = {
-                            "role": result_role.value
-                            if hasattr(result_role, "value")
-                            else result_role,
-                            "text": tool_calling_typed_data.state.result.text,
-                        }
-                if isinstance(meta.creator, ReActAgent):
-                    react_agent_typed_data = cast(ReActAgentSuccessEvent, data)
-                    tooling_result_role = react_agent_typed_data.data.role
-                    generated_message = {
-                        "role": tooling_result_role.value
-                        if hasattr(tooling_result_role, "value")
-                        else tooling_result_role,
-                        "text": react_agent_typed_data.data.text,
-                    }
-                    history = [
-                        {
-                            "text": m.text,
-                            "role": m.role.value if hasattr(m.role, "value") else m.role,
-                        }
-                        for m in react_agent_typed_data.memory.messages
-                    ]
-            except Exception as e:
-                logger.error("Instrumentation error: failed to extract success message", exc_info=e)
-
-        emitter.match(is_success_event, on_success)
-
-    return middleware

openinference/instrumentation/beeai/utils/build_trace_tree.py

@@ -1,170 +0,0 @@
-# Copyright 2025 IBM Corp.
-#
-# 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.
-
-from typing import Any, List, Optional, TypedDict
-
-from opentelemetry import trace
-
-from openinference.instrumentation import OITracer
-from openinference.semconv.trace import OpenInferenceSpanKindValues, SpanAttributes
-
-from .create_span import FrameworkSpan
-
-
-class BuildTraceTreeData(TypedDict):
-    prompt: Optional[str]
-    history: list[dict[str, Any]]
-    generatedMessage: dict[str, Any] | None
-    spans: List[FrameworkSpan]
-    traceId: str
-    version: str
-    startTime: int
-    endTime: int
-    source: Optional[str]
-    run_error_span_key: str
-
-
-def build_spans_for_parent(
-    tracer: OITracer, spans: List[FrameworkSpan], trace_id: str, parent_id: str | None
-) -> None:
-    children = [s for s in spans if s.get("parent_id") == parent_id]
-
-    for span in children:
-        attributes = {
-            "target": span["attributes"]["target"],
-            "name": span.get("name"),
-            "traceId": trace_id,
-        }
-
-        if span["attributes"]["metadata"]:
-            attributes["metadata"] = str(span["attributes"]["metadata"])
-
-        if span["attributes"]["data"]:
-            attributes.update(span["attributes"]["data"])
-
-        with tracer.start_as_current_span(
-            name=span["context"]["span_id"],
-            attributes={k: v for k, v in attributes.items() if v is not None},
-            start_time=span.get("start_time"),
-        ) as current_child:
-            status = span.get("status")
-            if status is not None:
-                current_child.set_status(status["code"])
-            build_spans_for_parent(
-                tracer=tracer,
-                spans=spans,
-                trace_id=trace_id,
-                parent_id=span["context"]["span_id"],
-            )
-
-
-def build_agent_main_span_data(data: BuildTraceTreeData) -> dict[str, Any]:
-    payload = {}
-    if data.get("prompt"):
-        payload[SpanAttributes.INPUT_VALUE] = data.get("prompt")
-    if data.get("generatedMessage"):
-        payload[SpanAttributes.OUTPUT_VALUE] = str(data.get("generatedMessage"))
-    if data.get("history"):
-        payload["history"] = str(data.get("history"))
-    return payload
-
-
-def build_tool_main_span_data(data: BuildTraceTreeData) -> dict[str, Any]:
-    start_span = next((s for s in data["spans"] if s["name"] == "start"), None)
-    success_span = next((s for s in data["spans"] if s["name"] == "success"), None)
-
-    payload = {}
-    if start_span and start_span["attributes"]["data"] is not None:
-        tool_params = start_span["attributes"]["data"].get(SpanAttributes.TOOL_PARAMETERS)
-        payload[SpanAttributes.INPUT_VALUE] = tool_params
-        payload[SpanAttributes.TOOL_PARAMETERS] = tool_params
-    if success_span and success_span["attributes"]["data"] is not None:
-        payload[SpanAttributes.OUTPUT_VALUE] = success_span["attributes"]["data"].get(
-            SpanAttributes.OUTPUT_VALUE
-        )
-    return payload
-
-
-def build_llm_main_span_data(data: BuildTraceTreeData) -> dict[str, Any]:
-    start_span = next((s for s in data["spans"] if s["name"] == "start"), None)
-    success_span = next((s for s in data["spans"] if s["name"] == "success"), None)
-    provider = None
-    model_name = None
-
-    if start_span and start_span["attributes"]["data"] is not None:
-        provider = start_span["attributes"]["data"].get(SpanAttributes.LLM_PROVIDER)
-        model_name = start_span["attributes"]["data"].get(SpanAttributes.LLM_MODEL_NAME)
-
-    if success_span and success_span["attributes"]["data"] is not None:
-        provider = provider or success_span["attributes"]["data"].get(SpanAttributes.LLM_PROVIDER)
-        model_name = model_name or success_span["attributes"]["data"].get(
-            SpanAttributes.LLM_MODEL_NAME
-        )
-
-    payload = {}
-    if start_span and start_span["attributes"]["data"] is not None:
-        payload[SpanAttributes.INPUT_VALUE] = start_span["attributes"]["data"].get(
-            SpanAttributes.INPUT_VALUE
-        )
-        payload[SpanAttributes.INPUT_MIME_TYPE] = start_span["attributes"]["data"].get(
-            SpanAttributes.INPUT_MIME_TYPE
-        )
-    if success_span and success_span["attributes"]["data"] is not None:
-        payload[SpanAttributes.OUTPUT_VALUE] = success_span["attributes"]["data"].get(
-            SpanAttributes.OUTPUT_VALUE
-        )
-        payload[SpanAttributes.OUTPUT_MIME_TYPE] = success_span["attributes"]["data"].get(
-            SpanAttributes.OUTPUT_MIME_TYPE
-        )
-    if provider:
-        payload[SpanAttributes.LLM_PROVIDER] = provider
-    if model_name:
-        payload[SpanAttributes.LLM_MODEL_NAME] = model_name
-
-    return payload
-
-
-def build_trace_tree(tracer: OITracer, main_span_kind: str, data: BuildTraceTreeData) -> None:
-    if main_span_kind == OpenInferenceSpanKindValues.AGENT.value:
-        computed_data = build_agent_main_span_data(data)
-    elif main_span_kind == OpenInferenceSpanKindValues.TOOL.value:
-        computed_data = build_tool_main_span_data(data)
-    elif main_span_kind == OpenInferenceSpanKindValues.LLM.value:
-        computed_data = build_llm_main_span_data(data)
-    else:
-        computed_data = {}
-
-    attributes = {
-        "source": data["source"],
-        "traceId": data["traceId"],
-        SpanAttributes.OPENINFERENCE_SPAN_KIND: main_span_kind,
-        "beeai.version": data["version"],
-        **computed_data,
-    }
-
-    with tracer.start_as_current_span(
-        name="beeai-framework-main",
-        start_time=data["startTime"],
-        attributes=attributes,
-    ) as current_span:
-        run_error_span = next(
-            (s for s in data["spans"] if s["attributes"]["target"] == data["run_error_span_key"]),
-            None,
-        )
-        if run_error_span is not None:
-            current_span.set_status(trace.StatusCode.ERROR)
-        else:
-            current_span.set_status(trace.StatusCode.OK)
-
-        build_spans_for_parent(tracer, data["spans"], data["traceId"], parent_id=None)

openinference/instrumentation/beeai/utils/create_span.py

@@ -1,80 +0,0 @@
-# Copyright 2025 IBM Corp.
-#
-# 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.
-
-import time
-from typing import Any, Dict, Optional, TypedDict
-
-from opentelemetry.trace import StatusCode
-
-
-class SpanContext(TypedDict):
-    span_id: str
-
-
-class SpanStatus(TypedDict):
-    code: StatusCode
-    message: str
-
-
-class SpanAttributes(TypedDict, total=False):
-    target: str
-    metadata: Optional[Dict[str, Any]]
-    data: Optional[Dict[str, Any]]
-    exception_message: Optional[str]
-    exception_type: Optional[str]
-
-
-class FrameworkSpan(TypedDict):
-    name: str
-    attributes: SpanAttributes
-    context: SpanContext
-    parent_id: Optional[str]
-    status: SpanStatus
-    start_time: int
-    end_time: int
-
-
-def create_span(
-    *,
-    id: str,
-    name: str,
-    target: str,
-    started_at: int,
-    ctx: Optional[Dict[str, Any]] = None,
-    data: Optional[Dict[str, Any]] = None,
-    error: Optional[str] = None,
-    parent: Optional[Dict[str, str]] = None,
-) -> FrameworkSpan:
-    attributes: SpanAttributes = {
-        "target": target,
-        "metadata": ctx if ctx else None,
-        "data": data if data else None,
-    }
-
-    if error:
-        attributes["exception_message"] = error
-        attributes["exception_type"] = "FrameworkError"
-
-    return {
-        "name": name,
-        "attributes": attributes,
-        "context": {"span_id": id},
-        "parent_id": parent["id"] if parent else None,
-        "status": {
-            "code": StatusCode.ERROR if error else StatusCode.OK,
-            "message": error or "",
-        },
-        "start_time": started_at,
-        "end_time": time.time_ns(),
-    }