railscope 0.1.0

data/lib/railscope/engine.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "subscribers/base_subscriber"
+require_relative "subscribers/request_subscriber"
+require_relative "subscribers/query_subscriber"
+require_relative "subscribers/exception_subscriber"
+require_relative "subscribers/job_subscriber"
+require_relative "subscribers/command_subscriber"
+require_relative "subscribers/view_subscriber"
+
+module Railscope
+  class Engine < ::Rails::Engine
+    isolate_namespace Railscope
+
+    initializer "railscope.static_assets" do |app|
+      # Serve static assets from public/railscope
+      app.middleware.insert_before(
+        ActionDispatch::Static,
+        Rack::Static,
+        urls: ["/railscope/assets"],
+        root: Railscope::Engine.root.join("public").to_s
+      )
+    end
+
+    initializer "railscope.middleware" do |app|
+      app.middleware.insert_before(0, Railscope::Middleware)
+    end
+
+    initializer "railscope.migrations" do |app|
+      unless app.root.to_s.match?(root.to_s)
+        config.paths["db/migrate"].expanded.each do |expanded_path|
+          app.config.paths["db/migrate"] << expanded_path
+        end
+      end
+    end
+
+    initializer "railscope.subscribers", after: :load_config_initializers do
+      # ActionController subscribers
+      if defined?(ActionController::Base)
+        Railscope::Subscribers::RequestSubscriber.subscribe
+        Railscope::Subscribers::ExceptionSubscriber.subscribe
+      else
+        ActiveSupport.on_load(:action_controller) do
+          Railscope::Subscribers::RequestSubscriber.subscribe
+          Railscope::Subscribers::ExceptionSubscriber.subscribe
+        end
+      end
+
+      # ActionView subscribers
+      if defined?(ActionView::Base)
+        Railscope::Subscribers::ViewSubscriber.subscribe
+      else
+        ActiveSupport.on_load(:action_view) do
+          Railscope::Subscribers::ViewSubscriber.subscribe
+        end
+      end
+
+      # ActiveRecord subscribers
+      if defined?(ActiveRecord::Base)
+        Railscope::Subscribers::QuerySubscriber.subscribe
+      else
+        ActiveSupport.on_load(:active_record) do
+          Railscope::Subscribers::QuerySubscriber.subscribe
+        end
+      end
+
+      # ActiveJob subscribers
+      if defined?(ActiveJob::Base)
+        Railscope::Subscribers::JobSubscriber.subscribe
+      else
+        ActiveSupport.on_load(:active_job) do
+          Railscope::Subscribers::JobSubscriber.subscribe
+        end
+      end
+    end
+
+    rake_tasks do
+      # Load sample tasks for testing
+      load Railscope::Engine.root.join("lib/tasks/railscope_sample.rake")
+
+      # Subscribe to rake tasks after they're loaded
+      Railscope::Subscribers::CommandSubscriber.subscribe
+    end
+  end
+end

data/lib/railscope/entry_data.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Railscope
+  # Plain Ruby object representing an entry, used by both storage adapters
+  # This provides a consistent interface regardless of storage backend
+  class EntryData
+    ATTRIBUTES = %i[
+      uuid
+      batch_id
+      family_hash
+      entry_type
+      payload
+      tags
+      should_display_on_index
+      occurred_at
+      created_at
+      updated_at
+    ].freeze
+
+    attr_accessor(*ATTRIBUTES)
+
+    # Alias id to uuid for compatibility with existing code
+    alias id uuid
+
+    def initialize(attributes = {})
+      attributes = attributes.symbolize_keys if attributes.respond_to?(:symbolize_keys)
+
+      ATTRIBUTES.each do |attr|
+        value = attributes[attr]
+        # Handle time parsing for string values
+        if %i[occurred_at created_at updated_at].include?(attr) && value.is_a?(String)
+          value = begin
+            Time.zone.parse(value)
+          rescue StandardError
+            value
+          end
+        end
+        send("#{attr}=", value)
+      end
+
+      # Set defaults
+      self.tags ||= []
+      self.payload ||= {}
+      self.should_display_on_index = true if should_display_on_index.nil?
+    end
+
+    def to_h
+      ATTRIBUTES.index_with do |attr|
+        send(attr)
+      end
+    end
+
+    def to_json(*args)
+      serializable_hash.to_json(*args)
+    end
+
+    def serializable_hash
+      to_h.transform_values do |value|
+        case value
+        when Time, DateTime, ActiveSupport::TimeWithZone
+          value.iso8601(6)
+        else
+          value
+        end
+      end
+    end
+
+    def displayable?
+      should_display_on_index
+    end
+
+    # For compatibility with ActiveRecord-style access
+    def [](key)
+      send(key) if respond_to?(key)
+    end
+
+    def []=(key, value)
+      send("#{key}=", value) if respond_to?("#{key}=")
+    end
+
+    # Comparison for sorting
+    def <=>(other)
+      return nil unless other.is_a?(EntryData)
+
+      other.occurred_at <=> occurred_at # desc by default
+    end
+
+    class << self
+      # Create from ActiveRecord Entry model
+      def from_active_record(record)
+        new(
+          uuid: record.uuid,
+          batch_id: record.batch_id,
+          family_hash: record.family_hash,
+          entry_type: record.entry_type,
+          payload: record.payload,
+          tags: record.tags,
+          should_display_on_index: record.should_display_on_index,
+          occurred_at: record.occurred_at,
+          created_at: record.created_at,
+          updated_at: record.updated_at
+        )
+      end
+
+      # Create from JSON hash (Redis)
+      def from_json(json_string)
+        data = JSON.parse(json_string, symbolize_names: true)
+        new(data)
+      end
+    end
+  end
+end

data/lib/railscope/filter.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Railscope
+  class Filter
+    MASK = "[FILTERED]"
+
+    DEFAULT_SENSITIVE_KEYS = %w[
+      password
+      password_confirmation
+      secret
+      token
+      api_key
+      apikey
+      access_token
+      refresh_token
+      authorization
+      auth
+      credential
+      private_key
+      secret_key
+      credit_card
+      card_number
+      cvv
+      ssn
+    ].freeze
+
+    class << self
+      def filter(payload)
+        return payload unless payload.is_a?(Hash)
+
+        filter_hash(payload.deep_dup)
+      end
+
+      def sensitive_keys
+        @sensitive_keys ||= build_sensitive_keys
+      end
+
+      def add_sensitive_keys(*keys)
+        @sensitive_keys = nil
+        @custom_keys ||= []
+        @custom_keys.concat(keys.map(&:to_s).map(&:downcase))
+      end
+
+      def reset_sensitive_keys!
+        @sensitive_keys = nil
+        @custom_keys = []
+      end
+
+      private
+
+      def build_sensitive_keys
+        keys = DEFAULT_SENSITIVE_KEYS.dup
+        keys.concat(rails_filter_parameters)
+        keys.concat(@custom_keys || [])
+        keys.uniq
+      end
+
+      def rails_filter_parameters
+        return [] unless defined?(Rails) && Rails.application
+
+        Rails.application.config.filter_parameters.map do |param|
+          param.is_a?(Regexp) ? nil : param.to_s.downcase
+        end.compact
+      end
+
+      def filter_hash(hash)
+        hash.each do |key, value|
+          if sensitive_key?(key)
+            hash[key] = MASK
+          elsif value.is_a?(Hash)
+            hash[key] = filter_hash(value)
+          elsif value.is_a?(Array)
+            hash[key] = filter_array(value)
+          elsif value.is_a?(String) && looks_like_secret?(value)
+            hash[key] = MASK
+          end
+        end
+        hash
+      end
+
+      def filter_array(array)
+        array.map do |item|
+          case item
+          when Hash
+            filter_hash(item)
+          when Array
+            filter_array(item)
+          else
+            item
+          end
+        end
+      end
+
+      def sensitive_key?(key)
+        key_str = key.to_s.downcase
+        sensitive_keys.any? { |sensitive| key_str.include?(sensitive) }
+      end
+
+      def looks_like_secret?(value)
+        return false if value.length < 20
+
+        # Bearer tokens
+        return true if value.start_with?("Bearer ")
+        # Base64 encoded secrets (common pattern)
+        return true if value.match?(%r{\A[A-Za-z0-9+/=]{40,}\z})
+        # JWT tokens
+        return true if value.match?(/\Aey[A-Za-z0-9_-]+\.ey[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\z/)
+
+        false
+      end
+    end
+  end
+end

data/lib/railscope/middleware.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Railscope
+  class Middleware
+    # Maximum size for response body capture (64KB like Telescope)
+    RESPONSE_SIZE_LIMIT = 64 * 1024
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      return @app.call(env) unless Railscope.enabled?
+
+      setup_context(env)
+      status, headers, response = @app.call(env)
+
+      # Capture response body for recording
+      context = Context.current
+      if context[:recording]
+        # Read body from env (where Rails stores the response)
+        body_content = extract_body_from_env(env)
+
+        context_data = {
+          batch_id: context.batch_id,
+          env: env,
+          headers: headers
+        }
+
+        # Update entry with response data
+        update_entry_async(context_data, body_content)
+      end
+
+      [status, headers, response]
+    ensure
+      Context.clear!
+    end
+
+    def extract_body_from_env(env)
+      body = ""
+
+      # Try to get from ActionDispatch::Response stored in env
+      if env["action_dispatch.response"]
+        response = env["action_dispatch.response"]
+        body = response.body.to_s if response.respond_to?(:body)
+      end
+
+      # Try action_controller.instance
+      if body.empty? && env["action_controller.instance"]
+        controller = env["action_controller.instance"]
+        if controller.respond_to?(:response) && controller.response.respond_to?(:body)
+          body = controller.response.body.to_s
+        end
+      end
+
+      # Truncate if too large
+      body = body.byteslice(0, RESPONSE_SIZE_LIMIT) if body.bytesize > RESPONSE_SIZE_LIMIT
+
+      body
+    rescue StandardError => e
+      Rails.logger.debug("[Railscope] Failed to extract body: #{e.message}")
+      ""
+    end
+
+    def update_entry_async(context_data, body_content)
+      # Update synchronously for now (could be made async later)
+      self.class.update_entry_with_response(context_data, body_content)
+    rescue StandardError => e
+      Rails.logger.debug("[Railscope] Failed to update entry: #{e.message}")
+    end
+
+    def self.update_entry_with_response(context_data, response_body)
+      return unless Railscope.ready?
+
+      headers = context_data[:headers]
+      response_headers = begin
+        headers.respond_to?(:to_h) ? headers.to_h : headers.to_hash
+      rescue StandardError
+        {}
+      end
+      session_data = extract_session_from_env(context_data[:env])
+
+      # Parse JSON if applicable
+      content_type = response_headers["Content-Type"] || response_headers["content-type"] || ""
+      looks_like_json = response_body.to_s.start_with?("{", "[")
+      is_json = content_type.include?("application/json") || looks_like_json
+
+      parsed_body = if is_json
+                      begin
+                        JSON.parse(response_body)
+                      rescue StandardError
+                        response_body
+                      end
+                    else
+                      response_body
+                    end
+
+      payload_updates = {
+        "response" => parsed_body.presence,
+        "response_headers" => response_headers,
+        "session" => session_data
+      }
+
+      storage = Railscope.storage
+
+      if storage.is_a?(Railscope::Storage::Database)
+        entry = Entry.where(batch_id: context_data[:batch_id], entry_type: "request").order(created_at: :desc).first
+        return unless entry
+
+        entry.payload = entry.payload.merge(payload_updates)
+        entry.save!
+
+      elsif storage.respond_to?(:update_by_batch)
+        storage.update_by_batch(
+          batch_id: context_data[:batch_id],
+          entry_type: "request",
+          payload_updates: payload_updates
+        )
+      end
+    rescue StandardError => e
+      Rails.logger.debug("[Railscope] Failed to update entry with response: #{e.message}")
+    end
+
+    def self.extract_session_from_env(env)
+      return {} unless env
+
+      session = env["rack.session"] || env["action_dispatch.request.session"]
+      return {} unless session
+
+      session.to_h.transform_keys(&:to_s).except("_csrf_token", "session_id")
+    rescue StandardError
+      {}
+    end
+
+    private
+
+    def setup_context(env)
+      path = env["PATH_INFO"]
+      context = Context.current
+
+      # Generate a new batch_id for this request
+      context.batch_id = SecureRandom.uuid
+
+      # Use Rails request_id if available, otherwise use batch_id
+      context.request_id = env["action_dispatch.request_id"] || context.batch_id
+
+      context[:path] = path
+      context[:method] = env["REQUEST_METHOD"]
+      context[:ip_address] = extract_ip(env)
+      context[:recording] = Railscope.should_record?(path: path)
+
+      # Store env reference to capture session later
+      context[:env] = env
+    end
+
+    def extract_ip(env)
+      env["HTTP_X_FORWARDED_FOR"]&.split(",")&.first&.strip ||
+        env["HTTP_X_REAL_IP"] ||
+        env["REMOTE_ADDR"]
+    end
+  end
+end

data/lib/railscope/storage/base.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Storage
+    class Base
+      # Write a new entry
+      # @param attributes [Hash] entry attributes
+      # @return [EntryData] the created entry
+      def write(attributes)
+        raise NotImplementedError, "#{self.class}#write must be implemented"
+      end
+
+      # Find an entry by UUID
+      # @param uuid [String] the entry UUID
+      # @return [EntryData, nil] the entry or nil if not found
+      def find(uuid)
+        raise NotImplementedError, "#{self.class}#find must be implemented"
+      end
+
+      # Find an entry by UUID, raising if not found
+      # @param uuid [String] the entry UUID
+      # @return [EntryData] the entry
+      # @raise [RecordNotFound] if entry not found
+      def find!(uuid)
+        find(uuid) || raise(RecordNotFound, "Entry not found: #{uuid}")
+      end
+
+      # List entries with optional filters
+      # @param filters [Hash] optional filters (:type, :tag, :batch_id, :family_hash)
+      # @param page [Integer] page number (1-indexed)
+      # @param per_page [Integer] entries per page
+      # @param displayable_only [Boolean] only return displayable entries
+      # @return [Array<EntryData>] list of entries
+      def all(filters: {}, page: 1, per_page: 25, displayable_only: true)
+        raise NotImplementedError, "#{self.class}#all must be implemented"
+      end
+
+      # Count entries with optional filters
+      # @param filters [Hash] optional filters
+      # @param displayable_only [Boolean] only count displayable entries
+      # @return [Integer] count of entries
+      def count(filters: {}, displayable_only: true)
+        raise NotImplementedError, "#{self.class}#count must be implemented"
+      end
+
+      # Get all entries in a batch
+      # @param batch_id [String] the batch UUID
+      # @return [Array<EntryData>] list of entries in the batch
+      def for_batch(batch_id)
+        raise NotImplementedError, "#{self.class}#for_batch must be implemented"
+      end
+
+      # Get all entries with the same family hash
+      # @param family_hash [String] the family hash
+      # @param page [Integer] page number
+      # @param per_page [Integer] entries per page
+      # @return [Array<EntryData>] list of entries with same family
+      def for_family(family_hash, page: 1, per_page: 25)
+        raise NotImplementedError, "#{self.class}#for_family must be implemented"
+      end
+
+      # Count entries with the same family hash
+      # @param family_hash [String] the family hash
+      # @return [Integer] count of entries
+      def family_count(family_hash)
+        raise NotImplementedError, "#{self.class}#family_count must be implemented"
+      end
+
+      # Delete all entries
+      # @return [Integer] number of deleted entries
+      def destroy_all!
+        raise NotImplementedError, "#{self.class}#destroy_all! must be implemented"
+      end
+
+      # Delete expired entries (older than retention_days)
+      # @return [Integer] number of deleted entries
+      def destroy_expired!
+        raise NotImplementedError, "#{self.class}#destroy_expired! must be implemented"
+      end
+
+      # Check if storage is available and ready
+      # @return [Boolean] true if ready
+      def ready?
+        raise NotImplementedError, "#{self.class}#ready? must be implemented"
+      end
+    end
+
+    class RecordNotFound < StandardError; end
+  end
+end

data/lib/railscope/storage/database.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Storage
+    class Database < Base
+      def write(attributes)
+        # Remove uuid if present - let the database generate it
+        attrs = attributes.except(:uuid, :created_at, :updated_at)
+        record = Entry.create!(attrs)
+        EntryData.from_active_record(record)
+      end
+
+      def find(uuid)
+        record = Entry.find_by(uuid: uuid)
+        return nil unless record
+
+        EntryData.from_active_record(record)
+      end
+
+      def all(filters: {}, page: 1, per_page: 25, displayable_only: true)
+        scope = build_scope(filters, displayable_only)
+        records = scope.recent.limit(per_page).offset((page - 1) * per_page)
+        records.map { |r| EntryData.from_active_record(r) }
+      end
+
+      def count(filters: {}, displayable_only: true)
+        build_scope(filters, displayable_only).count
+      end
+
+      def for_batch(batch_id)
+        records = Entry.for_batch(batch_id).order(:occurred_at)
+        records.map { |r| EntryData.from_active_record(r) }
+      end
+
+      def for_family(family_hash, page: 1, per_page: 25)
+        records = Entry.for_family(family_hash).recent.limit(per_page).offset((page - 1) * per_page)
+        records.map { |r| EntryData.from_active_record(r) }
+      end
+
+      def family_count(family_hash)
+        Entry.for_family(family_hash).count
+      end
+
+      def destroy_all!
+        Entry.delete_all
+      end
+
+      def destroy_expired!
+        total_deleted = 0
+        batch_size = 1000
+
+        loop do
+          expired_ids = Entry.expired.limit(batch_size).pluck(:uuid)
+          break if expired_ids.empty?
+
+          deleted = Entry.where(uuid: expired_ids).delete_all
+          total_deleted += deleted
+          break if deleted < batch_size
+        end
+
+        total_deleted
+      end
+
+      def ready?
+        Entry.table_exists?
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def build_scope(filters, displayable_only)
+        scope = Entry.all
+        scope = scope.displayable if displayable_only
+        scope = scope.by_type(filters[:type]) if filters[:type].present?
+        scope = scope.with_tag(filters[:tag]) if filters[:tag].present?
+        scope = scope.for_batch(filters[:batch_id]) if filters[:batch_id].present?
+        scope = scope.for_family(filters[:family_hash]) if filters[:family_hash].present?
+        scope
+      end
+    end
+  end
+end