fiddler-langgraph 1.0.0__tar.gz → 1.2.0__tar.gz

{fiddler_langgraph-1.0.0/fiddler_langgraph.egg-info → fiddler_langgraph-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fiddler-langgraph
-Version: 1.0.0
+Version: 1.2.0
 Summary: Python SDK for instrumenting GenAI Applications with Fiddler
 Home-page: https://fiddler.ai
 Author: Fiddler AI

fiddler_langgraph-1.2.0/fiddler_langgraph/VERSION

@@ -0,0 +1 @@
+1.2.0

{fiddler_langgraph-1.0.0 → fiddler_langgraph-1.2.0}/fiddler_langgraph/core/attributes.py

@@ -34,11 +34,14 @@ class FiddlerSpanAttributes:  # pylint: disable=too-few-public-methods
     LLM_TOKEN_COUNT_INPUT = 'gen_ai.usage.input_tokens'
     LLM_TOKEN_COUNT_OUTPUT = 'gen_ai.usage.output_tokens'
     LLM_TOKEN_COUNT_TOTAL = 'gen_ai.usage.total_tokens'
+    GEN_AI_INPUT_MESSAGES = 'gen_ai.input.messages'
+    GEN_AI_OUTPUT_MESSAGES = 'gen_ai.output.messages'
 
     # tool attributes
     TOOL_INPUT = 'gen_ai.tool.input'
     TOOL_OUTPUT = 'gen_ai.tool.output'
     TOOL_NAME = 'gen_ai.tool.name'
+    TOOL_DEFINITIONS = 'gen_ai.tool.definitions'
 
 
 class FiddlerResourceAttributes:

{fiddler_langgraph-1.0.0 → fiddler_langgraph-1.2.0}/fiddler_langgraph/core/client.py

@@ -1,6 +1,5 @@
 """Core client for Fiddler instrumentation."""
 
-import os
 import uuid
 from typing import Any
 from urllib.parse import urlparse
@@ -24,18 +23,6 @@ from fiddler_langgraph.core.attributes import FiddlerResourceAttributes
 from fiddler_langgraph.core.span_processor import FiddlerSpanProcessor
 from fiddler_langgraph.tracing.jsonl_capture import JSONLSpanExporter, initialize_jsonl_capture
 
-# Defaults are too permissive.
-# Set restrictive defaults for span limits - can be overridden by the user
-# See https://github.com/open-telemetry/opentelemetry-python/blob/main/opentelemetry-sdk/src/opentelemetry/sdk/environment_variables/__init__.py
-_default_span_limits = SpanLimits(
-    max_events=32,
-    max_links=32,
-    max_span_attributes=32,
-    max_event_attributes=32,
-    max_link_attributes=32,
-    max_span_attribute_length=2048,
-)
-
 
 class FiddlerClient:
     """The main client for instrumenting Generative AI applications with Fiddler observability.
@@ -62,7 +49,7 @@ class FiddlerClient:
         application_id: str,
         url: str,
         console_tracer: bool = False,
-        span_limits: SpanLimits | None = _default_span_limits,
+        span_limits: SpanLimits | None = None,
         sampler: sampling.Sampler | None = None,
         compression: Compression = Compression.Gzip,
         jsonl_capture_enabled: bool = False,
@@ -83,8 +70,18 @@ class FiddlerClient:
                 instead of being sent to the Fiddler backend. Useful for debugging.
                 Defaults to `False`.
             span_limits (SpanLimits | None): Configuration for span limits, such as the
-                maximum number of attributes or events. Defaults to a restrictive
-                set of internal limits (32 events/links/attributes, 2048 char limit).
+                maximum number of attributes or events. When `None` (default), OpenTelemetry
+                automatically applies its standard defaults:
+
+                - `max_attributes`: 128 (or `OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT` env var)
+                - `max_events`: 128 (or `OTEL_SPAN_EVENT_COUNT_LIMIT` env var)
+                - `max_links`: 128 (or `OTEL_SPAN_LINK_COUNT_LIMIT` env var)
+                - `max_event_attributes`: 128 (or `OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT` env var)
+                - `max_link_attributes`: 128 (or `OTEL_LINK_ATTRIBUTE_COUNT_LIMIT` env var)
+                - `max_span_attribute_length`: None/unlimited (or `OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT` env var)
+
+                You can override these by passing a custom `SpanLimits` object (see example below)
+                or by setting the environment variables.
             sampler (sampling.Sampler | None): The sampler for deciding which spans to record.
                 Defaults to `None`, which uses the parent-based always-on OpenTelemetry sampler
                 (100% sampling).
@@ -120,11 +117,15 @@ class FiddlerClient:
                 from opentelemetry.sdk.trace import SpanLimits, sampling
                 from opentelemetry.exporter.otlp.proto.http.trace_exporter import Compression
 
+                # Example: add custom limits
                 client = FiddlerClient(
                     api_key='YOUR_API_KEY',
                     application_id='YOUR_APPLICATION_ID',
                     url='https://your-instance.fiddler.ai',
-                    span_limits=SpanLimits(max_span_attributes=64),
+                    span_limits=SpanLimits(
+                        max_span_attributes=64,           # Reduce from default 128
+                        max_span_attribute_length=2048,   # Limit from default None (unlimited)
+                    ),
                     sampler=sampling.TraceIdRatioBased(0.1),  # Sample 10% of traces
                     compression=Compression.Gzip,
                 )
@@ -304,13 +305,9 @@ class FiddlerClient:
             },
             compression=self.compression,
         )
-        span_processor = BatchSpanProcessor(
-            otlp_exporter,
-            max_queue_size=int(os.environ.get('OTEL_BSP_MAX_QUEUE_SIZE', '100')),
-            schedule_delay_millis=int(os.environ.get('OTEL_BSP_SCHEDULE_DELAY_MILLIS', '1000')),
-            max_export_batch_size=int(os.environ.get('OTEL_BSP_MAX_EXPORT_BATCH_SIZE', '10')),
-            export_timeout_millis=int(os.environ.get('OTEL_BSP_EXPORT_TIMEOUT', '5000')),
-        )
+        # OpenTelemetry automatically applies defaults
+        # (OTEL_BSP_MAX_QUEUE_SIZE, OTEL_BSP_SCHEDULE_DELAY, OTEL_BSP_MAX_EXPORT_BATCH_SIZE, etc.)
+        span_processor = BatchSpanProcessor(otlp_exporter)
 
         self._provider.add_span_processor(span_processor)
 

{fiddler_langgraph-1.0.0 → fiddler_langgraph-1.2.0}/fiddler_langgraph/tracing/callback.py

@@ -9,7 +9,7 @@ from uuid import UUID
 
 from langchain_core.callbacks import BaseCallbackHandler
 from langchain_core.documents import Document
-from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage
 from langchain_core.outputs import ChatGeneration, LLMResult
 from opentelemetry import trace
 from opentelemetry.context.context import Context
@@ -138,6 +138,94 @@ def _set_token_usage_attributes(span: trace.Span, response: LLMResult) -> None:
         logger.warning('Failed to extract token usage: %s', e)
 
 
+def _set_tool_definitions(span: trace.Span, kwargs: dict[str, Any]) -> None:
+    """Extract and set tool definitions on the span.
+
+    Retrieves tool definitions from invocation params and stores them as a
+    JSON-serialized string attribute on the span.
+
+    Parameters
+    ----------
+    span : trace.Span
+        The OpenTelemetry span to set attributes on
+    kwargs : dict[str, Any]
+        Callback kwargs containing invocation_params
+
+    """
+    try:
+        invocation_params = kwargs.get('invocation_params', {})
+        tools = invocation_params.get('tools')
+
+        if tools and isinstance(tools, list) and len(tools) > 0:
+            # Store tool definitions as-is in OpenAI native format
+            tool_definitions_json = json.dumps(tools, cls=_LanggraphJSONEncoder)
+            span.set_attribute(FiddlerSpanAttributes.TOOL_DEFINITIONS, tool_definitions_json)
+    except Exception as e:
+        logger.warning('Failed to extract tool definitions: %s', e)
+
+
+def _convert_message_to_otel_format(message: BaseMessage) -> dict[str, Any]:
+    """Convert a LangChain message to OpenTelemetry format.
+
+    Parameters
+    ----------
+    message : BaseMessage
+        The LangChain message to convert
+
+    Returns
+    -------
+    dict[str, Any]
+        Message in OpenTelemetry format.
+
+    """
+    result: dict[str, Any] = {}
+
+    # Add OpenTelemetry role mapping
+    role_mapping = {'ai': 'assistant', 'human': 'user'}
+    result['role'] = role_mapping.get(message.type, message.type)
+
+    parts = []
+    content = _stringify_message_content(message)
+
+    # Handle ToolMessage separately
+    if isinstance(message, ToolMessage):
+        tool_response_part: dict[str, Any] = {
+            'type': 'tool_call_response',
+            'response': content,
+            'id': message.tool_call_id,
+        }
+        parts = [tool_response_part]
+    else:
+        # Add text content if present
+        if content:
+            parts.append({'type': 'text', 'content': content})
+
+        # Add tool calls if present (for AIMessage)
+        if isinstance(message, AIMessage) and hasattr(message, 'tool_calls') and message.tool_calls:
+            for tool_call in message.tool_calls:
+                tool_call_part: dict[str, Any] = {
+                    'type': 'tool_call',
+                    'name': tool_call.get('name', ''),
+                }
+                if 'id' in tool_call:
+                    tool_call_part['id'] = tool_call['id']
+                if 'args' in tool_call:
+                    tool_call_part['arguments'] = tool_call['args']
+                parts.append(tool_call_part)
+
+    result['parts'] = parts
+
+    # Extract finish_reason
+    if isinstance(message, AIMessage) and hasattr(message, 'response_metadata'):
+        response_metadata = message.response_metadata
+        if response_metadata:
+            finish_reason = response_metadata.get('finish_reason')
+            if finish_reason:
+                result['finish_reason'] = finish_reason
+
+    return result
+
+
 class _CallbackHandler(BaseCallbackHandler):
     """A LangChain callback handler that creates OpenTelemetry spans for Fiddler.
 
@@ -397,6 +485,7 @@ class _CallbackHandler(BaseCallbackHandler):
             return
         child_span = self._create_child_span(parent_span, serialized.get('name', 'unknown'))
         span_input = json.dumps(inputs, cls=_LanggraphJSONEncoder) if inputs else input_str
+
         child_span.set_attribute(FiddlerSpanAttributes.TYPE, SpanType.TOOL)
         child_span.set_attribute(FiddlerSpanAttributes.TOOL_NAME, serialized.get('name', 'unknown'))
         child_span.set_attribute(FiddlerSpanAttributes.TOOL_INPUT, span_input)
@@ -428,7 +517,6 @@ class _CallbackHandler(BaseCallbackHandler):
         """
         span = self._get_span(run_id)
         if span:
-            # limit the output to 100 characters for now - add formal limits later
             span.set_attribute(
                 FiddlerSpanAttributes.TOOL_OUTPUT,
                 json.dumps(output, cls=_LanggraphJSONEncoder),
@@ -623,14 +711,16 @@ class _CallbackHandler(BaseCallbackHandler):
 
         # chat models are a special case of LLMs with Structure Inputs (messages)
         # the ordering of messages is preserved over the lifecycle of an agent's invocation
-        # we are ignoring AIMessage, ToolMessage, FunctionMessage & ChatMessage
-        # see https://python.langchain.com/api_reference/core/messages.html#module-langchain_core.messages
         system_message = []
         user_message = []
+        message_history = []
+
         if messages and messages[0]:
             system_message = [m for m in messages[0] if isinstance(m, SystemMessage)]
             user_message = [m for m in messages[0] if isinstance(m, HumanMessage)]
 
+            message_history = list(messages[0])
+
         if metadata is not None:
             _set_agent_name(child_span, metadata)
 
@@ -641,6 +731,9 @@ class _CallbackHandler(BaseCallbackHandler):
         # Set model attributes
         _set_model_attributes(child_span, metadata)
 
+        # Extract and set tool definitions
+        _set_tool_definitions(child_span, kwargs)
+
         # We are only taking the 1st system message and 1st user message
         # as we are not supporting multiple system messages or multiple user messages
         # To support multiple system messages, we would need to add a new attribute with indexing
@@ -655,6 +748,16 @@ class _CallbackHandler(BaseCallbackHandler):
             FiddlerSpanAttributes.LLM_INPUT_USER,
             user_content,
         )
+
+        # Add complete message history as a span attribute (GenAI semantic convention)
+        if message_history:
+            # Convert messages to OpenTelemetry format
+            otel_messages = [_convert_message_to_otel_format(msg) for msg in message_history]
+            child_span.set_attribute(
+                FiddlerSpanAttributes.GEN_AI_INPUT_MESSAGES,
+                json.dumps(otel_messages, cls=_LanggraphJSONEncoder),
+            )
+
         self._set_session_id(child_span)
         self._add_span(child_span, run_id)
 
@@ -703,6 +806,9 @@ class _CallbackHandler(BaseCallbackHandler):
         # Set model attributes
         _set_model_attributes(child_span, metadata)
 
+        # Extract and set tool definitions
+        _set_tool_definitions(child_span, kwargs)
+
         # LLM model is more generic than a chat model, it only has a list on prompts
         # we are using the first prompt as both the system message and the user message
         # to capture all the prompts, we would need to add a new attribute with indexing
@@ -739,6 +845,8 @@ class _CallbackHandler(BaseCallbackHandler):
             # we always get only one element in the list - even with batch mode
             # Add safety checks to prevent index errors
             output = ''
+            output_message_dict = None
+
             if (
                 response.generations
                 and len(response.generations) > 0
@@ -746,22 +854,41 @@ class _CallbackHandler(BaseCallbackHandler):
                 and len(response.generations[0]) > 0
             ):
                 generation = response.generations[0][0]
+
                 output = generation.text
-                if (
-                    output == ''
-                    and isinstance(generation, ChatGeneration)
-                    and isinstance(generation.message, AIMessage)
-                    and hasattr(generation.message, 'tool_calls')
+
+                # Check if this is a ChatGeneration with an AIMessage
+                if isinstance(generation, ChatGeneration) and isinstance(
+                    generation.message, AIMessage
                 ):
-                    # if llm returns an empty string, it means it used a tool
-                    # we are using the tool calls to get the output
-                    output = json.dumps(generation.message.tool_calls, cls=_LanggraphJSONEncoder)
+                    # Use the complete output message
+                    output_message_dict = generation.message
+
+                    if (
+                        output == ''
+                        and hasattr(generation.message, 'tool_calls')
+                        and generation.message.tool_calls
+                    ):
+                        # if llm returns an empty string, it means it used a tool
+                        # we are using the tool calls to get the output
+                        output = json.dumps(
+                            generation.message.tool_calls, cls=_LanggraphJSONEncoder
+                        )
 
             span.set_attribute(FiddlerSpanAttributes.LLM_OUTPUT, output)
 
             # Extract and set token usage information
             _set_token_usage_attributes(span, response)
 
+            # Add output message as a span attribute
+            if output_message_dict:
+                # Convert message to OpenTelemetry format
+                otel_message = _convert_message_to_otel_format(output_message_dict)
+                span.set_attribute(
+                    FiddlerSpanAttributes.GEN_AI_OUTPUT_MESSAGES,
+                    json.dumps([otel_message], cls=_LanggraphJSONEncoder),
+                )
+
             span.end()
             self._remove_span(run_id)
         else:

{fiddler_langgraph-1.0.0 → fiddler_langgraph-1.2.0}/fiddler_langgraph/tracing/jsonl_capture.py

@@ -98,11 +98,18 @@ class JSONLSpanCapture:
         span_data['llm_input_user'] = attributes.get(FiddlerSpanAttributes.LLM_INPUT_USER, '')
         span_data['llm_output'] = attributes.get(FiddlerSpanAttributes.LLM_OUTPUT, '')
         span_data['llm_context'] = attributes.get(FiddlerSpanAttributes.LLM_CONTEXT, '')
+        span_data['gen_ai_input_messages'] = attributes.get(
+            FiddlerSpanAttributes.GEN_AI_INPUT_MESSAGES, ''
+        )
+        span_data['gen_ai_output_messages'] = attributes.get(
+            FiddlerSpanAttributes.GEN_AI_OUTPUT_MESSAGES, ''
+        )
 
         # Tool information
         span_data['tool_name'] = attributes.get(FiddlerSpanAttributes.TOOL_NAME, '')
         span_data['tool_input'] = attributes.get(FiddlerSpanAttributes.TOOL_INPUT, '')
         span_data['tool_output'] = attributes.get(FiddlerSpanAttributes.TOOL_OUTPUT, '')
+        span_data['tool_definitions'] = attributes.get(FiddlerSpanAttributes.TOOL_DEFINITIONS, '')
 
         # Library versions (from resource if available)
         resource_attributes = (
@@ -124,6 +131,7 @@ class JSONLSpanCapture:
 
         # Exception information
         exception_info = []
+
         if hasattr(span, 'events') and span.events:
             for event in span.events:
                 if event.name == 'exception':

{fiddler_langgraph-1.0.0 → fiddler_langgraph-1.2.0/fiddler_langgraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fiddler-langgraph
-Version: 1.0.0
+Version: 1.2.0
 Summary: Python SDK for instrumenting GenAI Applications with Fiddler
 Home-page: https://fiddler.ai
 Author: Fiddler AI

fiddler_langgraph-1.0.0/fiddler_langgraph/VERSION

@@ -1 +0,0 @@
-1.0.0