langsmithrb_rails 0.1.0 → 0.3.0

data/lib/langsmithrb_rails/otel/exporter.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module LangsmithrbRails
+  module OTEL
+    # OpenTelemetry exporter for LangSmith
+    class Exporter
+      # Initialize a new OpenTelemetry exporter
+      # @param api_key [String] LangSmith API key
+      # @param api_url [String] LangSmith API URL
+      def initialize(api_key: nil, api_url: nil)
+        @api_key = api_key || Config[:api_key]
+        @api_url = api_url || Config[:api_url]
+        @client = LangsmithrbRails::Client.new(api_key: @api_key, api_url: @api_url)
+      end
+
+      # Export spans to LangSmith
+      # @param spans [Array<OpenTelemetry::SDK::Trace::SpanData>] Spans to export
+      # @return [Integer] Export result (success, failure, etc.)
+      def export(spans)
+        return :success if spans.empty?
+
+        spans.each do |span|
+          export_span(span)
+        end
+
+        :success
+      rescue => e
+        LangsmithrbRails.logger.error("Failed to export spans: #{e.message}")
+        :failure
+      end
+
+      # Shutdown the exporter
+      # @param timeout [Integer] Timeout in seconds
+      # @return [Boolean] True if shutdown was successful
+      def shutdown(timeout = 0)
+        true
+      end
+
+      private
+
+      # Export a single span to LangSmith
+      # @param span [OpenTelemetry::SDK::Trace::SpanData] Span to export
+      def export_span(span)
+        # Convert span to LangSmith run
+        run_data = convert_span_to_run(span)
+        
+        # Create or update the run in LangSmith
+        if span.parent_span_id.nil?
+          @client.create_run(run_data)
+        else
+          @client.update_run(run_data[:id], run_data)
+        end
+      end
+
+      # Convert an OpenTelemetry span to a LangSmith run
+      # @param span [OpenTelemetry::SDK::Trace::SpanData] Span to convert
+      # @return [Hash] LangSmith run data
+      def convert_span_to_run(span)
+        # Extract span attributes
+        attributes = span.attributes.to_h
+        
+        # Basic run data
+        run_data = {
+          id: span.span_id.to_s,
+          name: span.name,
+          start_time: span.start_timestamp.to_time.utc.iso8601,
+          end_time: span.end_timestamp.to_time.utc.iso8601,
+          status: span.status.code == 0 ? "success" : "error"
+        }
+        
+        # Add parent run ID if present
+        if span.parent_span_id
+          run_data[:parent_run_id] = span.parent_span_id.to_s
+        end
+        
+        # Add error if present
+        if span.status.code != 0
+          run_data[:error] = span.status.description || "Unknown error"
+        end
+        
+        # Add inputs and outputs from attributes
+        if attributes[:inputs]
+          run_data[:inputs] = parse_json_attribute(attributes[:inputs])
+        end
+        
+        if attributes[:outputs]
+          run_data[:outputs] = parse_json_attribute(attributes[:outputs])
+        end
+        
+        # Add run type
+        run_data[:run_type] = attributes[:run_type] || "chain"
+        
+        # Add project name if present
+        if attributes[:project_name]
+          run_data[:session_name] = attributes[:project_name]
+        end
+        
+        # Add tags if present
+        if attributes[:tags]
+          run_data[:tags] = parse_json_attribute(attributes[:tags])
+        end
+        
+        run_data
+      end
+
+      # Parse a JSON attribute
+      # @param value [String] JSON string
+      # @return [Hash, Array, String] Parsed JSON or original string
+      def parse_json_attribute(value)
+        return value unless value.is_a?(String)
+        
+        begin
+          JSON.parse(value)
+        rescue JSON::ParserError
+          value
+        end
+      end
+    end
+  end
+end

data/lib/langsmithrb_rails/otel.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "otel/exporter"
+
+module LangsmithrbRails
+  # OpenTelemetry integration for LangSmith
+  module OTEL
+    class << self
+      # Initialize OpenTelemetry integration
+      # @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] True if initialization was successful
+      def init(api_key: nil, api_url: nil, service_name: "langsmithrb-rails", service_version: LangsmithrbRails::VERSION)
+        return false unless otel_available?
+
+        require "opentelemetry/sdk"
+        require "opentelemetry/exporter/otlp"
+        require "opentelemetry/instrumentation/all"
+
+        # Create LangSmith exporter
+        langsmith_exporter = Exporter.new(api_key: api_key, api_url: api_url)
+
+        # Configure OpenTelemetry
+        OpenTelemetry::SDK.configure do |c|
+          c.service_name = service_name
+          c.service_version = service_version
+          
+          # Add LangSmith exporter
+          c.add_span_processor(
+            OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(langsmith_exporter)
+          )
+          
+          # Use batch processor for better performance
+          c.add_span_processor(
+            OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+              langsmith_exporter,
+              max_queue_size: 1000,
+              max_export_batch_size: 100,
+              schedule_delay_millis: 5000
+            )
+          )
+          
+          # Install all available instrumentation
+          c.use_all()
+        end
+
+        true
+      rescue => e
+        LangsmithrbRails.logger.error("Failed to initialize OpenTelemetry: #{e.message}")
+        false
+      end
+
+      # Create a traced span
+      # @param name [String] Span name
+      # @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)
+        return yield unless otel_available? && otel_enabled?
+
+        tracer = OpenTelemetry.tracer_provider.tracer("langsmithrb_rails", LangsmithrbRails::VERSION)
+        
+        tracer.in_span(name, attributes: attributes, kind: kind, &block)
+      end
+
+      # Create a traced span for an LLM operation
+      # @param name [String] Operation name
+      # @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
+      # @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)
+        return yield unless otel_available? && otel_enabled?
+
+        attributes = {
+          inputs: inputs.to_json,
+          run_type: run_type
+        }
+        
+        if project_name
+          attributes[:project_name] = project_name
+        end
+        
+        if tags.any?
+          attributes[:tags] = tags.to_json
+        end
+        
+        trace(name, attributes: attributes) do |span|
+          begin
+            result = yield
+            
+            # Add outputs to span
+            if result
+              span.add_attributes(outputs: { result: result }.to_json)
+            end
+            
+            result
+          rescue => e
+            # Add error to span
+            if span.respond_to?(:record_exception)
+              span.record_exception(e)
+              if defined?(OpenTelemetry::Trace::Status)
+                span.status = OpenTelemetry::Trace::Status.error(e.message)
+              end
+            end
+            raise e
+          end
+        end
+      end
+
+      # Check if OpenTelemetry is available
+      # @return [Boolean] True if OpenTelemetry is available
+      def otel_available?
+        @otel_available ||= begin
+          require "opentelemetry"
+          require "opentelemetry/sdk"
+          true
+        rescue LoadError
+          false
+        end
+      end
+
+      # Check if OpenTelemetry is enabled
+      # @return [Boolean] True if OpenTelemetry is enabled
+      def otel_enabled?
+        Config[:otel_enabled]
+      end
+    end
+  end
+end

data/lib/langsmithrb_rails/railtie.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "langsmithrb"
+
+module LangsmithrbRails
+  # Rails integration for LangsmithrbRails
+  class Railtie < Rails::Railtie
+    initializer "langsmithrb_rails" do
+      # Configure LangSmith if enabled
+      if LangsmithrbRails.config.enabled && LangsmithrbRails.config.api_key
+        # Configure the langsmithrb gem
+        Langsmithrb.configure do |config|
+          config.api_key = LangsmithrbRails.config.api_key
+          config.project_name = LangsmithrbRails.config.project_name
+          config.tracing_enabled = true
+        end
+        
+        # Also configure our wrapper for consistency
+        LangsmithrbRails::LangSmith.configure(
+          api_key: LangsmithrbRails.config.api_key,
+          project_name: LangsmithrbRails.config.project_name,
+          tracing: true
+        )
+        
+        Rails.logger.info "LangSmith tracing enabled"
+      end
+    end
+
+    generators do
+      require_relative "generators/langsmithrb_rails/langsmith_generator"
+    end
+  end
+end

data/lib/langsmithrb_rails/redactor.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module LangsmithrbRails
+  # PII redaction utility for LangSmith traces
+  class Redactor
+    # Common PII patterns
+    PATTERNS = {
+      email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/,
+      phone: /\b(\+\d{1,2}\s?)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}\b/,
+      credit_card: /\b(?:\d{4}[-\s]?){3}\d{4}\b|\b\d{13,16}\b/,
+      ssn: /\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b/,
+      ip_address: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/
+    }.freeze
+
+    class << self
+      # Allowlist of patterns that should not be redacted
+      attr_accessor :allowlist
+
+      # Custom patterns to redact beyond the defaults
+      attr_accessor :custom_patterns
+
+      # Initialize the class variables
+      def setup
+        @allowlist = []
+        @custom_patterns = {}
+      end
+
+      # Scrub PII from the input
+      # @param input [Object] Input to scrub (String, Hash, Array, etc.)
+      # @return [Object] Redacted copy of the input
+      def scrub(input)
+        return input unless Config[:redact_by_default]
+        
+        case input
+        when String
+          scrub_string(input)
+        when Hash
+          input.transform_values { |v| scrub(v) }
+        when Array
+          input.map { |item| scrub(item) }
+        else
+          input
+        end
+      end
+
+      private
+
+      # Scrub PII from a string
+      # @param text [String] String to scrub
+      # @return [String] Redacted string
+      def scrub_string(text)
+        return text unless text.is_a?(String)
+        
+        result = text.dup
+        
+        # Skip redaction for allowlisted patterns
+        return result if @allowlist&.any? { |pattern| text.match?(pattern) }
+        
+        # Apply default patterns
+        PATTERNS.each do |type, pattern|
+          result.gsub!(pattern) { |match| "[REDACTED #{type.upcase}]" }
+        end
+        
+        # Apply custom patterns
+        @custom_patterns&.each do |type, pattern|
+          result.gsub!(pattern) { |match| "[REDACTED #{type.upcase}]" }
+        end
+        
+        result
+      end
+    end
+  end
+end
+
+# Initialize class variables
+LangsmithrbRails::Redactor.setup

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LangsmithrbRails
+  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