langsmithrb_rails 0.1.1 → 0.3.0

data/lib/langsmithrb_rails/run_trees.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module LangsmithrbRails
+  # Run trees for hierarchical tracing
+  class RunTree
+    attr_reader :run_id, :name, :run_type, :inputs, :parent_run_id, :start_time, :children, :project_name, :tags
+
+    # Initialize a new run tree
+    # @param name [String] Name of the run
+    # @param run_type [String] Type of run (e.g., "llm", "chain")
+    # @param inputs [Hash] Input data
+    # @param run_id [String] Optional run ID
+    # @param parent_run_id [String] Optional parent run ID
+    # @param project_name [String] Optional project name
+    # @param tags [Array<String>] Optional tags
+    def initialize(name:, run_type:, inputs:, run_id: nil, parent_run_id: nil, project_name: nil, tags: [])
+      @run_id = run_id || SecureRandom.uuid
+      @name = name
+      @run_type = run_type
+      @inputs = inputs
+      @parent_run_id = parent_run_id
+      @start_time = Time.now.utc
+      @children = []
+      @project_name = project_name
+      @tags = tags
+      @client = LangsmithrbRails::Client.new
+      @ended = false
+      
+      # Create the run in LangSmith
+      create_run
+    end
+
+    # Create a child run
+    # @param name [String] Name of the child run
+    # @param run_type [String] Type of run (e.g., "llm", "chain")
+    # @param inputs [Hash] Input data
+    # @param tags [Array<String>] Optional tags
+    # @return [RunTree] The child run tree
+    def create_child(name:, run_type:, inputs:, tags: [])
+      child_run_id = SecureRandom.uuid
+      
+      child_run = RunTree.new(
+        run_id: child_run_id,
+        parent_run_id: @run_id,
+        name: name,
+        run_type: run_type,
+        inputs: inputs,
+        project_name: @project_name,
+        tags: tags
+      )
+      
+      @children << child_run
+      child_run
+    end
+
+    # End the run with outputs
+    # @param outputs [Hash] Output data
+    # @param error [String] Optional error message
+    def end(outputs: {}, error: nil)
+      return if @ended
+
+      # End all children first
+      @children.each { |child| child.end unless child.ended? }
+
+      # Update the run in LangSmith
+      update_run(outputs, error)
+      @ended = true
+    end
+
+    # Check if the run has ended
+    # @return [Boolean] True if the run has ended
+    def ended?
+      @ended
+    end
+
+    private
+
+    # Create the run in LangSmith
+    def create_run
+      run_data = {
+        id: @run_id,
+        name: @name,
+        run_type: @run_type,
+        inputs: @inputs,
+        start_time: @start_time.iso8601,
+        parent_run_id: @parent_run_id,
+        execution_order: 1,
+        serialized: { name: @name },
+        session_name: @project_name,
+        tags: @tags
+      }.compact
+
+      response = @client.create_run(run_data)
+      
+      unless response[:status] >= 200 && response[:status] < 300
+        LangsmithrbRails.logger.error("Failed to create run: #{response[:error] || response[:body]}")
+      end
+    end
+
+    # Update the run in LangSmith
+    # @param outputs [Hash] Output data
+    # @param error [String] Optional error message
+    def update_run(outputs, error)
+      run_data = {
+        outputs: outputs,
+        end_time: Time.now.utc.iso8601
+      }
+      
+      if error
+        run_data[:error] = error
+        run_data[:status] = "error"
+      else
+        run_data[:status] = "success"
+      end
+      
+      response = @client.update_run(@run_id, run_data)
+      
+      unless response[:status] >= 200 && response[:status] < 300
+        LangsmithrbRails.logger.error("Failed to update run: #{response[:error] || response[:body]}")
+      end
+    end
+  end
+
+  # Context manager for run trees
+  class RunContext
+    # Start a new run context
+    # @param name [String] Name of the run
+    # @param run_type [String] Type of run (e.g., "llm", "chain")
+    # @param inputs [Hash] Input data
+    # @param parent_run_id [String] Optional parent run ID
+    # @param project_name [String] Optional project name
+    # @param tags [Array<String>] Optional tags
+    # @yield [RunTree] The run tree
+    # @return [Object] The result of the block
+    def self.run(name:, run_type:, inputs:, parent_run_id: nil, project_name: nil, tags: [], &block)
+      run_tree = RunTree.new(
+        name: name,
+        run_type: run_type,
+        inputs: inputs,
+        parent_run_id: parent_run_id,
+        project_name: project_name,
+        tags: tags
+      )
+
+      begin
+        result = yield(run_tree)
+        run_tree.end(outputs: { result: result })
+        result
+      rescue => e
+        run_tree.end(error: e.message)
+        raise e
+      end
+    end
+  end
+end

data/lib/langsmithrb_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LangsmithrbRails
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end

data/lib/langsmithrb_rails/wrappers/anthropic.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module LangsmithrbRails
+  module Wrappers
+    # Wrapper for Anthropic client
+    module Anthropic
+      # Wrap an Anthropic client with LangSmith tracing
+      # @param client [Object] The Anthropic client to wrap
+      # @param project_name [String] Optional project name for traces
+      # @param tags [Array<String>] Optional tags for traces
+      # @return [Object] The wrapped client
+      def self.wrap(client, project_name: nil, tags: [])
+        # Create a wrapper class that inherits from the client's class
+        wrapper_class = Class.new(client.class) do
+          attr_reader :original_client, :project_name, :tags
+
+          def initialize(original_client, project_name, tags)
+            @original_client = original_client
+            @project_name = project_name
+            @tags = tags
+          end
+
+          # Wrap messages (Claude API)
+          def messages(messages:, model: nil, max_tokens: nil, temperature: nil, **params)
+            # Prepare inputs for tracing
+            inputs = {
+              messages: messages,
+              model: model,
+              max_tokens: max_tokens,
+              temperature: temperature
+            }.merge(params).compact
+
+            # Create a run
+            run_id = nil
+            begin
+              run = LangsmithrbRails::Wrappers::Base.create_run(
+                "anthropic.messages",
+                inputs,
+                run_type: "llm",
+                project_name: project_name,
+                tags: tags
+              )
+              run_id = run&.dig("id")
+            rescue => e
+              LangsmithrbRails.logger.error("Failed to create LangSmith run: #{e.message}")
+            end
+
+            # Call the original method
+            begin
+              result = original_client.messages(
+                messages: messages,
+                model: model,
+                max_tokens: max_tokens,
+                temperature: temperature,
+                **params
+              )
+
+              # Update the run with the result
+              if run_id
+                outputs = { response: result }
+                LangsmithrbRails::Wrappers::Base.update_run(run_id, outputs)
+              end
+
+              result
+            rescue => e
+              # Update the run with the error
+              if run_id
+                LangsmithrbRails::Wrappers::Base.update_run(run_id, {}, error: e.message)
+              end
+              raise e
+            end
+          end
+
+          # Wrap completions (older Claude API)
+          def completions(prompt:, model: nil, max_tokens_to_sample: nil, temperature: nil, **params)
+            # Prepare inputs for tracing
+            inputs = {
+              prompt: prompt,
+              model: model,
+              max_tokens_to_sample: max_tokens_to_sample,
+              temperature: temperature
+            }.merge(params).compact
+
+            # Create a run
+            run_id = nil
+            begin
+              run = LangsmithrbRails::Wrappers::Base.create_run(
+                "anthropic.completions",
+                inputs,
+                run_type: "llm",
+                project_name: project_name,
+                tags: tags
+              )
+              run_id = run&.dig("id")
+            rescue => e
+              LangsmithrbRails.logger.error("Failed to create LangSmith run: #{e.message}")
+            end
+
+            # Call the original method
+            begin
+              result = original_client.completions(
+                prompt: prompt,
+                model: model,
+                max_tokens_to_sample: max_tokens_to_sample,
+                temperature: temperature,
+                **params
+              )
+
+              # Update the run with the result
+              if run_id
+                outputs = { response: result }
+                LangsmithrbRails::Wrappers::Base.update_run(run_id, outputs)
+              end
+
+              result
+            rescue => e
+              # Update the run with the error
+              if run_id
+                LangsmithrbRails::Wrappers::Base.update_run(run_id, {}, error: e.message)
+              end
+              raise e
+            end
+          end
+
+          # Forward other methods to the original client
+          def method_missing(method_name, *args, **kwargs, &block)
+            if original_client.respond_to?(method_name)
+              original_client.send(method_name, *args, **kwargs, &block)
+            else
+              super
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            original_client.respond_to?(method_name, include_private) || super
+          end
+        end
+
+        # Create and return an instance of the wrapper class
+        wrapper_class.new(client, project_name, tags)
+      end
+    end
+  end
+end

data/lib/langsmithrb_rails/wrappers/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module LangsmithrbRails
+  module Wrappers
+    # Base module for LLM provider wrappers
+    module Base
+      # Wrap a provider client with LangSmith tracing
+      # @param client [Object] The provider client to wrap
+      # @param project_name [String] Optional project name for traces
+      # @param tags [Array<String>] Optional tags for traces
+      # @return [Object] The wrapped client
+      def self.wrap(client, project_name: nil, tags: [])
+        # To be implemented by specific provider wrappers
+        raise NotImplementedError, "This method should be implemented by provider-specific wrappers"
+      end
+
+      # Create a run for a provider operation
+      # @param name [String] Name of the operation
+      # @param inputs [Hash] Input data
+      # @param run_type [String] Type of run (e.g., "llm", "chain")
+      # @param project_name [String] Optional project name
+      # @param tags [Array<String>] Optional tags
+      # @return [Hash] The created run data
+      def self.create_run(name, inputs, run_type: "llm", project_name: nil, tags: [])
+        client = LangsmithrbRails::Client.new
+        
+        run_data = {
+          name: name,
+          inputs: inputs,
+          run_type: run_type,
+          start_time: Time.now.utc.iso8601,
+          execution_order: 1,
+          serialized: { name: name },
+          session_name: project_name,
+          tags: tags
+        }
+        
+        response = client.create_run(run_data)
+        
+        if response[:status] >= 200 && response[:status] < 300
+          response[:body]
+        else
+          LangsmithrbRails.logger.error("Failed to create run: #{response[:error] || response[:body]}")
+          nil
+        end
+      end
+
+      # Update a run with outputs and end time
+      # @param run_id [String] ID of the run to update
+      # @param outputs [Hash] Output data
+      # @param error [String] Optional error message
+      # @return [Hash] The updated run data
+      def self.update_run(run_id, outputs, error: nil)
+        return unless run_id
+
+        client = LangsmithrbRails::Client.new
+        
+        run_data = {
+          outputs: outputs,
+          end_time: Time.now.utc.iso8601
+        }
+        
+        if error
+          run_data[:error] = error
+          run_data[:status] = "error"
+        else
+          run_data[:status] = "success"
+        end
+        
+        response = client.update_run(run_id, run_data)
+        
+        if response[:status] >= 200 && response[:status] < 300
+          response[:body]
+        else
+          LangsmithrbRails.logger.error("Failed to update run: #{response[:error] || response[:body]}")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/langsmithrb_rails/wrappers/llm.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module LangsmithrbRails
+  module Wrappers
+    # Wrapper for generic LLM providers
+    module LLM
+      # Wrap an LLM with LangSmith tracing
+      # @param llm [Object] The LLM to wrap
+      # @param project_name [String] Optional project name for traces
+      # @param tags [Array<String>] Optional tags for traces
+      # @return [Object] The wrapped LLM
+      def self.wrap(llm, project_name: nil, tags: [])
+        # Create a wrapper class
+        wrapper_class = Class.new do
+          attr_reader :llm, :project_name, :tags
+
+          def initialize(llm, project_name, tags)
+            @llm = llm
+            @project_name = project_name
+            @tags = tags
+          end
+
+          # Wrap the call method
+          def call(prompt, **params)
+            # Prepare inputs for tracing
+            inputs = {
+              prompt: prompt
+            }.merge(params).compact
+
+            # Create a run
+            run_id = nil
+            begin
+              run = LangsmithrbRails::Wrappers::Base.create_run(
+                "llm.call",
+                inputs,
+                run_type: "llm",
+                project_name: project_name,
+                tags: tags
+              )
+              run_id = run&.dig("id")
+            rescue => e
+              LangsmithrbRails.logger.error("Failed to create LangSmith run: #{e.message}")
+            end
+
+            # Call the original method
+            begin
+              result = if llm.respond_to?(:call)
+                llm.call(prompt, **params)
+              elsif llm.is_a?(Proc)
+                llm.call(prompt, **params)
+              else
+                raise ArgumentError, "LLM must respond to 'call' or be a Proc"
+              end
+
+              # Update the run with the result
+              if run_id
+                outputs = { response: result }
+                LangsmithrbRails::Wrappers::Base.update_run(run_id, outputs)
+              end
+
+              result
+            rescue => e
+              # Update the run with the error
+              if run_id
+                LangsmithrbRails::Wrappers::Base.update_run(run_id, {}, error: e.message)
+              end
+              raise e
+            end
+          end
+
+          # Forward other methods to the original LLM
+          def method_missing(method_name, *args, **kwargs, &block)
+            if llm.respond_to?(method_name)
+              llm.send(method_name, *args, **kwargs, &block)
+            else
+              super
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            llm.respond_to?(method_name, include_private) || super
+          end
+        end
+
+        # Create and return an instance of the wrapper class
+        wrapper_class.new(llm, project_name, tags)
+      end
+
+      # Create a traceable decorator for any method
+      # @param object [Object] The object with the method to trace
+      # @param method_name [Symbol] The name of the method to trace
+      # @param run_name [String] Name for the run
+      # @param project_name [String] Optional project name for traces
+      # @param tags [Array<String>] Optional tags for traces
+      # @return [Object] The object with the traced method
+      def self.traceable(object, method_name, run_name: nil, project_name: nil, tags: [])
+        run_name ||= "#{object.class.name}.#{method_name}"
+        
+        # Store the original method
+        original_method = object.method(method_name)
+        
+        # Define a new method that wraps the original
+        object.define_singleton_method(method_name) do |*args, **kwargs, &block|
+          # Prepare inputs for tracing
+          inputs = {
+            args: args,
+            kwargs: kwargs
+          }.compact
+          
+          # Create a run
+          run_id = nil
+          begin
+            run = LangsmithrbRails::Wrappers::Base.create_run(
+              run_name,
+              inputs,
+              run_type: "chain",
+              project_name: project_name,
+              tags: tags
+            )
+            run_id = run&.dig("id")
+          rescue => e
+            LangsmithrbRails.logger.error("Failed to create LangSmith run: #{e.message}")
+          end
+          
+          # Call the original method
+          begin
+            result = original_method.call(*args, **kwargs, &block)
+            
+            # Update the run with the result
+            if run_id
+              outputs = { result: result }
+              LangsmithrbRails::Wrappers::Base.update_run(run_id, outputs)
+            end
+            
+            result
+          rescue => e
+            # Update the run with the error
+            if run_id
+              LangsmithrbRails::Wrappers::Base.update_run(run_id, {}, error: e.message)
+            end
+            raise e
+          end
+        end
+        
+        object
+      end
+    end
+  end
+end