awesome_explain 0.3.0 → 1.0.0

data/lib/awesome_explain.rb

@@ -1,7 +1,84 @@
-require 'awesome_explain/version'
+require 'awesome_print'
+require 'sqlite3'
+require 'active_record'
+require 'kaminari'
+require 'awesome_print'
 require 'terminal-table'
-require 'awesome_explain/renderers/mongoid'
+require 'niceql'
+
+require 'awesome_explain/version'
+require 'awesome_explain/utils/color'
+
+require 'awesome_explain/mongodb/base'
+require 'awesome_explain/renderers/base'
+require 'awesome_explain/subscribers/base'
+require 'awesome_explain/insights/base'
+
+require 'awesome_explain/config'
+require 'awesome_explain/engine'
+
+require 'awesome_explain/queue/simple_queue'
+require 'awesome_explain/queue/command'
+require 'awesome_explain/sidekiq_middleware'
+require 'awesome_explain/stats/postgresql'
 require 'awesome_explain/kernel'
 
+DEFAULT_SOURCE_NAME = :server
+
+COMMAND_NAMES_BLACKLIST = [
+  'createIndexes',
+  'explain',
+  'saslStart',
+  'saslContinue',
+  'listCollections',
+  'listIndexes',
+  'endSessions',
+  'killCursors',
+  'create',
+  'drop'
+]
+QUERIES = [
+  :aggregate,
+  :count,
+  :delete,
+  :distinct,
+  :find,
+  :getMore,
+  :insert,
+  :update
+].freeze
+
+DML_COMMANDS = [
+  :insert,
+  :update,
+  :delete
+].freeze
+
+COMMAND_ALLOWED_KEYS = ([
+  'filter',
+  'sort',
+  'limit',
+  'key',
+  'query'
+] + (QUERIES.map {|q| q.to_s})).freeze
+
+require 'thread'
+
 module AwesomeExplain
+  def self.clean
+    AwesomeExplain::Log.delete_all
+    AwesomeExplain::SqlQuery.delete_all
+    AwesomeExplain::Explain.delete_all
+    AwesomeExplain::SqlExplain.delete_all
+    AwesomeExplain::Stacktrace.delete_all
+    AwesomeExplain::Controller.delete_all
+  end
+
+  def self.configure(&block)
+    raise NoBlockGivenException unless block_given?
+
+    Config.configure(&block)
+  end
+
+  class NoBlockGivenException < RuntimeError; end
 end

data/lib/awesome_explain/config.rb

@@ -0,0 +1,196 @@
+module AwesomeExplain
+  class Config
+    include Singleton
+    attr_reader :db_name,
+      :db_path,
+      :rails_path,
+      :enabled,
+      :active_record_enabled,
+      :include_full_plan,
+      :max_limit,
+      :app_name,
+      :logger,
+      :queue,
+      :logs,
+      :adapter
+
+    DEFAULT_DB_NAME = :awesome_explain
+    POSTGRES_DEV_DBNAME = 'awesome_explain_development'
+    POSTGRES_DEFAULT_HOST = 'localhost'
+    POSTGRES_DEFAULT_USERNAME = 'postgres'
+    POSTGRES_DEFAULT_PASSWORD = 'postgres'
+    DEFAULT_DB_PATH = './log'
+
+    alias :enabled? :enabled
+    alias :active_record_enabled? :active_record_enabled
+
+    def self.configure(&block)
+      raise NoBlockGivenException unless block_given?
+
+      instance = Config.instance
+      instance.instance_eval(&block)
+      instance.init
+
+      instance
+    end
+
+    def init
+      return unless enabled
+      @logs = []
+
+      if Rails.env.development?
+        # Misc
+        ActiveSupport::Notifications.subscribe 'start_processing.action_controller' do |*args|
+          data = args.extract_options!
+          unless data[:controller] =~ /AwesomeExplain/ || data[:controller] =~ /ErrorsController/ || data[:path] =~ /awesome_explain/
+            Thread.current[:ae_controller_data] = data
+          end
+          Thread.current[:ae_session_id] = SecureRandom.uuid
+        end
+
+        ActiveSupport::Notifications.subscribe 'process_action.action_controller' do |*args|
+          Thread.current[:ae_session_id] = nil
+        end
+
+        # Mongoid
+        if Rails.const_defined?('Mongo') && Rails.const_defined?('Mongoid')
+          command_subscribers = Mongo::Monitoring::Global.subscribers.dig('Command')
+          if command_subscribers.nil? || !command_subscribers.collect(&:class).include?(AwesomeExplain::Subscribers::CommandSubscriber)
+            command_subscriber = AwesomeExplain::Subscribers::CommandSubscriber.new
+            begin
+              Mongoid.default_client.subscribe(Mongo::Monitoring::COMMAND, command_subscriber)
+            rescue => exception
+              Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::COMMAND, command_subscriber)
+            end
+          end
+        end
+
+        # ActiveRecord
+        if active_record_enabled
+          ::AwesomeExplain::Subscribers::ActiveRecordSubscriber.attach_to :active_record
+        end
+      end
+    end
+
+    def connection
+      # TODO: Improve this condition
+      if AwesomeExplain::Config.rails4?
+        connection = ::ActiveRecord::Base.connection_handler.connection_pools.first.last.connection
+      else
+        connection = ::ActiveRecord::Base.connection_handler.connection_pools.select do |cp|
+          !cp.connection.current_database.match(/awesome_explain/)
+        end.first.connection
+      end
+
+      connection
+    end
+
+    def db_config
+      adapter == :postgres ? postgres_config : sqlite3_config
+    end
+
+    def postgres_config
+      {
+        ae_development: {
+          adapter: 'postgresql',
+          encoding: 'utf8',
+          host: postgres_host || POSTGRES_DEFAULT_HOST,
+          database: POSTGRES_DEV_DBNAME,
+          username: postgres_username || POSTGRES_DEFAULT_USERNAME,
+          password: postgres_password || POSTGRES_DEFAULT_PASSWORD,
+          pool: 5,
+          timeout: 5000,
+        },
+        ae_staging: {
+          adapter: 'postgresql',
+          encoding: 'utf8',
+          host: postgres_host || POSTGRES_DEFAULT_HOST,
+          database: POSTGRES_DEV_DBNAME,
+          username: postgres_username || POSTGRES_DEFAULT_USERNAME,
+          password: postgres_password || POSTGRES_DEFAULT_PASSWORD,
+          pool: 5,
+          timeout: 5000,
+        }
+      }.with_indifferent_access["ae_#{Rails.env}"]
+    end
+
+    def sqlite3_config
+      {
+        ae_development: {
+          adapter: 'sqlite3',
+          database: "#{db_path || './log'}/ae.db",
+          pool: 5,
+          timeout: 5000,
+        }
+      }.with_indifferent_access["ae_#{Rails.env}"]
+    end
+
+    def self.rails4?
+      Rails.version.start_with? '4'
+    end
+
+    def db_name=(value = DEFAULT_DB_NAME)
+      @db_name = "#{value.to_s}.db"
+    end
+
+    def db_path=(value = DEFAULT_DB_PATH)
+      @db_path = value
+    end
+
+    def rails_path=(value)
+      @rails_path = value
+    end
+
+    def enabled=(value = false)
+      @enabled = value
+    end
+
+    def active_record_enabled=(value = false)
+      @active_record_enabled = value
+    end
+
+    def include_full_plan=(value = false)
+      @include_full_plan = value
+    end
+
+    def max_limit=(value = :unlimited)
+      @max_limit = value
+    end
+
+    def app_name=(value = :rails)
+      @app_name = value
+    end
+
+    def logger=(value = nil)
+      @logger = value.nil? ? Logger.new(STDOUT) : value
+    end
+
+    def adapter=(value = :sqlite)
+      @adapter = value
+    end
+
+    def postgres_host=(value = 'localhost')
+      @postgres_host = value
+    end
+
+    def postgres_host
+      @postgres_host || 'localhost'
+    end
+
+    def postgres_username=(value = 'postgres')
+      @postgres_username = value
+    end
+
+    def postgres_username
+      @postgres_username || 'postgres'
+    end
+
+    def postgres_password=(value = 'postgres')
+      @postgres_password = value
+    end
+
+    def postgres_password
+      @postgres_password || 'postgres'
+    end
+  end
+end

data/lib/awesome_explain/engine.rb

@@ -0,0 +1,5 @@
+module AwesomeExplain
+  class Engine < ::Rails::Engine
+    isolate_namespace AwesomeExplain
+  end
+end

data/lib/awesome_explain/insights/active_record_insights.rb

@@ -0,0 +1,137 @@
+module AwesomeExplain::Insights
+  class ActiveRecordInsights
+    attr_accessor :options, :active_record_subscriber
+
+    def self.analyze(options, &block)
+      instance = new
+      instance.init
+      instance.options = options
+      block_result = instance.instance_eval(&block)
+      instance.tear_down
+      block_result
+    end
+
+    def init
+      subscribed = ::ActiveRecord::LogSubscriber.log_subscribers.select do |s|
+        s.is_a?(::AwesomeExplain::Subscribers::ActiveRecordPassiveSubscriber)
+      end.size.positive?
+
+      unless subscribed
+        SqlPlansInsights.clear
+        ::AwesomeExplain::Subscribers::ActiveRecordPassiveSubscriber.attach_to(
+          :active_record
+        )
+      end
+
+      Thread.current['ae_analyze'] = true
+      Thread.current['ae_source'] = 'console'
+    end
+
+    def print_sql?
+      options.dig(:print) == true
+    end
+
+    def tear_down
+      if SqlPlansInsights.plans_stats.size.positive?
+        SqlPlansInsights.queries.each do |query|
+          puts query
+        end if print_sql?
+
+        table = Terminal::Table.new do |t|
+          t << ['Time (sec)', total_time]
+          t << :separator
+          t << ['Total Rows Planned', total_rows_planned]
+          t << :separator
+          t << ['Total Rows', total_rows]
+          t << :separator
+          t << total_loops_row
+          t << :separator
+          t << seq_scans_row
+          t << :separator
+          t << ['Tables', tables]
+          t << :separator
+          t << ['Node Types', node_types]
+          t << :separator
+          t << ['Indexes', indexes]
+        end
+        puts table
+      end
+      SqlPlansInsights.clear
+      Thread.current['ae_analyze'] = false
+      Thread.current['ae_source'] = nil
+    end
+
+    def total_time
+      stats = SqlPlansInsights.plans_stats.map do |ps|
+        ps.table_stats if ps.table_stats.size.positive?
+      end.compact
+
+      time = stats.sum do |table_stat|
+        table_stat.values.first.dig(:time)
+      end
+
+      (time / 1000).round(3)
+    end
+
+    def total_rows_planned
+      SqlPlansInsights.plans_stats.sum { |ps| ps.total_rows_planned }
+    end
+
+    def total_rows
+      SqlPlansInsights.plans_stats.sum { |ps| ps.total_rows }
+    end
+
+    def total_loops
+      SqlPlansInsights.plans_stats.sum { |ps| ps.total_loops }
+    end
+
+    def seq_scans
+      SqlPlansInsights.plans_stats.sum { |ps| ps.seq_scans }
+    end
+
+    def tables
+      stats = SqlPlansInsights.plans_stats.map do |ps|
+        ps.table_stats if ps.table_stats.size.positive?
+      end.compact
+
+      stats.inject(Hash.new(0)) do |h, s|
+        h[s.keys.first] += s[s.keys.first].dig(:count)
+        h
+      end&.map {|s| "#{s.first} (#{s.last})"}&.join("\n")
+    end
+
+    def node_types
+      SqlPlansInsights.plans_stats.map do |ps|
+        ps.node_type_stats
+      end.inject(Hash.new(0)) do |h, s|
+        h[s.keys.first] += s[s.keys.first].dig(:count)
+        h
+      end&.map {|s| "#{s.first} (#{s.last})"}&.join("\n")
+    end
+
+    def indexes
+      stats = SqlPlansInsights.plans_stats.map do |ps|
+        ps.index_stats if ps.index_stats.size.positive?
+      end.compact
+
+      stats.inject(Hash.new(0)) do |h, s|
+        h[s.keys.first] += s[s.keys.first].dig(:count)
+        h
+      end&.map {|s| "#{s.first} (#{s.last})"}&.join("\n")
+    end
+
+    def total_loops_row
+      color = total_loops >= 100 ? :red : :green
+      title = AwesomeExplain::Utils::Color.fg_color color, 'Total Loops'
+      value = AwesomeExplain::Utils::Color.fg_color color, total_loops.to_s
+      [title, value]
+    end
+
+    def seq_scans_row
+      color = seq_scans >= 1 ? :cyan : :green
+      title = AwesomeExplain::Utils::Color.fg_color color, 'Seq Scans'
+      value = AwesomeExplain::Utils::Color.fg_color color, seq_scans.to_s
+      [title, value]
+    end
+  end
+end

data/lib/awesome_explain/insights/base.rb

@@ -0,0 +1,18 @@
+require 'awesome_explain/insights/sql_plans_insights'
+require 'awesome_explain/insights/mongoid_insights'
+require 'awesome_explain/insights/active_record_insights'
+
+
+module AwesomeExplain::Insights
+  class Base
+    attr_accessor :command_subscriber, :metrics
+
+    def self.analyze_mongoid(metrics = [], &block)
+      MongoidInsights.analyze(metrics, block)
+    end
+
+    def self.analyze_ar(&block)
+      ActiveRecordInsights.analyze(&block)
+    end
+  end
+end