langfuse-ruby 0.1.0

data/lib/langfuse/generation.rb

@@ -0,0 +1,190 @@
+module Langfuse
+  class Generation
+    attr_reader :id, :trace_id, :name, :start_time, :end_time, :completion_start_time,
+                :model, :model_parameters, :input, :output, :usage, :metadata, :level,
+                :status_message, :parent_observation_id, :version, :client
+
+    def initialize(client:, trace_id:, id: nil, name: nil, start_time: nil, end_time: nil,
+                   completion_start_time: nil, model: nil, model_parameters: nil, input: nil,
+                   output: nil, usage: nil, metadata: nil, level: nil, status_message: nil,
+                   parent_observation_id: nil, version: nil, **kwargs)
+      @client = client
+      @id = id || Utils.generate_id
+      @trace_id = trace_id
+      @name = name
+      @start_time = start_time
+      @end_time = end_time
+      @completion_start_time = completion_start_time
+      @model = model
+      @model_parameters = model_parameters || {}
+      @input = input
+      @output = output
+      @usage = usage || {}
+      @metadata = metadata || {}
+      @level = level
+      @status_message = status_message
+      @parent_observation_id = parent_observation_id
+      @version = version
+      @kwargs = kwargs
+
+      # Create the generation
+      create_generation
+    end
+
+    def update(name: nil, end_time: nil, completion_start_time: nil, model: nil,
+               model_parameters: nil, input: nil, output: nil, usage: nil, metadata: nil,
+               level: nil, status_message: nil, version: nil, **kwargs)
+      @name = name if name
+      @end_time = end_time if end_time
+      @completion_start_time = completion_start_time if completion_start_time
+      @model = model if model
+      @model_parameters.merge!(model_parameters) if model_parameters
+      @input = input if input
+      @output = output if output
+      @usage.merge!(usage) if usage
+      @metadata.merge!(metadata) if metadata
+      @level = level if level
+      @status_message = status_message if status_message
+      @version = version if version
+      @kwargs.merge!(kwargs)
+
+      update_generation
+      self
+    end
+
+    def end(output: nil, end_time: nil, usage: nil, **kwargs)
+      @end_time = end_time || Utils.current_timestamp
+      @output = output if output
+      @usage.merge!(usage) if usage
+      @kwargs.merge!(kwargs)
+
+      update_generation
+      self
+    end
+
+    def span(name: nil, start_time: nil, end_time: nil, input: nil, output: nil,
+             metadata: nil, level: nil, status_message: nil, version: nil, **kwargs)
+      @client.span(
+        trace_id: @trace_id,
+        name: name,
+        start_time: start_time,
+        end_time: end_time,
+        input: input,
+        output: output,
+        metadata: metadata,
+        level: level,
+        status_message: status_message,
+        parent_observation_id: @id,
+        version: version,
+        **kwargs
+      )
+    end
+
+    def generation(name: nil, start_time: nil, end_time: nil, completion_start_time: nil,
+                   model: nil, model_parameters: nil, input: nil, output: nil, usage: nil,
+                   metadata: nil, level: nil, status_message: nil, version: nil, **kwargs)
+      @client.generation(
+        trace_id: @trace_id,
+        name: name,
+        start_time: start_time,
+        end_time: end_time,
+        completion_start_time: completion_start_time,
+        model: model,
+        model_parameters: model_parameters,
+        input: input,
+        output: output,
+        usage: usage,
+        metadata: metadata,
+        level: level,
+        status_message: status_message,
+        parent_observation_id: @id,
+        version: version,
+        **kwargs
+      )
+    end
+
+    def score(name:, value:, data_type: nil, comment: nil, **kwargs)
+      @client.score(
+        observation_id: @id,
+        name: name,
+        value: value,
+        data_type: data_type,
+        comment: comment,
+        **kwargs
+      )
+    end
+
+    def get_url
+      "#{@client.host}/trace/#{@trace_id}?observation=#{@id}"
+    end
+
+    def to_dict
+      {
+        id: @id,
+        trace_id: @trace_id,
+        name: @name,
+        start_time: @start_time,
+        end_time: @end_time,
+        completion_start_time: @completion_start_time,
+        model: @model,
+        model_parameters: @model_parameters,
+        input: @input,
+        output: @output,
+        usage: @usage,
+        metadata: @metadata,
+        level: @level,
+        status_message: @status_message,
+        parent_observation_id: @parent_observation_id,
+        version: @version
+      }.merge(@kwargs).compact
+    end
+
+    private
+
+    def create_generation
+      data = {
+        id: @id,
+        trace_id: @trace_id,
+        name: @name,
+        start_time: @start_time,
+        end_time: @end_time,
+        completion_start_time: @completion_start_time,
+        model: @model,
+        model_parameters: @model_parameters,
+        input: @input,
+        output: @output,
+        usage: @usage,
+        metadata: @metadata,
+        level: @level,
+        status_message: @status_message,
+        parent_observation_id: @parent_observation_id,
+        version: @version
+      }.merge(@kwargs).compact
+
+      @client.enqueue_event('generation-create', data)
+    end
+
+    def update_generation
+      data = {
+        id: @id,
+        trace_id: @trace_id,
+        name: @name,
+        start_time: @start_time,
+        end_time: @end_time,
+        completion_start_time: @completion_start_time,
+        model: @model,
+        model_parameters: @model_parameters,
+        input: @input,
+        output: @output,
+        usage: @usage,
+        metadata: @metadata,
+        level: @level,
+        status_message: @status_message,
+        parent_observation_id: @parent_observation_id,
+        version: @version
+      }.merge(@kwargs).compact
+
+      @client.enqueue_event('generation-update', data)
+    end
+  end
+end

data/lib/langfuse/prompt.rb

@@ -0,0 +1,209 @@
+module Langfuse
+  class Prompt
+    attr_reader :id, :name, :version, :prompt, :config, :labels, :tags, :type, :created_at, :updated_at
+
+    def initialize(data)
+      @data = data.is_a?(Hash) ? Utils.deep_symbolize_keys(data) : data
+
+      @id = @data[:id]
+      @name = @data[:name]
+      @version = @data[:version]
+      @prompt = @data[:prompt]
+      @config = @data[:config] || {}
+      @labels = @data[:labels] || []
+      @tags = @data[:tags] || []
+      @type = @data[:type]
+      @created_at = @data[:created_at]
+      @updated_at = @data[:updated_at]
+    end
+
+    def get_langchain_prompt
+      # Convert Langfuse prompt format to LangChain format
+      case @type
+      when 'text'
+        text_to_langchain_prompt
+      when 'chat'
+        chat_to_langchain_prompt
+      else
+        raise ValidationError, "Unsupported prompt type: #{@type}"
+      end
+    end
+
+    def compile(variables = {})
+      # Compile prompt with variables
+      case @type
+      when 'text'
+        compile_text_prompt(variables)
+      when 'chat'
+        compile_chat_prompt(variables)
+      else
+        raise ValidationError, "Unsupported prompt type: #{@type}"
+      end
+    end
+
+    def to_dict
+      {
+        id: @id,
+        name: @name,
+        version: @version,
+        prompt: @prompt,
+        config: @config,
+        labels: @labels,
+        tags: @tags,
+        type: @type,
+        created_at: @created_at,
+        updated_at: @updated_at
+      }
+    end
+
+    private
+
+    def text_to_langchain_prompt
+      # Convert text prompt to LangChain PromptTemplate format
+      {
+        _type: "prompt",
+        input_variables: extract_variables(@prompt),
+        template: @prompt
+      }
+    end
+
+    def chat_to_langchain_prompt
+      # Convert chat prompt to LangChain ChatPromptTemplate format
+      messages = @prompt.map do |message|
+        {
+          _type: "#{message[:role]}_message",
+          content: message[:content],
+          input_variables: extract_variables(message[:content])
+        }
+      end
+
+      {
+        _type: "chat",
+        messages: messages,
+        input_variables: messages.flat_map { |m| m[:input_variables] }.uniq
+      }
+    end
+
+    def compile_text_prompt(variables)
+      compiled = @prompt.dup
+      variables.each do |key, value|
+        compiled.gsub!("{{#{key}}}", value.to_s)
+        compiled.gsub!("{#{key}}", value.to_s)
+      end
+      compiled
+    end
+
+    def compile_chat_prompt(variables)
+      @prompt.map do |message|
+        compiled_content = message[:content].dup
+        variables.each do |key, value|
+          compiled_content.gsub!("{{#{key}}}", value.to_s)
+          compiled_content.gsub!("{#{key}}", value.to_s)
+        end
+
+        {
+          role: message[:role],
+          content: compiled_content
+        }
+      end
+    end
+
+    def extract_variables(text)
+      # Extract variables from template text (supports {{var}} and {var} formats)
+      variables = []
+
+      # Match {{variable}} format
+      text.scan(/\{\{(\w+)\}\}/) do |match|
+        variables << match[0]
+      end
+
+      # Match {variable} format
+      text.scan(/\{(\w+)\}/) do |match|
+        variables << match[0] unless variables.include?(match[0])
+      end
+
+      variables
+    end
+  end
+
+  class PromptTemplate
+    attr_reader :template, :input_variables
+
+    def initialize(template:, input_variables: [])
+      @template = template
+      @input_variables = input_variables
+    end
+
+    def format(variables = {})
+      compiled = @template.dup
+      variables.each do |key, value|
+        compiled.gsub!("{{#{key}}}", value.to_s)
+        compiled.gsub!("{#{key}}", value.to_s)
+      end
+      compiled
+    end
+
+    def self.from_template(template)
+      variables = extract_variables(template)
+      new(template: template, input_variables: variables)
+    end
+
+    private
+
+    def self.extract_variables(text)
+      variables = []
+
+      # Match {{variable}} format
+      text.scan(/\{\{(\w+)\}\}/) do |match|
+        variables << match[0]
+      end
+
+      # Match {variable} format
+      text.scan(/\{(\w+)\}/) do |match|
+        variables << match[0] unless variables.include?(match[0])
+      end
+
+      variables
+    end
+  end
+
+  class ChatPromptTemplate
+    attr_reader :messages, :input_variables
+
+    def initialize(messages:, input_variables: [])
+      @messages = messages
+      @input_variables = input_variables
+    end
+
+    def format(variables = {})
+      @messages.map do |message|
+        compiled_content = message[:content].dup
+        variables.each do |key, value|
+          compiled_content.gsub!("{{#{key}}}", value.to_s)
+          compiled_content.gsub!("{#{key}}", value.to_s)
+        end
+
+        {
+          role: message[:role],
+          content: compiled_content
+        }
+      end
+    end
+
+    def self.from_messages(messages)
+      input_variables = []
+
+      messages.each do |message|
+        message[:content].scan(/\{\{(\w+)\}\}/) do |match|
+          input_variables << match[0] unless input_variables.include?(match[0])
+        end
+
+        message[:content].scan(/\{(\w+)\}/) do |match|
+          input_variables << match[0] unless input_variables.include?(match[0])
+        end
+      end
+
+      new(messages: messages, input_variables: input_variables)
+    end
+  end
+end

data/lib/langfuse/span.rb

@@ -0,0 +1,166 @@
+module Langfuse
+  class Span
+    attr_reader :id, :trace_id, :name, :start_time, :end_time, :input, :output,
+                :metadata, :level, :status_message, :parent_observation_id, :version, :client
+
+    def initialize(client:, trace_id:, id: nil, name: nil, start_time: nil, end_time: nil,
+                   input: nil, output: nil, metadata: nil, level: nil, status_message: nil,
+                   parent_observation_id: nil, version: nil, **kwargs)
+      @client = client
+      @id = id || Utils.generate_id
+      @trace_id = trace_id
+      @name = name
+      @start_time = start_time
+      @end_time = end_time
+      @input = input
+      @output = output
+      @metadata = metadata || {}
+      @level = level
+      @status_message = status_message
+      @parent_observation_id = parent_observation_id
+      @version = version
+      @kwargs = kwargs
+
+      # Create the span
+      create_span
+    end
+
+    def update(name: nil, end_time: nil, input: nil, output: nil, metadata: nil,
+               level: nil, status_message: nil, version: nil, **kwargs)
+      @name = name if name
+      @end_time = end_time if end_time
+      @input = input if input
+      @output = output if output
+      @metadata.merge!(metadata) if metadata
+      @level = level if level
+      @status_message = status_message if status_message
+      @version = version if version
+      @kwargs.merge!(kwargs)
+
+      update_span
+      self
+    end
+
+    def end(output: nil, end_time: nil, **kwargs)
+      @end_time = end_time || Utils.current_timestamp
+      @output = output if output
+      @kwargs.merge!(kwargs)
+
+      update_span
+      self
+    end
+
+    def span(name: nil, start_time: nil, end_time: nil, input: nil, output: nil,
+             metadata: nil, level: nil, status_message: nil, version: nil, **kwargs)
+      @client.span(
+        trace_id: @trace_id,
+        name: name,
+        start_time: start_time,
+        end_time: end_time,
+        input: input,
+        output: output,
+        metadata: metadata,
+        level: level,
+        status_message: status_message,
+        parent_observation_id: @id,
+        version: version,
+        **kwargs
+      )
+    end
+
+    def generation(name: nil, start_time: nil, end_time: nil, completion_start_time: nil,
+                   model: nil, model_parameters: nil, input: nil, output: nil, usage: nil,
+                   metadata: nil, level: nil, status_message: nil, version: nil, **kwargs)
+      @client.generation(
+        trace_id: @trace_id,
+        name: name,
+        start_time: start_time,
+        end_time: end_time,
+        completion_start_time: completion_start_time,
+        model: model,
+        model_parameters: model_parameters,
+        input: input,
+        output: output,
+        usage: usage,
+        metadata: metadata,
+        level: level,
+        status_message: status_message,
+        parent_observation_id: @id,
+        version: version,
+        **kwargs
+      )
+    end
+
+    def score(name:, value:, data_type: nil, comment: nil, **kwargs)
+      @client.score(
+        observation_id: @id,
+        name: name,
+        value: value,
+        data_type: data_type,
+        comment: comment,
+        **kwargs
+      )
+    end
+
+    def get_url
+      "#{@client.host}/trace/#{@trace_id}?observation=#{@id}"
+    end
+
+    def to_dict
+      {
+        id: @id,
+        trace_id: @trace_id,
+        name: @name,
+        start_time: @start_time,
+        end_time: @end_time,
+        input: @input,
+        output: @output,
+        metadata: @metadata,
+        level: @level,
+        status_message: @status_message,
+        parent_observation_id: @parent_observation_id,
+        version: @version
+      }.merge(@kwargs).compact
+    end
+
+    private
+
+    def create_span
+      data = {
+        id: @id,
+        trace_id: @trace_id,
+        name: @name,
+        start_time: @start_time,
+        end_time: @end_time,
+        input: @input,
+        output: @output,
+        metadata: @metadata,
+        level: @level,
+        status_message: @status_message,
+        parent_observation_id: @parent_observation_id,
+        version: @version
+      }.merge(@kwargs).compact
+
+      @client.enqueue_event('span-create', data)
+    end
+
+    def update_span
+      data = {
+        id: @id,
+        trace_id: @trace_id,
+        name: @name,
+        start_time: @start_time,
+        end_time: @end_time,
+        input: @input,
+        output: @output,
+        metadata: @metadata,
+        level: @level,
+        status_message: @status_message,
+        parent_observation_id: @parent_observation_id,
+        version: @version
+      }.merge(@kwargs).compact
+
+      @client.enqueue_event('span-update', data)
+    end
+  end
+end

data/lib/langfuse/trace.rb

@@ -0,0 +1,155 @@
+module Langfuse
+  class Trace
+    attr_reader :id, :name, :user_id, :session_id, :version, :release, :input, :output,
+                :metadata, :tags, :timestamp, :client
+
+    def initialize(client:, id:, name: nil, user_id: nil, session_id: nil, version: nil,
+                   release: nil, input: nil, output: nil, metadata: nil, tags: nil,
+                   timestamp: nil, **kwargs)
+      @client = client
+      @id = id
+      @name = name
+      @user_id = user_id
+      @session_id = session_id
+      @version = version
+      @release = release
+      @input = input
+      @output = output
+      @metadata = metadata || {}
+      @tags = tags || []
+      @timestamp = timestamp
+      @kwargs = kwargs
+
+      # Create the trace
+      create_trace
+    end
+
+    def update(name: nil, user_id: nil, session_id: nil, version: nil, release: nil,
+               input: nil, output: nil, metadata: nil, tags: nil, **kwargs)
+      @name = name if name
+      @user_id = user_id if user_id
+      @session_id = session_id if session_id
+      @version = version if version
+      @release = release if release
+      @input = input if input
+      @output = output if output
+      @metadata.merge!(metadata) if metadata
+      @tags.concat(tags) if tags
+      @kwargs.merge!(kwargs)
+
+      update_trace
+      self
+    end
+
+    def span(name: nil, start_time: nil, end_time: nil, input: nil, output: nil,
+             metadata: nil, level: nil, status_message: nil, parent_observation_id: nil,
+             version: nil, **kwargs)
+      @client.span(
+        trace_id: @id,
+        name: name,
+        start_time: start_time,
+        end_time: end_time,
+        input: input,
+        output: output,
+        metadata: metadata,
+        level: level,
+        status_message: status_message,
+        parent_observation_id: parent_observation_id,
+        version: version,
+        **kwargs
+      )
+    end
+
+    def generation(name: nil, start_time: nil, end_time: nil, completion_start_time: nil,
+                   model: nil, model_parameters: nil, input: nil, output: nil, usage: nil,
+                   metadata: nil, level: nil, status_message: nil, parent_observation_id: nil,
+                   version: nil, **kwargs)
+      @client.generation(
+        trace_id: @id,
+        name: name,
+        start_time: start_time,
+        end_time: end_time,
+        completion_start_time: completion_start_time,
+        model: model,
+        model_parameters: model_parameters,
+        input: input,
+        output: output,
+        usage: usage,
+        metadata: metadata,
+        level: level,
+        status_message: status_message,
+        parent_observation_id: parent_observation_id,
+        version: version,
+        **kwargs
+      )
+    end
+
+    def score(name:, value:, data_type: nil, comment: nil, **kwargs)
+      @client.score(
+        trace_id: @id,
+        name: name,
+        value: value,
+        data_type: data_type,
+        comment: comment,
+        **kwargs
+      )
+    end
+
+    def get_url
+      "#{@client.host}/trace/#{@id}"
+    end
+
+    def to_dict
+      {
+        id: @id,
+        name: @name,
+        user_id: @user_id,
+        session_id: @session_id,
+        version: @version,
+        release: @release,
+        input: @input,
+        output: @output,
+        metadata: @metadata,
+        tags: @tags,
+        timestamp: @timestamp
+      }.merge(@kwargs).compact
+    end
+
+    private
+
+    def create_trace
+      data = {
+        id: @id,
+        name: @name,
+        user_id: @user_id,
+        session_id: @session_id,
+        version: @version,
+        release: @release,
+        input: @input,
+        output: @output,
+        metadata: @metadata,
+        tags: @tags,
+        timestamp: @timestamp
+      }.merge(@kwargs).compact
+
+      @client.enqueue_event('trace-create', data)
+    end
+
+    def update_trace
+      data = {
+        id: @id,
+        name: @name,
+        user_id: @user_id,
+        session_id: @session_id,
+        version: @version,
+        release: @release,
+        input: @input,
+        output: @output,
+        metadata: @metadata,
+        tags: @tags
+      }.merge(@kwargs).compact
+
+      @client.enqueue_event('trace-update', data)
+    end
+  end
+end