mseep-agentops 0.4.18__py3-none-any.whl → 0.4.23__py3-none-any.whl

agentops/instrumentation/agentic/agno/__init__.py

@@ -0,0 +1,19 @@
+"""Agno Agent instrumentation package."""
+
+import logging
+from agentops.instrumentation.common import LibraryInfo
+
+from .instrumentor import AgnoInstrumentor
+
+logger = logging.getLogger(__name__)
+
+# Library information
+_library_info = LibraryInfo(name="agno", default_version="1.5.8")
+LIBRARY_NAME = _library_info.name
+LIBRARY_VERSION = _library_info.version
+
+__all__ = [
+    "AgnoInstrumentor",
+    "LIBRARY_NAME",
+    "LIBRARY_VERSION",
+]

agentops/instrumentation/agentic/agno/attributes/__init__.py

@@ -0,0 +1,20 @@
+"""Agno instrumentation attribute handlers."""
+
+from .agent import get_agent_run_attributes
+from .metrics import get_metrics_attributes
+from .team import get_team_run_attributes
+from .tool import get_tool_execution_attributes
+from .workflow import get_workflow_run_attributes, get_workflow_session_attributes, get_workflow_cache_attributes
+from .storage import get_storage_read_attributes, get_storage_write_attributes
+
+__all__ = [
+    "get_agent_run_attributes",
+    "get_metrics_attributes",
+    "get_team_run_attributes",
+    "get_tool_execution_attributes",
+    "get_workflow_run_attributes",
+    "get_workflow_session_attributes",
+    "get_workflow_cache_attributes",
+    "get_storage_read_attributes",
+    "get_storage_write_attributes",
+]

agentops/instrumentation/agentic/agno/attributes/agent.py

@@ -0,0 +1,250 @@
+"""Agno Agent run attributes handler."""
+
+from typing import Optional, Tuple, Dict, Any
+from agentops.instrumentation.common.attributes import AttributeMap
+from agentops.semconv import SpanAttributes, AgentAttributes, ToolAttributes
+from agentops.semconv.span_kinds import SpanKind as AgentOpsSpanKind
+import json
+
+
+def get_agent_run_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> AttributeMap:
+    """Extract span attributes for Agent.run/arun calls.
+
+    Args:
+        args: Positional arguments passed to the run method (self, message, ...)
+        kwargs: Keyword arguments passed to the run method
+        return_value: The return value from the run method (RunResponse)
+
+    Returns:
+        A dictionary of span attributes to be set on the agent span
+    """
+    attributes: AttributeMap = {}
+
+    # Initialize variables to avoid UnboundLocalError
+    agent_name = None
+
+    # Base attributes
+    attributes[SpanAttributes.AGENTOPS_SPAN_KIND] = AgentOpsSpanKind.AGENT
+    attributes[SpanAttributes.LLM_SYSTEM] = "agno"
+
+    # AgentOps entity attributes
+    attributes[SpanAttributes.AGENTOPS_ENTITY_NAME] = "agent"
+
+    # Extract agent information from args[0] (self)
+    if args and len(args) >= 1:
+        agent = args[0]
+
+        # Core agent identification - set directly at root level
+        if hasattr(agent, "agent_id") and agent.agent_id:
+            agent_id = str(agent.agent_id)
+            attributes[AgentAttributes.AGENT_ID] = agent_id
+
+        if hasattr(agent, "name") and agent.name:
+            agent_name = str(agent.name)
+            attributes[AgentAttributes.AGENT_NAME] = agent_name
+
+        if hasattr(agent, "role") and agent.role:
+            agent_role = str(agent.role)
+            attributes[AgentAttributes.AGENT_ROLE] = agent_role
+
+        # Check if agent is part of a team
+        if hasattr(agent, "_team") and agent._team:
+            team = agent._team
+            if hasattr(team, "name") and team.name:
+                attributes["agent.parent_team"] = str(team.name)
+                attributes["agent.parent_team_display"] = f"Under {team.name}"
+            if hasattr(team, "team_id") and team.team_id:
+                attributes["agent.parent_team_id"] = str(team.team_id)
+
+        # Model information -
+        if hasattr(agent, "model") and agent.model:
+            model = agent.model
+            if hasattr(model, "id"):
+                model_id = str(model.id)
+                attributes[SpanAttributes.LLM_REQUEST_MODEL] = model_id
+                attributes[SpanAttributes.LLM_RESPONSE_MODEL] = model_id
+
+            if hasattr(model, "provider"):
+                model_provider = str(model.provider)
+                attributes["agent.model_provider"] = model_provider
+
+        # Agent configuration details - set directly at root level
+        if hasattr(agent, "description") and agent.description:
+            attributes["agent.description"] = str(agent.description)
+        if hasattr(agent, "goal") and agent.goal:
+            attributes["agent.goal"] = str(agent.goal)
+
+        if hasattr(agent, "instructions") and agent.instructions:
+            if isinstance(agent.instructions, list):
+                attributes["agent.instruction"] = " | ".join(str(i) for i in agent.instructions)
+            else:
+                attributes["agent.instruction"] = str(agent.instructions)
+        if hasattr(agent, "expected_output") and agent.expected_output:
+            attributes["agent.expected_output"] = str(agent.expected_output)
+
+        if hasattr(agent, "markdown"):
+            attributes["agent.markdown"] = str(agent.markdown)
+
+        if hasattr(agent, "reasoning"):
+            attributes[AgentAttributes.AGENT_REASONING] = str(agent.reasoning)
+
+        if hasattr(agent, "stream"):
+            attributes["agent.stream"] = str(agent.stream)
+
+        if hasattr(agent, "show_tool_calls"):
+            attributes["agent.show_tool_calls"] = str(agent.show_tool_calls)
+
+        if hasattr(agent, "tool_call_limit") and agent.tool_call_limit:
+            attributes["agent.tool_call_limit"] = str(agent.tool_call_limit)
+
+        # Tools information
+        if hasattr(agent, "tools") and agent.tools:
+            # Set tool count based on actual number of tools
+            attributes["agent.tools_count"] = str(len(agent.tools))
+
+            # Collect all tool names for the AGENT_TOOLS attribute
+            tool_names = []
+
+            if len(agent.tools) == 1:
+                # Single tool - set directly at root level
+                tool = agent.tools[0]
+                tool_name = None
+                if hasattr(tool, "name"):
+                    tool_name = str(tool.name)
+                    attributes[ToolAttributes.TOOL_NAME] = tool_name
+                elif hasattr(tool, "__name__"):
+                    tool_name = str(tool.__name__)
+                    attributes[ToolAttributes.TOOL_NAME] = tool_name
+                elif callable(tool):
+                    tool_name = getattr(tool, "__name__", "unknown_tool")
+                    attributes[ToolAttributes.TOOL_NAME] = tool_name
+
+                if tool_name:
+                    tool_names.append(tool_name)
+
+                if hasattr(tool, "description") and tool.description:
+                    attributes[ToolAttributes.TOOL_DESCRIPTION] = str(tool.description)
+                elif hasattr(tool, "__doc__") and tool.__doc__:
+                    # Fallback to docstring if no description attribute
+                    attributes[ToolAttributes.TOOL_DESCRIPTION] = str(tool.__doc__).strip()
+            else:
+                # Multiple tools - use indexed format
+                for i, tool in enumerate(agent.tools):
+                    tool_name = None
+                    if hasattr(tool, "name"):
+                        tool_name = str(tool.name)
+                        attributes[f"tool.{i}.name"] = tool_name
+                    elif hasattr(tool, "__name__"):
+                        tool_name = str(tool.__name__)
+                        attributes[f"tool.{i}.name"] = tool_name
+                    elif callable(tool):
+                        tool_name = getattr(tool, "__name__", "unknown_tool")
+                        attributes[f"tool.{i}.name"] = tool_name
+
+                    if tool_name:
+                        tool_names.append(tool_name)
+
+                    if hasattr(tool, "description") and tool.description:
+                        attributes[f"tool.{i}.description"] = str(tool.description)
+                    elif hasattr(tool, "__doc__") and tool.__doc__:
+                        # Fallback to docstring if no description attribute
+                        attributes[f"tool.{i}.description"] = str(tool.__doc__).strip()
+
+            # Set the AGENT_TOOLS attribute with all tool names
+            if tool_names:
+                attributes[AgentAttributes.AGENT_TOOLS] = json.dumps(tool_names)
+
+        if hasattr(agent, "knowledge") and agent.knowledge:
+            knowledge_type = type(agent.knowledge).__name__
+            attributes["agent.knowledge_type"] = knowledge_type
+
+        if hasattr(agent, "storage") and agent.storage:
+            storage_type = type(agent.storage).__name__
+            attributes["agent.storage_type"] = storage_type
+
+        # Session information
+        if hasattr(agent, "session_id") and agent.session_id:
+            session_id = str(agent.session_id)
+            attributes["agent.session_id"] = session_id
+
+        if hasattr(agent, "user_id") and agent.user_id:
+            user_id = str(agent.user_id)
+            attributes["agent.user_id"] = user_id
+
+        # Output key if present
+        if hasattr(agent, "output_key") and agent.output_key:
+            attributes["agent.output_key"] = str(agent.output_key)
+
+    # Extract run input information
+    if args and len(args) >= 2:
+        message = args[1]  # The message argument
+        if message:
+            message_str = str(message)
+            attributes["agent.input"] = message_str
+            # AgentOps entity input
+            attributes[SpanAttributes.AGENTOPS_ENTITY_INPUT] = message_str
+
+    # Extract kwargs information
+    if kwargs:
+        if kwargs.get("stream") is not None:
+            attributes[SpanAttributes.LLM_REQUEST_STREAMING] = str(kwargs["stream"])
+
+        if kwargs.get("session_id"):
+            attributes["agent.run_session_id"] = str(kwargs["session_id"])
+
+        if kwargs.get("user_id"):
+            attributes["agent.run_user_id"] = str(kwargs["user_id"])
+
+    # Extract return value information
+    if return_value:
+        if hasattr(return_value, "run_id") and return_value.run_id:
+            run_id = str(return_value.run_id)
+            attributes["agent.run_id"] = run_id
+
+        if hasattr(return_value, "content") and return_value.content:
+            content = str(return_value.content)
+            attributes["agent.output"] = content
+
+        if hasattr(return_value, "event") and return_value.event:
+            event = str(return_value.event)
+            attributes["agent.event"] = event
+
+        # Tool executions from the response
+        if hasattr(return_value, "tools") and return_value.tools:
+            # Track the number of tool executions
+            attributes["agent.tool_executions_count"] = str(len(return_value.tools))
+
+            for i, tool_exec in enumerate(return_value.tools):  # No limit - show all tools
+                if hasattr(tool_exec, "tool_name") and tool_exec.tool_name:
+                    attributes[f"tool.{i}.name"] = str(tool_exec.tool_name)
+
+                if hasattr(tool_exec, "tool_args") and tool_exec.tool_args:
+                    try:
+                        args_str = json.dumps(tool_exec.tool_args)
+                        attributes[f"tool.{i}.parameters"] = args_str
+                    except:
+                        attributes[f"tool.{i}.parameters"] = str(tool_exec.tool_args)
+
+                if hasattr(tool_exec, "result") and tool_exec.result:
+                    result_str = str(tool_exec.result)
+                    attributes[f"tool.{i}.result"] = result_str
+
+                if hasattr(tool_exec, "tool_call_error") and tool_exec.tool_call_error:
+                    attributes[f"tool.{i}.error"] = str(tool_exec.tool_call_error)
+
+                attributes[f"tool.{i}.status"] = "success"  # Default to success
+
+    # Add display name for better UI visualization
+    if agent_name:
+        # Check if we have parent team info
+        parent_team = attributes.get("agent.parent_team")
+        if parent_team:
+            attributes["agent.display_name"] = f"{agent_name} (Agent under {parent_team})"
+        else:
+            attributes["agent.display_name"] = f"{agent_name}"
+
+    return attributes

agentops/instrumentation/agentic/agno/attributes/metrics.py

@@ -0,0 +1,214 @@
+"""Agno Agent session metrics attributes handler."""
+
+from typing import Optional, Tuple, Dict, Any
+
+from agentops.instrumentation.common.attributes import AttributeMap
+from agentops.semconv import SpanAttributes
+
+
+def get_metrics_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> AttributeMap:
+    """Extract span attributes for Agent._set_session_metrics calls.
+
+    Args:
+        args: Positional arguments passed to the _set_session_metrics method (self, run_messages)
+        kwargs: Keyword arguments passed to the _set_session_metrics method
+        return_value: The return value from the _set_session_metrics method
+
+    Returns:
+        A dictionary of span attributes to be set on the metrics span
+    """
+    attributes: AttributeMap = {}
+
+    # Base attributes
+    attributes[SpanAttributes.AGENTOPS_SPAN_KIND] = "llm"
+    attributes[SpanAttributes.LLM_SYSTEM] = "agno"
+    attributes[SpanAttributes.AGENTOPS_ENTITY_NAME] = "LLM"
+
+    # Initialize usage tracking variables
+    usage_data = {}
+
+    # Initialize counters for indexed messages
+    prompt_count = 0
+    completion_count = 0
+
+    # Extract agent and run_messages from args (self, run_messages)
+    if args and len(args) >= 2:
+        agent = args[0]  # self (Agent instance)
+        run_messages = args[1]  # RunMessages object
+
+        # Add agent display name for LLM calls
+        if hasattr(agent, "name") and agent.name:
+            attributes["agno.llm.display_name"] = f"{agent.name} → LLM"
+
+        # Model information - get additional request parameters if available
+        if hasattr(agent, "model") and agent.model:
+            model = agent.model
+            # Set model ID first
+            if hasattr(model, "id"):
+                attributes[SpanAttributes.LLM_REQUEST_MODEL] = str(model.id)
+                attributes[SpanAttributes.LLM_RESPONSE_MODEL] = str(model.id)
+            # Additional model parameters
+            if hasattr(model, "temperature") and model.temperature is not None:
+                attributes[SpanAttributes.LLM_REQUEST_TEMPERATURE] = str(model.temperature)
+            if hasattr(model, "max_tokens") and model.max_tokens is not None:
+                attributes[SpanAttributes.LLM_REQUEST_MAX_TOKENS] = str(model.max_tokens)
+            if hasattr(model, "top_p") and model.top_p is not None:
+                attributes[SpanAttributes.LLM_REQUEST_TOP_P] = str(model.top_p)
+            if hasattr(model, "provider"):
+                attributes["agno.model.provider"] = str(model.provider)
+
+            # Add model class name for better identification (with null check)
+            if hasattr(model, "__class__") and hasattr(model.__class__, "__name__"):
+                model_class = model.__class__.__name__
+                attributes["agno.model.class"] = model_class
+
+        if hasattr(run_messages, "messages") and run_messages.messages:
+            messages = run_messages.messages
+
+            # Initialize token tracking
+            total_prompt_tokens = 0
+            total_completion_tokens = 0
+            total_output_tokens = 0
+            total_input_tokens = 0
+            total_tokens = 0
+            total_time = 0.0
+
+            # Process messages to create individual indexed gen_ai.prompt.{i} and gen_ai.completion.{i} attributes
+            for i, msg in enumerate(messages):
+                # Extract message content for prompts/completions
+                if hasattr(msg, "role") and hasattr(msg, "content"):
+                    # Only process messages with actual content
+                    if msg.content is not None and str(msg.content).strip() != "" and str(msg.content) != "None":
+                        content = str(msg.content)
+                        # No truncation - keep full content for observability
+
+                        if msg.role == "user":
+                            attributes[f"{SpanAttributes.LLM_PROMPTS}.{prompt_count}.role"] = "user"
+                            attributes[f"{SpanAttributes.LLM_PROMPTS}.{prompt_count}.content"] = content
+                            prompt_count += 1
+                        elif msg.role == "assistant":
+                            attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_count}.role"] = "assistant"
+                            attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_count}.content"] = content
+                            completion_count += 1
+                        elif msg.role == "system":
+                            attributes[f"{SpanAttributes.LLM_PROMPTS}.{prompt_count}.role"] = "system"
+                            attributes[f"{SpanAttributes.LLM_PROMPTS}.{prompt_count}.content"] = content
+                            prompt_count += 1
+
+                # Extract token metrics from message
+                if hasattr(msg, "metrics") and msg.metrics:
+                    metrics = msg.metrics
+
+                    # Handle different token metric patterns
+                    if hasattr(metrics, "prompt_tokens") and metrics.prompt_tokens > 0:
+                        total_prompt_tokens += metrics.prompt_tokens
+                    if hasattr(metrics, "completion_tokens") and metrics.completion_tokens > 0:
+                        total_completion_tokens += metrics.completion_tokens
+                    if hasattr(metrics, "total_tokens") and metrics.total_tokens > 0:
+                        total_tokens += metrics.total_tokens
+                    # For messages that only have output_tokens
+                    if hasattr(metrics, "output_tokens") and metrics.output_tokens > 0:
+                        total_output_tokens += metrics.output_tokens
+                    if hasattr(metrics, "input_tokens") and metrics.input_tokens > 0:
+                        total_input_tokens += metrics.input_tokens
+                    if hasattr(metrics, "time") and metrics.time:
+                        total_time += metrics.time
+
+        # Token metrics from agent session metrics
+        if hasattr(agent, "session_metrics") and agent.session_metrics:
+            session_metrics = agent.session_metrics
+
+            # Try to get model name from session metrics if not already set
+            if SpanAttributes.LLM_REQUEST_MODEL not in attributes:
+                if hasattr(session_metrics, "model") and session_metrics.model:
+                    model_id = str(session_metrics.model)
+                    attributes[SpanAttributes.LLM_REQUEST_MODEL] = model_id
+                    attributes[SpanAttributes.LLM_RESPONSE_MODEL] = model_id
+
+            # Only set token variables if the attributes actually exist
+            session_prompt_tokens = None
+            session_completion_tokens = None
+            session_output_tokens = None
+            session_input_tokens = None
+            session_total_tokens = None
+
+            if hasattr(session_metrics, "prompt_tokens"):
+                session_prompt_tokens = session_metrics.prompt_tokens
+
+            if hasattr(session_metrics, "completion_tokens"):
+                session_completion_tokens = session_metrics.completion_tokens
+
+            if hasattr(session_metrics, "output_tokens"):
+                session_output_tokens = session_metrics.output_tokens
+
+            if hasattr(session_metrics, "input_tokens"):
+                session_input_tokens = session_metrics.input_tokens
+
+            if hasattr(session_metrics, "total_tokens"):
+                session_total_tokens = session_metrics.total_tokens
+
+            # For Anthropic, output_tokens represents completion tokens
+            if session_output_tokens is not None and session_output_tokens > 0:
+                if session_completion_tokens is None or session_completion_tokens == 0:
+                    session_completion_tokens = session_output_tokens
+
+            # For some providers, input_tokens represents prompt tokens
+            if session_input_tokens is not None and session_input_tokens > 0:
+                if session_prompt_tokens is None or session_prompt_tokens == 0:
+                    session_prompt_tokens = session_input_tokens
+
+            # Only set token attributes if we have actual values
+            if session_total_tokens is not None and session_total_tokens > 0:
+                usage_data["total_tokens"] = session_total_tokens
+
+                # Set breakdown if available
+                if session_prompt_tokens is not None and session_prompt_tokens > 0:
+                    usage_data["prompt_tokens"] = session_prompt_tokens
+                if session_completion_tokens is not None and session_completion_tokens > 0:
+                    usage_data["completion_tokens"] = session_completion_tokens
+
+            # Additional token types from session metrics - only set if present
+            if hasattr(session_metrics, "cached_tokens") and session_metrics.cached_tokens > 0:
+                usage_data["cache_read_input_tokens"] = session_metrics.cached_tokens
+            if hasattr(session_metrics, "reasoning_tokens") and session_metrics.reasoning_tokens > 0:
+                usage_data["reasoning_tokens"] = session_metrics.reasoning_tokens
+
+        # If we don't have token data from session metrics, try message aggregation
+        if "total_tokens" not in usage_data:
+            # Set aggregated token usage from messages
+            if total_prompt_tokens > 0 or total_input_tokens > 0:
+                usage_data["prompt_tokens"] = total_prompt_tokens or total_input_tokens
+            if total_completion_tokens > 0 or total_output_tokens > 0:
+                usage_data["completion_tokens"] = total_completion_tokens or total_output_tokens
+            if total_tokens > 0:
+                usage_data["total_tokens"] = total_tokens
+
+        # Extract user message info if available
+        if hasattr(run_messages, "user_message") and run_messages.user_message:
+            user_msg = run_messages.user_message
+            if hasattr(user_msg, "content"):
+                content = str(user_msg.content)
+                attributes["agno.metrics.user_input"] = content
+
+    # Set individual LLM usage attributes only for values we actually have
+    if "prompt_tokens" in usage_data:
+        attributes[SpanAttributes.LLM_USAGE_PROMPT_TOKENS] = usage_data["prompt_tokens"]
+    if "completion_tokens" in usage_data:
+        attributes[SpanAttributes.LLM_USAGE_COMPLETION_TOKENS] = usage_data["completion_tokens"]
+    if "total_tokens" in usage_data:
+        attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS] = usage_data["total_tokens"]
+    if "cache_read_input_tokens" in usage_data:
+        attributes[SpanAttributes.LLM_USAGE_CACHE_READ_INPUT_TOKENS] = usage_data["cache_read_input_tokens"]
+    if "reasoning_tokens" in usage_data:
+        attributes[SpanAttributes.LLM_USAGE_REASONING_TOKENS] = usage_data["reasoning_tokens"]
+
+    # But only if we have any usage data
+    if usage_data:
+        for key, value in usage_data.items():
+            attributes[f"gen_ai.usage.{key}"] = value
+
+    return attributes

agentops/instrumentation/agentic/agno/attributes/storage.py

@@ -0,0 +1,158 @@
+"""Storage operation attribute handlers for Agno workflow instrumentation."""
+
+import json
+from typing import Any, Dict, Optional, Tuple
+from opentelemetry.util.types import AttributeValue
+
+from agentops.semconv.span_attributes import SpanAttributes
+from agentops.semconv.span_kinds import SpanKind as AgentOpsSpanKind
+from agentops.instrumentation.common.attributes import get_common_attributes
+
+
+def get_storage_read_attributes(
+    args: Tuple[Any, ...] = (),
+    kwargs: Optional[Dict[str, Any]] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, AttributeValue]:
+    """Extract attributes from storage read operations.
+
+    Args:
+        args: Positional arguments passed to read_from_storage
+        kwargs: Keyword arguments passed to read_from_storage
+        return_value: Return value from read_from_storage (the cached data or None)
+
+    Returns:
+        Dictionary of OpenTelemetry attributes for storage read operations
+    """
+    attributes = get_common_attributes()
+    kwargs = kwargs or {}
+
+    # Mark this as a storage operation within workflow context
+    attributes["storage.operation"] = "read"
+    attributes[SpanAttributes.AGENTOPS_SPAN_KIND] = AgentOpsSpanKind.WORKFLOW
+
+    if args and len(args) > 0:
+        workflow = args[0]
+
+        # Get workflow information
+        if hasattr(workflow, "workflow_id") and workflow.workflow_id:
+            attributes["storage.workflow_id"] = str(workflow.workflow_id)
+        if hasattr(workflow, "session_id") and workflow.session_id:
+            attributes["storage.session_id"] = str(workflow.session_id)
+
+        # Get storage type
+        if hasattr(workflow, "storage") and workflow.storage:
+            storage_type = type(workflow.storage).__name__
+            attributes["storage.backend"] = storage_type
+
+        # Get session state info for context
+        if hasattr(workflow, "session_state") and isinstance(workflow.session_state, dict):
+            # Get all cache keys
+            cache_keys = list(workflow.session_state.keys())
+            attributes["storage.cache_size"] = len(cache_keys)
+            if cache_keys:
+                attributes["storage.cache_keys"] = json.dumps(cache_keys)
+
+    # Analyze the return value to determine cache hit/miss
+    if return_value is not None:
+        # Cache hit
+        attributes["storage.cache_hit"] = True
+        attributes["storage.result"] = "hit"
+
+        # Get data type and size
+        data_type = type(return_value).__name__
+        attributes["storage.data_type"] = data_type
+
+        # For dict/list, show structure
+        if isinstance(return_value, dict):
+            attributes["storage.data_keys"] = json.dumps(list(return_value.keys()))
+            attributes["storage.data_size"] = len(return_value)
+        elif isinstance(return_value, (list, tuple)):
+            attributes["storage.data_size"] = len(return_value)
+        elif isinstance(return_value, str):
+            attributes["storage.data_size"] = len(return_value)
+            # Show full string data without truncation
+            attributes["storage.data_preview"] = return_value
+    else:
+        # Cache miss
+        attributes["storage.cache_hit"] = False
+        attributes["storage.result"] = "miss"
+
+    return attributes
+
+
+def get_storage_write_attributes(
+    args: Tuple[Any, ...] = (),
+    kwargs: Optional[Dict[str, Any]] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, AttributeValue]:
+    """Extract attributes from storage write operations.
+
+    Args:
+        args: Positional arguments passed to write_to_storage
+        kwargs: Keyword arguments passed to write_to_storage
+        return_value: Return value from write_to_storage (usually None or success indicator)
+
+    Returns:
+        Dictionary of OpenTelemetry attributes for storage write operations
+    """
+    attributes = get_common_attributes()
+    kwargs = kwargs or {}
+
+    # Mark this as a storage operation within workflow context
+    attributes["storage.operation"] = "write"
+    attributes[SpanAttributes.AGENTOPS_SPAN_KIND] = AgentOpsSpanKind.WORKFLOW
+
+    if args and len(args) > 0:
+        workflow = args[0]
+
+        # Get workflow information
+        if hasattr(workflow, "workflow_id") and workflow.workflow_id:
+            attributes["storage.workflow_id"] = str(workflow.workflow_id)
+        if hasattr(workflow, "session_id") and workflow.session_id:
+            attributes["storage.session_id"] = str(workflow.session_id)
+
+        # Get storage type
+        if hasattr(workflow, "storage") and workflow.storage:
+            storage_type = type(workflow.storage).__name__
+            attributes["storage.backend"] = storage_type
+
+        # Get session state info to see what's being written
+        if hasattr(workflow, "session_state") and isinstance(workflow.session_state, dict):
+            # Get cache state after write
+            cache_keys = list(workflow.session_state.keys())
+            attributes["storage.cache_size"] = len(cache_keys)
+            if cache_keys:
+                attributes["storage.cache_keys"] = json.dumps(cache_keys)
+
+            # Try to identify what was written (the newest/changed data)
+            # This is a heuristic - in practice you might need to track state changes
+            if cache_keys:
+                # Show the last key as likely the one just written
+                last_key = cache_keys[-1]
+                attributes["storage.written_key"] = last_key
+
+                # Get value preview
+                value = workflow.session_state.get(last_key)
+                if value is not None:
+                    value_type = type(value).__name__
+                    attributes["storage.written_value_type"] = value_type
+
+                    if isinstance(value, str):
+                        if len(value) > 100:
+                            attributes["storage.written_value_preview"] = value[:100] + "..."
+                        else:
+                            attributes["storage.written_value_preview"] = value
+                        attributes["storage.written_value_size"] = len(value)
+                    elif isinstance(value, (dict, list)):
+                        attributes["storage.written_value_size"] = len(value)
+                        attributes["storage.written_value_preview"] = f"{value_type} with {len(value)} items"
+
+    # Check write result
+    if return_value is not None:
+        attributes["storage.write_success"] = True
+    else:
+        # Most storage writes return None on success, so this is normal
+        attributes["storage.write_success"] = True
+
+    return attributes