langsmithrb_rails 0.1.1 → 0.3.0

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

@@ -2,12 +2,19 @@
 
 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
@@ -25,7 +32,120 @@ module LangsmithrbRails
     # Get the current configuration
     # @return [LangsmithrbRails::Config] Configuration object
     def config
-      @config ||= Config.new
+      @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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: langsmithrb_rails
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Protocol Grid
 bindir: exe
 cert_chain: []
-date: 2025-08-12 00:00:00.000000000 Z
+date: 2025-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: langsmithrb
@@ -166,6 +166,7 @@ files:
 - README.md
 - Rakefile
 - langsmithrb_rails-0.1.0.gem
+- langsmithrb_rails-0.1.1.gem
 - langsmithrb_rails.gemspec
 - lib/generators/langsmithrb_rails/buffer/buffer_generator.rb
 - lib/generators/langsmithrb_rails/buffer/templates/create_langsmith_run_buffers.rb
@@ -204,12 +205,25 @@ files:
 - lib/langsmithrb_rails.rb
 - lib/langsmithrb_rails/client.rb
 - lib/langsmithrb_rails/config.rb
+- lib/langsmithrb_rails/evaluation.rb
+- lib/langsmithrb_rails/evaluation/evaluator.rb
+- lib/langsmithrb_rails/evaluation/llm_evaluator.rb
+- lib/langsmithrb_rails/evaluation/string_evaluator.rb
 - lib/langsmithrb_rails/generators/langsmithrb_rails/langsmith_generator.rb
 - lib/langsmithrb_rails/generators/langsmithrb_rails/templates/langsmith_initializer.rb
 - lib/langsmithrb_rails/langsmith.rb
+- lib/langsmithrb_rails/otel.rb
+- lib/langsmithrb_rails/otel/exporter.rb
 - lib/langsmithrb_rails/railtie.rb
 - lib/langsmithrb_rails/redactor.rb
+- lib/langsmithrb_rails/run_trees.rb
 - lib/langsmithrb_rails/version.rb
+- lib/langsmithrb_rails/wrappers.rb
+- lib/langsmithrb_rails/wrappers/anthropic.rb
+- lib/langsmithrb_rails/wrappers/base.rb
+- lib/langsmithrb_rails/wrappers/llm.rb
+- lib/langsmithrb_rails/wrappers/openai.rb
+- pkg/langsmithrb_rails-0.3.0.gem
 homepage: https://github.com/cdaviis/langsmithrb_rails
 licenses:
 - MIT