pghero 1.2.2 → 1.2.3

data/lib/pghero/connection.rb

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

data/lib/pghero/database.rb

@@ -5,17 +5,26 @@ module PgHero
     def initialize(id, config)
       @id = id
       @config = config
-      @connection_model =
+    end
+
+    def connection_model
+      @connection_model ||= begin
+        url = config["url"]
         Class.new(PgHero::Connection) do
           def self.name
             "PgHero::Connection::#{object_id}"
           end
-          establish_connection(config["url"]) if config["url"]
+          establish_connection(url) if url
         end
+      end
     end
 
     def db_instance_identifier
-      @config["db_instance_identifier"]
+      @db_instance_identifier ||= @config["db_instance_identifier"]
+    end
+
+    def name
+      @name ||= @config["name"] || id.titleize
     end
   end
 end

data/lib/pghero/methods/basic.rb

@@ -0,0 +1,104 @@
+module PgHero
+  module Methods
+    module Basic
+      def time_zone=(time_zone)
+        @time_zone = time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone[time_zone.to_s]
+      end
+
+      def time_zone
+        @time_zone || Time.zone
+      end
+
+      def config
+        Thread.current[:pghero_config] ||= begin
+          path = "config/pghero.yml"
+
+          config =
+            (YAML.load(ERB.new(File.read(path)).result)[env] if File.exist?(path))
+
+          if config
+            config
+          else
+            {
+              "databases" => {
+                "primary" => {
+                  "url" => ENV["PGHERO_DATABASE_URL"] || ActiveRecord::Base.connection_config,
+                  "db_instance_identifier" => ENV["PGHERO_DB_INSTANCE_IDENTIFIER"]
+                }
+              }
+            }
+          end
+        end
+      end
+
+      def settings
+        names = %w(
+          max_connections shared_buffers effective_cache_size work_mem
+          maintenance_work_mem checkpoint_segments checkpoint_completion_target
+          wal_buffers default_statistics_target
+        )
+        values = Hash[select_all(connection_model.send(:sanitize_sql_array, ["SELECT name, setting, unit FROM pg_settings WHERE name IN (?)", names])).sort_by { |row| names.index(row["name"]) }.map { |row| [row["name"], friendly_value(row["setting"], row["unit"])] }]
+        Hash[names.map { |name| [name, values[name]] }]
+      end
+
+      def ssl_used?
+        ssl_used = nil
+        connection_model.transaction do
+          execute("CREATE EXTENSION IF NOT EXISTS sslinfo")
+          ssl_used = select_all("SELECT ssl_is_used()").first["ssl_is_used"] == "t"
+          raise ActiveRecord::Rollback
+        end
+        ssl_used
+      end
+
+      private
+
+      def friendly_value(setting, unit)
+        if %w(kB 8kB).include?(unit)
+          value = setting.to_i
+          value *= 8 if unit == "8kB"
+
+          if value % (1024 * 1024) == 0
+            "#{value / (1024 * 1024)}GB"
+          elsif value % 1024 == 0
+            "#{value / 1024}MB"
+          else
+            "#{value}kB"
+          end
+        else
+          "#{setting}#{unit}".strip
+        end
+      end
+
+      def select_all(sql)
+        # squish for logs
+        connection.select_all(squish(sql)).to_a
+      end
+
+      def execute(sql)
+        connection.execute(sql)
+      end
+
+      def connection_model
+        databases[current_database].connection_model
+      end
+
+      def connection
+        connection_model.connection
+      end
+
+      # from ActiveSupport
+      def squish(str)
+        str.to_s.gsub(/\A[[:space:]]+/, "").gsub(/[[:space:]]+\z/, "").gsub(/[[:space:]]+/, " ")
+      end
+
+      def quote(value)
+        connection.quote(value)
+      end
+
+      def quote_table_name(value)
+        connection.quote_table_name(value)
+      end
+    end
+  end
+end

data/lib/pghero/methods/connections.rb

@@ -0,0 +1,49 @@
+module PgHero
+  module Methods
+    module Connections
+      def total_connections
+        select_all("SELECT COUNT(*) FROM pg_stat_activity WHERE pid <> pg_backend_pid()").first["count"].to_i
+      end
+
+      def connection_sources(options = {})
+        if options[:by_database]
+          select_all <<-SQL
+            SELECT
+              application_name AS source,
+              client_addr AS ip,
+              datname AS database,
+              COUNT(*) AS total_connections
+            FROM
+              pg_stat_activity
+            WHERE
+              pid <> pg_backend_pid()
+            GROUP BY
+              1, 2, 3
+            ORDER BY
+              COUNT(*) DESC,
+              application_name ASC,
+              client_addr ASC
+          SQL
+        else
+          select_all <<-SQL
+            SELECT
+              application_name AS source,
+              client_addr AS ip,
+              COUNT(*) AS total_connections
+            FROM
+              pg_stat_activity
+            WHERE
+              pid <> pg_backend_pid()
+            GROUP BY
+              application_name,
+              ip
+            ORDER BY
+              COUNT(*) DESC,
+              application_name ASC,
+              client_addr ASC
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/pghero/methods/databases.rb

@@ -0,0 +1,39 @@
+module PgHero
+  module Methods
+    module Databases
+      def databases
+        @databases ||= begin
+          Hash[
+            config["databases"].map do |id, c|
+              [id, PgHero::Database.new(id, c)]
+            end
+          ]
+        end
+      end
+
+      def primary_database
+        databases.keys.first
+      end
+
+      def current_database
+        Thread.current[:pghero_current_database] ||= primary_database
+      end
+
+      def current_database=(database)
+        raise "Database not found" unless databases[database]
+        Thread.current[:pghero_current_database] = database.to_s
+        database
+      end
+
+      def with(database)
+        previous_database = current_database
+        begin
+          self.current_database = database
+          yield
+        ensure
+          self.current_database = previous_database
+        end
+      end
+    end
+  end
+end

data/lib/pghero/methods/explain.rb

@@ -0,0 +1,29 @@
+module PgHero
+  module Methods
+    module Explain
+      def explain(sql)
+        sql = squish(sql)
+        explanation = nil
+        explain_safe = explain_safe?
+
+        # use transaction for safety
+        connection_model.transaction do
+          if !explain_safe && (sql.sub(/;\z/, "").include?(";") || sql.upcase.include?("COMMIT"))
+            raise ActiveRecord::StatementInvalid, "Unsafe statement"
+          end
+          explanation = select_all("EXPLAIN #{sql}").map { |v| v["QUERY PLAN"] }.join("\n")
+          raise ActiveRecord::Rollback
+        end
+
+        explanation
+      end
+
+      def explain_safe?
+        select_all("SELECT 1; SELECT 1")
+        false
+      rescue ActiveRecord::StatementInvalid
+        true
+      end
+    end
+  end
+end

data/lib/pghero/methods/indexes.rb

@@ -0,0 +1,154 @@
+module PgHero
+  module Methods
+    module Indexes
+      def index_hit_rate
+        select_all(<<-SQL
+          SELECT
+            (sum(idx_blks_hit)) / nullif(sum(idx_blks_hit + idx_blks_read), 0) AS rate
+          FROM
+            pg_statio_user_indexes
+        SQL
+        ).first["rate"].to_f
+      end
+
+      def index_caching
+        select_all <<-SQL
+          SELECT
+            indexrelname AS index,
+            relname AS table,
+            CASE WHEN idx_blks_hit + idx_blks_read = 0 THEN
+              0
+            ELSE
+              ROUND(1.0 * idx_blks_hit / (idx_blks_hit + idx_blks_read), 2)
+            END AS hit_rate
+          FROM
+            pg_statio_user_indexes
+          ORDER BY
+            3 DESC, 1
+        SQL
+      end
+
+      def index_usage
+        select_all <<-SQL
+          SELECT
+            schemaname AS schema,
+            relname AS table,
+            CASE idx_scan
+              WHEN 0 THEN 'Insufficient data'
+              ELSE (100 * idx_scan / (seq_scan + idx_scan))::text
+            END percent_of_times_index_used,
+            n_live_tup rows_in_table
+          FROM
+            pg_stat_user_tables
+          ORDER BY
+            n_live_tup DESC,
+            relname ASC
+         SQL
+      end
+
+      def missing_indexes
+        select_all <<-SQL
+          SELECT
+            schemaname AS schema,
+            relname AS table,
+            CASE idx_scan
+              WHEN 0 THEN 'Insufficient data'
+              ELSE (100 * idx_scan / (seq_scan + idx_scan))::text
+            END percent_of_times_index_used,
+            n_live_tup rows_in_table
+          FROM
+            pg_stat_user_tables
+          WHERE
+            idx_scan > 0
+            AND (100 * idx_scan / (seq_scan + idx_scan)) < 95
+            AND n_live_tup >= 10000
+          ORDER BY
+            n_live_tup DESC,
+            relname ASC
+         SQL
+      end
+
+      def unused_indexes
+        select_all <<-SQL
+          SELECT
+            schemaname AS schema,
+            relname AS table,
+            indexrelname AS index,
+            pg_size_pretty(pg_relation_size(i.indexrelid)) AS index_size,
+            idx_scan as index_scans
+          FROM
+            pg_stat_user_indexes ui
+          INNER JOIN
+            pg_index i ON ui.indexrelid = i.indexrelid
+          WHERE
+            NOT indisunique
+            AND idx_scan < 50
+          ORDER BY
+            pg_relation_size(i.indexrelid) DESC,
+            relname ASC
+        SQL
+      end
+
+      def invalid_indexes
+        select_all <<-SQL
+          SELECT
+            c.relname AS index
+          FROM
+            pg_catalog.pg_class c,
+            pg_catalog.pg_namespace n,
+            pg_catalog.pg_index i
+          WHERE
+            i.indisvalid = false
+            AND i.indexrelid = c.oid
+            AND c.relnamespace = n.oid
+            AND n.nspname != 'pg_catalog'
+            AND n.nspname != 'information_schema'
+            AND n.nspname != 'pg_toast'
+          ORDER BY
+            c.relname
+        SQL
+      end
+
+      # TODO parse array properly
+      # http://stackoverflow.com/questions/2204058/list-columns-with-indexes-in-postgresql
+      def indexes
+        select_all(<<-SQL
+          SELECT
+            t.relname AS table,
+            ix.relname AS name,
+            regexp_replace(pg_get_indexdef(indexrelid), '^[^\\(]*\\((.*)\\)$', '\\1') AS columns,
+            regexp_replace(pg_get_indexdef(indexrelid), '.* USING ([^ ]*) \\(.*', '\\1') AS using,
+            indisunique AS unique,
+            indisprimary AS primary,
+            indisvalid AS valid,
+            indexprs::text,
+            indpred::text,
+            pg_get_indexdef(indexrelid) AS definition
+          FROM
+            pg_index i
+          INNER JOIN
+            pg_class t ON t.oid = i.indrelid
+          INNER JOIN
+            pg_class ix ON ix.oid = i.indexrelid
+          ORDER BY
+            1, 2
+        SQL
+        ).map { |v| v["columns"] = v["columns"].sub(") WHERE (", " WHERE ").split(", "); v }
+      end
+
+      def duplicate_indexes
+        indexes = []
+
+        indexes_by_table = self.indexes.group_by { |i| i["table"] }
+        indexes_by_table.values.flatten.select { |i| i["primary"] == "f" && i["unique"] == "f" && !i["indexprs"] && !i["indpred"] && i["valid"] == "t" }.each do |index|
+          covering_index = indexes_by_table[index["table"]].find { |i| index_covers?(i["columns"], index["columns"]) && i["using"] == index["using"] && i["name"] != index["name"] && i["valid"] == "t" }
+          if covering_index
+            indexes << {"unneeded_index" => index, "covering_index" => covering_index}
+          end
+        end
+
+        indexes.sort_by { |i| ui = i["unneeded_index"]; [ui["table"], ui["columns"]] }
+      end
+    end
+  end
+end

data/lib/pghero/methods/kill.rb

@@ -0,0 +1,27 @@
+module PgHero
+  module Methods
+    module Kill
+      def kill(pid)
+        execute("SELECT pg_terminate_backend(#{pid.to_i})").first["pg_terminate_backend"] == "t"
+      end
+
+      def kill_long_running_queries
+        long_running_queries.each { |query| kill(query["pid"]) }
+        true
+      end
+
+      def kill_all
+        select_all <<-SQL
+          SELECT
+            pg_terminate_backend(pid)
+          FROM
+            pg_stat_activity
+          WHERE
+            pid <> pg_backend_pid()
+            AND query <> '<insufficient privilege>'
+        SQL
+        true
+      end
+    end
+  end
+end