coolhand 0.2.0 → 0.3.0

data/lib/coolhand/ruby/api_service.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "uri"
-require "json"
-require_relative "collector"
-
-module Coolhand
-  module Ruby
-    class ApiService
-      BASE_URI = "https://coolhandlabs.com/api"
-
-      attr_reader :api_endpoint
-
-      def initialize(endpoint_path = nil)
-        @api_endpoint = endpoint_path ? "#{BASE_URI}/#{endpoint_path}" : BASE_URI
-      end
-
-      def send_llm_request_log(request_data)
-        original_endpoint = @api_endpoint
-        @api_endpoint = "#{BASE_URI}/v2/llm_request_logs"
-
-        payload = {
-          llm_request_log: request_data.merge(
-            collector: Collector.get_collector_string
-          )
-        }
-
-        result = send_request(payload, "✅ Successfully sent request metadata")
-        @api_endpoint = original_endpoint
-        result
-      end
-
-      def configuration
-        Coolhand.configuration
-      end
-
-      def api_key
-        configuration.api_key
-      end
-
-      def silent
-        configuration.silent
-      end
-
-      protected
-
-      # Add collector field to the data being sent
-      def add_collector_to_data(data, collection_method = nil)
-        data.merge(collector: Collector.get_collector_string(collection_method))
-      end
-
-      def create_request_options(_payload)
-        {
-          "Content-Type" => "application/json",
-          "X-API-Key" => api_key
-        }
-      end
-
-      def send_request(payload, success_message)
-        uri = URI.parse(@api_endpoint)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.scheme == "https")
-
-        request = Net::HTTP::Post.new(uri.request_uri)
-        headers = create_request_options(payload)
-        headers.each do |key, value|
-          # Ensure header values are UTF-8 encoded
-          encoded_value = value.is_a?(String) ? value.dup.force_encoding("UTF-8") : value
-          request[key] = encoded_value
-        end
-
-        # Clean payload and ensure UTF-8 encoding before JSON generation
-        cleaned_payload = sanitize_payload_for_json(payload)
-        json_body = JSON.generate(cleaned_payload)
-
-        # Ensure the request body is properly encoded as UTF-8
-        request.body = json_body.force_encoding("UTF-8")
-
-        begin
-          response = http.request(request)
-
-          if response.is_a?(Net::HTTPSuccess)
-            result = JSON.parse(response.body, symbolize_names: true)
-            log success_message
-            result
-          else
-            body = response.body.force_encoding("UTF-8") if response.body
-            puts "❌ Request failed: #{response.code} - #{body}"
-            nil
-          end
-        rescue StandardError => e
-          log "❌ Request error: #{e.message}"
-          nil
-        end
-      end
-
-      def log(*args)
-        puts args.join(" ") unless silent
-      end
-
-      def log_separator
-        log("═" * 60) unless silent
-      end
-
-      def create_feedback(feedback, collection_method = nil)
-        feedback_with_collector = add_collector_to_data(feedback, collection_method)
-
-        payload = {
-          llm_request_log_feedback: feedback_with_collector
-        }
-
-        log_feedback_info(feedback)
-
-        result = send_request(
-          payload,
-          "✅ Successfully created feedback with ID: #{feedback[:llm_request_log_id] || 'N/A'}"
-        )
-
-        log_separator
-        result
-      end
-
-      def create_log(captured_data, collection_method = nil)
-        raw_request_with_collector = add_collector_to_data({ raw_request: captured_data }, collection_method)
-
-        payload = {
-          llm_request_log: raw_request_with_collector
-        }
-
-        log_request_info(captured_data)
-
-        result = send_request(
-          payload,
-          "✅ Successfully logged to API"
-        )
-
-        puts "✅ Successfully logged to API with ID: #{result[:id]}" if result && !silent
-
-        log_separator
-        result
-      end
-
-      # Filter list of known binary/problematic field names by service
-      BINARY_DATA_FILTERS = {
-        # ElevenLabs fields that contain binary audio data
-        elevenlabs: %w[
-          full_audio
-          audio
-          audio_data
-          raw_audio
-          audio_base64
-          voice_sample
-          audio_url
-        ],
-        # OpenAI fields that might contain binary data
-        openai: %w[
-          file_content
-          audio_data
-          image_data
-          binary_content
-        ]
-      }.freeze
-
-      private
-
-      # Get all filtered field names as a flat array
-      def filtered_field_names
-        @filtered_field_names ||= BINARY_DATA_FILTERS.values.flatten.map(&:downcase)
-      end
-
-      # Recursively sanitize payload to remove known problematic fields
-      def sanitize_payload_for_json(obj)
-        case obj
-        when Hash
-          obj.each_with_object({}) do |(key, value), sanitized|
-            key_str = key.to_s.downcase
-
-            # Skip if key matches any filtered field name
-            next if filtered_field_names.any? { |filter| key_str.include?(filter) }
-
-            sanitized[key] = sanitize_payload_for_json(value)
-          end
-        when Array
-          obj.map { |item| sanitize_payload_for_json(item) }
-        else
-          obj
-        end
-      rescue StandardError => e
-        log "⚠️ Warning: Error sanitizing payload: #{e.message}"
-        obj
-      end
-
-      def log_feedback_info(feedback)
-        return if silent
-
-        # Log the appropriate identifier based on what was provided
-        if feedback[:llm_request_log_id]
-          puts "\n📝 CREATING FEEDBACK for LLM Request Log ID: #{feedback[:llm_request_log_id]}"
-        elsif feedback[:llm_provider_unique_id]
-          puts "\n📝 CREATING FEEDBACK for Provider Unique ID: #{feedback[:llm_provider_unique_id]}"
-        else
-          puts "\n📝 CREATING FEEDBACK"
-        end
-
-        puts "👍/👎 Like: #{feedback[:like]}"
-
-        if feedback[:explanation]
-          explanation = feedback[:explanation]
-          truncated = explanation.length > 100 ? "#{explanation[0..99]}..." : explanation
-          puts "💭 Explanation: #{truncated}"
-        end
-
-        puts "📤 Sending to: #{@api_endpoint}"
-      end
-
-      def log_request_info(captured_data)
-        return if silent
-
-        puts "\n🎉 LOGGING OpenAI API Call #{@api_endpoint}"
-        puts captured_data
-        puts "📤 Sending to: #{@api_endpoint}"
-      end
-    end
-  end
-end

data/lib/coolhand/ruby/base_interceptor.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require "json"
-
-module Coolhand
-  module Ruby
-    # Base module with common functionality for all interceptors
-    module BaseInterceptor
-      module_function
-
-      def extract_response_data(response)
-        case response
-        when Hash
-          response
-        when Struct
-          response.to_h
-        else
-          # Handle streaming responses - these are often enumerator objects
-          # that can't be serialized directly
-          if response.class.name.include?("Stream") || response.respond_to?(:each)
-            {
-              response_type: "streaming",
-              class: response.class.name,
-              note: "Streaming response - content captured during enumeration"
-            }
-          elsif response.respond_to?(:to_h)
-            begin
-              response.to_h
-            rescue StandardError => e
-              {
-                serialization_error: e.message,
-                class: response.class.name,
-                raw_response: response.to_s
-              }
-            end
-          else
-            # Extract content and token usage information
-            response_data = {}
-
-            # Get content
-            response_data[:content] = response.content if response.respond_to?(:content)
-
-            # Extract token usage information
-            response_data[:usage] = extract_usage_metadata(response.usage) if response.respond_to?(:usage)
-
-            # Extract model information
-            response_data[:model] = response.model if response.respond_to?(:model)
-
-            # Extract role information
-            response_data[:role] = response.role if response.respond_to?(:role)
-
-            # Extract ID if available
-            response_data[:id] = response.id if response.respond_to?(:id)
-
-            # Extract stop reason if available
-            response_data[:stop_reason] = response.stop_reason if response.respond_to?(:stop_reason)
-
-            # Add class info for debugging
-            response_data[:class] = response.class.name
-
-            response_data.empty? ? { raw_response: response.to_s, class: response.class.name } : response_data
-          end
-        end
-      end
-
-      def extract_usage_metadata(usage)
-        if usage.respond_to?(:to_h)
-          usage.to_h
-        elsif usage.is_a?(Hash)
-          usage
-        else
-          # Extract individual usage fields
-          usage_data = {}
-          usage_data[:input_tokens] = usage.input_tokens if usage.respond_to?(:input_tokens)
-          usage_data[:output_tokens] = usage.output_tokens if usage.respond_to?(:output_tokens)
-          usage_data[:total_tokens] = usage_data[:input_tokens].to_i + usage_data[:output_tokens].to_i
-          usage_data
-        end
-      end
-
-      def clean_request_headers(headers)
-        cleaned = headers.dup
-
-        # Remove sensitive headers
-        cleaned.delete("Authorization")
-        cleaned.delete("authorization")
-        cleaned.delete("x-api-key")
-        cleaned.delete("X-API-Key")
-
-        cleaned
-      end
-
-      def clean_response_headers(headers)
-        # Response headers typically don't contain sensitive data
-        # but we can filter if needed
-        headers.dup
-      end
-
-      def sanitize_headers(headers)
-        sanitized = headers.transform_keys(&:to_s).dup
-
-        if sanitized["Authorization"]
-          sanitized["Authorization"] = sanitized["Authorization"].gsub(/Bearer .+/, "Bearer [REDACTED]")
-        end
-
-        %w[openai-api-key api-key x-api-key X-API-Key].each do |key|
-          sanitized[key] = "[REDACTED]" if sanitized[key]
-        end
-
-        sanitized
-      end
-
-      def send_complete_request_log(request_id:, method:, url:, request_headers:, request_body:, response_headers:,
-        response_body:, status_code:, start_time:, end_time:, duration_ms:, is_streaming:)
-        request_data = {
-          raw_request: {
-            id: request_id,
-            timestamp: start_time.iso8601,
-            method: method.to_s.downcase,
-            url: url,
-            headers: request_headers,
-            request_body: request_body,
-            response_headers: response_headers,
-            response_body: response_body,
-            status_code: status_code,
-            duration_ms: duration_ms,
-            completed_at: end_time.iso8601,
-            is_streaming: is_streaming
-          }
-        }
-
-        api_service = Coolhand::Ruby::ApiService.new
-        api_service.send_llm_request_log(request_data)
-
-        Coolhand.log "📤 Sent complete request/response log for #{request_id} (duration: #{duration_ms}ms)"
-      rescue StandardError => e
-        Coolhand.log "❌ Error sending complete request log: #{e.message}"
-      end
-
-      def parse_json(string)
-        JSON.parse(string)
-      rescue JSON::ParserError, TypeError
-        string
-      end
-    end
-  end
-end

data/lib/coolhand/ruby/collector.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Coolhand
-  module Ruby
-    # Utility for generating collector identification string
-    module Collector
-      COLLECTION_METHODS = %w[manual auto-monitor].freeze
-
-      class << self
-        # Gets the collector identification string
-        # Format: "coolhand-ruby-X.Y.Z" or "coolhand-ruby-X.Y.Z-method"
-        # @param method [String, nil] Optional collection method suffix
-        # @return [String] Collector string identifying this SDK version and collection method
-        def get_collector_string(method = nil)
-          base = "coolhand-ruby-#{VERSION}"
-          method && COLLECTION_METHODS.include?(method) ? "#{base}-#{method}" : base
-        end
-      end
-    end
-  end
-end

data/lib/coolhand/ruby/configuration.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Coolhand
-  # Handles all configuration settings for the gem.
-  class Configuration
-    attr_accessor :api_key, :environment, :silent
-    attr_reader :intercept_addresses
-
-    def initialize
-      # Set defaults
-      @environment = "production"
-      @api_key = nil
-      @silent = false
-      @intercept_addresses = ["api.openai.com", "api.anthropic.com", "api.elevenlabs.io", ":generateContent"]
-    end
-
-    # Custom setter that preserves defaults when nil/empty array is provided
-    def intercept_addresses=(value)
-      return if value.nil? || (value.is_a?(Array) && value.empty?)
-
-      @intercept_addresses = value.is_a?(Array) ? value : [value]
-    end
-
-    def validate!
-      # Validate API Key after configuration
-      if api_key.nil?
-        Coolhand.log "❌ Coolhand Error: API Key is required. Please set it in the configuration."
-        raise Error, "API Key is required"
-      end
-
-      # Validate intercept_addresses after configuration
-      if intercept_addresses.nil? || intercept_addresses.empty?
-        Coolhand.log "❌ Coolhand Error: Intercept addresses cannot be empty. Please set it in the configuration."
-        raise Error, "Intercept addresses cannot be empty"
-      end
-    end
-  end
-end

data/lib/coolhand/ruby/faraday_interceptor.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_interceptor"
-
-module Coolhand
-  module Ruby
-    class FaradayInterceptor < Faraday::Middleware
-      include BaseInterceptor
-
-      ORIGINAL_METHOD_ALIAS = :coolhand_original_initialize
-
-      def self.patch!
-        return if @patched
-
-        @patched = true
-        Coolhand.log "📡 Monitoring outbound requests ..."
-
-        # Use prepend instead of alias_method to avoid conflicts with other gems
-        Faraday::Connection.prepend(Module.new do
-          def initialize(url = nil, options = nil, &block)
-            super
-
-            # Only add interceptor if it's not already present
-            unless @builder.handlers.any? { |h| h.klass == Coolhand::Ruby::FaradayInterceptor }
-              use Coolhand::Ruby::FaradayInterceptor
-            end
-          end
-        end)
-
-        Coolhand.log "🔧 Setting up monitoring for Faraday ..."
-      end
-
-      def self.unpatch!
-        # NOTE: With prepend, there's no clean way to unpatch
-        # We'll mark it as unpatched so it can be re-patched
-        @patched = false
-        Coolhand.log "🔌 Faraday monitoring disabled ..."
-      end
-
-      def self.patched?
-        @patched
-      end
-
-      def call(env)
-        # Skip if Faraday interception is temporarily disabled for this thread
-        return super if Thread.current[:coolhand_disable_faraday]
-
-        return super unless llm_api_request?(env)
-
-        Coolhand.log "🎯 INTERCEPTING OpenAI call #{env.url}"
-
-        call_data = build_call_data(env)
-        buffer = override_on_data(env)
-
-        process_complete_callback(env, buffer, call_data)
-      end
-
-      private
-
-      def llm_api_request?(env)
-        Coolhand.configuration.intercept_addresses.any? do |address|
-          env.url.to_s.include?(address)
-        end
-      end
-
-      def build_call_data(env)
-        {
-          id: SecureRandom.uuid,
-          timestamp: DateTime.now,
-          method: env.method,
-          url: env.url.to_s,
-          request_headers: sanitize_headers(env.request_headers),
-          request_body: parse_json(env.request_body),
-          response_body: nil,
-          response_headers: nil,
-          status_code: nil
-        }
-      end
-
-      def override_on_data(env)
-        buffer = +""
-        original_on_data = env.request.on_data
-        env.request.on_data = proc do |chunk, overall_received_bytes|
-          buffer << chunk
-
-          original_on_data&.call(chunk, overall_received_bytes)
-        end
-
-        buffer
-      end
-
-      def process_complete_callback(env, buffer, call_data)
-        @app.call(env).on_complete do |response_env|
-          if buffer.empty?
-            body = response_env.body
-          else
-            body = buffer
-            response_env.body = body
-          end
-
-          call_data[:response_body] = parse_json(body)
-          call_data[:response_headers] = sanitize_headers(response_env.response_headers)
-          call_data[:status_code] = response_env.status
-
-          end_time = Time.now
-          duration_ms = ((end_time - call_data[:timestamp].to_time) * 1000).round(2)
-
-          # Send complete request/response data in single API call
-          Thread.new do
-            send_complete_request_log(
-              request_id: call_data[:id],
-              method: call_data[:method],
-              url: call_data[:url],
-              request_headers: call_data[:request_headers],
-              request_body: call_data[:request_body],
-              response_headers: call_data[:response_headers],
-              response_body: call_data[:response_body],
-              status_code: call_data[:status_code],
-              start_time: call_data[:timestamp],
-              end_time: end_time,
-              duration_ms: duration_ms,
-              is_streaming: false
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/coolhand/ruby/feedback_service.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "api_service"
-
-module Coolhand
-  module Ruby
-    class FeedbackService < ApiService
-      def initialize
-        super("v2/llm_request_log_feedbacks")
-      end
-
-      def create_feedback(feedback)
-        super(feedback, "manual")
-      end
-    end
-  end
-end

data/lib/coolhand/ruby/logger_service.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "api_service"
-
-module Coolhand
-  module Ruby
-    class LoggerService < ApiService
-      def initialize
-        super("v2/llm_request_logs")
-      end
-
-      def log_to_api(captured_data)
-        create_log(captured_data, "auto-monitor")
-      end
-
-      # Helper method for forwarding webhook data to Coolhand
-      def forward_webhook(webhook_body:, source:, event_type: nil, headers: {}, **options)
-        # Validate required parameters
-        unless Coolhand.required_field?(webhook_body)
-          error_msg = "webhook_body is required and cannot be nil or empty"
-          if Coolhand.configuration.silent
-            puts "COOLHAND WARNING: #{error_msg}"
-            return false
-          else
-            raise ArgumentError, error_msg
-          end
-        end
-
-        unless Coolhand.required_field?(source)
-          error_msg = "source is required and cannot be nil or empty"
-          if Coolhand.configuration.silent
-            puts "COOLHAND WARNING: #{error_msg}"
-            return false
-          else
-            raise ArgumentError, error_msg
-          end
-        end
-
-        # Auto-generate required fields unless provided
-        webhook_data = {
-          id: options[:id] || SecureRandom.uuid,
-          timestamp: options[:timestamp] || Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%6NZ"),
-          method: options[:method] || "POST",
-          url: options[:url] || build_webhook_url(source, event_type),
-          headers: sanitize_headers(headers),
-          request_body: clean_webhook_body(webhook_body, source),
-          response_body: options[:response_body],
-          response_headers: options[:response_headers],
-          status_code: options[:status_code] || 200,
-          source: "#{source}_webhook"
-        }.merge(options.slice(:metadata, :conversation_id, :agent_id))
-
-        # Send to API asynchronously
-        log_to_api(webhook_data)
-      end
-
-      private
-
-      def build_webhook_url(source, event_type)
-        base = "webhook://#{source}"
-        event_type ? "#{base}/#{event_type}" : base
-      end
-
-      def sanitize_headers(headers)
-        return {} if headers.nil?
-        return {} if headers.respond_to?(:empty?) && headers.empty?
-        return {} unless headers.respond_to?(:each)
-
-        # Handle Rails request headers or plain hash
-        clean_headers = {}
-        headers.each do |key, value|
-          next unless key && value
-
-          # Convert Rails HTTP_ prefix headers
-          clean_key = key.to_s.gsub(/^HTTP_/, "").tr("_", "-").downcase
-
-          # Redact sensitive headers
-          clean_value = clean_key.match?(/key|token|secret|authorization|signature/i) ? "[REDACTED]" : value.to_s
-          clean_headers[clean_key] = clean_value
-        end
-        clean_headers
-      end
-
-      def clean_webhook_body(body, source)
-        # Service-specific binary field filters
-        binary_fields = case source.to_s.downcase
-                        when "elevenlabs"
-                          %w[full_audio audio audio_data raw_audio audio_base64 voice_sample audio_url]
-                        when "twilio"
-                          %w[recording_url media_url]
-                        else
-                          %w[audio_data image_data file_content binary_content]
-        end
-
-        remove_binary_fields(body, binary_fields)
-      end
-
-      def remove_binary_fields(obj, fields_to_remove)
-        case obj
-        when Hash
-          obj.each_with_object({}) do |(key, value), cleaned|
-            next if fields_to_remove.any? { |field| key.to_s.downcase.include?(field) }
-
-            cleaned[key] = remove_binary_fields(value, fields_to_remove)
-          end
-        when Array
-          obj.map { |item| remove_binary_fields(item, fields_to_remove) }
-        else
-          obj
-        end
-      end
-    end
-  end
-end