langsmithrb_rails 0.1.0 → 0.3.0

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

data/lib/langsmithrb_rails/wrappers/openai.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module LangsmithrbRails
+  module Wrappers
+    # Wrapper for OpenAI client
+    module OpenAI
+      # Wrap an OpenAI client with LangSmith tracing
+      # @param client [Object] The OpenAI 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 chat completions
+          def chat(messages:, model: nil, temperature: nil, max_tokens: nil, **params)
+            # Prepare inputs for tracing
+            inputs = {
+              messages: messages,
+              model: model,
+              temperature: temperature,
+              max_tokens: max_tokens
+            }.merge(params).compact
+
+            # Create a run
+            run_id = nil
+            begin
+              run = LangsmithrbRails::Wrappers::Base.create_run(
+                "openai.chat",
+                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.chat(
+                messages: messages,
+                model: model,
+                temperature: temperature,
+                max_tokens: max_tokens,
+                **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
+          def completions(prompt:, model: nil, temperature: nil, max_tokens: nil, **params)
+            # Prepare inputs for tracing
+            inputs = {
+              prompt: prompt,
+              model: model,
+              temperature: temperature,
+              max_tokens: max_tokens
+            }.merge(params).compact
+
+            # Create a run
+            run_id = nil
+            begin
+              run = LangsmithrbRails::Wrappers::Base.create_run(
+                "openai.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,
+                temperature: temperature,
+                max_tokens: max_tokens,
+                **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 embeddings
+          def embeddings(input:, model: nil, **params)
+            # Prepare inputs for tracing
+            inputs = {
+              input: input,
+              model: model
+            }.merge(params).compact
+
+            # Create a run
+            run_id = nil
+            begin
+              run = LangsmithrbRails::Wrappers::Base.create_run(
+                "openai.embeddings",
+                inputs,
+                run_type: "embedding",
+                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.embeddings(
+                input: input,
+                model: model,
+                **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.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "wrappers/base"
+require_relative "wrappers/openai"
+require_relative "wrappers/anthropic"
+require_relative "wrappers/llm"
+
+module LangsmithrbRails
+  # Wrappers for LLM providers
+  module Wrappers
+    # Wrap an LLM provider client with LangSmith tracing
+    # @param client [Object] The provider client to wrap
+    # @param provider [Symbol] The provider type (:openai, :anthropic, :llm)
+    # @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, provider:, project_name: nil, tags: [])
+      case provider.to_sym
+      when :openai
+        OpenAI.wrap(client, project_name: project_name, tags: tags)
+      when :anthropic
+        Anthropic.wrap(client, project_name: project_name, tags: tags)
+      when :llm
+        LLM.wrap(client, project_name: project_name, tags: tags)
+      else
+        raise ArgumentError, "Unsupported provider: #{provider}"
+      end
+    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: [])
+      LLM.traceable(object, method_name, run_name: run_name, project_name: project_name, tags: tags)
+    end
+  end
+end

data/lib/langsmithrb_rails.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "langsmithrb"
+require "rails"
+require "json"
+require "securerandom"
+require "logger"
+
+require_relative "langsmithrb_rails/version"
+require_relative "langsmithrb_rails/config"
+require_relative "langsmithrb_rails/client"
+require_relative "langsmithrb_rails/redactor"
+require_relative "langsmithrb_rails/langsmith"
+require_relative "langsmithrb_rails/wrappers"
+require_relative "langsmithrb_rails/run_trees"
+require_relative "langsmithrb_rails/otel"
+require_relative "langsmithrb_rails/evaluation"
+require_relative "langsmithrb_rails/railtie" if defined?(Rails)
+
+# LangsmithRails provides integration with LangSmith for Rails applications
+module LangsmithrbRails
+  class << self
+    # Configure LangsmithrbRails
+    # @yield [config] Configuration block
+    # @yieldparam config [LangsmithrbRails::Config] Configuration object
+    # @return [LangsmithrbRails::Config] Configuration object
+    def configure
+      yield config if block_given?
+      config
+    end
+
+    # Get the current configuration
+    # @return [LangsmithrbRails::Config] Configuration object
+    def config
+      @config ||= Config.instance
+    end
+    
+    # Get the logger
+    # @return [Logger] Logger instance
+    def logger
+      config.logger
+    end
+    
+    # Wrap an LLM provider client with LangSmith tracing
+    # @param client [Object] The provider client to wrap
+    # @param provider [Symbol] The provider type (:openai, :anthropic, :llm)
+    # @param project_name [String] Optional project name for traces
+    # @param tags [Array<String>] Optional tags for traces
+    # @return [Object] The wrapped client
+    def wrap(client, provider:, project_name: nil, tags: [])
+      Wrappers.wrap(client, provider: provider, project_name: project_name, tags: 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 traceable(object, method_name, run_name: nil, project_name: nil, tags: [])
+      Wrappers.traceable(object, method_name, run_name: run_name, project_name: project_name, tags: tags)
+    end
+    
+    # Create a run context for hierarchical tracing
+    # @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 run(name:, run_type:, inputs:, parent_run_id: nil, project_name: nil, tags: [], &block)
+      RunContext.run(
+        name: name,
+        run_type: run_type,
+        inputs: inputs,
+        project_name: project_name,
+        tags: tags,
+        &block
+      )
+    end
+    
+    # Create an evaluator
+    # @param type [Symbol] Type of evaluator (:string, :llm)
+    # @param options [Hash] Options for the evaluator
+    # @return [Evaluation::Evaluator] The evaluator instance
+    def evaluator(type, **options)
+      Evaluation.create(type, **options)
+    end
+    
+    # Alias for evaluator for better naming consistency
+    # @param type [Symbol] Type of evaluator (:string, :llm)
+    # @param options [Hash] Options for the evaluator
+    # @return [Evaluation::Evaluator] The evaluator instance
+    def create_evaluator(type, **options)
+      Evaluation.create(type, **options)
+    end
+    
+    # Get a client instance
+    # @return [LangsmithrbRails::Client] Client instance
+    def client
+      @client ||= Client.new(api_key: config.api_key, api_url: config.api_url)
+    end
+    
+    # Initialize OpenTelemetry with LangSmith exporter
+    # @param api_key [String] LangSmith API key
+    # @param api_url [String] LangSmith API URL
+    # @param service_name [String] Service name for OpenTelemetry
+    # @param service_version [String] Service version for OpenTelemetry
+    # @return [Boolean] Whether OpenTelemetry was initialized
+    def init_otel(api_key: nil, api_url: nil, service_name: nil, service_version: nil)
+      OTEL.init(
+        api_key: api_key || config.api_key,
+        api_url: api_url || config.api_url,
+        service_name: service_name || config.otel_service_name,
+        service_version: service_version
+      )
+    end
+    
+    # Create a trace span
+    # @param name [String] Name of the span
+    # @param attributes [Hash] Span attributes
+    # @param kind [Symbol] Span kind
+    # @yield Block to execute within the span
+    # @return [Object] Result of the block
+    def trace(name, attributes: {}, kind: :internal, &block)
+      OTEL.trace(name, attributes: attributes, kind: kind, &block)
+    end
+    
+    # Create a trace span for LLM operations
+    # @param name [String] Name of the span
+    # @param inputs [Hash] LLM inputs
+    # @param run_type [String] Type of run
+    # @param project_name [String] Project name
+    # @param tags [Array<String>] Tags
+    # @yield Block to execute within the span
+    # @return [Object] Result of the block
+    def trace_llm(name, inputs: {}, run_type: "llm", project_name: nil, tags: [], &block)
+      OTEL.trace_llm(
+        name,
+        inputs: inputs,
+        run_type: run_type,
+        project_name: project_name || config.project_name,
+        tags: tags,
+        &block
+      )
+    end
+  end
+end