factorial-debugbar 0.3.3

data/lib/debugbar/middlewares/track_current_request.rb

@@ -0,0 +1,39 @@
+module Debugbar
+  class TrackCurrentRequest
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      Debugbar::Current.ignore = Debugbar.config.ignore_request?(env)
+
+      return @app.call(env) if Debugbar::Current.ignore?
+
+      Debugbar::Current.new_request!(SecureRandom.uuid)
+
+      res = @app.call(env)
+
+      # TODO: Remove this if statement?
+      # We check meta because the frontend doesn't support request without meta yet.
+      # It might happen with ActionController::Live where the following code
+      # will run BEFORE ActionControllerEventSubscriber.process_action is called
+      if Debugbar::Current.request&.meta
+        # filename = "#{Time.now.to_i}--#{Debugbar::Current.request.meta.dig(:params, :controller)}_#{Debugbar::Current.request.meta.dig(:params, :action).gsub('/', '_')}.json"
+        # File.open(Rails.root.join('_requests', filename), "w") do |f|
+        #   f.write(Debugbar::Current.request.to_json)
+        # end
+
+        RequestBuffer.push(Debugbar::Current.pop_request!)
+
+        # TODO: Refactor has not having ActionCable might more common than I thought
+        if Debugbar.connected? && defined?(ActionCable)
+          data = RequestBuffer.all.map(&:to_h)
+          ActionCable.server.broadcast("debugbar_channel", data)
+        end
+      end
+
+      res
+    end
+  end
+
+end

data/lib/debugbar/request.rb

@@ -0,0 +1,99 @@
+module Debugbar
+  class Request
+    attr_reader :request_id, :meta,
+                :models, :queries, :jobs,
+                :messages, :cache, :logs
+    attr_accessor :request, :response, :headers
+
+    def initialize(request_id)
+      @request_id = request_id
+      @models = {}
+      @queries = []
+      @jobs = []
+      @messages = []
+      @cache = []
+      @logs = []
+    end
+
+    alias_method :id, :request_id
+
+    def meta=(meta)
+      meta.delete(:headers)
+      meta.delete(:request)
+      meta.delete(:response)
+      @meta = meta
+    end
+
+    def inc_model(name)
+      if @models[name]
+        @models[name] += 1
+      else
+        @models[name] = 1
+      end
+    end
+
+    def add_query(query)
+      @queries << query
+    end
+
+    def add_job(job)
+      @jobs << job
+    end
+
+    def add_msg(msg, extra, source)
+      @messages << {id: SecureRandom.hex(8), msg: msg, extra: extra, source: source}
+    end
+
+    def add_cache(c)
+      @cache << c
+    end
+
+    def add_log(l)
+      @logs << l
+    end
+
+    def to_h
+      {
+        id: request_id,
+        meta: meta,
+        request: request_hash,
+        response: response_hash,
+        models: models,
+        queries: queries,
+        jobs: jobs,
+        messages: messages,
+        cache: cache,
+        logs: logs,
+      }
+    end
+
+    def to_json
+      JSON.pretty_generate(to_h)
+    end
+
+    private
+
+    def request_hash
+      {
+        method: request.method,
+        path: request.path,
+        format: meta.dig(:format),
+        params: meta.dig(:params),
+        headers: request.env.select { |k,v| k.start_with? 'HTTP_'} # https://stackoverflow.com/a/55406700/1001125
+                        .transform_keys { |k| k.sub(/^HTTP_/, '').split('_').map(&:capitalize).join('-') }
+                        .sort.to_h
+      }
+    end
+
+    def response_hash
+      return nil if response.nil?
+      return nil unless response&.body
+
+      {
+        status: response.status,
+        headers: response.headers.to_h.transform_keys { |s| s.split('-').map(&:capitalize).join('-') },
+        body: response.body,
+      }
+    end
+  end
+end

data/lib/debugbar/subscribers/action_controller.rb

@@ -0,0 +1,33 @@
+module Debugbar
+  class ActionControllerEventSubscriber
+    class << self
+      def start_processing(event)
+        return if Debugbar::Current.ignore?
+
+        Debugbar::Tracker.request = event.payload[:request]
+      end
+
+      def process_action(event)
+        return if Debugbar::Current.ignore?
+
+        meta = event.payload
+
+        meta.delete :headers
+        request = meta.delete :request
+        response = meta.delete :response
+
+        meta.merge!({
+          duration: event.duration,
+          cpu_time: event.cpu_time,
+          idle_time: event.idle_time,
+          allocations: event.allocations,
+        })
+
+        Debugbar::Tracker.request = request
+        Debugbar::Tracker.response = response
+        Debugbar::Tracker.meta = meta
+
+      end
+    end
+  end
+end

data/lib/debugbar/subscribers/active_job.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Debugbar
+  class ActiveJobEventSubscriber
+    class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
+
+    class << self
+      def enqueue(event)
+        return if Debugbar::Current.ignore?
+
+        job = event.payload[:job]
+        ex = event.payload[:exception_object] || job.enqueue_error
+
+        logs = []
+        logs << if ex
+          "Failed enqueuing #{job.class.name} to #{queue_name(event)}: #{ex.class} (#{ex.message})"
+        elsif event.payload[:aborted]
+          "Failed enqueuing #{job.class.name} to #{queue_name(event)}, a before_enqueue callback halted the enqueuing execution."
+        else
+          "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)}" + args_info(job)
+        end
+        logs << log_enqueue_source
+
+        Debugbar::Tracker.add_job({
+          id: job.job_id,
+          class: job.class.name,
+          queue: queue_name(event),
+          args: job.arguments.map { |arg| format(arg) },
+          successfully_enqueued: job.successfully_enqueued?,
+          scheduled_at: scheduled_at(job),
+          logs: logs,
+        })
+      end
+      # subscribe_log_level :enqueue, :info # ???
+
+      def enqueue_at(event)
+        return if Debugbar::Current.ignore?
+
+        job = event.payload[:job]
+        ex = event.payload[:exception_object] || job.enqueue_error
+
+        logs = []
+        logs << if ex
+          "Failed enqueuing #{job.class.name} to #{queue_name(event)}: #{ex.class} (#{ex.message})"
+        elsif event.payload[:aborted]
+          "Failed enqueuing #{job.class.name} to #{queue_name(event)}, a before_enqueue callback halted the enqueuing execution."
+        else
+          "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)} at #{scheduled_at(job)}" + args_info(job)
+        end
+        logs << log_enqueue_source
+
+        Debugbar::Tracker.add_job({
+          id: job.job_id,
+          class: job.class.name,
+          queue: queue_name(event),
+          args: job.arguments.map { |arg| format(arg) },
+          successfully_enqueued: job.successfully_enqueued?,
+          scheduled_at: scheduled_at(job),
+          logs: logs,
+        })
+      end
+      # subscribe_log_level :enqueue_at, :info
+
+      # def enqueue_all(event)
+      #   info do
+      #     jobs = event.payload[:jobs]
+      #     adapter = event.payload[:adapter]
+      #     enqueued_count = event.payload[:enqueued_count]
+      #
+      #     if enqueued_count == jobs.size
+      #       enqueued_jobs_message(adapter, jobs)
+      #     elsif jobs.any?(&:successfully_enqueued?)
+      #       enqueued_jobs = jobs.select(&:successfully_enqueued?)
+      #
+      #       failed_enqueue_count = jobs.size - enqueued_count
+      #       if failed_enqueue_count == 0
+      #         enqueued_jobs_message(adapter, enqueued_jobs)
+      #       else
+      #         "#{enqueued_jobs_message(adapter, enqueued_jobs)}. "\
+      #           "Failed enqueuing #{failed_enqueue_count} #{'job'.pluralize(failed_enqueue_count)}"
+      #       end
+      #     else
+      #       failed_enqueue_count = jobs.size - enqueued_count
+      #       "Failed enqueuing #{failed_enqueue_count} #{'job'.pluralize(failed_enqueue_count)} "\
+      #         "to #{adapter_name(adapter)}"
+      #     end
+      #   end
+      # end
+      # # subscribe_log_level :enqueue_all, :info
+
+      private
+
+      # See ActiveJob.adapter_name for orignal implementation. This is redefined here
+      # to be compatible with the older Rails version.
+      def adapter_name(adapter) # :nodoc:
+        return adapter.queue_adapter_name if adapter.respond_to?(:queue_adapter_name)
+
+        adapter_class = adapter.is_a?(Module) ? adapter : adapter.class
+        "#{adapter_class.name.demodulize.delete_suffix('Adapter')}"
+      end
+
+      def queue_name(event)
+        adapter_name(event.payload[:adapter]) + "(#{event.payload[:job].queue_name})"
+      end
+
+      def args_info(job)
+        if job.class.log_arguments? && job.arguments.any?
+          " with arguments: " +
+            job.arguments.map { |arg| format(arg).inspect }.join(", ")
+        else
+          ""
+        end
+      end
+
+      def format(arg)
+        case arg
+        when Hash
+          arg.transform_values { |value| format(value) }
+        when Array
+          arg.map { |value| format(value) }
+        when GlobalID::Identification
+          arg.to_global_id rescue arg
+        else
+          arg
+        end
+      end
+
+      def scheduled_at(job)
+        Time.at(job.scheduled_at).utc if job.scheduled_at
+      end
+
+      def logger
+        ActiveJob::Base.logger
+      end
+
+      def info(progname = nil, &block)
+        return unless super
+
+        if ActiveJob.verbose_enqueue_logs
+          log_enqueue_source
+        end
+      end
+
+      def error(progname = nil, &block)
+        return unless super
+
+        if ActiveJob.verbose_enqueue_logs
+          log_enqueue_source
+        end
+      end
+
+      def log_enqueue_source
+        extract_enqueue_source_location(caller)
+      end
+
+      def extract_enqueue_source_location(locations)
+        backtrace_cleaner.clean(locations.lazy).first
+      end
+
+      def enqueued_jobs_message(adapter, enqueued_jobs)
+        enqueued_count = enqueued_jobs.size
+        job_classes_counts = enqueued_jobs.map(&:class).tally.sort_by { |_k, v| -v }
+        "Enqueued #{enqueued_count} #{'job'.pluralize(enqueued_count)} to #{adapter_name(adapter)}"\
+          " (#{job_classes_counts.map { |klass, count| "#{count} #{klass}" }.join(', ')})"
+      end
+    end
+  end
+end

data/lib/debugbar/subscribers/active_record.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Debugbar
+  class ActiveRecordEventSubscriber
+    class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
+
+    class << self
+      def sql(event)
+        return if Debugbar::Current.ignore?
+
+        payload = event.payload
+
+        return if payload[:name]&.starts_with? "SCHEMA"
+
+        title = if payload[:async]
+          "ASYNC #{payload[:name]} (#{payload[:lock_wait].round(1)}ms) (db time #{event.duration.round(1)}ms)"
+        else
+          "#{payload[:name] || "Unnamed"} (#{event.duration.round(1)}ms)"
+        end
+        title = "CACHE #{title}" if payload[:cached]
+
+        sql = payload[:sql]&.gsub(/\/\*.*\*\//, "") # remove comments
+
+        binds = nil
+        # if payload[:binds]&.any?
+        #   TODO: Restore binds when I can figure out how to get something in poayload[:binds]
+        # end
+
+        Debugbar::Tracker.add_query({
+          id: event.transaction_id,
+          title: title,
+          name: payload[:name],
+          sql: sql,
+          cached: payload[:cached].present?,
+          async: payload[:async],
+          duration: event.duration.round(1),
+          lock_wait: payload[:lock_wait]&.round(1),
+          binds: binds,
+          source: query_source_location
+        })
+      end
+
+      def query_source_location
+        str = backtrace_cleaner.clean(caller(3))[0]
+        str&.split(":in")&.map { |s| s.delete_prefix("#{Rails.root}/").strip.tr("`'", '' ) } # Duplicated in Debugbar.msg
+      end
+    end
+  end
+end

data/lib/debugbar/subscribers/active_support.rb

@@ -0,0 +1,30 @@
+module Debugbar
+  class ActiveSupportEventSubscriber
+    class << self
+      def cache(event)
+        evt = event.payload
+        evt[:name] = event.name
+        evt[:transaction_id] = event.transaction_id
+        evt[:time] = Time.at(event.time).strftime(Debugbar::TIME_FORMAT)
+        evt[:label] = case event.name
+          when "cache_read.active_support"
+            "read"
+          when "cache_generate.active_support"
+            "generate"
+          when "cache_fetch_hit.active_support"
+            "fetch hit"
+          when "cache_write.active_support"
+            "write"
+          when "cache_delete.active_support"
+            "delete"
+          when "cache_exist?.active_support"
+            "exist?"
+          else
+            "unknown"
+          end
+
+        Debugbar::Tracker.add_cache evt
+      end
+    end
+  end
+end

data/lib/debugbar/version.rb

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

data/lib/debugbar.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Debugbar
+  autoload :VERSION, "debugbar/version"
+  autoload :Current, "debugbar/current"
+  autoload :Request, "debugbar/request"
+  autoload :RequestBuffer, "debugbar/buffers/request_buffer"
+  autoload :SimpleLogger, "debugbar/loggers/simple_logger"
+
+  TIME_FORMAT = "%H:%M:%S.%L"
+
+  module Tracker
+    class << self
+      SETTERS = %i[request response headers meta].freeze
+      METHODS = %i[inc_model add_query add_job add_cache add_log].freeze
+
+      SETTERS.each do |m|
+        define_method("#{m}=") do |val|
+          return if Debugbar::Current.ignore?
+
+          if Current.request
+            return Current.request.send("#{m}=", val)
+          end
+
+          if Current.request.nil? && ENV["DEBUGBAR_VERBOSE_MODE"] == "true"
+            # TODO: Much, much better logging needed
+            puts "The current request is not set yet. Was trying to set #{m} = #{val.class.name}."
+            pp val
+            nil
+          end
+        end
+      end
+
+      METHODS.each do |m|
+        define_method(m) do |*args, &block|
+          return if Debugbar::Current.ignore?
+
+          if Current.request
+            return Current.request.send(m, *args, &block)
+          end
+
+          if Current.request.nil? && ENV["DEBUGBAR_VERBOSE_MODE"] == "true"
+            puts "The current request is not set yet. Was trying to call #{m}(#{args.map{ _1.class.name}.join(',')})."
+            pp args
+            nil
+          end
+        end
+      end
+
+      def msg(msg, extra, source)
+        if Current.request.nil?
+          puts "The current request is not set yet. Printing to STDOUT instead."
+          puts msg, extra, source
+        else
+          Current.request.add_msg(msg, extra, source)
+        end
+      end
+    end
+  end
+
+  include Tracker
+
+  class << self
+    def config
+      @config ||= Config.new(enabled: true)
+    end
+
+    def configure
+      yield config
+    end
+
+    def connect!
+      @connected = true
+    end
+
+    def disconnect!
+      @connected = false
+    end
+
+    def connected?
+      @connected
+    end
+
+    def msg(msg, *extra)
+      source = caller.first&.split(":in")&.map { |s| s.delete_prefix("#{Rails.root}/").strip.tr("`'", '' ) }
+      Tracker.msg(msg, extra, source)
+    end
+  end
+end
+
+require 'debugbar/engine'