dspy 0.3.0 → 0.4.0

data/lib/dspy/subscribers/logger_subscriber.rb

@@ -7,14 +7,20 @@ module DSPy
     class LoggerSubscriber
       extend T::Sig
 
-      sig { params(logger: T.nilable(Logger)).void }
+      sig { params(logger: T.nilable(T.any(Logger, Dry::Logger::Dispatcher))).void }
       def initialize(logger: nil)
-        @logger = T.let(logger || DSPy.config.logger, Logger)
+        @explicit_logger = T.let(logger, T.nilable(T.any(Logger, Dry::Logger::Dispatcher)))
         setup_event_subscriptions
       end
 
       private
 
+      # Always use the current configured logger or the explicit one
+      sig { returns(T.any(Logger, Dry::Logger::Dispatcher)) }
+      def logger
+        @explicit_logger || DSPy.config.logger
+      end
+
       sig { void }
       def setup_event_subscriptions
         # Subscribe to DSPy instrumentation events
@@ -41,6 +47,27 @@ module DSPy
         DSPy::Instrumentation.subscribe('dspy.react.tool_call') do |event|
           log_react_tool_call(event)
         end
+
+        # Subscribe to optimization events
+        DSPy::Instrumentation.subscribe('dspy.optimization.start') do |event|
+          log_optimization_start(event)
+        end
+
+        DSPy::Instrumentation.subscribe('dspy.optimization.complete') do |event|
+          log_optimization_complete(event)
+        end
+
+        DSPy::Instrumentation.subscribe('dspy.optimization.trial_start') do |event|
+          log_optimization_trial_start(event)
+        end
+
+        DSPy::Instrumentation.subscribe('dspy.optimization.trial_complete') do |event|
+          log_optimization_trial_complete(event)
+        end
+
+        DSPy::Instrumentation.subscribe('dspy.optimization.error') do |event|
+          log_optimization_error(event)
+        end
       end
 
       # Callback methods for different event types
@@ -82,18 +109,19 @@ module DSPy
         model = payload[:gen_ai_request_model] || payload[:model]
         duration = payload[:duration_ms]&.round(2)
         status = payload[:status]
-        tokens = if payload[:tokens_total]
-                   " (#{payload[:tokens_total]} tokens)"
-                 else
-                   ""
-                 end
-
-        status_emoji = status == 'success' ? '✅' : '❌'
-        @logger.info("#{status_emoji} LM Request [#{provider}/#{model}] - #{status} (#{duration}ms)#{tokens}")
-        
-        if status == 'error' && payload[:error_message]
-          @logger.error("  Error: #{payload[:error_message]}")
-        end
+        tokens = payload[:tokens_total]
+
+        log_parts = [
+          "event=lm_request",
+          "provider=#{provider}",
+          "model=#{model}",
+          "status=#{status}",
+          "duration_ms=#{duration}"
+        ]
+        log_parts << "tokens=#{tokens}" if tokens
+        log_parts << "error=\"#{payload[:error_message]}\"" if status == 'error' && payload[:error_message]
+
+        logger.info(log_parts.join(' '))
       end
 
       sig { params(event: T.untyped).void }
@@ -104,13 +132,16 @@ module DSPy
         status = payload[:status]
         input_size = payload[:input_size]
 
-        status_emoji = status == 'success' ? '🔮' : '❌'
-        @logger.info("#{status_emoji} Prediction [#{signature}] - #{status} (#{duration}ms)")
-        @logger.info("  Input size: #{input_size} chars") if input_size
-        
-        if status == 'error' && payload[:error_message]
-          @logger.error("  Error: #{payload[:error_message]}")
-        end
+        log_parts = [
+          "event=prediction",
+          "signature=#{signature}",
+          "status=#{status}",
+          "duration_ms=#{duration}"
+        ]
+        log_parts << "input_size=#{input_size}" if input_size
+        log_parts << "error=\"#{payload[:error_message]}\"" if status == 'error' && payload[:error_message]
+
+        logger.info(log_parts.join(' '))
       end
 
       sig { params(event: T.untyped).void }
@@ -122,14 +153,17 @@ module DSPy
         reasoning_steps = payload[:reasoning_steps]
         reasoning_length = payload[:reasoning_length]
 
-        status_emoji = status == 'success' ? '🧠' : '❌'
-        @logger.info("#{status_emoji} Chain of Thought [#{signature}] - #{status} (#{duration}ms)")
-        @logger.info("  Reasoning steps: #{reasoning_steps}") if reasoning_steps
-        @logger.info("  Reasoning length: #{reasoning_length} chars") if reasoning_length
-        
-        if status == 'error' && payload[:error_message]
-          @logger.error("  Error: #{payload[:error_message]}")
-        end
+        log_parts = [
+          "event=chain_of_thought",
+          "signature=#{signature}",
+          "status=#{status}",
+          "duration_ms=#{duration}"
+        ]
+        log_parts << "reasoning_steps=#{reasoning_steps}" if reasoning_steps
+        log_parts << "reasoning_length=#{reasoning_length}" if reasoning_length
+        log_parts << "error=\"#{payload[:error_message]}\"" if status == 'error' && payload[:error_message]
+
+        logger.info(log_parts.join(' '))
       end
 
       sig { params(event: T.untyped).void }
@@ -142,20 +176,18 @@ module DSPy
         tools_used = payload[:tools_used]
         final_answer = payload[:final_answer]
 
-        status_emoji = case status
-                       when 'success' then '🤖'
-                       when 'max_iterations' then '⏰'
-                       else '❌'
-                       end
-        
-        @logger.info("#{status_emoji} ReAct Agent [#{signature}] - #{status} (#{duration}ms)")
-        @logger.info("  Iterations: #{iteration_count}") if iteration_count
-        @logger.info("  Tools used: #{tools_used.join(', ')}") if tools_used&.any?
-        @logger.info("  Final answer: #{final_answer}") if final_answer
-        
-        if status == 'error' && payload[:error_message]
-          @logger.error("  Error: #{payload[:error_message]}")
-        end
+        log_parts = [
+          "event=react",
+          "signature=#{signature}",
+          "status=#{status}",
+          "duration_ms=#{duration}"
+        ]
+        log_parts << "iterations=#{iteration_count}" if iteration_count
+        log_parts << "tools_used=\"#{tools_used.join(',')}\"" if tools_used&.any?
+        log_parts << "final_answer=\"#{final_answer&.truncate(100)}\"" if final_answer
+        log_parts << "error=\"#{payload[:error_message]}\"" if status == 'error' && payload[:error_message]
+
+        logger.info(log_parts.join(' '))
       end
 
       sig { params(event: T.untyped).void }
@@ -167,14 +199,17 @@ module DSPy
         duration = payload[:duration_ms]&.round(2)
         status = payload[:status]
 
-        status_emoji = status == 'success' ? '🔄' : '❌'
-        @logger.info("#{status_emoji} ReAct Iteration #{iteration} - #{status} (#{duration}ms)")
-        @logger.info("  Thought: #{thought.truncate(100)}") if thought
-        @logger.info("  Action: #{action}") if action
-        
-        if status == 'error' && payload[:error_message]
-          @logger.error("  Error: #{payload[:error_message]}")
-        end
+        log_parts = [
+          "event=react_iteration",
+          "iteration=#{iteration}",
+          "status=#{status}",
+          "duration_ms=#{duration}"
+        ]
+        log_parts << "thought=\"#{thought&.truncate(100)}\"" if thought
+        log_parts << "action=\"#{action}\"" if action
+        log_parts << "error=\"#{payload[:error_message]}\"" if status == 'error' && payload[:error_message]
+
+        logger.info(log_parts.join(' '))
       end
 
       sig { params(event: T.untyped).void }
@@ -185,12 +220,115 @@ module DSPy
         duration = payload[:duration_ms]&.round(2)
         status = payload[:status]
 
-        status_emoji = status == 'success' ? '🔧' : '❌'
-        @logger.info("#{status_emoji} Tool Call [#{tool_name}] (Iteration #{iteration}) - #{status} (#{duration}ms)")
-        
-        if status == 'error' && payload[:error_message]
-          @logger.error("  Error: #{payload[:error_message]}")
-        end
+        log_parts = [
+          "event=tool_call",
+          "tool=#{tool_name}",
+          "iteration=#{iteration}",
+          "status=#{status}",
+          "duration_ms=#{duration}"
+        ]
+        log_parts << "error=\"#{payload[:error_message]}\"" if status == 'error' && payload[:error_message]
+
+        logger.info(log_parts.join(' '))
+      end
+
+      # Optimization event logging methods
+      sig { params(event: T.untyped).void }
+      def log_optimization_start(event)
+        payload = event.payload
+        optimization_id = payload[:optimization_id]
+        optimizer = payload[:optimizer]
+        trainset_size = payload[:trainset_size]
+        valset_size = payload[:valset_size]
+
+        log_parts = [
+          "event=optimization_start",
+          "optimization_id=#{optimization_id}",
+          "optimizer=#{optimizer}",
+          "trainset_size=#{trainset_size}"
+        ]
+        log_parts << "valset_size=#{valset_size}" if valset_size
+
+        logger.info(log_parts.join(' '))
+      end
+
+      sig { params(event: T.untyped).void }
+      def log_optimization_complete(event)
+        payload = event.payload
+        optimization_id = payload[:optimization_id]
+        optimizer = payload[:optimizer]
+        duration = payload[:duration_ms]&.round(2)
+        best_score = payload[:best_score]
+        trials_count = payload[:trials_count]
+
+        log_parts = [
+          "event=optimization_complete",
+          "optimization_id=#{optimization_id}",
+          "optimizer=#{optimizer}",
+          "duration_ms=#{duration}"
+        ]
+        log_parts << "best_score=#{best_score}" if best_score
+        log_parts << "trials_count=#{trials_count}" if trials_count
+
+        logger.info(log_parts.join(' '))
+      end
+
+      sig { params(event: T.untyped).void }
+      def log_optimization_trial_start(event)
+        payload = event.payload
+        optimization_id = payload[:optimization_id]
+        trial_number = payload[:trial_number]
+        instruction = payload[:instruction]
+
+        log_parts = [
+          "event=optimization_trial_start",
+          "optimization_id=#{optimization_id}",
+          "trial_number=#{trial_number}"
+        ]
+        log_parts << "instruction=\"#{instruction&.slice(0, 100)}\"" if instruction
+
+        logger.info(log_parts.join(' '))
+      end
+
+      sig { params(event: T.untyped).void }
+      def log_optimization_trial_complete(event)
+        payload = event.payload
+        optimization_id = payload[:optimization_id]
+        trial_number = payload[:trial_number]
+        duration = payload[:duration_ms]&.round(2)
+        score = payload[:score]
+        status = payload[:status]
+
+        log_parts = [
+          "event=optimization_trial_complete",
+          "optimization_id=#{optimization_id}",
+          "trial_number=#{trial_number}",
+          "status=#{status}",
+          "duration_ms=#{duration}"
+        ]
+        log_parts << "score=#{score}" if score
+        log_parts << "error=\"#{payload[:error_message]}\"" if status == 'error' && payload[:error_message]
+
+        logger.info(log_parts.join(' '))
+      end
+
+      sig { params(event: T.untyped).void }
+      def log_optimization_error(event)
+        payload = event.payload
+        optimization_id = payload[:optimization_id]
+        optimizer = payload[:optimizer]
+        error_message = payload[:error_message]
+        error_type = payload[:error_type]
+
+        log_parts = [
+          "event=optimization_error",
+          "optimization_id=#{optimization_id}",
+          "optimizer=#{optimizer}",
+          "error_type=#{error_type}"
+        ]
+        log_parts << "error=\"#{error_message}\"" if error_message
+
+        logger.info(log_parts.join(' '))
       end
     end
   end