binocs 0.1.0

data/lib/binocs/engine.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "turbo-rails"
+require "stimulus-rails"
+
+module Binocs
+  class Engine < ::Rails::Engine
+    isolate_namespace Binocs
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.assets false
+      g.helper false
+    end
+
+    initializer "binocs.middleware" do |app|
+      next unless Binocs.enabled?
+
+      require_relative "middleware/request_recorder"
+      app.middleware.use Binocs::Middleware::RequestRecorder
+    end
+
+    initializer "binocs.log_subscriber" do
+      next unless Binocs.enabled?
+
+      require_relative "log_subscriber"
+      Binocs::LogSubscriber.attach_to :action_controller
+    end
+
+    initializer "binocs.assets" do |app|
+      next unless Binocs.enabled?
+
+      app.config.assets.precompile += %w[binocs/application.css binocs/application.js] if app.config.respond_to?(:assets)
+    end
+
+    initializer "binocs.importmap", before: "importmap" do |app|
+      next unless Binocs.enabled?
+      next unless app.config.respond_to?(:importmap)
+
+      app.config.importmap.paths << Engine.root.join("config/importmap.rb")
+    end
+
+    initializer "binocs.helpers" do
+      ActiveSupport.on_load(:action_controller_base) do
+        helper Binocs::ApplicationHelper
+      end
+    end
+
+    config.after_initialize do
+      if Rails.env.production? && Binocs.configuration.enabled
+        Rails.logger.warn "[Binocs] WARNING: Binocs is disabled in production for security reasons."
+        Binocs.configuration.enabled = false
+      end
+
+      # Configure renderer for Turbo broadcasts (no request context available)
+      if defined?(ApplicationController)
+        ApplicationController.renderer.defaults[:http_host] = ENV.fetch("DOMAIN", "localhost:3000")
+      end
+    end
+  end
+end

data/lib/binocs/log_subscriber.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Binocs
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def process_action(event)
+      return unless Thread.current[:binocs_logs]
+
+      payload = event.payload
+
+      Thread.current[:binocs_logs] << {
+        type: "controller",
+        controller: payload[:controller],
+        action: payload[:action],
+        format: payload[:format],
+        method: payload[:method],
+        path: payload[:path],
+        status: payload[:status],
+        view_runtime: payload[:view_runtime]&.round(2),
+        db_runtime: payload[:db_runtime]&.round(2),
+        duration: event.duration.round(2),
+        timestamp: Time.current.iso8601
+      }
+    end
+
+    def halted_callback(event)
+      return unless Thread.current[:binocs_logs]
+
+      Thread.current[:binocs_logs] << {
+        type: "halted",
+        filter: event.payload[:filter],
+        timestamp: Time.current.iso8601
+      }
+    end
+
+    def send_data(event)
+      return unless Thread.current[:binocs_logs]
+
+      Thread.current[:binocs_logs] << {
+        type: "send_data",
+        filename: event.payload[:filename],
+        timestamp: Time.current.iso8601
+      }
+    end
+
+    def redirect_to(event)
+      return unless Thread.current[:binocs_logs]
+
+      Thread.current[:binocs_logs] << {
+        type: "redirect",
+        location: event.payload[:location],
+        status: event.payload[:status],
+        timestamp: Time.current.iso8601
+      }
+    end
+  end
+end

data/lib/binocs/middleware/request_recorder.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Binocs
+  module Middleware
+    class RequestRecorder
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless Binocs.enabled?
+        return @app.call(env) if ignored_path?(env["PATH_INFO"])
+
+        request_id = SecureRandom.uuid
+        Thread.current[:binocs_request_id] = request_id
+        Thread.current[:binocs_logs] = []
+        Thread.current[:binocs_start_time] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        Thread.current[:binocs_memory_before] = get_memory_usage
+
+        request = ActionDispatch::Request.new(env)
+
+        recorded_request = build_request_record(request, request_id)
+
+        begin
+          status, headers, response = @app.call(env)
+
+          complete_request_record(recorded_request, status, headers, response, env)
+
+          [status, headers, response]
+        rescue Exception => e
+          record_exception(recorded_request, e)
+          raise
+        ensure
+          save_request_record(recorded_request)
+          cleanup_thread_locals
+        end
+      end
+
+      private
+
+      def ignored_path?(path)
+        Binocs.configuration.ignored_paths.any? { |ignored| path.start_with?(ignored) }
+      end
+
+      def build_request_record(request, request_id)
+        {
+          uuid: request_id,
+          method: request.request_method,
+          path: request.path,
+          full_url: request.original_url,
+          params: sanitize_params(request),
+          request_headers: extract_headers(request.headers),
+          ip_address: request.remote_ip,
+          session_id: request.session.id&.to_s,
+          content_type: request.content_type,
+          request_body: extract_request_body(request)
+        }
+      end
+
+      def complete_request_record(record, status, headers, response, env)
+        record[:status_code] = status
+        record[:response_headers] = headers.to_h
+        record[:response_body] = extract_response_body(response, headers)
+        record[:duration_ms] = calculate_duration
+        record[:memory_delta] = calculate_memory_delta
+        record[:logs] = Thread.current[:binocs_logs] || []
+        record[:controller_name] = env["action_controller.instance"]&.class&.name
+        record[:action_name] = env["action_controller.instance"]&.action_name
+        record[:route_name] = extract_route_name(env)
+      end
+
+      def record_exception(record, exception)
+        record[:exception] = {
+          class: exception.class.name,
+          message: exception.message,
+          backtrace: exception.backtrace&.first(20)
+        }
+        record[:status_code] ||= 500
+        record[:duration_ms] = calculate_duration
+        record[:memory_delta] = calculate_memory_delta
+        record[:logs] = Thread.current[:binocs_logs] || []
+      end
+
+      def save_request_record(record)
+        return unless record[:status_code]
+
+        Binocs::Request.create!(
+          uuid: record[:uuid],
+          method: record[:method],
+          path: record[:path],
+          full_url: record[:full_url],
+          controller_name: record[:controller_name],
+          action_name: record[:action_name],
+          route_name: record[:route_name],
+          params: record[:params],
+          request_headers: record[:request_headers],
+          response_headers: record[:response_headers],
+          request_body: record[:request_body],
+          response_body: record[:response_body],
+          status_code: record[:status_code],
+          duration_ms: record[:duration_ms],
+          ip_address: record[:ip_address],
+          session_id: record[:session_id],
+          logs: record[:logs],
+          exception: record[:exception],
+          memory_delta: record[:memory_delta]
+        )
+
+        broadcast_new_request(record)
+        cleanup_old_requests
+      rescue => e
+        Rails.logger.error "[Binocs] Failed to save request: #{e.message}"
+      end
+
+      def broadcast_new_request(record)
+        unless defined?(Turbo::StreamsChannel)
+          Rails.logger.debug "[Binocs] Turbo::StreamsChannel not defined, skipping broadcast"
+          return
+        end
+
+        request = Binocs::Request.find_by(uuid: record[:uuid])
+        unless request
+          Rails.logger.debug "[Binocs] Request not found for broadcast: #{record[:uuid]}"
+          return
+        end
+
+        Rails.logger.debug "[Binocs] Broadcasting new request: #{request.method} #{request.path}"
+
+        Turbo::StreamsChannel.broadcast_prepend_to(
+          "binocs_requests",
+          target: "requests-list",
+          partial: "binocs/requests/request",
+          locals: { request: request }
+        )
+
+        Rails.logger.debug "[Binocs] Broadcast complete"
+      rescue => e
+        Rails.logger.error "[Binocs] Failed to broadcast request: #{e.message}"
+        Rails.logger.error e.backtrace.first(5).join("\n")
+      end
+
+      def cleanup_old_requests
+        return unless rand < 0.01 # Only run 1% of the time
+
+        max_requests = Binocs.configuration.max_requests
+        retention_period = Binocs.configuration.retention_period
+
+        Binocs::Request.where("created_at < ?", retention_period.ago).delete_all
+
+        count = Binocs::Request.count
+        if count > max_requests
+          Binocs::Request.order(created_at: :asc).limit(count - max_requests).delete_all
+        end
+      rescue => e
+        Rails.logger.error "[Binocs] Failed to cleanup old requests: #{e.message}"
+      end
+
+      def sanitize_params(request)
+        params = request.filtered_parameters.except("controller", "action")
+        params.deep_transform_values { |v| truncate_value(v) }
+      rescue
+        {}
+      end
+
+      def extract_headers(headers)
+        result = {}
+        headers.each do |key, value|
+          next unless key.start_with?("HTTP_") || %w[CONTENT_TYPE CONTENT_LENGTH].include?(key)
+
+          header_name = key.sub(/^HTTP_/, "").split("_").map(&:capitalize).join("-")
+          result[header_name] = value.to_s
+        end
+        result.except("Cookie") # Don't store cookies for security
+      end
+
+      def extract_request_body(request)
+        return nil unless Binocs.configuration.record_request_body
+        return nil if ignored_content_type?(request.content_type)
+
+        body = request.body.read
+        request.body.rewind
+        truncate_body(body)
+      rescue
+        nil
+      end
+
+      def extract_response_body(response, headers)
+        return nil unless Binocs.configuration.record_response_body
+
+        content_type = headers["Content-Type"]
+        return nil if ignored_content_type?(content_type)
+
+        body = ""
+        response.each { |part| body << part.to_s }
+        truncate_body(body)
+      rescue
+        nil
+      end
+
+      def ignored_content_type?(content_type)
+        return true if content_type.nil?
+
+        Binocs.configuration.ignored_content_types.any? do |ignored|
+          content_type.to_s.include?(ignored)
+        end
+      end
+
+      def extract_route_name(env)
+        route = Rails.application.routes.recognize_path(
+          env["PATH_INFO"],
+          method: env["REQUEST_METHOD"]
+        )
+        "#{route[:controller]}##{route[:action]}"
+      rescue
+        nil
+      end
+
+      def truncate_value(value)
+        return value unless value.is_a?(String)
+        return value if value.length <= 1000
+
+        "#{value[0, 1000]}... (truncated)"
+      end
+
+      def truncate_body(body)
+        return nil if body.nil? || body.empty?
+
+        max_size = Binocs.configuration.max_body_size
+        if body.bytesize > max_size
+          "#{body.byteslice(0, max_size)}... (truncated, #{body.bytesize} bytes total)"
+        else
+          body
+        end
+      end
+
+      def calculate_duration
+        start_time = Thread.current[:binocs_start_time]
+        return nil unless start_time
+
+        ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+      end
+
+      def get_memory_usage
+        `ps -o rss= -p #{Process.pid}`.to_i * 1024 rescue 0
+      end
+
+      def calculate_memory_delta
+        before = Thread.current[:binocs_memory_before]
+        return nil unless before
+
+        get_memory_usage - before
+      end
+
+      def cleanup_thread_locals
+        Thread.current[:binocs_request_id] = nil
+        Thread.current[:binocs_logs] = nil
+        Thread.current[:binocs_start_time] = nil
+        Thread.current[:binocs_memory_before] = nil
+      end
+    end
+  end
+end

data/lib/binocs/swagger/client.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'yaml'
+
+module Binocs
+  module Swagger
+    class Client
+      CACHE_TTL = 300 # 5 minutes
+
+      class << self
+        def fetch_spec
+          return nil unless Binocs.configuration.swagger_enabled?
+
+          if cached_spec_valid?
+            @cached_spec
+          else
+            refresh_spec
+          end
+        end
+
+        def clear_cache
+          @cached_spec = nil
+          @cache_time = nil
+        end
+
+        private
+
+        def cached_spec_valid?
+          @cached_spec && @cache_time && (Time.now - @cache_time) < CACHE_TTL
+        end
+
+        def refresh_spec
+          spec_url = build_spec_url
+          return nil unless spec_url
+
+          begin
+            response = fetch_with_redirects(spec_url)
+            return nil unless response
+
+            @cached_spec = parse_spec(response.body, response['content-type'])
+            @cache_time = Time.now
+            @cached_spec
+          rescue StandardError => e
+            Rails.logger.error("[Binocs] Failed to fetch Swagger spec: #{e.message}") if defined?(Rails)
+            nil
+          end
+        end
+
+        def fetch_with_redirects(url, limit = 5)
+          return nil if limit == 0
+
+          uri = URI(url)
+          response = Net::HTTP.get_response(uri)
+
+          case response
+          when Net::HTTPSuccess
+            response
+          when Net::HTTPRedirection
+            redirect_url = response['location']
+            # Handle relative redirects
+            redirect_url = URI.join(url, redirect_url).to_s unless redirect_url.start_with?('http')
+            fetch_with_redirects(redirect_url, limit - 1)
+          else
+            nil
+          end
+        end
+
+        def build_spec_url
+          spec_path = Binocs.configuration.swagger_spec_url
+          return nil if spec_path.blank?
+
+          # If it's already a full URL, use it directly
+          return spec_path if spec_path.start_with?('http://', 'https://')
+
+          # Otherwise, build from Rails default_url_options or localhost
+          if defined?(Rails)
+            host = Rails.application.routes.default_url_options[:host] || 'localhost'
+            port = Rails.application.routes.default_url_options[:port] || 3000
+            protocol = Rails.application.routes.default_url_options[:protocol] || 'http'
+            "#{protocol}://#{host}:#{port}#{spec_path}"
+          else
+            "http://localhost:3000#{spec_path}"
+          end
+        end
+
+        def parse_spec(body, content_type)
+          if content_type&.include?('yaml') || body.strip.start_with?('openapi:', 'swagger:')
+            YAML.safe_load(body, permitted_classes: [Date, Time])
+          else
+            JSON.parse(body)
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/binocs/swagger/path_matcher.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Binocs
+  module Swagger
+    class PathMatcher
+      class << self
+        def find_operation(request)
+          spec = Client.fetch_spec
+          return nil unless spec && spec['paths']
+
+          method = request.method.downcase
+          path = normalize_path(request.path)
+
+          spec['paths'].each do |spec_path, path_item|
+            next unless path_item.is_a?(Hash)
+
+            operation = path_item[method]
+            next unless operation
+
+            if path_matches?(path, spec_path)
+              return build_operation_result(spec_path, method, operation, path_item, spec)
+            end
+          end
+
+          nil
+        end
+
+        def build_swagger_ui_url(operation)
+          return nil unless operation
+
+          base_url = Binocs.configuration.swagger_ui_url
+          return nil if base_url.blank?
+
+          # Build full URL if needed
+          unless base_url.start_with?('http://', 'https://')
+            if defined?(Rails)
+              host = Rails.application.routes.default_url_options[:host] || 'localhost'
+              port = Rails.application.routes.default_url_options[:port] || 3000
+              protocol = Rails.application.routes.default_url_options[:protocol] || 'http'
+              base_url = "#{protocol}://#{host}:#{port}#{base_url}"
+            else
+              base_url = "http://localhost:3000#{base_url}"
+            end
+          end
+
+          # Build anchor for Swagger UI
+          # Format: #/{tag}/{operationId}
+          # Example: #/Company%20Invitations/get_v1_companies__company_uuid__invitations
+          tag = operation[:tags]&.first || 'default'
+          encoded_tag = URI.encode_www_form_component(tag).gsub('+', '%20')
+
+          if operation[:operation_id]
+            "#{base_url}#/#{encoded_tag}/#{operation[:operation_id]}"
+          else
+            # Fallback: build operation ID from method and path
+            # get /v1/companies/{company_uuid}/invitations -> get_v1_companies__company_uuid__invitations
+            fallback_op_id = "#{operation[:method]}#{operation[:spec_path]}"
+              .gsub('/', '_')
+              .gsub(/[{}]/, '_')
+              .gsub(/__+/, '__')
+            "#{base_url}#/#{encoded_tag}/#{fallback_op_id}"
+          end
+        end
+
+        private
+
+        def normalize_path(path)
+          # Remove query string and normalize
+          path = path.split('?').first
+          path = path.chomp('/')
+          path = '/' if path.empty?
+          path
+        end
+
+        def path_matches?(request_path, spec_path)
+          # Convert spec path template to regex
+          # /users/{id}/posts/{post_id} -> /users/[^/]+/posts/[^/]+
+          pattern = spec_path.gsub(/\{[^}]+\}/, '[^/]+')
+          pattern = "^#{pattern}$"
+
+          Regexp.new(pattern).match?(request_path)
+        end
+
+        def build_operation_result(spec_path, method, operation, path_item, spec)
+          {
+            spec_path: spec_path,
+            method: method,
+            operation_id: operation['operationId'],
+            summary: operation['summary'],
+            description: operation['description'],
+            tags: operation['tags'] || [],
+            parameters: collect_parameters(operation, path_item),
+            request_body: operation['requestBody'],
+            responses: operation['responses'] || {},
+            deprecated: operation['deprecated'] || false,
+            security: operation['security'] || spec['security']
+          }
+        end
+
+        def collect_parameters(operation, path_item)
+          params = []
+
+          # Path-level parameters
+          if path_item['parameters'].is_a?(Array)
+            params.concat(path_item['parameters'])
+          end
+
+          # Operation-level parameters
+          if operation['parameters'].is_a?(Array)
+            params.concat(operation['parameters'])
+          end
+
+          params.uniq { |p| "#{p['in']}-#{p['name']}" }
+        end
+      end
+    end
+  end
+end