railscope 0.1.0

data/lib/railscope/subscribers/job_subscriber.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Subscribers
+    class JobSubscriber < BaseSubscriber
+      ENQUEUE_EVENT = "enqueue.active_job"
+      PERFORM_START_EVENT = "perform_start.active_job"
+      PERFORM_EVENT = "perform.active_job"
+
+      def self.subscribe
+        return if @subscribed
+
+        @subscribed = true
+
+        ActiveSupport::Notifications.subscribe(ENQUEUE_EVENT) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          new.record_enqueue(event)
+        end
+
+        # Setup context BEFORE job runs (so queries are linked)
+        ActiveSupport::Notifications.subscribe(PERFORM_START_EVENT) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          new.setup_perform_context(event)
+        end
+
+        # Record result AFTER job completes
+        ActiveSupport::Notifications.subscribe(PERFORM_EVENT) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          new.record_perform(event)
+        end
+      end
+
+      def setup_perform_context(event)
+        return unless Railscope.enabled?
+        return if ignore_job?(event.payload[:job])
+
+        job = event.payload[:job]
+        setup_job_context(job)
+      end
+
+      def record_enqueue(event)
+        return unless Railscope.enabled?
+        return unless Railscope.ready?
+        return if ignore_job?(event.payload[:job])
+
+        job = event.payload[:job]
+
+        create_entry!(
+          entry_type: "job_enqueue",
+          payload: build_enqueue_payload(event),
+          tags: build_tags(event, "enqueue"),
+          family_hash: build_family_hash(job),
+          should_display_on_index: true
+        )
+      rescue StandardError => e
+        Rails.logger.error("[Railscope] Failed to record job enqueue: #{e.message}")
+      end
+
+      def record_perform(event)
+        return unless Railscope.enabled?
+        return unless Railscope.ready?
+        return if ignore_job?(event.payload[:job])
+
+        job = event.payload[:job]
+        exception_object = event.payload[:exception_object]
+
+        # Create the job perform entry
+        create_entry!(
+          entry_type: "job_perform",
+          payload: build_perform_payload(event),
+          tags: build_tags(event, "perform"),
+          family_hash: build_family_hash(job),
+          should_display_on_index: true
+        )
+
+        # Also create a separate exception entry if job failed
+        create_exception_entry!(job, exception_object) if exception_object
+
+        # Clear context after job completes
+        Railscope::Context.clear!
+      rescue StandardError => e
+        Rails.logger.error("[Railscope] Failed to record job perform: #{e.message}")
+      end
+
+      private
+
+      def build_enqueue_payload(event)
+        job = event.payload[:job]
+
+        {
+          job_id: job.job_id,
+          job_class: job.class.name,
+          queue_name: job.queue_name,
+          connection: job.queue_adapter&.class&.name&.demodulize&.sub("Adapter", ""),
+          hostname: Socket.gethostname,
+          arguments: safe_arguments(job.arguments),
+          scheduled_at: job.scheduled_at,
+          priority: job.priority
+        }.compact
+      end
+
+      def build_perform_payload(event)
+        job = event.payload[:job]
+
+        {
+          job_id: job.job_id,
+          job_class: job.class.name,
+          queue_name: job.queue_name,
+          connection: job.queue_adapter&.class&.name&.demodulize&.sub("Adapter", ""),
+          hostname: Socket.gethostname,
+          arguments: safe_arguments(job.arguments),
+          duration: event.duration.round(2),
+          executions: job.executions,
+          exception: extract_exception(event)
+        }.compact
+      end
+
+      def build_tags(event, action)
+        job = event.payload[:job]
+        tags = ["job", action, job.queue_name]
+        tags << "failed" if event.payload[:exception_object].present?
+        tags << job.class.name.underscore.tr("/", "_")
+        tags.compact
+      end
+
+      # Group jobs by class name
+      def build_family_hash(job)
+        generate_family_hash("job", job.class.name)
+      end
+
+      def safe_arguments(arguments)
+        arguments.map do |arg|
+          case arg
+          when String, Numeric, TrueClass, FalseClass, NilClass
+            arg
+          when Hash
+            arg.transform_values { |v| safe_value(v) }
+          when Array
+            arg.map { |v| safe_value(v) }
+          else
+            arg.to_s
+          end
+        end
+      rescue StandardError
+        ["[unserializable]"]
+      end
+
+      def safe_value(value)
+        case value
+        when String, Numeric, TrueClass, FalseClass, NilClass
+          value
+        else
+          value.to_s
+        end
+      end
+
+      def extract_exception(event)
+        return nil unless event.payload[:exception_object]
+
+        exception = event.payload[:exception_object]
+        file, line = extract_file_and_line(exception)
+        line_preview = extract_line_preview(file, line)
+
+        {
+          class: exception.class.name,
+          message: exception.message,
+          file: file,
+          line: line,
+          line_preview: line_preview,
+          backtrace: exception.backtrace&.first(20)
+        }.compact
+      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
+
+      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 ignore_job?(job)
+        job.class.name.start_with?("Railscope::")
+      end
+
+      def setup_job_context(job)
+        # Clear any existing context to ensure a fresh batch_id
+        Railscope::Context.clear!
+
+        ctx = Railscope::Context.current
+        new_batch_id = SecureRandom.uuid
+        ctx.batch_id = new_batch_id
+        ctx[:recording] = true
+        ctx[:job_class] = job.class.name
+        ctx[:job_id] = job.job_id
+      end
+
+      def create_exception_entry!(job, 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: "job",
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name
+          }.compact,
+          tags: build_exception_tags(exception, job),
+          family_hash: generate_family_hash("exception", exception.class.name, "job", job.class.name),
+          should_display_on_index: true
+        )
+      end
+
+      def build_exception_tags(exception, job)
+        tags = %w[exception job]
+        tags << exception.class.name.underscore.tr("/", "_") if exception.class.name
+        tags << job.class.name.underscore.tr("/", "_")
+        tags
+      end
+    end
+  end
+end

data/lib/railscope/subscribers/query_subscriber.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Subscribers
+    class QuerySubscriber < BaseSubscriber
+      EVENT_NAME = "sql.active_record"
+
+      IGNORED_NAMES = %w[SCHEMA TRANSACTION].freeze
+      IGNORED_SQL_PATTERNS = [
+        /\A\s*SELECT.*sqlite_master/i,
+        /\A\s*SELECT.*pg_catalog/i,
+        /\A\s*SELECT.*information_schema/i,
+        /\A\s*SHOW/i,
+        /\A\s*SET/i
+      ].freeze
+
+      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 ignore_query?(event)
+
+        # Debug: log the batch_id being used
+        if context[:job_class].present?
+          Rails.logger.debug("[Railscope] Query in job context - batch_id: #{context.batch_id}, job: #{context[:job_class]}")
+        end
+
+        create_entry!(
+          entry_type: "query",
+          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 query: #{e.message}")
+      end
+
+      private
+
+      def build_payload(event)
+        file, line = extract_caller_location
+
+        {
+          sql: event.payload[:sql],
+          name: event.payload[:name],
+          duration: event.duration.round(2),
+          cached: event.payload[:cached] || false,
+          async: event.payload[:async] || false,
+          row_count: event.payload[:row_count],
+          connection: event.payload[:connection]&.adapter_name,
+          file: file,
+          line: line
+        }.compact
+      end
+
+      # Extract the location where the query was called from (application code)
+      def extract_caller_location
+        # Filter out Rails internals, gems, and Railscope itself
+        app_line = caller.find do |line|
+          line.include?(Rails.root.to_s) &&
+            !line.include?("/vendor/") &&
+            !line.include?("/railscope/")
+        end
+
+        return [nil, nil] unless app_line
+
+        if app_line =~ /\A(.+):(\d+)/
+          [Regexp.last_match(1), Regexp.last_match(2).to_i]
+        else
+          [nil, nil]
+        end
+      rescue StandardError
+        [nil, nil]
+      end
+
+      def build_tags(event)
+        tags = ["query"]
+        tags << query_type(event.payload[:sql])
+        tags << "cached" if event.payload[:cached]
+        tags << "slow" if event.duration > 100
+        tags.compact
+      end
+
+      # Generate family hash based on normalized SQL (without literal values)
+      def build_family_hash(event)
+        normalized_sql = normalize_sql(event.payload[:sql])
+        generate_family_hash("query", normalized_sql)
+      end
+
+      # Normalize SQL by replacing literal values with placeholders
+      def normalize_sql(sql)
+        sql.to_s
+           .gsub(/\d+/, "?")                          # Replace numbers
+           .gsub(/'[^']*'/, "?")                      # Replace single-quoted strings
+           .gsub(/"[^"]*"/, "?")                      # Replace double-quoted strings
+           .gsub(/\$\d+/, "?")                        # Replace PostgreSQL positional params
+           .gsub(/\s+/, " ")                          # Normalize whitespace
+           .strip
+      end
+
+      def query_type(sql)
+        case sql.to_s.strip
+        when /\A\s*SELECT/i then "select"
+        when /\A\s*INSERT/i then "insert"
+        when /\A\s*UPDATE/i then "update"
+        when /\A\s*DELETE/i then "delete"
+        end
+      end
+
+      def ignore_query?(event)
+        return true if event.payload[:name].to_s.in?(IGNORED_NAMES)
+        return true if IGNORED_SQL_PATTERNS.any? { |pattern| event.payload[:sql].to_s.match?(pattern) }
+        return true if event.payload[:sql].to_s.include?("railscope_entries")
+
+        false
+      end
+    end
+  end
+end

data/lib/railscope/subscribers/request_subscriber.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Subscribers
+    class RequestSubscriber < 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?
+
+        create_entry!(
+          entry_type: "request",
+          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 request: #{e.message}")
+      end
+
+      private
+
+      def build_payload(event)
+        request = event.payload[:request]
+        headers = extract_headers(event.payload[:headers] || request&.headers)
+
+        {
+          path: event.payload[:path],
+          method: event.payload[:method],
+          status: event.payload[:status],
+          duration: event.duration.round(2),
+          controller: event.payload[:controller],
+          action: event.payload[:action],
+          controller_action: "#{event.payload[:controller]}@#{event.payload[:action]}",
+          format: event.payload[:format],
+          view_runtime: event.payload[:view_runtime]&.round(2),
+          db_runtime: event.payload[:db_runtime]&.round(2),
+          ip_address: context[:ip_address] || extract_ip(request),
+          hostname: Socket.gethostname,
+          # Request data
+          payload: filter_params(event.payload[:params]),
+          headers: headers
+        }.compact
+      end
+
+      def extract_headers(headers)
+        return {} unless headers
+
+        result = {}
+        headers.each do |key, value|
+          # Only include HTTP headers, skip internal Rails headers
+          if key.start_with?("HTTP_") || %w[CONTENT_TYPE CONTENT_LENGTH].include?(key)
+            header_name = key.sub(/^HTTP_/, "").split("_").map(&:capitalize).join("-")
+            result[header_name] = value
+          end
+        end
+        result
+      rescue StandardError
+        {}
+      end
+
+      def extract_ip(request)
+        return nil unless request
+
+        request.try(:remote_ip) || request.try(:ip)
+      rescue StandardError
+        nil
+      end
+
+      def filter_params(params)
+        return nil if params.blank?
+
+        # Convert ActionController::Parameters to hash
+        params_hash = if params.respond_to?(:to_unsafe_h)
+                        params.to_unsafe_h
+                      elsif params.respond_to?(:to_hash)
+                        params.to_hash
+                      else
+                        params.to_h
+                      end
+
+        # Remove controller/action/format (both string and symbol keys)
+        filtered = params_hash.reject { |k, _| %w[controller action format].include?(k.to_s) }
+
+        return nil if filtered.empty?
+
+        Railscope.filter(filtered)
+      rescue StandardError => e
+        Rails.logger.error("[Railscope] filter_params error: #{e.message}")
+        nil
+      end
+
+      def build_tags(event)
+        tags = ["request", event.payload[:method]&.downcase].compact
+        tags << "error" if event.payload[:status].to_i >= 400
+        tags << "slow" if event.duration > 1000
+        tags
+      end
+
+      # Group requests by controller#action
+      def build_family_hash(event)
+        controller = event.payload[:controller]
+        action = event.payload[:action]
+        generate_family_hash("request", controller, action)
+      end
+    end
+  end
+end

data/lib/railscope/subscribers/view_subscriber.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Railscope
+  module Subscribers
+    class ViewSubscriber < BaseSubscriber
+      TEMPLATE_EVENT = "render_template.action_view"
+      PARTIAL_EVENT = "render_partial.action_view"
+      LAYOUT_EVENT = "render_layout.action_view"
+
+      def self.subscribe
+        return if @subscribed
+
+        @subscribed = true
+
+        # Include controller tracking in ApplicationController
+        setup_controller_tracking
+
+        ActiveSupport::Notifications.subscribe(TEMPLATE_EVENT) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          new.record_template(event)
+        end
+
+        ActiveSupport::Notifications.subscribe(PARTIAL_EVENT) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          new.record_partial(event)
+        end
+      end
+
+      def self.setup_controller_tracking
+        return if @controller_tracking_setup
+
+        @controller_tracking_setup = true
+
+        controller_module = Module.new do
+          extend ActiveSupport::Concern
+
+          included do
+            around_action :railscope_track_controller
+          end
+
+          private
+
+          def railscope_track_controller
+            Thread.current[:railscope_current_controller] = self
+            yield
+          ensure
+            Thread.current[:railscope_current_controller] = nil
+          end
+        end
+
+        if defined?(ActionController::Base)
+          ActionController::Base.include(controller_module)
+        else
+          ActiveSupport.on_load(:action_controller_base) do
+            include controller_module
+          end
+        end
+      end
+
+      def record_template(event)
+        return unless Railscope.enabled?
+        return unless Railscope.ready?
+        return if ignore_view?(event)
+
+        create_entry!(
+          entry_type: "view",
+          payload: build_payload(event, "template"),
+          tags: build_tags(event, "template"),
+          family_hash: build_family_hash(event),
+          should_display_on_index: true
+        )
+      rescue StandardError => e
+        Rails.logger.error("[Railscope] Failed to record view template: #{e.message}")
+      end
+
+      def record_partial(event)
+        return unless Railscope.enabled?
+        return unless Railscope.ready?
+        return if ignore_view?(event)
+
+        create_entry!(
+          entry_type: "view",
+          payload: build_payload(event, "partial"),
+          tags: build_tags(event, "partial"),
+          family_hash: build_family_hash(event),
+          should_display_on_index: false # Partials don't show in index, only in related entries
+        )
+      rescue StandardError => e
+        Rails.logger.error("[Railscope] Failed to record view partial: #{e.message}")
+      end
+
+      private
+
+      def build_payload(event, view_type)
+        identifier = event.payload[:identifier] || ""
+        layout = event.payload[:layout]
+
+        {
+          name: extract_view_name(identifier),
+          path: extract_relative_path(identifier),
+          full_path: identifier,
+          view_type: view_type,
+          layout: layout,
+          duration: event.duration.round(2),
+          # View data (instance variables) - extracted from controller if available
+          data: extract_view_data
+        }.compact
+      end
+
+      def extract_view_name(identifier)
+        return "" if identifier.blank?
+
+        # Extract view name from path like:
+        # /app/views/posts/index.html.erb -> posts/index
+        if identifier.include?("/app/views/")
+          identifier.split("/app/views/").last&.sub(/\.\w+\.\w+$/, "") || identifier
+        elsif identifier.include?("/views/")
+          identifier.split("/views/").last&.sub(/\.\w+\.\w+$/, "") || identifier
+        else
+          File.basename(identifier, ".*").sub(/\.\w+$/, "")
+        end
+      end
+
+      def extract_relative_path(identifier)
+        return "" if identifier.blank?
+
+        if identifier.include?(Rails.root.to_s)
+          identifier.sub(Rails.root.join("").to_s, "")
+        else
+          identifier
+        end
+      end
+
+      def extract_view_data
+        # Try to get instance variables from the current controller
+        controller = Thread.current[:railscope_current_controller]
+        return nil unless controller
+
+        # Get instance variables that were set in the controller
+        ivars = {}
+        controller.instance_variables.each do |ivar|
+          name = ivar.to_s.sub("@", "")
+          # Skip internal Rails variables
+          next if name.start_with?("_")
+          next if %w[request response performed_redirect marked_for_same_origin_verification].include?(name)
+
+          value = controller.instance_variable_get(ivar)
+          ivars[name] = safe_serialize(value)
+        end
+
+        ivars.presence
+      rescue StandardError
+        nil
+      end
+
+      def safe_serialize(value)
+        case value
+        when String, Numeric, TrueClass, FalseClass, NilClass
+          value
+        when Array
+          value.first(10).map { |v| safe_serialize(v) }
+        when Hash
+          value.transform_values { |v| safe_serialize(v) }
+        when ActiveRecord::Base
+          { class: value.class.name, id: value.try(:id) }
+        when ActiveRecord::Relation
+          { class: value.klass.name, count: value.size, sql: value.to_sql[0..200] }
+        else
+          value.class.name
+        end
+      rescue StandardError
+        value.class.name
+      end
+
+      def build_tags(event, view_type)
+        tags = ["view", view_type]
+        tags << "slow" if event.duration > 100
+        tags
+      end
+
+      def build_family_hash(event)
+        identifier = event.payload[:identifier] || ""
+        view_name = extract_view_name(identifier)
+        generate_family_hash("view", view_name)
+      end
+
+      def ignore_view?(event)
+        identifier = event.payload[:identifier].to_s
+
+        # Ignore Railscope's own views
+        return true if identifier.include?("railscope")
+
+        # Ignore Rails internal views
+        return true if identifier.include?("actionmailer")
+        return true if identifier.include?("action_mailbox")
+
+        false
+      end
+    end
+  end
+end

data/lib/railscope/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Railscope
+  VERSION = "0.1.0"
+end