dspy 0.24.0 → 0.24.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8fb5750b0bc898e3bfb2b64305e5b7eb186c494aba525fd8b739822385e7129
-  data.tar.gz: 530f9d8163c914845a2b472cdacce848ba187b9e69f9304d8743966b744ddf9f
+  metadata.gz: a4383ac0dbb6237559bb521cf0d1355f9333f6495895742f6b2c4360d7c68392
+  data.tar.gz: 914f295500dd86cf4d2fe611450ddf3f8f6a01b1c7834cb5b8a9057d7449c8b4
 SHA512:
-  metadata.gz: 9f8e5fa70b1be656f174e5370f529086cb6c836030382c04fd1392e79998c43e93b71db7dbc47ec3cf424254cbd42343ac6f1447f800185d6ce499204dec05f2
-  data.tar.gz: 95971087479ca0efa66da1bb6084e94a6cb2120203721c2a949c6fc002d152da9f4587061e8e67c246760dbee5167718f8a6f067024e61106d9fa94c1bd0cd55
+  metadata.gz: 3d48a54390b11eee3a38d15770abda175cd7545aa30b24d48123e2ab6657e7f3212bbc4aa3bddab5a6ec700d3137b1e7bbd8b7f4d5e78313f7d3d90b574b47a3
+  data.tar.gz: 6189b3137e9fe1a36e6bedfc45a1a9ba10308089d497885edbfd8a20ba7879824c4e103b96eaa1efaca93e8e6c90aa4154f99ba8aa278528045d96aec7ff2024

data/README.md

@@ -191,6 +191,7 @@ DSPy.rb has rapidly evolved from experimental to production-ready:
 - ✅ **Optimization Framework** - MIPROv2 algorithm with storage & persistence
 
 ### Recent Advances  
+- ✅ **Enhanced Langfuse Integration (v0.24.1)** - Comprehensive OpenTelemetry span reporting with proper input/output, hierarchical nesting, accurate timing, and observation types
 - ✅ **Comprehensive Multimodal Framework** - Complete image analysis with `DSPy::Image`, type-safe bounding boxes, vision model integration
 - ✅ **Advanced Type System** - `T::Enum` integration, union types for agentic workflows, complex type coercion
 - ✅ **Production-Ready Evaluation** - Multi-factor metrics beyond accuracy, error-resilient evaluation pipelines

data/lib/dspy/chain_of_thought.rb

@@ -82,16 +82,45 @@ module DSPy
     sig { returns(T.class_of(DSPy::Signature)) }
     attr_reader :original_signature
 
-    # Override forward_untyped to add ChainOfThought-specific analysis
+    # Override forward_untyped to add ChainOfThought-specific analysis and tracing
     sig { override.params(input_values: T.untyped).returns(T.untyped) }
     def forward_untyped(**input_values)
-      # Call parent prediction logic
-      prediction_result = super(**input_values)
-      
-      # Analyze reasoning if present
-      analyze_reasoning(prediction_result)
-      
-      prediction_result
+      # Wrap in chain-specific span tracking (overrides parent's span attributes)
+      DSPy::Context.with_span(
+        operation: "#{self.class.name}.forward",
+        'langfuse.observation.type' => 'chain',
+        'langfuse.observation.input' => input_values.to_json,
+        'dspy.module' => 'ChainOfThought',
+        'dspy.signature' => @original_signature.name
+      ) do |span|
+        # Call parent prediction logic (which will create its own nested span)
+        prediction_result = super(**input_values)
+        
+        # Enhance span with reasoning data
+        if span && prediction_result
+          # Include reasoning in output for chain observation
+          output_with_reasoning = if prediction_result.respond_to?(:reasoning) && prediction_result.reasoning
+            output_hash = prediction_result.respond_to?(:to_h) ? prediction_result.to_h : {}
+            output_hash.merge(reasoning: prediction_result.reasoning)
+          else
+            prediction_result.respond_to?(:to_h) ? prediction_result.to_h : prediction_result.to_s
+          end
+          
+          span.set_attribute('langfuse.observation.output', output_with_reasoning.to_json)
+          
+          # Add reasoning metrics
+          if prediction_result.respond_to?(:reasoning) && prediction_result.reasoning
+            span.set_attribute('cot.reasoning_length', prediction_result.reasoning.length)
+            span.set_attribute('cot.has_reasoning', true)
+            span.set_attribute('cot.reasoning_steps', count_reasoning_steps(prediction_result.reasoning))
+          end
+        end
+        
+        # Analyze reasoning (emits events for backwards compatibility)
+        analyze_reasoning(prediction_result)
+        
+        prediction_result
+      end
     end
 
     private

data/lib/dspy/context.rb

@@ -26,37 +26,58 @@ module DSPy
           **attributes
         }
         
-        # Log span start with proper hierarchy
+        # Log span start with proper hierarchy (internal logging only)
         DSPy.log('span.start', **span_attributes)
         
-        # Create OpenTelemetry span if observability is enabled
-        otel_span = nil
-        if DSPy::Observability.enabled?
-          otel_span = DSPy::Observability.start_span(operation, span_attributes)
-        end
-        
-        # Push to stack for child spans
+        # Push to stack for child spans tracking
         current[:span_stack].push(span_id)
         
         begin
-          result = yield
+          # Use OpenTelemetry's proper context management for nesting
+          if DSPy::Observability.enabled? && DSPy::Observability.tracer
+            # Prepare attributes and add trace name for root spans
+            span_attributes = attributes.transform_keys(&:to_s).reject { |k, v| v.nil? }
+            
+            # Set trace name if this is likely a root span (no parent in our stack)
+            if current[:span_stack].length == 1  # This will be the first span
+              span_attributes['langfuse.trace.name'] = operation
+            end
+            
+            # Record start time for explicit duration tracking
+            otel_start_time = Time.now
+            
+            DSPy::Observability.tracer.in_span(
+              operation,
+              attributes: span_attributes,
+              kind: :internal
+            ) do |span|
+              result = yield(span)
+              
+              # Add explicit timing information to help Langfuse
+              if span
+                duration_ms = ((Time.now - otel_start_time) * 1000).round(3)
+                span.set_attribute('duration.ms', duration_ms)
+                span.set_attribute('langfuse.observation.startTime', otel_start_time.iso8601(3))
+                span.set_attribute('langfuse.observation.endTime', Time.now.iso8601(3))
+              end
+              
+              result
+            end
+          else
+            yield(nil)
+          end
         ensure
           # Pop from stack
           current[:span_stack].pop
           
-          # Log span end with duration
+          # Log span end with duration (internal logging only)
           duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
           DSPy.log('span.end',
             trace_id: current[:trace_id],
             span_id: span_id,
             duration_ms: duration_ms
           )
-          
-          # Finish OpenTelemetry span
-          DSPy::Observability.finish_span(otel_span) if otel_span
         end
-        
-        result
       end
       
       def clear!

data/lib/dspy/lm/adapters/openai_adapter.rb

@@ -16,18 +16,26 @@ module DSPy
 
       def chat(messages:, signature: nil, response_format: nil, &block)
         normalized_messages = normalize_messages(messages)
-        
+
         # Validate vision support if images are present
         if contains_images?(normalized_messages)
           VisionModels.validate_vision_support!('openai', model)
           # Convert messages to OpenAI format with proper image handling
           normalized_messages = format_multimodal_messages(normalized_messages)
         end
-        
+
+        # Set temperature based on model capabilities
+        temperature = case model
+        when /^gpt-5/, /^gpt-4o/
+          1.0 # GPT-5 and GPT-4o models only support default temperature of 1.0
+        else
+          0.0 # Near-deterministic for other models (0.0 no longer universally supported)
+        end
+
         request_params = {
           model: model,
           messages: normalized_messages,
-          temperature: 0.0 # DSPy default for deterministic responses
+          temperature: temperature
         }
 
         # Add response format if provided by strategy
@@ -48,7 +56,7 @@ module DSPy
 
         begin
           response = @client.chat.completions.create(**request_params)
-          
+
           if response.respond_to?(:error) && response.error
             raise AdapterError, "OpenAI API error: #{response.error}"
           end
@@ -65,7 +73,7 @@ module DSPy
 
           # Convert usage data to typed struct
           usage_struct = UsageFactory.create('openai', usage)
-          
+
           # Create typed metadata
           metadata = ResponseMetadataFactory.create('openai', {
             model: model,
@@ -75,7 +83,7 @@ module DSPy
             system_fingerprint: response.system_fingerprint,
             finish_reason: choice.finish_reason
           })
-          
+
           Response.new(
             content: content,
             usage: usage_struct,
@@ -84,14 +92,14 @@ module DSPy
         rescue => e
           # Check for specific error types and messages
           error_msg = e.message.to_s
-          
+
           # Try to parse error body if it looks like JSON
           error_body = if error_msg.start_with?('{')
                          JSON.parse(error_msg) rescue nil
                        elsif e.respond_to?(:response) && e.response
                          e.response[:body] rescue nil
                        end
-          
+
           # Check for specific image-related errors
           if error_msg.include?('image_parse_error') || error_msg.include?('unsupported image')
             raise AdapterError, "Image processing failed: #{error_msg}. Ensure your image is a valid PNG, JPEG, GIF, or WebP format and under 5MB."
@@ -113,7 +121,7 @@ module DSPy
       def supports_structured_outputs?
         DSPy::LM::Adapters::OpenAI::SchemaConverter.supports_structured_outputs?(model)
       end
-      
+
       def format_multimodal_messages(messages)
         messages.map do |msg|
           if msg[:content].is_a?(Array)
@@ -130,7 +138,7 @@ module DSPy
                 item
               end
             end
-            
+
             {
               role: msg[:role],
               content: formatted_content

data/lib/dspy/lm.rb

@@ -209,35 +209,48 @@ module DSPy
 
     # Common instrumentation method for LM requests
     def instrument_lm_request(messages, signature_class_name, &execution_block)
-      # Handle both Message objects and hash format
-      input_text = messages.map do |m|
+      # Prepare input for tracing - convert messages to JSON for input tracking
+      input_messages = messages.map do |m|
         if m.is_a?(Message)
-          m.content
+          { role: m.role, content: m.content }
         else
-          m[:content]
+          m
         end
-      end.join(' ')
-      input_size = input_text.length
+      end
+      input_json = input_messages.to_json
       
       # Wrap LLM call in span tracking
       response = DSPy::Context.with_span(
         operation: 'llm.generate',
+        'langfuse.observation.type' => 'generation',
+        'langfuse.observation.input' => input_json,
         'gen_ai.system' => provider,
         'gen_ai.request.model' => model,
+        'gen_ai.prompt' => input_json,
         'dspy.signature' => signature_class_name
-      ) do
+      ) do |span|
         result = execution_block.call
         
-        # Add usage data if available
-        if result.respond_to?(:usage) && result.usage
-          usage = result.usage
-          DSPy.log('span.attributes',
-            span_id: DSPy::Context.current[:span_stack].last,
-            'gen_ai.response.model' => result.metadata.model,
-            'gen_ai.usage.prompt_tokens' => usage.input_tokens,
-            'gen_ai.usage.completion_tokens' => usage.output_tokens,
-            'gen_ai.usage.total_tokens' => usage.total_tokens
-          )
+        # Add output and usage data directly to span
+        if span && result
+          # Add completion output
+          if result.content
+            span.set_attribute('langfuse.observation.output', result.content)
+            span.set_attribute('gen_ai.completion', result.content)
+          end
+          
+          # Add response model if available
+          if result.respond_to?(:metadata) && result.metadata&.model
+            span.set_attribute('gen_ai.response.model', result.metadata.model)
+          end
+          
+          # Add token usage
+          if result.respond_to?(:usage) && result.usage
+            usage = result.usage
+            span.set_attribute('gen_ai.usage.prompt_tokens', usage.input_tokens) if usage.input_tokens
+            span.set_attribute('gen_ai.usage.completion_tokens', usage.output_tokens) if usage.output_tokens
+            span.set_attribute('gen_ai.usage.total_tokens', usage.total_tokens) if usage.total_tokens
+          end
         end
         
         result

data/lib/dspy/observability.rb

@@ -20,7 +20,7 @@ module DSPy
 
         # Determine endpoint based on host
         host = ENV['LANGFUSE_HOST'] || 'https://cloud.langfuse.com'
-        @endpoint = "#{host}/api/public/otel"
+        @endpoint = "#{host}/api/public/otel/v1/traces"
 
         begin
           # Load OpenTelemetry gems
@@ -73,6 +73,10 @@ module DSPy
         @enabled == true
       end
 
+      def tracer
+        @tracer
+      end
+
       def start_span(operation_name, attributes = {})
         return nil unless enabled? && tracer
 
@@ -99,6 +103,15 @@ module DSPy
         DSPy.log('observability.span_finish_error', error: e.message)
       end
 
+      def flush!
+        return unless enabled?
+        
+        # Force flush any pending spans
+        OpenTelemetry.tracer_provider.force_flush
+      rescue StandardError => e
+        DSPy.log('observability.flush_error', error: e.message)
+      end
+
       def reset!
         @enabled = false
         @tracer = nil

data/lib/dspy/predict.rb

@@ -141,9 +141,11 @@ module DSPy
       # Wrap prediction in span tracking
       DSPy::Context.with_span(
         operation: "#{self.class.name}.forward",
+        'langfuse.observation.type' => 'span',
+        'langfuse.observation.input' => input_values.to_json,
         'dspy.module' => self.class.name,
         'dspy.signature' => @signature_class.name
-      ) do
+      ) do |span|
         # Validate input
         validate_input_struct(input_values)
         
@@ -158,7 +160,15 @@ module DSPy
         processed_output = process_lm_output(output_attributes)
         
         # Create combined result struct
-        create_prediction_result(input_values, processed_output)
+        prediction_result = create_prediction_result(input_values, processed_output)
+        
+        # Add output to span
+        if span && prediction_result
+          output_hash = prediction_result.respond_to?(:to_h) ? prediction_result.to_h : prediction_result.to_s
+          span.set_attribute('langfuse.observation.output', output_hash.to_json)
+        end
+        
+        prediction_result
       end
     end
 

data/lib/dspy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DSPy
-  VERSION = "0.24.0"
+  VERSION = "0.24.2"
 end

data/lib/dspy.rb

@@ -99,8 +99,21 @@ module DSPy
     logger.info(attributes)
   end
 
+  # Internal events that should not create OpenTelemetry spans
+  INTERNAL_EVENTS = [
+    'span.start', 
+    'span.end', 
+    'span.attributes',
+    'observability.disabled',
+    'observability.error',
+    'observability.span_error',
+    'observability.span_finish_error',
+    'event.span_creation_error'
+  ].freeze
+
   def self.create_event_span(event_name, attributes)
     return unless DSPy::Observability.enabled?
+    return if INTERNAL_EVENTS.include?(event_name)
     
     begin
       # Flatten nested hashes for OpenTelemetry span attributes

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.24.2
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: 0.22.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: 0.22.0
 - !ruby/object:Gem::Dependency
   name: anthropic
   requirement: !ruby/object:Gem::Requirement