railscope 0.1.0

data/lib/railscope/storage/redis_storage.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Storage
+    class RedisStorage < Base
+      # Key prefixes
+      PREFIX = "railscope"
+      ENTRY_KEY = "#{PREFIX}:entry:%s".freeze           # Hash with entry data
+      ALL_ENTRIES_KEY = "#{PREFIX}:entries".freeze      # Sorted set (score=timestamp)
+      DISPLAYABLE_KEY = "#{PREFIX}:displayable".freeze  # Sorted set of displayable entries
+      BATCH_KEY = "#{PREFIX}:batch:%s".freeze           # Sorted set per batch
+      FAMILY_KEY = "#{PREFIX}:family:%s".freeze         # Sorted set per family
+      TYPE_KEY = "#{PREFIX}:type:%s".freeze             # Sorted set per entry type
+      TAG_KEY = "#{PREFIX}:tag:%s".freeze               # Set per tag
+
+      def write(attributes)
+        entry = build_entry(attributes)
+        store_entry(entry)
+        entry
+      end
+
+      def update_by_batch(batch_id:, entry_type:, payload_updates:)
+        # Find entries in this batch with the given type
+        uuids = redis.zrevrange(batch_key(batch_id), 0, -1)
+        return nil if uuids.empty?
+
+        # Find the entry of the specified type
+        uuids.each do |uuid|
+          entry = find(uuid)
+          next unless entry && entry.entry_type == entry_type
+
+          # Merge payload updates
+          updated_payload = entry.payload.merge(payload_updates)
+          updated_entry = EntryData.new(
+            uuid: entry.uuid,
+            batch_id: entry.batch_id,
+            family_hash: entry.family_hash,
+            entry_type: entry.entry_type,
+            payload: updated_payload,
+            tags: entry.tags,
+            should_display_on_index: entry.displayable?,
+            occurred_at: entry.occurred_at,
+            created_at: entry.created_at,
+            updated_at: Time.current
+          )
+
+          # Re-store the entry (overwrites the existing one)
+          ttl = Railscope.retention_days.days.to_i
+          redis.set(entry_key(uuid), updated_entry.to_json, ex: ttl)
+
+          return updated_entry
+        end
+
+        nil
+      end
+
+      def find(uuid)
+        json = redis.get(entry_key(uuid))
+        return nil unless json
+
+        EntryData.from_json(json)
+      end
+
+      def all(filters: {}, page: 1, per_page: 25, displayable_only: true)
+        uuids = fetch_uuids(filters, displayable_only, page, per_page)
+        fetch_entries(uuids)
+      end
+
+      def count(filters: {}, displayable_only: true)
+        if filters.empty?
+          key = displayable_only ? DISPLAYABLE_KEY : ALL_ENTRIES_KEY
+          redis.zcard(key)
+        elsif filters[:type].present? && filters.keys == [:type]
+          # Simple type filter - use zcard directly
+          key = type_key(filters[:type])
+          if displayable_only
+            # Intersection count
+            count_intersection(key, DISPLAYABLE_KEY)
+          else
+            redis.zcard(key)
+          end
+        elsif filters[:batch_id].present? && filters.keys == [:batch_id]
+          redis.zcard(batch_key(filters[:batch_id]))
+        elsif filters[:family_hash].present? && filters.keys == [:family_hash]
+          redis.zcard(family_key(filters[:family_hash]))
+        else
+          # Complex filter - fetch all matching UUIDs and count
+          count_filtered(filters, displayable_only)
+        end
+      end
+
+      def for_batch(batch_id)
+        uuids = redis.zrevrange(batch_key(batch_id), 0, -1)
+        fetch_entries(uuids)
+      end
+
+      def for_family(family_hash, page: 1, per_page: 25)
+        start_idx = (page - 1) * per_page
+        end_idx = start_idx + per_page - 1
+        uuids = redis.zrevrange(family_key(family_hash), start_idx, end_idx)
+        fetch_entries(uuids)
+      end
+
+      def family_count(family_hash)
+        redis.zcard(family_key(family_hash))
+      end
+
+      def destroy_all!
+        keys = redis.keys("#{PREFIX}:*")
+        return 0 if keys.empty?
+
+        count = redis.zcard(ALL_ENTRIES_KEY)
+        redis.del(*keys)
+        count
+      end
+
+      def destroy_expired!
+        cutoff = Railscope.retention_days.days.ago.to_f
+
+        # Get expired entry UUIDs
+        expired_uuids = redis.zrangebyscore(ALL_ENTRIES_KEY, "-inf", cutoff)
+        return 0 if expired_uuids.empty?
+
+        # Delete each entry and its index references
+        expired_uuids.each { |uuid| delete_entry(uuid) }
+
+        expired_uuids.size
+      end
+
+      def ready?
+        Railscope.redis_available?
+      end
+
+      private
+
+      def redis
+        Railscope.redis
+      end
+
+      def build_entry(attributes)
+        now = Time.current
+        EntryData.new(
+          uuid: attributes[:uuid] || SecureRandom.uuid,
+          batch_id: attributes[:batch_id],
+          family_hash: attributes[:family_hash],
+          entry_type: attributes[:entry_type],
+          payload: attributes[:payload] || {},
+          tags: attributes[:tags] || [],
+          should_display_on_index: attributes.fetch(:should_display_on_index, true),
+          occurred_at: attributes[:occurred_at] || now,
+          created_at: attributes[:created_at] || now,
+          updated_at: attributes[:updated_at] || now
+        )
+      end
+
+      def store_entry(entry)
+        uuid = entry.uuid
+        score = entry.occurred_at.to_f
+        ttl = Railscope.retention_days.days.to_i
+
+        redis.multi do |multi|
+          # Store entry data
+          multi.set(entry_key(uuid), entry.to_json, ex: ttl)
+
+          # Add to main sorted set
+          multi.zadd(ALL_ENTRIES_KEY, score, uuid)
+
+          # Add to displayable set if applicable
+          multi.zadd(DISPLAYABLE_KEY, score, uuid) if entry.displayable?
+
+          # Add to batch set
+          multi.zadd(batch_key(entry.batch_id), score, uuid) if entry.batch_id
+
+          # Add to family set
+          multi.zadd(family_key(entry.family_hash), score, uuid) if entry.family_hash
+
+          # Add to type set
+          multi.zadd(type_key(entry.entry_type), score, uuid) if entry.entry_type
+
+          # Add to tag sets
+          entry.tags.each do |tag|
+            multi.sadd(tag_key(tag), uuid)
+          end
+
+          # Set TTL on index keys
+          multi.expire(batch_key(entry.batch_id), ttl) if entry.batch_id
+          multi.expire(family_key(entry.family_hash), ttl) if entry.family_hash
+        end
+      end
+
+      def delete_entry(uuid)
+        entry = find(uuid)
+        return unless entry
+
+        redis.multi do |multi|
+          # Remove from all indexes
+          multi.del(entry_key(uuid))
+          multi.zrem(ALL_ENTRIES_KEY, uuid)
+          multi.zrem(DISPLAYABLE_KEY, uuid)
+          multi.zrem(batch_key(entry.batch_id), uuid) if entry.batch_id
+          multi.zrem(family_key(entry.family_hash), uuid) if entry.family_hash
+          multi.zrem(type_key(entry.entry_type), uuid) if entry.entry_type
+          entry.tags.each { |tag| multi.srem(tag_key(tag), uuid) }
+        end
+      end
+
+      def fetch_uuids(filters, displayable_only, page, per_page)
+        # Determine which set to query
+        base_key = if filters[:type].present?
+                     type_key(filters[:type])
+                   elsif filters[:batch_id].present?
+                     batch_key(filters[:batch_id])
+                   elsif filters[:family_hash].present?
+                     family_key(filters[:family_hash])
+                   elsif displayable_only
+                     DISPLAYABLE_KEY
+                   else
+                     ALL_ENTRIES_KEY
+                   end
+
+        # Calculate pagination
+        start_idx = (page - 1) * per_page
+        end_idx = per_page == Float::INFINITY ? -1 : start_idx + per_page - 1
+
+        uuids = redis.zrevrange(base_key, start_idx, end_idx)
+
+        # Apply additional filters if needed
+        if filters[:tag].present?
+          tag_members = redis.smembers(tag_key(filters[:tag]))
+          uuids &= tag_members
+        end
+
+        # If displayable filter and we're using a type/batch/family key
+        if displayable_only && !%W[#{DISPLAYABLE_KEY} #{ALL_ENTRIES_KEY}].include?(base_key)
+          displayable_members = redis.zrange(DISPLAYABLE_KEY, 0, -1)
+          uuids &= displayable_members
+        end
+
+        uuids
+      end
+
+      def fetch_entries(uuids)
+        return [] if uuids.empty?
+
+        # Fetch all entries in a single pipeline
+        jsons = redis.pipelined do |pipeline|
+          uuids.each { |uuid| pipeline.get(entry_key(uuid)) }
+        end
+
+        # Parse and filter out nil results (expired entries)
+        jsons.compact.map { |json| EntryData.from_json(json) }
+      end
+
+      # Key generators
+      def entry_key(uuid)
+        format(ENTRY_KEY, uuid)
+      end
+
+      def batch_key(batch_id)
+        format(BATCH_KEY, batch_id)
+      end
+
+      def family_key(family_hash)
+        format(FAMILY_KEY, family_hash)
+      end
+
+      def type_key(entry_type)
+        format(TYPE_KEY, entry_type)
+      end
+
+      def tag_key(tag)
+        format(TAG_KEY, tag)
+      end
+
+      def count_intersection(key1, key2)
+        # Get members from both sets and count intersection
+        members1 = redis.zrange(key1, 0, -1)
+        members2 = redis.zrange(key2, 0, -1)
+        (members1 & members2).size
+      end
+
+      def count_filtered(filters, displayable_only)
+        # Get all UUIDs matching the primary filter
+        base_key = if filters[:type].present?
+                     type_key(filters[:type])
+                   elsif filters[:batch_id].present?
+                     batch_key(filters[:batch_id])
+                   elsif filters[:family_hash].present?
+                     family_key(filters[:family_hash])
+                   elsif displayable_only
+                     DISPLAYABLE_KEY
+                   else
+                     ALL_ENTRIES_KEY
+                   end
+
+        uuids = redis.zrange(base_key, 0, -1)
+
+        # Apply tag filter
+        if filters[:tag].present?
+          tag_members = redis.smembers(tag_key(filters[:tag]))
+          uuids &= tag_members
+        end
+
+        # Apply displayable filter
+        if displayable_only && base_key != DISPLAYABLE_KEY
+          displayable_members = redis.zrange(DISPLAYABLE_KEY, 0, -1)
+          uuids &= displayable_members
+        end
+
+        uuids.size
+      end
+    end
+  end
+end

data/lib/railscope/subscribers/base_subscriber.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Subscribers
+    class BaseSubscriber
+      private
+
+      def context
+        Railscope::Context.current
+      end
+
+      def recording?
+        context[:recording] != false
+      end
+
+      def context_payload
+        {
+          request_id: context.request_id,
+          user_id: context.user_id
+        }.compact
+      end
+
+      def context_tags
+        context.tags.dup
+      end
+
+      def create_entry!(entry_type:, payload:, tags:, family_hash: nil, should_display_on_index: true)
+        return unless recording?
+
+        filtered_payload = Railscope.filter(payload.merge(context_payload))
+
+        Railscope.storage.write(
+          entry_type: entry_type,
+          batch_id: context.batch_id,
+          family_hash: family_hash,
+          should_display_on_index: should_display_on_index,
+          payload: filtered_payload,
+          tags: (tags + context_tags).uniq,
+          occurred_at: Time.current
+        )
+      end
+
+      # Generate a family hash for grouping similar entries
+      # Override in subclasses for specific hashing logic
+      def generate_family_hash(*components)
+        return nil if components.compact.empty?
+
+        Digest::SHA256.hexdigest(components.compact.join("::"))[0, 16]
+      end
+    end
+  end
+end

data/lib/railscope/subscribers/command_subscriber.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Subscribers
+    class CommandSubscriber < BaseSubscriber
+      class << self
+        def subscribe
+          return unless defined?(Rake::Task)
+
+          instrument_rake_tasks
+        end
+
+        private
+
+        def instrument_rake_tasks
+          Rake::Task.tasks.each do |task|
+            instrument_task(task)
+          end
+
+          # Also instrument tasks defined after initial load
+          Rake::Task.singleton_class.prepend(TaskInstrumentation)
+        end
+
+        def instrument_task(task)
+          return if task.name.start_with?("railscope:")
+          return if instrumented_tasks.include?(task.name)
+
+          instrumented_tasks << task.name
+
+          original_execute = task.method(:execute)
+
+          task.define_singleton_method(:execute) do |args = nil|
+            CommandSubscriber.new.record(task, args) do
+              original_execute.call(args)
+            end
+          end
+        end
+
+        def instrumented_tasks
+          @instrumented_tasks ||= Set.new
+        end
+      end
+
+      # Module to intercept new task definitions
+      module TaskInstrumentation
+        def define_task(*args, &block)
+          task = super
+          CommandSubscriber.send(:instrument_task, task) if task.is_a?(Rake::Task)
+          task
+        end
+      end
+
+      def record(task, args)
+        return yield unless Railscope.enabled?
+        return yield unless Railscope.ready?
+
+        # Setup context for this command (similar to middleware for HTTP requests)
+        setup_command_context(task)
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        exit_code = 0
+        exception_info = nil
+        caught_exception = nil
+
+        begin
+          result = yield
+          result
+        rescue SystemExit => e
+          exit_code = e.status
+          raise
+        rescue Exception => e
+          exit_code = 1
+          caught_exception = e
+          exception_info = {
+            class: e.class.name,
+            message: e.message,
+            backtrace: e.backtrace&.first(20)
+          }
+          raise
+        ensure
+          duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+
+          # Create the command entry
+          create_entry!(
+            entry_type: "command",
+            payload: build_payload(task, args, duration, exit_code, exception_info),
+            tags: build_tags(task, exit_code),
+            family_hash: generate_family_hash("command", task.name),
+            should_display_on_index: true
+          )
+
+          # Also create a separate exception entry (appears in exceptions list)
+          create_exception_entry!(task, caught_exception) if caught_exception
+
+          # Clear context after command completes
+          Railscope::Context.clear!
+        end
+      end
+
+      private
+
+      def setup_command_context(task)
+        ctx = Railscope::Context.current
+        ctx.batch_id = SecureRandom.uuid
+        ctx[:recording] = true
+        ctx[:command] = task.name
+      end
+
+      def build_payload(task, args, duration, exit_code, exception_info)
+        {
+          command: task.name,
+          arguments: serialize_args(args),
+          options: extract_options,
+          description: task.comment,
+          hostname: Socket.gethostname,
+          duration: duration,
+          exit_code: exit_code,
+          exception: exception_info
+        }.compact
+      end
+
+      def build_tags(task, exit_code)
+        tags = ["command"]
+        tags << "failed" if exit_code != 0
+        tags << task.name.split(":").first if task.name.include?(":")
+        tags
+      end
+
+      def create_exception_entry!(task, exception)
+        file, line = extract_file_and_line(exception)
+        line_preview = extract_line_preview(file, line)
+
+        create_entry!(
+          entry_type: "exception",
+          payload: {
+            class: exception.class.name,
+            message: exception.message,
+            file: file,
+            line: line,
+            line_preview: line_preview,
+            backtrace: exception.backtrace&.first(20),
+            source: "command",
+            command: task.name
+          },
+          tags: build_exception_tags(exception),
+          family_hash: generate_family_hash("exception", exception.class.name, "command", task.name),
+          should_display_on_index: true
+        )
+      end
+
+      def extract_file_and_line(exception)
+        return [nil, nil] unless exception&.backtrace&.any?
+
+        first_line = exception.backtrace.first
+        if first_line =~ /\A(.+):(\d+)/
+          [Regexp.last_match(1), Regexp.last_match(2).to_i]
+        else
+          [nil, nil]
+        end
+      end
+
+      # Extract code context around the exception line (like Telescope)
+      def extract_line_preview(file, line)
+        return nil unless file && line && File.exist?(file)
+
+        lines = File.readlines(file)
+        start_line = [line - 10, 1].max
+        end_line = [line + 9, lines.length].min
+
+        result = {}
+        (start_line..end_line).each do |line_num|
+          result[line_num] = lines[line_num - 1]&.chomp || ""
+        end
+        result
+      rescue StandardError
+        nil
+      end
+
+      def build_exception_tags(exception)
+        tags = %w[exception command]
+        tags << exception.class.name.underscore.tr("/", "_") if exception.class.name
+        tags
+      end
+
+      def serialize_args(args)
+        return {} if args.nil?
+
+        case args
+        when Rake::TaskArguments
+          args.to_hash.transform_keys(&:to_s)
+        when Hash
+          args.transform_keys(&:to_s)
+        else
+          { "value" => args.to_s }
+        end
+      rescue StandardError
+        {}
+      end
+
+      def extract_options
+        # Only capture options that are actually passed (unlike Telescope which shows all defaults)
+        options = {}
+
+        ARGV.each do |arg|
+          case arg
+          when "--trace", "-t"
+            options["trace"] = true
+          when "--dry-run", "-n"
+            options["dry-run"] = true
+          when "--verbose", "-v"
+            options["verbose"] = true
+          when "--silent", "-s"
+            options["silent"] = true
+          when "--quiet", "-q"
+            options["quiet"] = true
+          when "--help", "-h", "-H"
+            options["help"] = true
+          when "--version", "-V"
+            options["version"] = true
+          when "--prereqs", "-P"
+            options["prereqs"] = true
+          when /^--(\w[\w-]*)=(.*)$/
+            options[Regexp.last_match(1)] = Regexp.last_match(2)
+          when /^--(\w[\w-]*)$/
+            options[Regexp.last_match(1)] = true
+          when /^-(\w)$/
+            options[Regexp.last_match(1)] = true
+          end
+        end
+
+        options
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end

data/lib/railscope/subscribers/exception_subscriber.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Subscribers
+    class ExceptionSubscriber < BaseSubscriber
+      EVENT_NAME = "process_action.action_controller"
+
+      def self.subscribe
+        return if @subscribed
+
+        @subscribed = true
+
+        ActiveSupport::Notifications.subscribe(EVENT_NAME) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          new.record(event)
+        end
+      end
+
+      def record(event)
+        return unless Railscope.enabled?
+        return unless Railscope.ready?
+        return if event.payload[:exception].blank?
+
+        create_entry!(
+          entry_type: "exception",
+          payload: build_payload(event),
+          tags: build_tags(event),
+          family_hash: build_family_hash(event),
+          should_display_on_index: true
+        )
+      rescue StandardError => e
+        Rails.logger.error("[Railscope] Failed to record exception: #{e.message}")
+      end
+
+      private
+
+      def build_payload(event)
+        exception_class, exception_message = event.payload[:exception]
+        exception_object = event.payload[:exception_object]
+        file, line = extract_file_and_line(exception_object)
+        line_preview = extract_line_preview(file, line)
+
+        {
+          class: exception_class,
+          message: exception_message,
+          file: file,
+          line: line,
+          line_preview: line_preview,
+          backtrace: exception_object&.backtrace&.first(20),
+          path: event.payload[:path],
+          method: event.payload[:method],
+          controller: event.payload[:controller],
+          action: event.payload[:action],
+          params: filtered_params(event.payload[:params]),
+          status: event.payload[:status]
+        }
+      end
+
+      def extract_file_and_line(exception)
+        return [nil, nil] unless exception&.backtrace&.any?
+
+        first_line = exception.backtrace.first
+        if first_line =~ /\A(.+):(\d+)/
+          [Regexp.last_match(1), Regexp.last_match(2).to_i]
+        else
+          [nil, nil]
+        end
+      end
+
+      # Extract code context around the exception line (like Telescope)
+      def extract_line_preview(file, line)
+        return nil unless file && line && File.exist?(file)
+
+        lines = File.readlines(file)
+        start_line = [line - 10, 1].max
+        end_line = [line + 9, lines.length].min
+
+        result = {}
+        (start_line..end_line).each do |line_num|
+          result[line_num] = lines[line_num - 1]&.chomp || ""
+        end
+        result
+      rescue StandardError
+        nil
+      end
+
+      def build_tags(event)
+        exception_class = event.payload[:exception]&.first
+        tags = ["exception"]
+        tags << exception_class.underscore.tr("/", "_") if exception_class
+        tags
+      end
+
+      # Group exceptions by class and location (controller#action)
+      def build_family_hash(event)
+        exception_class = event.payload[:exception]&.first
+        controller = event.payload[:controller]
+        action = event.payload[:action]
+        generate_family_hash("exception", exception_class, controller, action)
+      end
+
+      def filtered_params(params)
+        return {} if params.nil?
+
+        params.except(:controller, :action, :format).to_h.deep_transform_values do |value|
+          value.is_a?(String) && value.length > 200 ? "#{value[0..200]}..." : value
+        end
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end