veadk-python 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

veadk/tracing/telemetry/attributes/extractors/llm_attributes_extractors.py

@@ -244,8 +244,26 @@ def llm_gen_ai_messages(params: LLMAttributesParams) -> ExtractorResponse:
                                     )
                             if part.inline_data:
                                 if len(content.parts) == 1:
-                                    # TODO(qingliang)
-                                    pass
+                                    part = content.parts[0]
+                                    user_event["gen_ai.user.message"].update(
+                                        {
+                                            "parts.0.type": "image_url",
+                                            "parts.0.image_url.name": (
+                                                part.inline_data.display_name.split(
+                                                    "/"
+                                                )[-1]
+                                                if part.inline_data
+                                                and part.inline_data.display_name
+                                                else "<unknown_image_name>"
+                                            ),
+                                            "parts.0.image_url.url": (
+                                                part.inline_data.display_name
+                                                if part.inline_data
+                                                and part.inline_data.display_name
+                                                else "<unknown_image_url>"
+                                            ),
+                                        }
+                                    )
                                 else:
                                     user_event["gen_ai.user.message"].update(
                                         {

veadk/tracing/telemetry/exporters/apmplus_exporter.py

@@ -12,11 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import time
+from dataclasses import dataclass
 from typing import Any
 
+from google.adk.agents.invocation_context import InvocationContext
 from google.adk.models.llm_request import LlmRequest
 from google.adk.models.llm_response import LlmResponse
-from opentelemetry import metrics
+from opentelemetry import metrics, trace
 from opentelemetry import metrics as metrics_api
 from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
@@ -28,13 +31,100 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from pydantic import BaseModel, Field
 from typing_extensions import override
 
-from veadk.config import getenv
+from veadk.config import settings
 from veadk.tracing.telemetry.exporters.base_exporter import BaseExporter
 from veadk.utils.logger import get_logger
 
 logger = get_logger(__name__)
 
 
+_GEN_AI_CLIENT_OPERATION_DURATION_BUCKETS = [
+    0.01,
+    0.02,
+    0.04,
+    0.08,
+    0.16,
+    0.32,
+    0.64,
+    1.28,
+    2.56,
+    5.12,
+    10.24,
+    20.48,
+    40.96,
+    81.92,
+]
+
+_GEN_AI_SERVER_TIME_PER_OUTPUT_TOKEN_BUCKETS = [
+    0.01,
+    0.025,
+    0.05,
+    0.075,
+    0.1,
+    0.15,
+    0.2,
+    0.3,
+    0.4,
+    0.5,
+    0.75,
+    1.0,
+    2.5,
+]
+
+_GEN_AI_SERVER_TIME_TO_FIRST_TOKEN_BUCKETS = [
+    0.001,
+    0.005,
+    0.01,
+    0.02,
+    0.04,
+    0.06,
+    0.08,
+    0.1,
+    0.25,
+    0.5,
+    0.75,
+    1.0,
+    2.5,
+    5.0,
+    7.5,
+    10.0,
+]
+
+_GEN_AI_CLIENT_TOKEN_USAGE_BUCKETS = [
+    1,
+    4,
+    16,
+    64,
+    256,
+    1024,
+    4096,
+    16384,
+    65536,
+    262144,
+    1048576,
+    4194304,
+    16777216,
+    67108864,
+]
+
+
+@dataclass
+class Meters:
+    LLM_CHAT_COUNT = "gen_ai.chat.count"
+    LLM_TOKEN_USAGE = "gen_ai.client.token.usage"
+    LLM_OPERATION_DURATION = "gen_ai.client.operation.duration"
+    LLM_COMPLETIONS_EXCEPTIONS = "gen_ai.chat_completions.exceptions"
+    LLM_STREAMING_TIME_TO_FIRST_TOKEN = (
+        "gen_ai.chat_completions.streaming_time_to_first_token"
+    )
+    LLM_STREAMING_TIME_TO_GENERATE = (
+        "gen_ai.chat_completions.streaming_time_to_generate"
+    )
+    LLM_STREAMING_TIME_PER_OUTPUT_TOKEN = (
+        "gen_ai.chat_completions.streaming_time_per_output_token"
+    )
+
+
 class MeterUploader:
     def __init__(
         self, name: str, endpoint: str, headers: dict, resource_attributes: dict
@@ -65,17 +155,53 @@ class MeterUploader:
 
         # create meter attributes
         self.llm_invoke_counter = self.meter.create_counter(
-            name="gen_ai.chat.count",
+            name=Meters.LLM_CHAT_COUNT,
             description="Number of LLM invocations",
             unit="count",
         )
         self.token_usage = self.meter.create_histogram(
-            name="gen_ai.client.token.usage",
+            name=Meters.LLM_TOKEN_USAGE,
             description="Token consumption of LLM invocations",
             unit="count",
+            explicit_bucket_boundaries_advisory=_GEN_AI_CLIENT_TOKEN_USAGE_BUCKETS,
+        )
+        self.duration_histogram = self.meter.create_histogram(
+            name=Meters.LLM_OPERATION_DURATION,
+            unit="s",
+            description="GenAI operation duration",
+            explicit_bucket_boundaries_advisory=_GEN_AI_CLIENT_OPERATION_DURATION_BUCKETS,
+        )
+        self.chat_exception_counter = self.meter.create_counter(
+            name=Meters.LLM_COMPLETIONS_EXCEPTIONS,
+            unit="time",
+            description="Number of exceptions occurred during chat completions",
+        )
+        self.streaming_time_to_first_token = self.meter.create_histogram(
+            name=Meters.LLM_STREAMING_TIME_TO_FIRST_TOKEN,
+            unit="s",
+            description="Time to first token in streaming chat completions",
+            explicit_bucket_boundaries_advisory=_GEN_AI_SERVER_TIME_TO_FIRST_TOKEN_BUCKETS,
+        )
+        self.streaming_time_to_generate = self.meter.create_histogram(
+            name=Meters.LLM_STREAMING_TIME_TO_GENERATE,
+            unit="s",
+            description="Time between first token and completion in streaming chat completions",
+            explicit_bucket_boundaries_advisory=_GEN_AI_CLIENT_OPERATION_DURATION_BUCKETS,
+        )
+        self.streaming_time_per_output_token = self.meter.create_histogram(
+            name=Meters.LLM_STREAMING_TIME_PER_OUTPUT_TOKEN,
+            unit="s",
+            description="Time per output token in streaming chat completions",
+            explicit_bucket_boundaries_advisory=_GEN_AI_SERVER_TIME_PER_OUTPUT_TOKEN_BUCKETS,
         )
 
-    def record(self, llm_request: LlmRequest, llm_response: LlmResponse) -> None:
+    def record(
+        self,
+        invocation_context: InvocationContext,
+        event_id: str,
+        llm_request: LlmRequest,
+        llm_response: LlmResponse,
+    ) -> None:
         attributes = {
             "gen_ai_system": "volcengine",
             "gen_ai_response_model": llm_request.model,
@@ -99,22 +225,58 @@ class MeterUploader:
                 token_attributes = {**attributes, "gen_ai_token_type": "output"}
                 self.token_usage.record(output_token, attributes=token_attributes)
 
+            # Get llm duration
+            span = trace.get_current_span()
+            if span and hasattr(span, "start_time") and self.duration_histogram:
+                # We use span start time as the llm request start time
+                tik = span.start_time  # type: ignore
+                # We use current time as the llm request end time
+                tok = time.time_ns()
+                # Calculate duration in seconds
+                duration = (tok - tik) / 1e9
+                self.duration_histogram.record(
+                    duration, attributes=attributes
+                )  # unit in seconds
+
+            # Get model request error
+            if llm_response.error_code and self.chat_exception_counter:
+                exception_attributes = {
+                    **attributes,
+                    "error_type": llm_response.error_message,
+                }
+                self.chat_exception_counter.add(1, exception_attributes)
+
+            # TODO: Get streaming time to first token
+            # time_to_frist_token = 0.1
+            # if self.streaming_time_to_first_token:
+            #     self.streaming_time_to_first_token.record(
+            #         time_to_frist_token, attributes=attributes
+            #     )
+
+            # TODO: Get streaming time to generate
+            # time_to_generate = 1.0
+            # if self.streaming_time_to_generate:
+            #     self.streaming_time_to_generate.record(
+            #         time_to_generate, attributes=attributes
+            #     )
+
+            # TODO: Get streaming time per output token
+            # time_per_output_token = 0.01
+            # if self.streaming_time_per_output_token:
+            #     self.streaming_time_per_output_token.record(
+            #         time_per_output_token, attributes=attributes
+            #     )
+
 
 class APMPlusExporterConfig(BaseModel):
     endpoint: str = Field(
-        default_factory=lambda: getenv(
-            "OBSERVABILITY_OPENTELEMETRY_APMPLUS_ENDPOINT",
-            "http://apmplus-cn-beijing.volces.com:4317",
-        ),
+        default_factory=lambda: settings.apmplus_config.otel_exporter_endpoint,
     )
     app_key: str = Field(
-        default_factory=lambda: getenv("OBSERVABILITY_OPENTELEMETRY_APMPLUS_API_KEY"),
+        default_factory=lambda: settings.apmplus_config.otel_exporter_api_key,
     )
     service_name: str = Field(
-        default_factory=lambda: getenv(
-            "OBSERVABILITY_OPENTELEMETRY_APMPLUS_SERVICE_NAME",
-            "veadk_tracing_service",
-        ),
+        default_factory=lambda: settings.apmplus_config.otel_exporter_service_name,
         description="Service name shown in APMPlus frontend.",
     )
 
@@ -123,6 +285,8 @@ class APMPlusExporter(BaseExporter):
     config: APMPlusExporterConfig = Field(default_factory=APMPlusExporterConfig)
 
     def model_post_init(self, context: Any) -> None:
+        logger.info(f"APMPlusExporter sevice name: {self.config.service_name}")
+
         headers = {
             "x-byteapm-appkey": self.config.app_key,
         }

veadk/tracing/telemetry/exporters/cozeloop_exporter.py

@@ -19,7 +19,7 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from pydantic import BaseModel, Field
 from typing_extensions import override
 
-from veadk.config import getenv
+from veadk.config import settings
 from veadk.tracing.telemetry.exporters.base_exporter import BaseExporter
 from veadk.utils.logger import get_logger
 
@@ -28,18 +28,13 @@ logger = get_logger(__name__)
 
 class CozeloopExporterConfig(BaseModel):
     endpoint: str = Field(
-        default_factory=lambda: getenv(
-            "OBSERVABILITY_OPENTELEMETRY_COZELOOP_ENDPOINT",
-            "https://api.coze.cn/v1/loop/opentelemetry/v1/traces",
-        ),
+        default_factory=lambda: settings.cozeloop_config.otel_exporter_endpoint,
     )
     space_id: str = Field(
-        default_factory=lambda: getenv(
-            "OBSERVABILITY_OPENTELEMETRY_COZELOOP_SERVICE_NAME"
-        ),
+        default_factory=lambda: settings.cozeloop_config.otel_exporter_space_id,
     )
     token: str = Field(
-        default_factory=lambda: getenv("OBSERVABILITY_OPENTELEMETRY_COZELOOP_API_KEY"),
+        default_factory=lambda: settings.cozeloop_config.otel_exporter_api_key,
     )
 
 
@@ -47,6 +42,8 @@ class CozeloopExporter(BaseExporter):
     config: CozeloopExporterConfig = Field(default_factory=CozeloopExporterConfig)
 
     def model_post_init(self, context: Any) -> None:
+        logger.info(f"CozeloopExporter space ID: {self.config.space_id}")
+
         headers = {
             "cozeloop-workspace-id": self.config.space_id,
             "authorization": f"Bearer {self.config.token}",

veadk/tracing/telemetry/exporters/inmemory_exporter.py

@@ -75,11 +75,22 @@ class _InMemoryExporter(export.SpanExporter):
 class _InMemorySpanProcessor(export.SimpleSpanProcessor):
     def __init__(self, exporter: _InMemoryExporter) -> None:
         super().__init__(exporter)
-        self.spans = []
 
     def on_start(self, span, parent_context) -> None:
-        if span.context:
-            self.spans.append(span)
+        if span.name.startswith("invocation"):
+            span.set_attribute("gen_ai.operation.name", "chain")
+            span.set_attribute("gen_ai.usage.total_tokens", 0)
+
+            ctx = set_value("invocation_span_instance", span, context=parent_context)
+            token = attach(ctx)  # mount context on `invocation` root span in Google ADK
+            setattr(span, "_invocation_token", token)  # for later detach
+
+        if span.name.startswith("agent_run"):
+            span.set_attribute("gen_ai.operation.name", "agent")
+
+            ctx = set_value("agent_run_span_instance", span, context=parent_context)
+            token = attach(ctx)
+            setattr(span, "_agent_run_token", token)  # for later detach
 
     def on_end(self, span: ReadableSpan) -> None:
         if span.context:
@@ -92,8 +103,14 @@ class _InMemorySpanProcessor(export.SimpleSpanProcessor):
             except Exception:
                 logger.exception("Exception while exporting Span.")
             detach(token)
-            if span in self.spans:
-                self.spans.remove(span)
+
+            token = getattr(span, "_invocation_token", None)
+            if token:
+                detach(token)
+
+            token = getattr(span, "_agent_run_token", None)
+            if token:
+                detach(token)
 
 
 class InMemoryExporter(BaseExporter):
@@ -106,6 +123,3 @@ class InMemoryExporter(BaseExporter):
 
         self._exporter = _InMemoryExporter()
         self.processor = _InMemorySpanProcessor(self._exporter)
-
-
-_INMEMORY_EXPORTER_INSTANCE = InMemoryExporter()

veadk/tracing/telemetry/exporters/tls_exporter.py

@@ -19,7 +19,7 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from pydantic import BaseModel, Field
 from typing_extensions import override
 
-from veadk.config import getenv
+from veadk.config import getenv, settings
 from veadk.tracing.telemetry.exporters.base_exporter import BaseExporter
 from veadk.utils.logger import get_logger
 
@@ -28,19 +28,13 @@ logger = get_logger(__name__)
 
 class TLSExporterConfig(BaseModel):
     endpoint: str = Field(
-        default_factory=lambda: getenv(
-            "OBSERVABILITY_OPENTELEMETRY_TLS_ENDPOINT",
-            "https://tls-cn-beijing.volces.com:4318/v1/traces",
-        ),
+        default_factory=lambda: settings.tls_config.otel_exporter_endpoint,
     )
     region: str = Field(
-        default_factory=lambda: getenv(
-            "OBSERVABILITY_OPENTELEMETRY_TLS_REGION",
-            "cn-beijing",
-        ),
+        default_factory=lambda: settings.tls_config.otel_exporter_region,
     )
     topic_id: str = Field(
-        default_factory=lambda: getenv("OBSERVABILITY_OPENTELEMETRY_TLS_SERVICE_NAME"),
+        default_factory=lambda: settings.tls_config.otel_exporter_topic_id,
     )
     access_key: str = Field(default_factory=lambda: getenv("VOLCENGINE_ACCESS_KEY"))
     secret_key: str = Field(default_factory=lambda: getenv("VOLCENGINE_SECRET_KEY"))
@@ -50,6 +44,8 @@ class TLSExporter(BaseExporter):
     config: TLSExporterConfig = Field(default_factory=TLSExporterConfig)
 
     def model_post_init(self, context: Any) -> None:
+        logger.info(f"TLSExporter topic ID: {self.config.topic_id}")
+
         headers = {
             "x-tls-otel-tracetopic": self.config.topic_id,
             "x-tls-otel-ak": self.config.access_key,

veadk/tracing/telemetry/opentelemetry_tracer.py

@@ -19,7 +19,6 @@ import time
 from typing import Any
 
 from opentelemetry import trace as trace_api
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk import trace as trace_sdk
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -30,12 +29,10 @@ from typing_extensions import override
 from veadk.tracing.base_tracer import BaseTracer
 from veadk.tracing.telemetry.exporters.apmplus_exporter import APMPlusExporter
 from veadk.tracing.telemetry.exporters.base_exporter import BaseExporter
-from veadk.tracing.telemetry.exporters.inmemory_exporter import (
-    _INMEMORY_EXPORTER_INSTANCE,
-    InMemoryExporter,
-)
+from veadk.tracing.telemetry.exporters.inmemory_exporter import InMemoryExporter
 from veadk.utils.logger import get_logger
 from veadk.utils.patches import patch_google_adk_telemetry
+from veadk.utils.misc import get_temp_dir
 
 logger = get_logger(__name__)
 
@@ -88,7 +85,7 @@ class OpentelemetryTracer(BaseModel, BaseTracer):
         span_processors = global_tracer_provider._active_span_processor._span_processors
         have_apmplus_exporter = any(
             isinstance(p, (BatchSpanProcessor, SimpleSpanProcessor))
-            and isinstance(p.span_exporter, OTLPSpanExporter)
+            and hasattr(p.span_exporter, "_endpoint")
             and "apmplus" in p.span_exporter._endpoint
             for p in span_processors
         )
@@ -119,7 +116,7 @@ class OpentelemetryTracer(BaseModel, BaseTracer):
                     f"Add span processor for exporter `{exporter.__class__.__name__}` to OpentelemetryTracer failed."
                 )
 
-        self._inmemory_exporter = _INMEMORY_EXPORTER_INSTANCE
+        self._inmemory_exporter = InMemoryExporter()
         if self._inmemory_exporter.processor:
             # make sure the in memory exporter processor is added at index 0
             # because we use this to record all spans
@@ -159,7 +156,7 @@ class OpentelemetryTracer(BaseModel, BaseTracer):
         self,
         user_id: str = "unknown_user_id",
         session_id: str = "unknown_session_id",
-        path: str = "/tmp",
+        path: str = get_temp_dir(),
     ) -> str:
         def _build_trace_file_path(path: str, user_id: str, session_id: str) -> str:
             return f"{path}/{self.name}_{user_id}_{session_id}_{self.trace_id}.json"

veadk/tracing/telemetry/telemetry.py

@@ -20,7 +20,8 @@ from google.adk.models.llm_request import LlmRequest
 from google.adk.models.llm_response import LlmResponse
 from google.adk.tools import BaseTool
 from opentelemetry import trace
-from opentelemetry.sdk.trace import _Span
+from opentelemetry.context import get_value
+from opentelemetry.sdk.trace import Span, _Span
 
 from veadk.tracing.telemetry.attributes.attributes import ATTRIBUTES
 from veadk.tracing.telemetry.attributes.extractors.types import (
@@ -28,16 +29,14 @@ from veadk.tracing.telemetry.attributes.extractors.types import (
     LLMAttributesParams,
     ToolAttributesParams,
 )
-from veadk.tracing.telemetry.exporters.inmemory_exporter import (
-    _INMEMORY_EXPORTER_INSTANCE,
-)
 from veadk.utils.logger import get_logger
 
 logger = get_logger(__name__)
 
 
-def upload_metrics(
+def _upload_metrics(
     invocation_context: InvocationContext,
+    event_id: str,
     llm_request: LlmRequest,
     llm_response: LlmResponse,
 ) -> None:
@@ -48,11 +47,13 @@ def upload_metrics(
         for tracer in tracers:
             for exporter in getattr(tracer, "exporters", []):
                 if getattr(exporter, "meter_uploader", None):
-                    exporter.meter_uploader.record(llm_request, llm_response)
+                    exporter.meter_uploader.record(
+                        invocation_context, event_id, llm_request, llm_response
+                    )
 
 
 def _set_agent_input_attribute(
-    span: _Span, invocation_context: InvocationContext
+    span: Span, invocation_context: InvocationContext
 ) -> None:
     # We only save the original user input as the agent input
     # hence once the `agent.input` has been set, we don't overwrite it
@@ -106,7 +107,7 @@ def _set_agent_input_attribute(
                 )
 
 
-def _set_agent_output_attribute(span: _Span, llm_response: LlmResponse) -> None:
+def _set_agent_output_attribute(span: Span, llm_response: LlmResponse) -> None:
     content = llm_response.content
     if content and content.parts:
         for idx, part in enumerate(content.parts):
@@ -126,64 +127,64 @@ def set_common_attributes_on_model_span(
     current_span: _Span,
     **kwargs,
 ) -> None:
-    if current_span.context:
-        current_span_id = current_span.context.trace_id
-    else:
-        logger.warning(
-            "Current span context is missing, failed to get `trace_id` to set common attributes."
-        )
-        return
-
+    common_attributes = ATTRIBUTES.get("common", {})
     try:
-        spans = _INMEMORY_EXPORTER_INSTANCE.processor.spans  # type: ignore
-
-        spans_in_current_trace = [
-            span
-            for span in spans
-            if span.context and span.context.trace_id == current_span_id
-        ]
-
-        common_attributes = ATTRIBUTES.get("common", {})
-        for span in spans_in_current_trace:
-            if span.is_recording():
-                if span.name.startswith("invocation"):
-                    span.set_attribute("gen_ai.operation.name", "chain")
-                    _set_agent_input_attribute(span, invocation_context)
-                    _set_agent_output_attribute(span, llm_response)
-                elif span.name.startswith("agent_run"):
-                    span.set_attribute("gen_ai.operation.name", "agent")
-                    _set_agent_input_attribute(span, invocation_context)
-                    _set_agent_output_attribute(span, llm_response)
-                for attr_name, attr_extractor in common_attributes.items():
-                    value = attr_extractor(**kwargs)
-                    span.set_attribute(attr_name, value)
+        invocation_span: Span = get_value("invocation_span_instance")  # type: ignore
+        agent_run_span: Span = get_value("agent_run_span_instance")  # type: ignore
+
+        if invocation_span and invocation_span.name.startswith("invocation"):
+            _set_agent_input_attribute(invocation_span, invocation_context)
+            _set_agent_output_attribute(invocation_span, llm_response)
+            for attr_name, attr_extractor in common_attributes.items():
+                value = attr_extractor(**kwargs)
+                invocation_span.set_attribute(attr_name, value)
+
+            # Calculate the token usage for the whole invocation span
+            current_step_token_usage = (
+                llm_response.usage_metadata.total_token_count
+                if llm_response.usage_metadata
+                and llm_response.usage_metadata.total_token_count
+                else 0
+            )
+            prev_total_token_usage = (
+                invocation_span.attributes["gen_ai.usage.total_tokens"]
+                if invocation_span.attributes
+                else 0
+            )
+            accumulated_total_token_usage = (
+                current_step_token_usage + int(prev_total_token_usage)  # type: ignore
+            )  # we can ignore this warning, cause we manually set the attribute to int before
+            invocation_span.set_attribute(
+                "gen_ai.usage.total_tokens", accumulated_total_token_usage
+            )
+
+        if agent_run_span and agent_run_span.name.startswith("agent_run"):
+            _set_agent_input_attribute(agent_run_span, invocation_context)
+            _set_agent_output_attribute(agent_run_span, llm_response)
+            for attr_name, attr_extractor in common_attributes.items():
+                value = attr_extractor(**kwargs)
+                agent_run_span.set_attribute(attr_name, value)
+
+        for attr_name, attr_extractor in common_attributes.items():
+            value = attr_extractor(**kwargs)
+            current_span.set_attribute(attr_name, value)
     except Exception as e:
         logger.error(f"Failed to set common attributes for spans: {e}")
 
 
 def set_common_attributes_on_tool_span(current_span: _Span) -> None:
-    # find parent span (generally a llm span)
-    if not current_span.context:
-        logger.warning(
-            f"Get tool span's context failed. Skip setting common attributes for span {current_span.name}"
-        )
-        return
-
-    if not current_span.parent:
-        logger.warning(
-            f"Get tool span's parent failed. Skip setting common attributes for span {current_span.name}"
-        )
-        return
-
-    parent_span_id = current_span.parent.span_id
-    for span in _INMEMORY_EXPORTER_INSTANCE.processor.spans:  # type: ignore
-        if span.context.span_id == parent_span_id:
-            common_attributes = ATTRIBUTES.get("common", {})
-            for attr_name in common_attributes.keys():
-                current_span.set_attribute(attr_name, span.attributes[attr_name])
+    common_attributes = ATTRIBUTES.get("common", {})
 
+    invocation_span: Span = get_value("invocation_span_instance")  # type: ignore
 
-def trace_send_data(): ...
+    for attr_name in common_attributes.keys():
+        if (
+            invocation_span
+            and invocation_span.name.startswith("invocation")
+            and invocation_span.attributes
+            and attr_name in invocation_span.attributes
+        ):
+            current_span.set_attribute(attr_name, invocation_span.attributes[attr_name])
 
 
 def trace_tool_call(
@@ -209,7 +210,7 @@ def trace_call_llm(
     llm_request: LlmRequest,
     llm_response: LlmResponse,
 ) -> None:
-    span = trace.get_current_span()
+    span: Span = trace.get_current_span()  # type: ignore
 
     from veadk.agent import Agent
 
@@ -231,6 +232,7 @@ def trace_call_llm(
             span.context.trace_state.get("call_type", "")
             if (
                 hasattr(span, "context")
+                and span.context
                 and hasattr(span.context, "trace_state")
                 and hasattr(span.context.trace_state, "get")
             )
@@ -250,4 +252,8 @@ def trace_call_llm(
         response: ExtractorResponse = attr_extractor(params)
         ExtractorResponse.update_span(span, attr_name, response)
 
-    upload_metrics(invocation_context, llm_request, llm_response)
+    _upload_metrics(invocation_context, event_id, llm_request, llm_response)
+
+
+# Do not modify this function
+def trace_send_data(): ...

veadk/utils/logger.py

@@ -16,7 +16,7 @@ import sys
 
 from loguru import logger
 
-from veadk.config import getenv
+from veadk.utils.misc import getenv
 
 
 def filter_log():