langsmithrb_rails 0.1.0 → 0.1.1

data/lib/generators/langsmithrb_rails/privacy/templates/custom_redactor.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module LangsmithrbRails
+  # Custom redactor for PII in LangSmith traces
+  class CustomRedactor
+    # Initialize the redactor with configuration
+    # @param config [Hash] Configuration options
+    def initialize(config = {})
+      @config = config || {}
+      @base_redactor = LangsmithrbRails::Redactor.new(config)
+    end
+    
+    # Redact PII from text
+    # @param text [String] Text to redact
+    # @return [String] Redacted text
+    def redact(text)
+      return text unless text.is_a?(String)
+      
+      # First apply the base redactor
+      result = @base_redactor.redact(text)
+      
+      # Then apply custom patterns
+      custom_patterns.each do |pattern_name, pattern|
+        result = apply_pattern(result, pattern_name, pattern)
+      end
+      
+      result
+    end
+    
+    # Redact PII from a hash or array
+    # @param data [Hash, Array] Data to redact
+    # @return [Hash, Array] Redacted data
+    def redact_data(data)
+      case data
+      when String
+        redact(data)
+      when Hash
+        redact_hash(data)
+      when Array
+        redact_array(data)
+      else
+        data
+      end
+    end
+    
+    private
+    
+    # Redact PII from a hash
+    # @param hash [Hash] Hash to redact
+    # @return [Hash] Redacted hash
+    def redact_hash(hash)
+      result = {}
+      
+      hash.each do |key, value|
+        # Skip redaction for allowlisted keys
+        if allowlisted_key?(key.to_s)
+          result[key] = value
+        else
+          result[key] = redact_data(value)
+        end
+      end
+      
+      result
+    end
+    
+    # Redact PII from an array
+    # @param array [Array] Array to redact
+    # @return [Array] Redacted array
+    def redact_array(array)
+      array.map { |item| redact_data(item) }
+    end
+    
+    # Check if a key is allowlisted
+    # @param key [String] Key to check
+    # @return [Boolean] Whether the key is allowlisted
+    def allowlisted_key?(key)
+      (@config[:allowlist_keys] || []).any? do |pattern|
+        if pattern.is_a?(Regexp)
+          key =~ pattern
+        else
+          key == pattern.to_s
+        end
+      end
+    end
+    
+    # Apply a redaction pattern
+    # @param text [String] Text to redact
+    # @param pattern_name [Symbol] Pattern name
+    # @param pattern [Regexp, Hash] Pattern to apply
+    # @return [String] Redacted text
+    def apply_pattern(text, pattern_name, pattern)
+      # Skip if the pattern is disabled
+      return text if @config[:disabled_patterns]&.include?(pattern_name.to_s)
+      
+      if pattern.is_a?(Regexp)
+        # Simple regex replacement
+        text.gsub(pattern, "[REDACTED:#{pattern_name.upcase}]")
+      elsif pattern.is_a?(Hash) && pattern[:pattern].is_a?(Regexp)
+        # Advanced pattern with custom replacement
+        replacement = pattern[:replacement] || "[REDACTED:#{pattern_name.upcase}]"
+        text.gsub(pattern[:pattern], replacement)
+      else
+        # Invalid pattern
+        text
+      end
+    end
+    
+    # Custom redaction patterns
+    # @return [Hash] Custom patterns
+    def custom_patterns
+      {
+        # Example: Redact API keys
+        api_key: /\b(?:api[_-]?key|access[_-]?token)[=:]\s*["']?([a-zA-Z0-9]{20,})/i,
+        
+        # Example: Redact database connection strings
+        db_connection: {
+          pattern: /(?:postgres|mysql|mongodb):\/\/[^\s"']+/i,
+          replacement: "[REDACTED:DATABASE_URL]"
+        },
+        
+        # Example: Redact JWT tokens
+        jwt: /eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/,
+        
+        # Example: Redact session IDs
+        session_id: /\b(?:session_id|sid)=([a-zA-Z0-9]{16,})/i,
+        
+        # Add your own custom patterns here
+        # custom_pattern: /pattern/
+      }
+    end
+  end
+end

data/lib/generators/langsmithrb_rails/privacy/templates/privacy.yml

@@ -0,0 +1,88 @@
+# LangSmith Privacy Configuration
+# This file configures PII redaction for LangSmith traces
+
+# Default configuration for all environments
+default: &default
+  # Enable or disable PII redaction
+  redact_pii: true
+  
+  # Fields that should never be redacted
+  allowlist_keys:
+    - id
+    - created_at
+    - updated_at
+    - type
+    - status
+    - count
+    - total
+    - name
+    - title
+    - description
+    - category
+    - tags
+    - "*.id"
+    - "*.type"
+    - "*.status"
+  
+  # Patterns that should be disabled
+  disabled_patterns: []
+  
+  # Specific fields to always redact
+  redact_fields:
+    - password
+    - token
+    - secret
+    - key
+    - credential
+    - auth
+    - ssn
+    - social_security
+    - credit_card
+    - cc_number
+    - cvv
+    - user_data
+    - personal_info
+
+# Development environment
+development:
+  <<: *default
+  # You can override settings for development here
+  # For example, to disable redaction in development:
+  # redact_pii: false
+
+# Test environment
+test:
+  <<: *default
+  # Test-specific settings
+  redact_pii: true
+
+# Production environment
+production:
+  <<: *default
+  # Production-specific settings
+  redact_pii: true
+  
+  # Additional fields to redact in production
+  redact_fields:
+    - password
+    - token
+    - secret
+    - key
+    - credential
+    - auth
+    - ssn
+    - social_security
+    - credit_card
+    - cc_number
+    - cvv
+    - user_data
+    - personal_info
+    - email
+    - phone
+    - address
+    - zip
+    - postal
+    - birthdate
+    - dob
+    - ip_address
+    - location

data/lib/generators/langsmithrb_rails/privacy/templates/privacy_initializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Load custom redactor
+require_relative "../../app/lib/langsmithrb_rails/custom_redactor"
+
+# Load privacy configuration
+privacy_config_path = Rails.root.join("config/langsmith_privacy.yml")
+privacy_config = if File.exist?(privacy_config_path)
+                   YAML.load_file(privacy_config_path)[Rails.env] || {}
+                 else
+                   {}
+                 end
+
+# Convert string keys to symbols
+privacy_config = privacy_config.transform_keys(&:to_sym)
+
+# Convert allowlist patterns to regex if they use wildcard syntax
+if privacy_config[:allowlist_keys].is_a?(Array)
+  privacy_config[:allowlist_keys] = privacy_config[:allowlist_keys].map do |pattern|
+    if pattern.is_a?(String) && pattern.include?("*")
+      # Convert glob pattern to regex
+      Regexp.new("^#{Regexp.escape(pattern).gsub("\\*", ".*")}$")
+    else
+      pattern
+    end
+  end
+end
+
+# Initialize the custom redactor
+LangsmithrbRails.configure do |config|
+  # Use the custom redactor for PII redaction
+  config.redactor = LangsmithrbRails::CustomRedactor.new(privacy_config)
+  
+  # Configure privacy-related settings
+  config.redact_pii = privacy_config[:redact_pii] != false
+  
+  # Optionally configure specific fields to redact
+  if privacy_config[:redact_fields].is_a?(Array)
+    config.redact_fields = privacy_config[:redact_fields]
+  end
+end

data/lib/generators/langsmithrb_rails/tracing/templates/langsmith_traced.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+# Concern for adding LangSmith tracing to services
+module LangsmithTraced
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Trace a block of code with LangSmith
+    # @param name [String] Name of the trace
+    # @param type [String] Type of the trace (llm, tool, retriever, etc.)
+    # @param meta [Hash] Additional metadata for the trace
+    # @return [Object] Result of the block
+    def trace(name:, type: "llm", meta: {})
+      # Skip tracing if sampling rate check fails
+      return yield if rand > LangsmithrbRails::Config[:sampling_rate]
+
+      # Get the start time
+      started = Time.now
+
+      # Extract and redact input if present
+      input = meta.delete(:input)
+      input = LangsmithrbRails::Redactor.scrub(input) if input
+
+      # Create a client
+      client = LangsmithrbRails::Client.new
+
+      # Prepare the run payload
+      run_payload = {
+        name: name,
+        run_type: type,
+        meta: meta.merge(started_at: started.iso8601),
+        parent_run_id: Thread.current[:langsmith_run_id]
+      }
+      run_payload[:input] = input if input
+
+      # Create the run
+      create_response = send_trace("create", nil, run_payload)
+      run_id = create_response&.dig(:body, "id")
+
+      # Store the previous run ID
+      previous_run_id = Thread.current[:langsmith_run_id]
+      
+      # Set the current run ID for nested traces
+      Thread.current[:langsmith_run_id] = run_id if run_id
+
+      # Execute the block
+      result = yield
+
+      # Restore the previous run ID
+      Thread.current[:langsmith_run_id] = previous_run_id
+
+      # Update the run with the result
+      if run_id
+        update_payload = { 
+          ended_at: Time.now.iso8601
+        }
+        
+        # Add output if present
+        if result
+          update_payload[:output] = LangsmithrbRails::Redactor.scrub(result)
+        end
+        
+        send_trace("update", run_id, update_payload)
+      end
+
+      # Return the result
+      result
+    rescue => e
+      # Restore the previous run ID
+      Thread.current[:langsmith_run_id] = previous_run_id
+
+      # Update the run with the error
+      if run_id
+        begin
+          send_trace("update", run_id, {
+            ended_at: Time.now.iso8601,
+            error: e.message
+          })
+        rescue => trace_error
+          Rails.logger.error("LangSmith error update failed: #{trace_error.message}")
+        end
+      end
+
+      # Re-raise the original error
+      raise
+    end
+
+    private
+
+    # Send a trace to LangSmith
+    # @param action [String] Action to perform (create or update)
+    # @param run_id [String, nil] Run ID for updates
+    # @param payload [Hash] Payload to send
+    # @return [Hash, nil] Response from LangSmith
+    def send_trace(action, run_id, payload)
+      # Check if we should use the buffer
+      if defined?(LangsmithRunBuffer) && LangsmithrbRails::Config[:use_buffer]
+        # Store in buffer
+        buffer = LangsmithRunBuffer.new(
+          name: payload[:name],
+          run_type: payload[:run_type],
+          status: "pending",
+          request_id: payload.dig(:meta, :request_id),
+          user_ref: payload.dig(:meta, :user_ref),
+          run_id: run_id,
+          parent_run_id: payload[:parent_run_id],
+          started_at: payload[:started_at] || payload.dig(:meta, :started_at),
+          ended_at: payload[:ended_at],
+          meta: payload[:meta],
+          payload: payload,
+          error: payload[:error]
+        )
+        buffer.save
+        return { body: { "id" => buffer.id } } if action == "create"
+        return { status: 200 }
+      end
+
+      # Check if we should use a job
+      if defined?(LangsmithSendTraceJob)
+        if defined?(Sidekiq) && Sidekiq.server?
+          # Use Sidekiq directly
+          LangsmithSendTraceJob.perform_async(action, run_id, payload)
+          return { body: { "id" => SecureRandom.uuid } } if action == "create"
+          return { status: 200 }
+        elsif Rails.application.config.active_job.queue_adapter == :sidekiq
+          # Use ActiveJob with Sidekiq
+          LangsmithSendTraceJob.perform_later(action, run_id, payload)
+          return { body: { "id" => SecureRandom.uuid } } if action == "create"
+          return { status: 200 }
+        end
+      end
+
+      # Fall back to direct API call
+      client = LangsmithrbRails::Client.new
+      
+      if action == "create"
+        client.create_run(payload)
+      else
+        client.update_run(run_id, payload)
+      end
+    rescue => e
+      Rails.logger.error("LangSmith trace error: #{e.message}")
+      nil
+    end
+  end
+end

data/lib/generators/langsmithrb_rails/tracing/templates/langsmith_traced_job.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+# Concern for adding LangSmith tracing to background jobs
+module LangsmithTracedJob
+  extend ActiveSupport::Concern
+
+  included do
+    # Add around_perform callback to trace job execution
+    around_perform do |job, block|
+      # Skip tracing if sampling rate check fails
+      if rand > LangsmithrbRails::Config[:sampling_rate]
+        block.call
+        return
+      end
+
+      # Extract parent run ID from arguments or Current
+      parent_run_id = extract_parent_run_id(job.arguments)
+
+      # Create metadata for the trace
+      meta = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        queue_name: job.queue_name,
+        env: LangsmithrbRails::Config[:env]
+      }
+
+      # Add arguments if not sensitive
+      unless LangsmithrbRails::Config[:redact_job_arguments]
+        meta[:arguments] = LangsmithrbRails::Redactor.scrub(job.arguments)
+      end
+
+      # Create a client
+      client = LangsmithrbRails::Client.new
+
+      # Get the start time
+      started = Time.now
+
+      # Create the run
+      run_payload = {
+        name: "#{job.class.name}#perform",
+        run_type: "job",
+        meta: meta.merge(started_at: started.iso8601),
+        parent_run_id: parent_run_id
+      }
+
+      create_response = send_trace("create", nil, run_payload)
+      run_id = create_response&.dig(:body, "id")
+
+      # Store the run ID in thread local for nested traces
+      Thread.current[:langsmith_run_id] = run_id if run_id
+
+      # Execute the job
+      result = block.call
+
+      # Update the run with completion
+      if run_id
+        send_trace("update", run_id, {
+          ended_at: Time.now.iso8601,
+          output: { status: "completed" }
+        })
+      end
+
+      # Clean up thread local
+      Thread.current[:langsmith_run_id] = nil
+
+      # Return the result
+      result
+    rescue => e
+      # Update the run with the error
+      if run_id
+        begin
+          send_trace("update", run_id, {
+            ended_at: Time.now.iso8601,
+            error: e.message
+          })
+        rescue => trace_error
+          Rails.logger.error("LangSmith error update failed: #{trace_error.message}")
+        end
+      end
+
+      # Clean up thread local
+      Thread.current[:langsmith_run_id] = nil
+
+      # Re-raise the original error
+      raise
+    end
+  end
+
+  private
+
+  # Extract parent run ID from job arguments or Current
+  # @param arguments [Array] Job arguments
+  # @return [String, nil] Parent run ID
+  def extract_parent_run_id(arguments)
+    # Check if any argument is a hash with a langsmith_run_id key
+    arguments.each do |arg|
+      if arg.is_a?(Hash) && arg.key?(:langsmith_run_id)
+        return arg[:langsmith_run_id]
+      end
+    end
+
+    # Check if Current has a langsmith_run_id
+    if defined?(Current) && Current.respond_to?(:langsmith_run_id) && Current.langsmith_run_id
+      return Current.langsmith_run_id
+    end
+
+    # Fall back to thread local
+    Thread.current[:langsmith_run_id]
+  end
+
+  # Send a trace to LangSmith
+  # @param action [String] Action to perform (create or update)
+  # @param run_id [String, nil] Run ID for updates
+  # @param payload [Hash] Payload to send
+  # @return [Hash, nil] Response from LangSmith
+  def send_trace(action, run_id, payload)
+    # Check if we should use the buffer
+    if defined?(LangsmithRunBuffer) && LangsmithrbRails::Config[:use_buffer]
+      # Store in buffer
+      buffer = LangsmithRunBuffer.new(
+        name: payload[:name],
+        run_type: payload[:run_type],
+        status: "pending",
+        request_id: payload.dig(:meta, :request_id),
+        user_ref: payload.dig(:meta, :user_ref),
+        run_id: run_id,
+        parent_run_id: payload[:parent_run_id],
+        started_at: payload[:started_at] || payload.dig(:meta, :started_at),
+        ended_at: payload[:ended_at],
+        meta: payload[:meta],
+        payload: payload,
+        error: payload[:error]
+      )
+      buffer.save
+      return { body: { "id" => buffer.id } } if action == "create"
+      return { status: 200 }
+    end
+
+    # Fall back to direct API call
+    client = LangsmithrbRails::Client.new
+    
+    if action == "create"
+      client.create_run(payload)
+    else
+      client.update_run(run_id, payload)
+    end
+  rescue => e
+    Rails.logger.error("LangSmith trace error: #{e.message}")
+    nil
+  end
+end

data/lib/generators/langsmithrb_rails/tracing/templates/request_tracing.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module LangsmithrbRails
+  # Middleware for tracing Rails requests in LangSmith
+  class RequestTracing
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # Skip tracing if sampling rate check fails
+      return @app.call(env) if rand > LangsmithrbRails::Config[:sampling_rate]
+
+      req = ActionDispatch::Request.new(env)
+      
+      # Prepare metadata for the trace
+      meta = {
+        path: req.path,
+        method: req.request_method,
+        request_id: req.request_id,
+        env: LangsmithrbRails::Config[:env]
+      }
+      
+      # Add user reference if available (and not in development/test)
+      if defined?(Current) && Current.respond_to?(:user) && Current.user && !%w[development test].include?(Rails.env)
+        # Use a hash of the user ID to avoid sending PII
+        meta[:user_ref] = Digest::SHA256.hexdigest(Current.user.id.to_s)
+      end
+      
+      # Create the run in LangSmith
+      client = LangsmithrbRails::Client.new
+      started = Time.now
+      
+      # Create the run asynchronously if possible
+      run = create_run_async(client, {
+        name: "rails_request",
+        run_type: "request",
+        meta: meta.merge(started_at: started.iso8601)
+      })
+      
+      # Store run ID in thread local for child spans
+      Thread.current[:langsmith_run_id] = run&.dig(:body, "id")
+      
+      # Process the request
+      status, headers, body = @app.call(env)
+      
+      # Update the run asynchronously if possible
+      if run&.dig(:body, "id")
+        update_run_async(client, run.dig(:body, "id"), {
+          ended_at: Time.now.iso8601,
+          output: { status: status }
+        })
+      end
+      
+      # Clean up thread local
+      Thread.current[:langsmith_run_id] = nil
+      
+      [status, headers, body]
+    rescue => e
+      # Log error but don't fail the request
+      Rails.logger.error("LangSmith tracing error: #{e.message}")
+      
+      # Clean up thread local
+      Thread.current[:langsmith_run_id] = nil
+      
+      # Continue with the request
+      @app.call(env)
+    end
+    
+    private
+    
+    # Create a run asynchronously
+    def create_run_async(client, payload)
+      if defined?(Sidekiq) && Sidekiq.server?
+        # Use Sidekiq if available
+        LangsmithSendTraceJob.perform_async("create", nil, payload)
+        nil
+      elsif Rails.application.config.active_job.queue_adapter == :sidekiq
+        # Use ActiveJob with Sidekiq
+        LangsmithSendTraceJob.perform_later("create", nil, payload)
+        nil
+      else
+        # Use a lightweight thread
+        Thread.new do
+          begin
+            client.create_run(payload)
+          rescue => e
+            Rails.logger.error("LangSmith async create error: #{e.message}")
+          end
+        end
+        
+        # Return a synchronous result for the run ID
+        client.create_run(payload)
+      end
+    end
+    
+    # Update a run asynchronously
+    def update_run_async(client, run_id, payload)
+      if defined?(Sidekiq) && Sidekiq.server?
+        # Use Sidekiq if available
+        LangsmithSendTraceJob.perform_async("update", run_id, payload)
+      elsif Rails.application.config.active_job.queue_adapter == :sidekiq
+        # Use ActiveJob with Sidekiq
+        LangsmithSendTraceJob.perform_later("update", run_id, payload)
+      else
+        # Use a lightweight thread
+        Thread.new do
+          begin
+            client.update_run(run_id, payload)
+          rescue => e
+            Rails.logger.error("LangSmith async update error: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end