langsmithrb_rails 0.1.0 → 0.3.0

data/lib/generators/langsmithrb_rails/tracing/tracing_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module LangsmithrbRails
+  module Generators
+    # Generator for adding LangSmith tracing to Rails applications
+    class TracingGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+      
+      desc "Adds LangSmith tracing to your Rails application"
+      
+      def create_middleware
+        template "request_tracing.rb", "app/middleware/langsmithrb_rails/request_tracing.rb"
+      end
+      
+      def create_service_concern
+        template "langsmith_traced.rb", "app/services/concerns/langsmith_traced.rb"
+      end
+      
+      def create_job_concern
+        template "langsmith_traced_job.rb", "app/jobs/concerns/langsmith_traced_job.rb"
+      end
+      
+      def update_application_config
+        application_rb_path = "config/application.rb"
+        
+        if File.exist?(application_rb_path)
+          middleware_line = "    config.middleware.use LangsmithrbRails::RequestTracing"
+          
+          # Check if middleware is already configured
+          if File.read(application_rb_path).include?(middleware_line)
+            say_status :skip, "Middleware already configured in application.rb", :yellow
+          else
+            # Find the class Application < Rails::Application line
+            application_content = File.read(application_rb_path)
+            
+            if application_content =~ /class Application < Rails::Application/
+              inject_into_file application_rb_path, after: "class Application < Rails::Application\n" do
+                <<~RUBY
+                  # Use LangSmith request tracing middleware
+                  #{middleware_line}
+                
+                RUBY
+              end
+              
+              say_status :insert, "Added middleware to application.rb", :green
+            else
+              say_status :error, "Could not find the Application class in application.rb", :red
+            end
+          end
+        else
+          say_status :error, "Could not find application.rb", :red
+        end
+      end
+      
+      def create_directories
+        empty_directory "app/middleware/langsmithrb_rails"
+        empty_directory "app/services/concerns"
+        empty_directory "app/jobs/concerns"
+      end
+      
+      def display_post_install_message
+        say "\n"
+        say "LangSmith tracing has been added to your Rails application! 🎉", :green
+        say "\n"
+        say "Usage:", :yellow
+        say "  1. Use the LangsmithTraced concern in your services:", :yellow
+        say "     include LangsmithTraced", :yellow
+        say "     LangsmithTraced.trace(name: 'my_operation', type: 'llm') { ... }", :yellow
+        say "  2. Use the LangsmithTracedJob concern in your jobs:", :yellow
+        say "     include LangsmithTracedJob", :yellow
+        say "\n"
+        say "To add a local buffer for traces, run:", :yellow
+        say "  bin/rails g langsmithrb_rails:buffer", :yellow
+        say "\n"
+      end
+    end
+  end
+end

data/lib/langsmithrb_rails/client.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require "securerandom"
+
+module LangsmithrbRails
+  # Direct REST client for LangSmith API
+  class Client
+    # Initialize a new LangSmith client
+    # @param api_key [String] LangSmith API key
+    # @param api_url [String] LangSmith API URL
+    def initialize(api_key: Config[:api_key], api_url: Config[:api_url])
+      @api_key = api_key
+      @api_url = api_url.chomp("/")
+    end
+
+    # Create a new run in LangSmith
+    # @param payload [Hash] Run data
+    # @return [Hash] Response with status and body
+    def create_run(payload)
+      post("/runs", payload)
+    end
+
+    # Update an existing run in LangSmith
+    # @param id [String] Run ID
+    # @param payload [Hash] Updated run data
+    # @return [Hash] Response with status and body
+    def update_run(id, payload)
+      patch("/runs/#{id}", payload)
+    end
+
+    # Get a run by ID
+    # @param id [String] Run ID
+    # @return [Hash] Response with status and body
+    def get_run(id)
+      get("/runs/#{id}")
+    end
+
+    # List runs with optional filters
+    # @param project_name [String] Filter by project name
+    # @param trace_id [String] Filter by trace ID
+    # @param run_type [String] Filter by run type
+    # @param limit [Integer] Maximum number of runs to return
+    # @param offset [Integer] Offset for pagination
+    # @return [Hash] Response with status and body
+    def list_runs(project_name: nil, trace_id: nil, run_type: nil, limit: 100, offset: 0)
+      query_params = {
+        project_name: project_name,
+        trace_id: trace_id,
+        run_type: run_type,
+        limit: limit,
+        offset: offset
+      }.compact
+      
+      query_string = query_params.map { |k, v| "#{k}=#{URI.encode_www_form_component(v.to_s)}" }.join("&")
+      get("/runs?#{query_string}")
+    end
+
+    # Create a dataset in LangSmith
+    # @param name [String] Dataset name
+    # @param description [String] Dataset description
+    # @return [Hash] Response with status and body
+    def create_dataset(name, description: nil)
+      payload = {
+        name: name,
+        description: description
+      }.compact
+      post("/datasets", payload)
+    end
+
+    # Get a dataset by ID
+    # @param id [String] Dataset ID
+    # @return [Hash] Response with status and body
+    def get_dataset(id)
+      get("/datasets/#{id}")
+    end
+
+    # List datasets
+    # @param limit [Integer] Maximum number of datasets to return
+    # @param offset [Integer] Offset for pagination
+    # @return [Hash] Response with status and body
+    def list_datasets(limit: 100, offset: 0)
+      get("/datasets?limit=#{limit}&offset=#{offset}")
+    end
+
+    # Create an example in a dataset
+    # @param dataset_id [String] Dataset ID
+    # @param inputs [Hash] Example inputs
+    # @param outputs [Hash] Example outputs (optional)
+    # @return [Hash] Response with status and body
+    def create_example(dataset_id, inputs, outputs = nil)
+      payload = {
+        dataset_id: dataset_id,
+        inputs: inputs,
+        outputs: outputs
+      }.compact
+      post("/examples", payload)
+    end
+
+    # Get an example by ID
+    # @param id [String] Example ID
+    # @return [Hash] Response with status and body
+    def get_example(id)
+      get("/examples/#{id}")
+    end
+
+    # List examples in a dataset
+    # @param dataset_id [String] Dataset ID
+    # @param limit [Integer] Maximum number of examples to return
+    # @param offset [Integer] Offset for pagination
+    # @return [Hash] Response with status and body
+    def list_examples(dataset_id, limit: 100, offset: 0)
+      get("/datasets/#{dataset_id}/examples?limit=#{limit}&offset=#{offset}")
+    end
+
+    # Create feedback for a run
+    # @param run_id [String] Run ID
+    # @param key [String] Feedback key
+    # @param score [Float, Integer, Boolean] Feedback score
+    # @param value [Hash] Additional feedback data (optional)
+    # @param comment [String] Feedback comment (optional)
+    # @return [Hash] Response with status and body
+    def create_feedback(run_id, key, score, value: nil, comment: nil)
+      payload = {
+        id: SecureRandom.uuid,
+        run_id: run_id,
+        key: key,
+        score: score,
+        value: value,
+        comment: comment
+      }.compact
+      post("/feedback", payload)
+    end
+
+    # Get feedback by ID
+    # @param id [String] Feedback ID
+    # @return [Hash] Response with status and body
+    def get_feedback(id)
+      get("/feedback/#{id}")
+    end
+
+    # List feedback for a run
+    # @param run_id [String] Run ID
+    # @return [Hash] Response with status and body
+    def list_feedback(run_id)
+      get("/runs/#{run_id}/feedback")
+    end
+
+    # Create a project in LangSmith
+    # @param name [String] Project name
+    # @param description [String] Project description (optional)
+    # @return [Hash] Response with status and body
+    def create_project(name, description: nil)
+      payload = {
+        name: name,
+        description: description
+      }.compact
+      post("/projects", payload)
+    end
+
+    # Get a project by name
+    # @param name [String] Project name
+    # @return [Hash] Response with status and body
+    def get_project(name)
+      get("/projects/#{URI.encode_www_form_component(name)}")
+    end
+
+    # List projects
+    # @param limit [Integer] Maximum number of projects to return
+    # @param offset [Integer] Offset for pagination
+    # @return [Hash] Response with status and body
+    def list_projects(limit: 100, offset: 0)
+      get("/projects?limit=#{limit}&offset=#{offset}")
+    end
+
+    # Upload a file attachment
+    # @param file_path [String] Path to the file
+    # @return [Hash] Response with status and body containing the file ID
+    def upload_file(file_path)
+      uri = URI.parse("#{@api_url}/files")
+      
+      File.open(file_path, 'rb') do |file|
+        boundary = SecureRandom.hex(16)
+        
+        req = Net::HTTP::Post.new(uri.request_uri)
+        req['Authorization'] = "Bearer #{@api_key}" if @api_key
+        req['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+        
+        body = []
+        body << "--#{boundary}\r\n"
+        body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{File.basename(file_path)}\"\r\n"
+        body << "Content-Type: #{content_type_for_file(file_path)}\r\n\r\n"
+        body << file.read
+        body << "\r\n--#{boundary}--\r\n"
+        
+        req.body = body.join
+        
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = Config[:open_timeout_seconds]
+        http.read_timeout = Config[:timeout_seconds]
+        
+        res = http.request(req)
+        { 
+          status: res.code.to_i, 
+          body: (JSON.parse(res.body) rescue { "raw" => res.body })
+        }
+      end
+    rescue => e
+      { status: 0, error: e.message }
+    end
+
+    private
+
+    # Make a GET request
+    # @param path [String] API path
+    # @return [Hash] Response with status and body
+    def get(path)
+      request(Net::HTTP::Get, path, nil)
+    end
+
+    # Make a POST request
+    # @param path [String] API path
+    # @param payload [Hash] Request payload
+    # @return [Hash] Response with status and body
+    def post(path, payload)
+      request(Net::HTTP::Post, path, payload)
+    end
+
+    # Make a PATCH request
+    # @param path [String] API path
+    # @param payload [Hash] Request payload
+    # @return [Hash] Response with status and body
+    def patch(path, payload)
+      request(Net::HTTP::Patch, path, payload)
+    end
+
+    # Make a DELETE request
+    # @param path [String] API path
+    # @return [Hash] Response with status and body
+    def delete(path)
+      request(Net::HTTP::Delete, path, nil)
+    end
+
+    # Make an HTTP request
+    # @param klass [Class] Net::HTTP request class
+    # @param path [String] API path
+    # @param payload [Hash] Request payload
+    # @return [Hash] Response with status and body
+    def request(klass, path, payload)
+      uri = URI.parse("#{@api_url}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = Config[:open_timeout_seconds]
+      http.read_timeout = Config[:timeout_seconds]
+      
+      req = klass.new(uri.request_uri)
+      req["Authorization"] = "Bearer #{@api_key}" if @api_key
+      
+      if payload
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(payload)
+      end
+      
+      res = http.request(req)
+      { 
+        status: res.code.to_i, 
+        body: (JSON.parse(res.body) rescue { "raw" => res.body })
+      }
+    rescue => e
+      { status: 0, error: e.message }
+    end
+
+    # Determine content type for a file
+    # @param file_path [String] Path to the file
+    # @return [String] Content type
+    def content_type_for_file(file_path)
+      ext = File.extname(file_path).downcase
+      case ext
+      when ".jpg", ".jpeg" then "image/jpeg"
+      when ".png" then "image/png"
+      when ".pdf" then "application/pdf"
+      when ".txt" then "text/plain"
+      when ".json" then "application/json"
+      when ".csv" then "text/csv"
+      else "application/octet-stream"
+      end
+    end
+  end
+end

data/lib/langsmithrb_rails/config.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "ostruct"
+require "logger"
+require "singleton"
+
+module LangsmithrbRails
+  # Configuration class for LangsmithrbRails
+  class Config
+    include Singleton
+    
+    # Default configuration values
+    DEFAULTS = {
+      api_url: "https://api.smith.langchain.com",
+      project_name: "default",
+      api_key: ENV["LANGSMITH_API_KEY"],
+      sampling: 1.0,
+      redact_by_default: true,
+      timeout_seconds: 3.0,
+      open_timeout_seconds: 1.0,
+      env: ENV["RAILS_ENV"] || "development",
+      enabled: true,
+      # Advanced tracing options
+      trace_all: ENV.fetch("LANGSMITH_TRACE_ALL", "false") == "true",
+      trace_level: ENV.fetch("LANGSMITH_TRACE_LEVEL", "info").to_sym,
+      # OpenTelemetry options
+      otel_enabled: ENV.fetch("LANGSMITH_OTEL_ENABLED", "false") == "true",
+      otel_service_name: ENV.fetch("LANGSMITH_OTEL_SERVICE_NAME", "langsmithrb_rails"),
+      # Evaluation options
+      evaluation_enabled: ENV.fetch("LANGSMITH_EVALUATION_ENABLED", "false") == "true",
+      # Logging options
+      log_level: ENV.fetch("LANGSMITH_LOG_LEVEL", "info").to_sym,
+      log_to_stdout: ENV.fetch("LANGSMITH_LOG_TO_STDOUT", "false") == "true"
+    }.freeze
+
+    # Configuration attributes
+    attr_accessor :api_key, :api_url, :project_name, :enabled, :sampling,
+                  :trace_all, :trace_level, :otel_enabled, :otel_service_name,
+                  :evaluation_enabled, :log_level, :log_to_stdout
+    attr_reader :logger
+
+    # Initialize with default values
+    def initialize
+      # Set defaults first
+      DEFAULTS.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+      
+      # Then override with environment variables if present
+      load_from_env
+      
+      # Initialize logger
+      @logger = create_logger(@log_level, @log_to_stdout)
+    end
+    
+    # Load configuration from environment variables
+    # @return [Config] Self for chaining
+    def load_from_env
+      @api_key = ENV["LANGSMITH_API_KEY"] if ENV["LANGSMITH_API_KEY"]
+      @api_url = ENV["LANGSMITH_API_URL"] if ENV["LANGSMITH_API_URL"]
+      @project_name = ENV["LANGSMITH_PROJECT"] if ENV["LANGSMITH_PROJECT"]
+      @enabled = ENV["LANGSMITH_ENABLED"] == "true" if ENV.key?("LANGSMITH_ENABLED")
+      @sampling = ENV["LANGSMITH_SAMPLING"].to_f if ENV["LANGSMITH_SAMPLING"]
+      @trace_all = ENV["LANGSMITH_TRACE_ALL"] == "true" if ENV.key?("LANGSMITH_TRACE_ALL")
+      @trace_level = ENV["LANGSMITH_TRACE_LEVEL"].to_sym if ENV["LANGSMITH_TRACE_LEVEL"]
+      @otel_enabled = ENV["LANGSMITH_OTEL_ENABLED"] == "true" if ENV.key?("LANGSMITH_OTEL_ENABLED")
+      @otel_service_name = ENV["LANGSMITH_OTEL_SERVICE_NAME"] if ENV["LANGSMITH_OTEL_SERVICE_NAME"]
+      @evaluation_enabled = ENV["LANGSMITH_EVALUATION_ENABLED"] == "true" if ENV.key?("LANGSMITH_EVALUATION_ENABLED")
+      @log_level = ENV["LANGSMITH_LOG_LEVEL"].to_sym if ENV["LANGSMITH_LOG_LEVEL"]
+      @log_to_stdout = ENV["LANGSMITH_LOG_TO_STDOUT"] == "true" if ENV.key?("LANGSMITH_LOG_TO_STDOUT")
+      self
+    end
+    
+    # Load configuration from YAML file
+    # @param path [String] Path to YAML file
+    # @return [Config] Self for chaining
+    def load_from_yaml(path)
+      return self unless File.exist?(path)
+      
+      yml = YAML.load_file(path)
+      env = (ENV["RAILS_ENV"] || "development").to_s
+      config = yml.fetch(env, {})
+      
+      config.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+      
+      # Reset logger if log settings changed
+      @logger = create_logger(@log_level, @log_to_stdout)
+      
+      self
+    end
+    
+    # Check if LangSmith is enabled
+    # @return [Boolean] Whether LangSmith is enabled
+    def enabled?
+      @enabled
+    end
+    
+    # Check if a trace should be sampled
+    # @return [Boolean] Whether to sample the trace
+    def should_sample?
+      return true if @sampling >= 1.0
+      return false if @sampling <= 0.0
+      Random.rand < @sampling
+    end
+    
+    # Check if OpenTelemetry is enabled
+    # @return [Boolean] Whether OpenTelemetry is enabled
+    def otel_enabled?
+      @otel_enabled
+    end
+    
+    # Check if evaluation is enabled
+    # @return [Boolean] Whether evaluation is enabled
+    def evaluation_enabled?
+      @evaluation_enabled
+    end
+    
+    # Set log level
+    # @param level [Symbol, String] Log level
+    # @return [Symbol] Log level
+    def log_level=(level)
+      level = level.to_sym if level.is_a?(String)
+      unless [:debug, :info, :warn, :error, :fatal].include?(level)
+        raise ArgumentError, "Invalid log level: #{level}"
+      end
+      @log_level = level
+      @logger = create_logger(@log_level, @log_to_stdout)
+      @log_level
+    end
+    
+    # Get logger instance
+    # @return [Logger] Logger instance
+    def logger
+      @logger ||= create_logger(@log_level, @log_to_stdout)
+    end
+    
+    private
+    
+    # Create a logger
+    # @param level [Symbol] Log level
+    # @param to_stdout [Boolean] Whether to log to STDOUT
+    # @return [Logger] Logger instance
+    def create_logger(level, to_stdout)
+      logger = Logger.new(to_stdout ? STDOUT : IO::NULL)
+      logger.level = parse_log_level(level)
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        "[LangsmithrbRails] [#{severity}] #{msg}\n"
+      end
+      logger
+    end
+    
+    # Parse log level
+    # @param level [Symbol, String] Log level
+    # @return [Integer] Logger level constant
+    def parse_log_level(level)
+      case level.to_s.downcase
+      when "debug" then Logger::DEBUG
+      when "info" then Logger::INFO
+      when "warn" then Logger::WARN
+      when "error" then Logger::ERROR
+      when "fatal" then Logger::FATAL
+      else Logger::INFO
+      end
+    end
+  end
+end