debugbar 0.0.1 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5380fa3760a1309aacd1404c077e3e6c78ed94d21bde373eb0f96f90da96abe6
+  data.tar.gz: 7e9f86653a25e202c9ebf4c64b8d74f5816aaadbee1f2e2d75b46423fa17a8dd
+SHA512:
+  metadata.gz: '08f084f414d3520d4f7f287b3ffcde2a1a322b7bc04492bcf80ca0087b7fe1a853db6dac041bafceaa352944d8c09ed8d12ecf47bfa30cbc03643f29e2573179'
+  data.tar.gz: 2836203deb352f9d344d8784423b801d6ca6ff26e7e48adaec4ea58b142434999ef145f32207de68ba80cf499dba137e8f41d507d97bb9f025d84084a205ac65

data/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "printWidth": 120,
+  "semi": false
+}

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Julien Bourdeau
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,5 @@
+# Debugbar for Rails
+
+Find all documentation on [debugbar.dev](https://debugbar.dev/)
+
+[![debugbar screesnhot](https://debugbar.dev/assets/screenshots/home.png)](https://debugbar.dev/docs/)

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/app/channels/debugbar/debugbar_channel.rb

@@ -0,0 +1,26 @@
+module Debugbar
+  class DebugbarChannel < ActionCable::Channel::Base
+    def subscribed
+      stream_from "debugbar_channel"
+    end
+
+    def receive(data)
+      if data["clear"]
+        RequestBuffer.clear!
+      end
+
+      if data["ids"].present?
+        RequestBuffer.remove(data["ids"])
+      end
+
+      Debugbar.connect!
+
+      data = RequestBuffer.all.map(&:to_h)
+      ActionCable.server.broadcast("debugbar_channel", data)
+    end
+
+    def unsubscribed
+      Debugbar.disconnect!
+    end
+  end
+end

data/app/controllers/debugbar/application_controller.rb

@@ -0,0 +1,4 @@
+module Debugbar
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/debugbar/assets_controller.rb

@@ -0,0 +1,15 @@
+module Debugbar
+  class AssetsController < ApplicationController
+    def js
+      render file: File.join(Gem.loaded_specs['debugbar'].full_gem_path, 'public', 'debugbar.js'),
+        layout: false,
+        content_type: 'text/javascript'
+    end
+
+    private
+
+    def verify_same_origin_request
+      true # YOLO
+    end
+  end
+end

data/app/helpers/debugbar/tag_helpers.rb

@@ -0,0 +1,19 @@
+module Debugbar::TagHelpers
+  def debugbar_javascript(opt = {})
+    html = <<-HTML
+      <div id="__debugbar"></div>
+    HTML
+
+    html += <<-HTML
+      <script type="text/javascript">
+        window._debugbarConfigOptions = #{opt.to_json}
+      </script>
+    HTML
+
+    html += <<-HTML
+      <script defer src="#{Debugbar.config.prefix}/assets/script"></script>
+      HTML
+
+    raw html
+  end
+end

data/app/models/debugbar/application_record.rb

@@ -0,0 +1,5 @@
+module Debugbar
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/build.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+rm -rf client/dist
+(cd client && npm run build)
+cp client/dist/assets/debugbar-*.js public/debugbar.js
+
+gem build debugbar.gemspec

data/config/routes.rb

@@ -0,0 +1,7 @@
+Debugbar::Engine.routes.draw do
+  mount ActionCable.server => '/cable'
+
+  # TODO: Silence logs for these routes if `::Rails.application.config.assets.quiet` is true
+  get 'assets/style' => "assets#css", format: :css
+  get 'assets/script' => "assets#js"
+end

data/debugbar.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "lib/debugbar/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "debugbar"
+  spec.version = Debugbar::VERSION
+  spec.authors = ["Julien Bourdeau"]
+  spec.email = ["julien@debugbar.dev"]
+
+  spec.summary = "Powerful devtools for Ruby on Rails"
+  spec.description = "Get a better understanding of your application performance and behavior (SQL queries, jobs, cache, routes, logs, etc)"
+  spec.homepage = "https://debugbar.dev"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/julienbourdeau/debugbar"
+  spec.metadata["changelog_uri"] = "https://debugbar.dev/changelog/"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  files_to_remove = %w[
+    bin/ test/ spec/ features/ fixtures/
+    client/
+    .git .circleci appveyor Gemfile package.json package-lock.json
+  ]
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*files_to_remove)
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rails" #, ">= 7.1.1"
+  spec.add_dependency "actioncable" #, ">= 7.1.1"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/debugbar/buffers/memory_buffer.rb

@@ -0,0 +1,34 @@
+module Debugbar
+  class MemoryBuffer
+    def initialize
+      @collection = {}
+    end
+
+    def push(request)
+      @collection[request.id] = request
+      nil
+    end
+
+    def remove(ids)
+      ids = Array.wrap(ids)
+      ids.each do |id|
+        @collection.delete(id)
+      end
+      :self
+    end
+
+    def all
+      @collection.values
+    end
+
+    def each(&block)
+      @collection.each(&block)
+      :self
+    end
+
+    def clear!
+      @collection = {}
+      :self
+    end
+  end
+end

data/lib/debugbar/buffers/null_buffer.rb

@@ -0,0 +1,18 @@
+module Debugbar
+  class NullBuffer
+    def push(_request)
+    end
+
+    def remove(_ids)
+    end
+
+    def all
+    end
+
+    def each
+    end
+
+    def clear!
+    end
+  end
+end

data/lib/debugbar/buffers/request_buffer.rb

@@ -0,0 +1,31 @@
+module Debugbar
+  class RequestBuffer
+    class << self
+      def init(adapter)
+        @enabled = false
+        @adapter = adapter
+      end
+
+      def enable!
+        @enabled = true
+        send_all
+      end
+
+      def disable!
+        @enabled = false
+      end
+
+      def send_all
+        data = @collection.values.map(&:to_h)
+        ActionCable.server.broadcast("debugbar_channel", data)
+      end
+
+      %w(push each all remove clear!).each do |name|
+        define_method(name) do |*args, &block|
+          ret = @adapter.send(name, *args, &block)
+          ret == :self ? self : ret
+        end
+      end
+    end
+  end
+end

data/lib/debugbar/config.rb

@@ -0,0 +1,50 @@
+module Debugbar
+  class Config
+    attr_accessor :enabled, :prefix, :buffer_adapter, :ignore_request,
+                  :active_record, :action_controller, :active_job,
+                  :min_log_level
+
+    alias_method :enabled?, :enabled
+
+    def initialize(options = {})
+      opt = defaults.merge options
+      @enabled = opt[:enabled] && !defined?(Rails::Console)
+      @prefix = opt[:prefix]
+      @active_record = opt[:active_record]
+      @action_controller = opt[:action_controller]
+      @active_job = opt[:active_job]
+      @min_log_level = opt[:min_log_level]
+      @buffer_adapter = opt[:buffer_adapter]
+    end
+
+    def defaults
+      {
+        enabled: Rails.env.development?,
+        prefix: "/_debugbar",
+        active_record: true,
+        action_controller: true,
+        active_job: true,
+        min_log_level: -1,
+        buffer_adapter: :memory,
+      }
+    end
+
+    def ignore_request?(env)
+      if ignore_request.is_a? Proc
+        ignore_request.call(env)
+      else
+        [Debugbar.config.prefix, "/assets"].any? { |s| env['PATH_INFO'].start_with? s }
+      end
+    end
+
+    def use_logger?
+      @enabled && @min_log_level >= 0
+    end
+
+    %w(active_record action_controller active_job).each do |name|
+      define_method("#{name}?") do
+        @enabled && instance_variable_get("@#{name}")
+      end
+    end
+  end
+end

data/lib/debugbar/current.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Debugbar
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :request
+    attribute :ignore
+
+    alias_method :ignore?, :ignore
+
+    def new_request!(request_id)
+      self.request = Request.new(request_id)
+    end
+
+    def pop_request!
+      request.tap { self.request = nil }
+    end
+  end
+end

data/lib/debugbar/engine.rb

@@ -1,10 +1,93 @@
+require_relative 'config'
+require_relative 'middlewares/track_current_request'
+
 module Debugbar
-  class Engine < Rails::Engine
-    # This should fix rails3 rc, and also work with beta
-    config.autoload_paths << File.expand_path(File.join(File.dirname(__FILE__), "..", "..")) if config.respond_to? :autoload_paths
+  class Engine < ::Rails::Engine
+    isolate_namespace Debugbar
+
+    initializer 'debugbar.config' do |app|
+      app.config.debugbar = ::Debugbar.config
+    end
+
+    initializer 'debugbar.init' do |app|
+      adapter = case(app.config.debugbar.buffer_adapter)
+      when :memory
+        require_relative 'buffers/memory_buffer'
+        MemoryBuffer.new
+      when :null
+        require_relative 'buffers/null_buffer'
+        NullBuffer.new
+      else
+        throw "Invalid RequestBuffer adapter"
+      end
+
+      Debugbar::RequestBuffer.init(adapter)
+    end
+
+    initializer 'debugbar.helper' do
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.helper(Debugbar::TagHelpers)
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        include Debugbar::TagHelpers
+      end
+    end
+
+    initializer 'debugbar.inject_middlewares' do |app|
+      next unless Debugbar.config.enabled?
+      app.middleware.insert_after ActionDispatch::RequestId, Debugbar::TrackCurrentRequest
+    end
+
+    initializer 'debugbar.subscribe' do
+      if Debugbar.config.active_record?
+        require_relative 'subscribers/active_record'
+        subscribe "Debugbar::ActiveRecordEventSubscriber" => "sql.active_record"
+      end
+
+      if Debugbar.config.action_controller?
+        require_relative 'subscribers/action_controller'
+        subscribe "Debugbar::ActionControllerEventSubscriber" => %w[
+          start_processing.action_controller process_action.action_controller
+        ]
+      end
+
+      if Debugbar.config.active_job?
+        require_relative 'subscribers/active_job'
+        subscribe "Debugbar::ActiveJobEventSubscriber" => ["enqueue.active_job", "enqueue_at.active_job"]
+      end
+
+      require_relative 'subscribers/active_support'
+      subscribe "Debugbar::ActiveSupportEventSubscriber.cache" => %w(
+        cache_read.active_support
+        cache_generate.active_support
+        cache_fetch_hit.active_support
+        cache_write.active_support
+        cache_delete.active_support
+        cache_exist?.active_support
+      )
+    end
+
+    initializer 'debugbar.track_models' do
+      next unless Debugbar.config.active_record?
+      ActiveSupport.on_load(:active_record) do
+        after_initialize do |model|
+          Debugbar::Tracker.inc_model(model.class.name)
+        end
+      end
+    end
 
-    rake_tasks do
-      load "debugbar/railties/tasks.rake"
+    def subscribe(config)
+      config.each do |subscriber, event_names|
+        event_names = Array.wrap(event_names)
+        class_name, class_method_name = subscriber.split('.')
+        event_names.each do |name|
+          method_name = class_method_name || name.split('.').first
+          ActiveSupport::Notifications.subscribe name do |event|
+            class_name.constantize.send method_name, event
+          end
+        end
+      end
     end
   end
 end

data/lib/debugbar/loggers/simple_logger.rb

@@ -0,0 +1,34 @@
+module Debugbar
+  class SimpleLogger < ::Logger
+    def initialize(min_level= 2)
+      @min_level = min_level
+    end
+
+    def add(severity, message = nil, progname = nil)
+      # We normally rely on the Tracker to know if the current request is set or nil and log an error to STDOUT,
+      # but in this case, it happens so often that the logs are annoying.
+      # In ActiveCable, only the first call goes through the Rake middleware, so every following communication
+      # doesn't go through TrackCurrentRequest, which initializes the request.
+      return if ::Debugbar::Current.request.nil?
+
+      return if severity < @min_level
+
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = nil
+        end
+      end
+
+      Debugbar::Tracker.add_log({
+        time: Time.now.strftime(Debugbar::TIME_FORMAT),
+        severity: severity,
+        severity_label: SEV_LABEL[severity],
+        message: message,
+        progname: progname,
+      })
+    end
+  end
+end

data/lib/debugbar/middlewares/track_current_request.rb

@@ -0,0 +1,35 @@
+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!(env['action_dispatch.request_id'])
+
+      res = @app.call(env)
+
+      # TODO: Remove this if statement?
+      if Debugbar::Current.request&.id
+        # 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!)
+
+        if Debugbar.connected?
+          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,98 @@
+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)
+      @messages << {msg: msg, extra: extra}
+    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?
+
+      {
+        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,158 @@
+# 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 #{ActiveJob.adapter_name(adapter)}"
+      #     end
+      #   end
+      # end
+      # # subscribe_log_level :enqueue_all, :info
+
+      private
+      def queue_name(event)
+        ActiveJob.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 #{ActiveJob.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,65 @@
+# 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?
+          casted_params = type_casted_binds(payload[:type_casted_binds])
+
+          binds = []
+          payload[:binds].each_with_index do |attr, i|
+            attribute_name = if attr.respond_to?(:name)
+              attr.name
+            elsif attr.respond_to?(:[]) && attr[i].respond_to?(:name)
+              attr[i].name
+            else
+              nil
+            end
+
+            filtered_params = filter(attribute_name, casted_params[i])
+
+            binds << render_bind(attr, filtered_params)
+          end
+          binds = binds.inspect
+          binds.prepend("  ")
+        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&.split(":in"),
+        })
+      end
+
+      def query_source_location
+        backtrace_cleaner.clean(caller(3))[0]
+      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.1.1"
+end

data/lib/debugbar.rb

@@ -1,8 +1,82 @@
-require 'pathname'
-require 'debugbar/engine' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+# frozen_string_literal: true
 
-module DebugBar
-  def self.root
-    Pathname.new(File.join(File.dirname(__FILE__), ".."))
+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|
+          if Current.request.nil?
+            # TODO: Much, much better logging needed
+            puts "The current request is not set yet. Was trying to set #{m}=[#{val.class.name}]."
+          else
+            Current.request.send("#{m}=", val)
+          end
+        end
+      end
+
+      METHODS.each do |m|
+        define_method(m) do |*args, &block|
+          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)
+        if Current.request.nil?
+          puts "The current request is not set yet. Printing to STDOUT instead."
+          puts msg, extra
+        else
+          Current.request.add_msg(msg, extra)
+        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)
+      Tracker.msg(msg, *extra)
+    end
   end
 end
+
+require 'debugbar/engine'

data/sig/debugbar.rbs

@@ -0,0 +1,4 @@
+module Debugbar
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -1,59 +1,103 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: debugbar
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.1
+version: !ruby/object:Gem::Version
+  version: 0.1.1
 platform: ruby
-authors: 
-- Andy Jeffries
-autorequire: 
-bindir: bin
+authors:
+- Julien Bourdeau
+autorequire:
+bindir: exe
 cert_chain: []
-
-date: 2011-03-17 00:00:00 +00:00
-default_executable: 
-dependencies: []
-
-description: Debugbar gem for Rails 3
-email: andy@andyjeffries.co.uk
+date: 2024-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: actioncable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Get a better understanding of your application performance and behavior
+  (SQL queries, jobs, cache, routes, logs, etc)
+email:
+- julien@debugbar.dev
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README.textile
-files: 
+extra_rdoc_files: []
+files:
+- ".prettierrc"
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/channels/debugbar/debugbar_channel.rb
+- app/controllers/debugbar/application_controller.rb
+- app/controllers/debugbar/assets_controller.rb
+- app/helpers/debugbar/tag_helpers.rb
+- app/models/debugbar/application_record.rb
+- build.sh
+- config/routes.rb
+- debugbar.gemspec
 - lib/debugbar.rb
+- lib/debugbar/buffers/memory_buffer.rb
+- lib/debugbar/buffers/null_buffer.rb
+- lib/debugbar/buffers/request_buffer.rb
+- lib/debugbar/config.rb
+- lib/debugbar/current.rb
 - lib/debugbar/engine.rb
-- lib/debugbar/railties/tasks.rake
-- README.textile
-has_rdoc: true
-homepage: http://andyjeffries.co.uk/
-licenses: []
-
-post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+- lib/debugbar/loggers/simple_logger.rb
+- lib/debugbar/middlewares/track_current_request.rb
+- lib/debugbar/request.rb
+- lib/debugbar/subscribers/action_controller.rb
+- lib/debugbar/subscribers/active_job.rb
+- lib/debugbar/subscribers/active_record.rb
+- lib/debugbar/subscribers/active_support.rb
+- lib/debugbar/version.rb
+- sig/debugbar.rbs
+homepage: https://debugbar.dev
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://debugbar.dev
+  source_code_uri: https://github.com/julienbourdeau/debugbar
+  changelog_uri: https://debugbar.dev/changelog/
+post_install_message:
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.6.1
-signing_key: 
-specification_version: 3
-summary: Debugbar gem for Rails 3
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Powerful devtools for Ruby on Rails
 test_files: []
-

data/README.textile

@@ -1,18 +0,0 @@
-h1. Debug Bar Gem v0.0.1
-
-h2. Installation
-
-Add the following to your Gemfile:
-
-<pre><code>gem 'debugbar'</code></pre>
-
-And restart your application with:
-
-<pre><code>bundle install
-touch tmp/restart.txt</code></pre>
-
-h2. Introduction
-
-DebugBar provides a Django/Symfony like Debug Bar for Ruby on Rails 3.
-
-This project is only in it's infancy...

data/lib/debugbar/railties/tasks.rake

@@ -1 +0,0 @@
-# Put your custom rake tasks here