langfuse 0.1.0

data/lib/langfuse/models/ingestion_event.rb

@@ -0,0 +1,27 @@
+require 'securerandom'
+
+module Langfuse
+  module Models
+    class IngestionEvent
+      attr_accessor :id, :type, :timestamp, :body, :metadata
+
+      def initialize(type:, body:, metadata: nil)
+        @id = SecureRandom.uuid
+        @type = type
+        @timestamp = Time.now.utc.iso8601(3) # Millisecond precision
+        @body = body
+        @metadata = metadata
+      end
+
+      def to_h
+        {
+          id: @id,
+          type: @type,
+          timestamp: @timestamp,
+          body: @body.respond_to?(:to_h) ? @body.to_h : @body,
+          metadata: @metadata
+        }.compact
+      end
+    end
+  end
+end

data/lib/langfuse/models/score.rb

@@ -0,0 +1,31 @@
+require 'securerandom'
+
+module Langfuse
+  module Models
+    class Score
+      attr_accessor :id, :trace_id, :name, :value, :observation_id,
+                    :comment, :data_type, :config_id, :environment
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+        @id ||= SecureRandom.uuid
+      end
+
+      def to_h
+        {
+          id: @id,
+          traceId: @trace_id,
+          name: @name,
+          value: @value,
+          observationId: @observation_id,
+          comment: @comment,
+          dataType: @data_type,
+          configId: @config_id,
+          environment: @environment
+        }.compact
+      end
+    end
+  end
+end

data/lib/langfuse/models/span.rb

@@ -0,0 +1,37 @@
+require 'securerandom'
+
+module Langfuse
+  module Models
+    class Span
+      attr_accessor :id, :trace_id, :name, :start_time, :end_time,
+                    :metadata, :input, :output, :level, :status_message,
+                    :parent_observation_id, :version, :environment
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+        @id ||= SecureRandom.uuid
+        @start_time ||= Time.now.utc
+      end
+
+      def to_h
+        {
+          id: @id,
+          traceId: @trace_id,
+          name: @name,
+          startTime: @start_time&.iso8601(3),
+          endTime: @end_time&.iso8601(3),
+          metadata: @metadata,
+          input: @input,
+          output: @output,
+          level: @level,
+          statusMessage: @status_message,
+          parentObservationId: @parent_observation_id,
+          version: @version,
+          environment: @environment
+        }.compact
+      end
+    end
+  end
+end

data/lib/langfuse/models/trace.rb

@@ -0,0 +1,37 @@
+require 'securerandom'
+
+module Langfuse
+  module Models
+    class Trace
+      attr_accessor :id, :name, :user_id, :input, :output,
+                    :session_id, :metadata, :tags, :public,
+                    :release, :version, :timestamp, :environment
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+        @id ||= SecureRandom.uuid
+        @timestamp ||= Time.now.utc
+      end
+
+      def to_h
+        {
+          id: @id,
+          name: @name,
+          userId: @user_id,
+          input: @input,
+          output: @output,
+          sessionId: @session_id,
+          metadata: @metadata,
+          tags: @tags,
+          public: @public,
+          release: @release,
+          version: @version,
+          timestamp: @timestamp&.iso8601(3),
+          environment: @environment
+        }.compact
+      end
+    end
+  end
+end

data/lib/langfuse/models/usage.rb

@@ -0,0 +1,30 @@
+module Langfuse
+  module Models
+    class Usage
+      attr_accessor :input, :output, :total, :unit,
+                    :input_cost, :output_cost, :total_cost,
+                    :prompt_tokens, :completion_tokens, :total_tokens
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+
+      def to_h
+        {
+          input: @input,
+          output: @output,
+          total: @total,
+          unit: @unit,
+          inputCost: @input_cost,
+          outputCost: @output_cost,
+          totalCost: @total_cost,
+          promptTokens: @prompt_tokens,
+          completionTokens: @completion_tokens,
+          totalTokens: @total_tokens
+        }.compact
+      end
+    end
+  end
+end

data/lib/langfuse/rails.rb

@@ -0,0 +1,31 @@
+require 'active_support/notifications'
+
+module Langfuse
+  module Rails
+    class << self
+      def setup_notifications
+        ActiveSupport::Notifications.subscribe(/langfuse/) do |name, start, finish, _id, payload|
+          case name
+          when 'langfuse.trace'
+            Langfuse.trace(payload)
+          when 'langfuse.span'
+            # Set end_time based on notification timing if not provided
+            payload[:end_time] ||= finish
+            payload[:start_time] ||= start
+            Langfuse.span(payload)
+          when 'langfuse.generation'
+            # Set end_time based on notification timing if not provided
+            payload[:end_time] ||= finish
+            payload[:start_time] ||= start
+            Langfuse.generation(payload)
+          when 'langfuse.score'
+            Langfuse.score(payload)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Set up notifications if we're in a Rails environment
+Langfuse::Rails.setup_notifications if defined?(::Rails)

data/lib/langfuse/version.rb

@@ -0,0 +1,3 @@
+module Langfuse
+  VERSION = '0.1.0'
+end

data/lib/langfuse.rb

@@ -0,0 +1,71 @@
+require 'langfuse/version'
+require 'langfuse/configuration'
+
+# Load models
+require 'langfuse/models/ingestion_event'
+require 'langfuse/models/trace'
+require 'langfuse/models/span'
+require 'langfuse/models/generation'
+require 'langfuse/models/event'
+require 'langfuse/models/score'
+require 'langfuse/models/usage'
+
+# Load API client
+require 'langfuse/api_client'
+
+# Load batch worker (works with or without Sidekiq)
+require 'langfuse/batch_worker'
+
+# Load main client
+require 'langfuse/client'
+
+module Langfuse
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    # Convenience delegators to the client instance
+    def trace(attributes = {})
+      Client.instance.trace(attributes)
+    end
+
+    def span(attributes = {})
+      Client.instance.span(attributes)
+    end
+
+    def update_span(span)
+      Client.instance.update_span(span)
+    end
+
+    def generation(attributes = {})
+      Client.instance.generation(attributes)
+    end
+
+    def update_generation(generation)
+      Client.instance.update_generation(generation)
+    end
+
+    def event(attributes = {})
+      Client.instance.event(attributes)
+    end
+
+    def score(attributes = {})
+      Client.instance.score(attributes)
+    end
+
+    def flush
+      Client.instance.flush
+    end
+
+    def shutdown
+      Client.instance.shutdown
+    end
+  end
+end

data/lib/langfuse_context.rb

@@ -0,0 +1,33 @@
+class LangfuseContext
+  def self.current
+    Thread.current[:langfuse_context] ||= {}
+  end
+
+  def self.current_trace_id
+    current[:trace_id]
+  end
+
+  def self.current_span_id
+    current[:span_id]
+  end
+
+  def self.with_trace(trace)
+    old_context = current.dup
+    begin
+      Thread.current[:langfuse_context] = { trace_id: trace.id }
+      yield
+    ensure
+      Thread.current[:langfuse_context] = old_context
+    end
+  end
+
+  def self.with_span(span)
+    old_context = current.dup
+    begin
+      Thread.current[:langfuse_context] = current.merge({ span_id: span.id })
+      yield
+    ensure
+      Thread.current[:langfuse_context] = old_context
+    end
+  end
+end

data/lib/langfuse_helper.rb

@@ -0,0 +1,176 @@
+require_relative 'langfuse_context'
+
+module LangfuseHelper
+  # Execute a block within the context of a span
+  def with_span(name:, trace_id:, parent_id: nil, input: nil, **attributes)
+    # Create the span
+    span = Langfuse.span(
+      name: name,
+      trace_id: trace_id,
+      parent_observation_id: parent_id,
+      input: input,
+      **attributes
+    )
+
+    with_span_implementation(span) { yield(span) }
+  end
+
+  # Execute a block within the context of an LLM generation
+  def with_generation(name:, trace_id:, model:, input:, parent_id: nil, model_parameters: {}, **attributes)
+    # Create the generation
+    generation = Langfuse.generation(
+      name: name,
+      trace_id: trace_id,
+      parent_observation_id: parent_id,
+      model: model,
+      input: input,
+      model_parameters: model_parameters,
+      **attributes
+    )
+
+    start_time = Time.now
+    result = nil
+    error = nil
+
+    begin
+      # Execute the block with the generation passed as argument
+      result = yield(generation)
+      result
+    rescue StandardError => e
+      # Capture any error
+      error = e
+      raise
+    ensure
+      # Always update the generation with results
+      generation.end_time = Time.now.utc
+      generation.start_time = start_time.utc
+
+      # Add output if there was a result and it wasn't already set
+      generation.output = result if result && !generation.output
+
+      # Add error information if there was an error
+      if error
+        generation.level = 'ERROR'
+        generation.status_message = error.message
+        generation.metadata ||= {}
+        generation.metadata[:error_backtrace] = error.backtrace.first(10) if error.backtrace
+      end
+
+      # Update the generation
+      Langfuse.update_generation(generation)
+    end
+  end
+
+  # Execute a block within the context of a trace
+  def with_trace(name:, user_id: nil, **attributes)
+    # Create the trace
+    trace = Langfuse.trace(
+      name: name,
+      user_id: user_id,
+      **attributes
+    )
+
+    result = nil
+    error = nil
+
+    begin
+      # Execute the block with the trace passed as argument
+      result = yield(trace)
+      result
+    rescue StandardError => e
+      # Capture any error
+      error = e
+      raise
+    ensure
+      # Update trace output if available
+      if result && !trace.output
+        trace.output = result.is_a?(String) ? result : result
+
+        # Create a new trace event to update the trace
+        Langfuse.trace(
+          id: trace.id,
+          output: trace.output
+        )
+      end
+
+      # Ensure all events are sent (only in case of error, otherwise let the automatic flushing handle it)
+      Langfuse.flush if error
+    end
+  end
+
+  # Create a trace and set it as the current context
+  def with_context_trace(name:, user_id: nil, **attributes)
+    trace = Langfuse.trace(
+      name: name,
+      user_id: user_id,
+      **attributes
+    )
+
+    LangfuseContext.with_trace(trace) do
+      yield(trace)
+    end
+  end
+
+  # Create a span using the current trace context
+  def with_context_span(name:, input: nil, **attributes)
+    # Get trace_id from context
+    trace_id = LangfuseContext.current_trace_id
+    parent_id = LangfuseContext.current_span_id
+
+    raise 'No trace context found. Make sure to call within with_context_trace' if trace_id.nil?
+
+    span = Langfuse.span(
+      name: name,
+      trace_id: trace_id,
+      parent_observation_id: parent_id,
+      input: input,
+      **attributes
+    )
+
+    LangfuseContext.with_span(span) do
+      # Execute the block with the span
+      with_span_implementation(span) { yield(span) }
+    end
+  end
+
+  # Add a score to a trace
+  def score_trace(trace_id:, name:, value:, comment: nil)
+    Langfuse.score(
+      trace_id: trace_id,
+      name: name,
+      value: value,
+      comment: comment
+    )
+  end
+
+  private
+
+  def with_span_implementation(span)
+    Time.now
+    result = nil
+    error = nil
+
+    begin
+      # Execute the block with the span passed as argument
+      result = yield
+      result
+    rescue StandardError => e
+      # Capture any error
+      error = e
+      raise
+    ensure
+      # Update span
+      span.end_time = Time.now.utc
+      span.output = result if result && !span.output
+
+      if error
+        span.level = 'ERROR'
+        span.status_message = error.message
+        span.metadata ||= {}
+        span.metadata[:error_backtrace] = error.backtrace.first(10) if error.backtrace
+      end
+
+      Langfuse.update_span(span)
+    end
+  end
+end