added observable

lib/llm_eval_ruby.rb

@@ -4,6 +4,7 @@
 require_relative "llm_eval_ruby/prompt_repository"
 require_relative "llm_eval_ruby/configuration"
 require_relative "llm_eval_ruby/tracer"
+require_relative "llm_eval_ruby/observable"
 
 module LlmEvalRuby
   class Error < StandardError; end

lib/llm_eval_ruby/api_clients/langfuse.rb

@@ -27,6 +27,7 @@ def create_trace(params = {})
         body = {
           id: params[:id],
           name: params[:name],
+          input: params[:input],
           sessionId: params[:session_id]
         }
         create_event(type: "trace-create", body:)
@@ -36,6 +37,7 @@ def create_span(params = {})
         body = {
           id: params[:id],
           name: params[:name],
+          input: params[:input],
           traceId: params[:trace_id]
         }
         create_event(type: "span-create", body:)

lib/llm_eval_ruby/observable.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module LlmEvalRuby
+  module Observable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def observed_methods
+        @observed_methods ||= {}
+      end
+
+      def observe(method_name, options = {})
+        observed_methods[method_name] = options
+      end
+
+      def method_added(method_name)
+        return unless observed_methods.key?(method_name)
+
+        options = observed_methods[method_name]
+
+        original_method = instance_method(method_name)
+        observed_methods.delete(method_name)
+
+        define_method(method_name) do |*args, **kwargs, &block|
+          result = nil
+          input = prepare_input(args, kwargs)
+          case options[:type]
+          when :span
+            LlmEvalRuby::Tracer.span(name: method_name, input: input, trace_id: @trace_id) do
+              result = original_method.bind(self).call(*args, **kwargs, &block)
+            end
+          when :generation
+            LlmEvalRuby::Tracer.generation(name: method_name, input: input, trace_id: @trace_id) do
+              result = original_method.bind(self).call(*args, **kwargs, &block)
+            end
+          else
+            LlmEvalRuby::Tracer.trace(name: method_name, input: input, trace_id: @trace_id) do
+              result = original_method.bind(self).call(*args, **kwargs, &block)
+            end
+          end
+
+          result
+        end
+      end
+    end
+
+    def prepare_input(*args, **kwargs)
+      return nil if args.empty? && kwargs.empty?
+
+      Array[*args, **kwargs].flatten
+    end
+  end
+end

lib/llm_eval_ruby/trace_types.rb

@@ -2,9 +2,9 @@
 
 module LlmEvalRuby
   module TraceTypes
-    Trace = Struct.new(:id, :name, :session_id, keyword_init: true)
+    Trace = Struct.new(:id, :name, :input, :output, :session_id, keyword_init: true)
 
-    Span = Struct.new(:id, :name, :trace_id, :output, :end_time, keyword_init: true)
+    Span = Struct.new(:id, :name, :trace_id, :input, :output, :end_time, keyword_init: true)
 
     Generation = Struct.new(:tracer,
                             :id,

lib/llm_eval_ruby/tracer.rb

@@ -2,6 +2,7 @@
 
 require_relative "trace_adapters/langfuse"
 require_relative "trace_adapters/local"
+
 module LlmEvalRuby
   class Tracer
     attr_reader :adapter

lib/serializers/generation_serializer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class GenerationSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(generation)
+    super({
+      "id" => generation.id,
+      "name" => generation.name,
+      "input" => generation.input,
+      "prompt_name" => generation.prompt_name,
+      "prompt_version" => generation.prompt_version,
+      "trace_id" => generation.trace_id,
+      "output" => generation.output,
+      "end_time" => generation.end_time,
+      "usage" => generation.usage
+    })
+  end
+
+  def deserialize(hash)
+    klass.new(
+      tracer: hash["tracer"],
+      id: hash["id"],
+      name: hash["name"],
+      input: hash["input"],
+      prompt_name: hash["prompt_name"],
+      prompt_version: hash["prompt_version"],
+      trace_id: hash["trace_id"],
+      output: hash["output"],
+      end_time: hash["end_time"],
+      usage: hash["usage"]
+    )
+  end
+
+  private
+
+  def klass
+    LlmEvalRuby::TraceTypes::Generation
+  end
+end

lib/serializers/trace_serializer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class TraceSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(trace)
+    super({
+      "id" => trace.id,
+      "session_id" => trace.session_id
+    })
+  end
+
+  def deserialize(hash)
+    klass.new(
+      id: hash["id"],
+      session_id: hash["session_id"]
+    )
+  end
+
+  private
+
+  def klass
+    LlmEvalRuby::TraceTypes::Trace
+  end
+end