coolhand 0.1.4 → 0.2.0

data/lib/coolhand/ruby/anthropic_interceptor.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+begin
+  require "anthropic"
+rescue LoadError
+  # Anthropic gem not available - interceptor will be a no-op
+end
+require "securerandom"
+require "json"
+require "ostruct"
+require_relative "base_interceptor"
+
+module Coolhand
+  module Ruby
+    module AnthropicInterceptor
+      module_function
+
+      def patch!
+        return if @patched
+        return unless defined?(Anthropic)
+
+        # Check if both anthropic gems are installed
+        if both_gems_installed?
+          # Always show this warning, regardless of silent mode
+          warn_message = "⚠️  Warning: Both 'anthropic' and 'ruby-anthropic' gems are installed. " \
+                         "Coolhand will only monitor ruby-anthropic (Faraday-based) requests. " \
+                         "Official anthropic gem monitoring has been disabled."
+          puts "COOLHAND: #{warn_message}"
+
+          # Mark as patched since ruby-anthropic will be handled by FaradayInterceptor
+          @patched = true
+          return
+        end
+
+        # Check if we're using the official anthropic gem
+        # The official gem has Anthropic::Internal, ruby-anthropic doesn't
+        if defined?(Anthropic::Internal)
+          # Patch the BaseClient request method for official anthropic gem
+          require "anthropic/internal/transport/base_client"
+          ::Anthropic::Internal::Transport::BaseClient.prepend(RequestInterceptor)
+        else
+          # ruby-anthropic uses Faraday, so the FaradayInterceptor already handles it
+          Coolhand.log "✅ ruby-anthropic detected, using Faraday interceptor"
+          @patched = true
+          return
+        end
+
+        # Patch MessageStream to capture completion data
+        patch_message_stream!
+
+        @patched = true
+        Coolhand.log "✅ Anthropic interceptor patched"
+      end
+
+      def unpatch!
+        # NOTE: Ruby doesn't have a clean way to unpatch prepended modules
+        # This is mainly for testing - in production, patching is permanent
+        @patched = false
+        Coolhand.log "⚠️  Anthropic interceptor unpatch requested (not fully implemented)"
+      end
+
+      def patched?
+        @patched ||= false
+      end
+
+      def both_gems_installed?
+        # Check if both gems are installed by looking at loaded specs
+        anthropic_gem = Gem.loaded_specs["anthropic"]
+        ruby_anthropic_gem = Gem.loaded_specs["ruby-anthropic"]
+
+        anthropic_gem && ruby_anthropic_gem
+      end
+
+      def patch_message_stream!
+        # Try to load MessageStream class if available
+        begin
+          require "anthropic/helpers/streaming/message_stream"
+        rescue LoadError
+          # MessageStream not available in this version of anthropic gem
+          return
+        end
+
+        # Only proceed if the constant is now defined
+        return unless defined?(Anthropic::Streaming::MessageStream)
+
+        # Prepend our patch module
+        ::Anthropic::Streaming::MessageStream.prepend(MessageStreamInterceptor)
+      end
+
+      module RequestInterceptor
+        def request(method:, path:, body: nil, headers: {}, **options)
+          # Generate request ID for correlation
+          request_id = SecureRandom.hex(16)
+          start_time = Time.now
+
+          # Store request ID in thread-local storage for application access
+          Thread.current[:coolhand_current_request_id] = request_id
+
+          # Temporarily disable Faraday interception for this thread to prevent double logging
+          Thread.current[:coolhand_disable_faraday] = true
+
+          # Extract request metadata
+          full_url = "#{@base_url}#{path}"
+
+          # Capture all request headers including those added by the client
+          request_headers = BaseInterceptor.clean_request_headers(headers.dup)
+          request_body = body
+
+          # Detect if this is a streaming request
+          is_streaming = streaming_request?(body, headers)
+
+          # Call the original request method
+          begin
+            response = super
+            end_time = Time.now
+            duration_ms = ((end_time - start_time) * 1000).round(2)
+
+            # For streaming responses, store request metadata for later logging
+            if is_streaming
+              Thread.current[:coolhand_streaming_request] = {
+                request_id: request_id,
+                method: method,
+                url: full_url,
+                request_headers: request_headers,
+                request_body: request_body,
+                start_time: start_time,
+                end_time: end_time,
+                duration_ms: duration_ms,
+                is_streaming: is_streaming
+              }
+            else
+              # Extract response data
+              response_data = BaseInterceptor.extract_response_data(response)
+
+              # Send complete request/response data in single API call
+              BaseInterceptor.send_complete_request_log(
+                request_id: request_id,
+                method: method,
+                url: full_url,
+                request_headers: request_headers,
+                request_body: request_body,
+                response_headers: extract_response_headers(response),
+                response_body: response_data,
+                status_code: nil,
+                start_time: start_time,
+                end_time: end_time,
+                duration_ms: duration_ms,
+                is_streaming: is_streaming
+              )
+            end
+
+            response
+          rescue StandardError => e
+            end_time = Time.now
+            duration_ms = ((end_time - start_time) * 1000).round(2)
+
+            # Send error response in single API call
+            BaseInterceptor.send_complete_request_log(
+              request_id: request_id,
+              method: method,
+              url: full_url,
+              request_headers: request_headers,
+              request_body: request_body,
+              response_headers: {},
+              response_body: {
+                error: {
+                  message: e.message,
+                  class: e.class.name
+                }
+              },
+              status_code: nil,
+              start_time: start_time,
+              end_time: end_time,
+              duration_ms: duration_ms,
+              is_streaming: is_streaming
+            )
+            raise
+          ensure
+            # Always re-enable Faraday interception for this thread
+            Thread.current[:coolhand_disable_faraday] = false
+          end
+        end
+
+        # Public method for applications to log final streaming response
+        def self.log_streaming_completion(final_response_body)
+          streaming_request = Thread.current[:coolhand_streaming_request]
+          return unless streaming_request
+
+          begin
+            send_complete_request_log(
+              request_id: streaming_request[:request_id],
+              method: streaming_request[:method],
+              url: streaming_request[:url],
+              request_headers: streaming_request[:request_headers],
+              request_body: streaming_request[:request_body],
+              response_headers: {},
+              response_body: final_response_body,
+              start_time: streaming_request[:start_time],
+              end_time: streaming_request[:end_time],
+              duration_ms: streaming_request[:duration_ms],
+              is_streaming: streaming_request[:is_streaming]
+            )
+
+            # Clear the thread-local data
+            Thread.current[:coolhand_streaming_request] = nil
+          rescue StandardError => e
+            Coolhand.log "❌ Error logging streaming completion: #{e.message}"
+          end
+        end
+
+        def self.send_complete_request_log(request_id:, method:, url:, request_headers:, request_body:,
+          response_headers:, response_body:, start_time:, end_time:, duration_ms:, is_streaming:)
+          BaseInterceptor.send_complete_request_log(
+            request_id: request_id,
+            method: method,
+            url: url,
+            request_headers: request_headers,
+            request_body: request_body,
+            response_headers: response_headers,
+            response_body: response_body,
+            status_code: nil,
+            start_time: start_time,
+            end_time: end_time,
+            duration_ms: duration_ms,
+            is_streaming: is_streaming
+          )
+        end
+
+        private
+
+        def streaming_request?(body, headers)
+          # Check if stream parameter is set in request body
+          return true if body.is_a?(Hash) && body[:stream] == true
+
+          # Check Accept header for Server-Sent Events
+          accept_header = headers["Accept"] || headers["accept"]
+          return true if accept_header&.include?("text/event-stream")
+
+          false
+        end
+
+        def extract_response_headers(response)
+          # Try to extract headers if the response object exposes them
+          if response.respond_to?(:headers)
+            BaseInterceptor.clean_response_headers(response.headers)
+          elsif response.respond_to?(:response_headers)
+            BaseInterceptor.clean_response_headers(response.response_headers)
+          else
+            # Anthropic gem doesn't expose response headers directly
+            # Return empty hash to indicate no headers are available
+            {}
+          end
+        end
+      end
+
+      module MessageStreamInterceptor
+        def accumulated_message
+          # Call the original method to get the accumulated message
+          message = super
+
+          # Log the completion data if we have streaming request metadata
+          streaming_request = Thread.current[:coolhand_streaming_request]
+          log_streaming_completion(message, streaming_request) if streaming_request
+
+          message
+        end
+
+        private
+
+        def log_streaming_completion(message, streaming_request)
+          # Convert message to hash for logging (preserving natural format)
+          response_body = extract_response_data(message)
+
+          # Send the completion log
+          BaseInterceptor.send_complete_request_log(
+            request_id: streaming_request[:request_id],
+            method: streaming_request[:method],
+            url: streaming_request[:url],
+            request_headers: streaming_request[:request_headers],
+            request_body: streaming_request[:request_body],
+            response_headers: {},
+            response_body: response_body,
+            status_code: nil,
+            start_time: streaming_request[:start_time],
+            end_time: streaming_request[:end_time],
+            duration_ms: streaming_request[:duration_ms],
+            is_streaming: streaming_request[:is_streaming]
+          )
+
+          # Clear the thread-local data
+          Thread.current[:coolhand_streaming_request] = nil
+        end
+
+        def extract_response_data(message)
+          BaseInterceptor.extract_response_data(message)
+        end
+      end
+    end
+  end
+end

data/lib/coolhand/ruby/api_service.rb

@@ -8,12 +8,27 @@ require_relative "collector"
 module Coolhand
   module Ruby
     class ApiService
-      BASE_URI = "https://coolhand.io/api"
+      BASE_URI = "https://coolhandlabs.com/api"
 
       attr_reader :api_endpoint
 
-      def initialize(endpoint_path)
-        @api_endpoint = "#{BASE_URI}/#{endpoint_path}"
+      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

data/lib/coolhand/ruby/base_interceptor.rb

@@ -0,0 +1,148 @@
+# 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/faraday_interceptor.rb

@@ -0,0 +1,129 @@
+# 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/version.rb

@@ -2,6 +2,6 @@
 
 module Coolhand
   module Ruby
-    VERSION = "0.1.4"
+    VERSION = "0.2.0"
   end
 end

data/lib/coolhand/ruby.rb

@@ -8,7 +8,8 @@ require "securerandom"
 require_relative "ruby/version"
 require_relative "ruby/configuration"
 require_relative "ruby/collector"
-require_relative "ruby/interceptor"
+require_relative "ruby/faraday_interceptor"
+require_relative "ruby/anthropic_interceptor"
 require_relative "ruby/api_service"
 require_relative "ruby/logger_service"
 require_relative "ruby/feedback_service"
@@ -43,10 +44,22 @@ module Coolhand
 
       configuration.validate!
 
-      # Apply the patch after configuration is set
-      Interceptor.patch!
-
-      log "✅ Coolhand ready - will log OpenAI calls"
+      # Apply the Faraday patch (needed for ruby-anthropic and other Faraday-based gems)
+      Ruby::FaradayInterceptor.patch!
+
+      # Conditionally patch the official Anthropic gem if it's loaded
+      if anthropic_gem_loaded?
+        if defined?(Anthropic::Internal)
+          # Official anthropic gem - patch the AnthropicInterceptor for Net::HTTP requests
+          Ruby::AnthropicInterceptor.patch!
+          log "✅ Coolhand ready - will log OpenAI and Anthropic (official gem) calls"
+        else
+          # ruby-anthropic gem uses Faraday, so FaradayInterceptor is sufficient
+          log "✅ Coolhand ready - will log OpenAI and Anthropic (ruby-anthropic via Faraday) calls"
+        end
+      else
+        log "✅ Coolhand ready - will log OpenAI calls"
+      end
     end
 
     def capture
@@ -55,11 +68,19 @@ module Coolhand
         return
       end
 
-      Interceptor.patch!
+      Ruby::FaradayInterceptor.patch!
+
+      # Only patch AnthropicInterceptor for official anthropic gem
+      anthropic_patched = false
+      if anthropic_gem_loaded? && defined?(Anthropic::Internal)
+        Ruby::AnthropicInterceptor.patch!
+        anthropic_patched = true
+      end
 
       yield
     ensure
-      Interceptor.unpatch!
+      Ruby::FaradayInterceptor.unpatch!
+      Ruby::AnthropicInterceptor.unpatch! if anthropic_patched
     end
 
     # A simple logger that respects the 'silent' configuration option.
@@ -86,5 +107,15 @@ module Coolhand
 
       true
     end
+
+    def current_request_id
+      Thread.current[:coolhand_current_request_id]
+    end
+
+    private
+
+    def anthropic_gem_loaded?
+      defined?(Anthropic::Client)
+    end
   end
 end