pghero 2.2.1 → 2.7.0

data/lib/pghero/methods/constraints.rb

@@ -0,0 +1,30 @@
+module PgHero
+  module Methods
+    module Constraints
+      # referenced fields can be nil
+      # as not all constraints are foreign keys
+      def invalid_constraints
+        select_all <<-SQL
+          SELECT
+            nsp.nspname AS schema,
+            rel.relname AS table,
+            con.conname AS name,
+            fnsp.nspname AS referenced_schema,
+            frel.relname AS referenced_table
+          FROM
+            pg_catalog.pg_constraint con
+          INNER JOIN
+            pg_catalog.pg_class rel ON rel.oid = con.conrelid
+          LEFT JOIN
+            pg_catalog.pg_class frel ON frel.oid = con.confrelid
+          LEFT JOIN
+            pg_catalog.pg_namespace nsp ON nsp.oid = con.connamespace
+          LEFT JOIN
+            pg_catalog.pg_namespace fnsp ON fnsp.oid = frel.relnamespace
+          WHERE
+            con.convalidated = 'f'
+        SQL
+      end
+    end
+  end
+end

data/lib/pghero/methods/explain.rb

@@ -6,7 +6,7 @@ module PgHero
         explanation = nil
 
         # use transaction for safety
-        with_transaction(statement_timeout: (explain_timeout_sec * 1000), rollback: true) do
+        with_transaction(statement_timeout: (explain_timeout_sec * 1000).round, rollback: true) do
           if (sql.sub(/;\z/, "").include?(";") || sql.upcase.include?("COMMIT")) && !explain_safe?
             raise ActiveRecord::StatementInvalid, "Unsafe statement"
           end

data/lib/pghero/methods/indexes.rb

@@ -195,7 +195,7 @@ module PgHero
             FROM
               pg_index
             JOIN
-              pg_class ON pg_class.oid=pg_index.indexrelid
+              pg_class ON pg_class.oid = pg_index.indexrelid
             JOIN
               pg_namespace ON pg_namespace.oid = pg_class.relnamespace
             JOIN

data/lib/pghero/methods/maintenance.rb

@@ -57,7 +57,9 @@ module PgHero
             last_vacuum,
             last_autovacuum,
             last_analyze,
-            last_autoanalyze
+            last_autoanalyze,
+            n_dead_tup AS dead_rows,
+            n_live_tup AS live_rows
           FROM
             pg_stat_user_tables
           ORDER BY

data/lib/pghero/methods/queries.rb

@@ -2,7 +2,7 @@ module PgHero
   module Methods
     module Queries
       def running_queries(min_duration: nil, all: false)
-        select_all <<-SQL
+        query = <<-SQL
           SELECT
             pid,
             state,
@@ -24,6 +24,8 @@ module PgHero
           ORDER BY
             COALESCE(query_start, xact_start) DESC
         SQL
+
+        select_all(query, query_columns: [:query])
       end
 
       def long_running_queries
@@ -31,9 +33,9 @@ module PgHero
       end
 
       # from https://wiki.postgresql.org/wiki/Lock_Monitoring
-      # and http://big-elephants.com/2013-09/exploring-query-locks-in-postgres/
+      # and https://big-elephants.com/2013-09/exploring-query-locks-in-postgres/
       def blocked_queries
-        select_all <<-SQL
+        query = <<-SQL
           SELECT
             COALESCE(blockingl.relation::regclass::text,blockingl.locktype) as locked_item,
             blockeda.pid AS blocked_pid,
@@ -65,6 +67,8 @@ module PgHero
           ORDER BY
             blocked_duration DESC
         SQL
+
+        select_all(query, query_columns: [:blocked_query, :current_or_recent_query_in_blocking_process])
       end
     end
   end

data/lib/pghero/methods/query_stats.rb

@@ -2,7 +2,7 @@ module PgHero
   module Methods
     module QueryStats
       def query_stats(historical: false, start_at: nil, end_at: nil, min_average_time: nil, min_calls: nil, **options)
-        current_query_stats = historical && end_at && end_at < Time.now ? [] : current_query_stats(options)
+        current_query_stats = historical && end_at && end_at < Time.now ? [] : current_query_stats(**options)
         historical_query_stats = historical && historical_query_stats_enabled? ? historical_query_stats(start_at: start_at, end_at: end_at, **options) : []
 
         query_stats = combine_query_stats((current_query_stats + historical_query_stats).group_by { |q| [q[:query_hash], q[:user]] })
@@ -56,8 +56,46 @@ module PgHero
         true
       end
 
-      def reset_query_stats(raise_errors: false)
-        execute("SELECT pg_stat_statements_reset()")
+      # TODO scope by database in PgHero 3.0
+      # (add database: database_name to options)
+      def reset_query_stats(**options)
+        reset_instance_query_stats(**options)
+      end
+
+      # resets query stats for the entire instance
+      # it's possible to reset stats for a specific
+      # database, user or query hash in Postgres 12+
+      def reset_instance_query_stats(database: nil, user: nil, query_hash: nil, raise_errors: false)
+        if database || user || query_hash
+          raise PgHero::Error, "Requires PostgreSQL 12+" if server_version_num < 120000
+
+          if database
+            database_id = execute("SELECT oid FROM pg_database WHERE datname = #{quote(database)}").first.try(:[], "oid")
+            raise PgHero::Error, "Database not found: #{database}" unless database_id
+          else
+            database_id = 0
+          end
+
+          if user
+            user_id = execute("SELECT usesysid FROM pg_user WHERE usename = #{quote(user)}").first.try(:[], "usesysid")
+            raise PgHero::Error, "User not found: #{user}" unless user_id
+          else
+            user_id = 0
+          end
+
+          if query_hash
+            query_id = query_hash.to_i
+            # may not be needed
+            # but not intuitive that all query hashes are reset with 0
+            raise PgHero::Error, "Invalid query hash: #{query_hash}" if query_id == 0
+          else
+            query_id = 0
+          end
+
+          execute("SELECT pg_stat_statements_reset(#{quote(user_id.to_i)}, #{quote(database_id.to_i)}, #{quote(query_id.to_i)})")
+        else
+          execute("SELECT pg_stat_statements_reset()")
+        end
         true
       rescue ActiveRecord::StatementInvalid => e
         raise e if raise_errors
@@ -104,31 +142,32 @@ module PgHero
           query_stats[database_id] = query_stats(limit: 1000000, database: database_name)
         end
 
-        supports_query_hash = supports_query_hash?
+        query_stats = query_stats.select { |_, v| v.any? }
+
+        # nothing to do
+        return if query_stats.empty?
 
-        if query_stats.any? { |_, v| v.any? } && reset_query_stats(raise_errors: raise_errors)
+        # use mapping, not query stats here
+        # TODO add option for this, and make default in PgHero 3.0
+        if false # mapping.size == 1 && server_version_num >= 120000
           query_stats.each do |db_id, db_query_stats|
-            if db_query_stats.any?
-              values =
-                db_query_stats.map do |qs|
-                  [
-                    db_id,
-                    qs[:query],
-                    qs[:total_minutes] * 60 * 1000,
-                    qs[:calls],
-                    now,
-                    supports_query_hash ? qs[:query_hash] : nil,
-                    qs[:user]
-                  ]
-                end
-
-              columns = %w[database query total_time calls captured_at query_hash user]
-              insert_stats("pghero_query_stats", columns, values)
+            if reset_query_stats(database: mapping[db_id], raise_errors: raise_errors)
+              insert_query_stats(db_id, db_query_stats, now)
+            end
+          end
+        else
+          if reset_query_stats(raise_errors: raise_errors)
+            query_stats.each do |db_id, db_query_stats|
+              insert_query_stats(db_id, db_query_stats, now)
             end
           end
         end
       end
 
+      def clean_query_stats
+        PgHero::QueryStats.where(database: id).where("captured_at < ?", 14.days.ago).delete_all
+      end
+
       def slow_queries(query_stats: nil, **options)
         query_stats ||= self.query_stats(options)
         query_stats.select { |q| q[:calls].to_i >= slow_query_calls.to_i && q[:average_time].to_f >= slow_query_ms.to_f }
@@ -166,14 +205,15 @@ module PgHero
         if query_stats_enabled?
           limit ||= 100
           sort ||= "total_minutes"
-          select_all <<-SQL
+          total_time = server_version_num >= 130000 ? "(total_plan_time + total_exec_time)" : "total_time"
+          query = <<-SQL
             WITH query_stats AS (
               SELECT
                 LEFT(query, 10000) AS query,
                 #{supports_query_hash? ? "queryid" : "md5(query)"} AS query_hash,
                 rolname AS user,
-                (total_time / 1000 / 60) AS total_minutes,
-                (total_time / calls) AS average_time,
+                (#{total_time} / 1000 / 60) AS total_minutes,
+                (#{total_time} / calls) AS average_time,
                 calls
               FROM
                 pg_stat_statements
@@ -182,6 +222,7 @@ module PgHero
               INNER JOIN
                 pg_roles ON pg_roles.oid = pg_stat_statements.userid
               WHERE
+                calls > 0 AND
                 pg_database.datname = #{database ? quote(database) : "current_database()"}
                 #{query_hash ? "AND queryid = #{quote(query_hash)}" : nil}
             )
@@ -200,6 +241,11 @@ module PgHero
               #{quote_table_name(sort)} DESC
             LIMIT #{limit.to_i}
           SQL
+
+          # we may be able to skip query_columns
+          # in more recent versions of Postgres
+          # as pg_stat_statements should be already normalized
+          select_all(query, query_columns: [:query])
         else
           raise NotEnabled, "Query stats not enabled"
         end
@@ -208,7 +254,7 @@ module PgHero
       def historical_query_stats(sort: nil, start_at: nil, end_at: nil, query_hash: nil)
         if historical_query_stats_enabled?
           sort ||= "total_minutes"
-          select_all_stats <<-SQL
+          query = <<-SQL
             WITH query_stats AS (
               SELECT
                 #{supports_query_hash? ? "query_hash" : "md5(query)"} AS query_hash,
@@ -244,6 +290,10 @@ module PgHero
               #{quote_table_name(sort)} DESC
             LIMIT 100
           SQL
+
+          # we can skip query_columns if all stored data is normalized
+          # for now, assume it's not
+          select_all_stats(query, query_columns: [:query, :explainable_query])
         else
           raise NotEnabled, "Historical query stats not enabled"
         end
@@ -276,6 +326,24 @@ module PgHero
       def normalize_query(query)
         squish(query.to_s.gsub(/\?(, ?\?)+/, "?").gsub(/\/\*.+?\*\//, ""))
       end
+
+      def insert_query_stats(db_id, db_query_stats, now)
+        values =
+          db_query_stats.map do |qs|
+            [
+              db_id,
+              qs[:query],
+              qs[:total_minutes] * 60 * 1000,
+              qs[:calls],
+              now,
+              supports_query_hash? ? qs[:query_hash] : nil,
+              qs[:user]
+            ]
+          end
+
+        columns = %w[database query total_time calls captured_at query_hash user]
+        insert_stats("pghero_query_stats", columns, values)
+      end
     end
   end
 end

data/lib/pghero/methods/sequences.rb

@@ -25,7 +25,7 @@ module PgHero
           WHERE
             NOT a.attisdropped
             AND a.attnum > 0
-            AND d.adsrc LIKE 'nextval%'
+            AND pg_get_expr(d.adbin, d.adrelid) LIKE 'nextval%'
             AND n.nspname NOT LIKE 'pg\\_temp\\_%'
         SQL
 

data/lib/pghero/methods/space.rb

@@ -129,6 +129,10 @@ module PgHero
         insert_stats("pghero_space_stats", columns, values) if values.any?
       end
 
+      def clean_space_stats
+        PgHero::SpaceStats.where(database: id).where("captured_at < ?", 90.days.ago).delete_all
+      end
+
       def space_stats_enabled?
         table_exists?("pghero_space_stats")
       end

data/lib/pghero/methods/suggested_indexes.rb

@@ -48,7 +48,7 @@ module PgHero
       def suggested_indexes(suggested_indexes_by_query: nil, **options)
         indexes = []
 
-        (suggested_indexes_by_query || self.suggested_indexes_by_query(options)).select { |_s, i| i[:found] && !i[:covering_index] }.group_by { |_s, i| i[:index] }.each do |index, group|
+        (suggested_indexes_by_query || self.suggested_indexes_by_query(**options)).select { |_s, i| i[:found] && !i[:covering_index] }.group_by { |_s, i| i[:index] }.each do |index, group|
           details = {}
           group.map(&:second).each do |g|
             details = details.except(:index).deep_merge(g)

data/lib/pghero/methods/system.rb

@@ -1,31 +1,46 @@
 module PgHero
   module Methods
     module System
+      def system_stats_enabled?
+        !system_stats_provider.nil?
+      end
+
+      # TODO remove defined checks in 3.0
+      def system_stats_provider
+        if aws_db_instance_identifier && (defined?(Aws) || defined?(AWS))
+          :aws
+        elsif gcp_database_id
+          :gcp
+        elsif azure_resource_id
+          :azure
+        end
+      end
+
       def cpu_usage(**options)
-        rds_stats("CPUUtilization", options)
+        system_stats(:cpu, **options)
       end
 
       def connection_stats(**options)
-        rds_stats("DatabaseConnections", options)
+        system_stats(:connections, **options)
       end
 
       def replication_lag_stats(**options)
-        rds_stats("ReplicaLag", options)
+        system_stats(:replication_lag, **options)
       end
 
       def read_iops_stats(**options)
-        rds_stats("ReadIOPS", options)
+        system_stats(:read_iops, **options)
       end
 
       def write_iops_stats(**options)
-        rds_stats("WriteIOPS", options)
+        system_stats(:write_iops, **options)
       end
 
       def free_space_stats(**options)
-        rds_stats("FreeStorageSpace", options)
+        system_stats(:free_space, **options)
       end
 
-      def rds_stats(metric_name, duration: nil, period: nil, offset: nil)
+      def rds_stats(metric_name, duration: nil, period: nil, offset: nil, series: false)
         if system_stats_enabled?
           aws_options = {region: region}
           if access_key_id
@@ -43,16 +58,14 @@ module PgHero
           duration = (duration || 1.hour).to_i
           period = (period || 1.minute).to_i
           offset = (offset || 0).to_i
-
-          end_time = (Time.now - offset)
-          # ceil period
-          end_time = Time.at((end_time.to_f / period).ceil * period)
+          end_time = Time.at(((Time.now - offset).to_f / period).ceil * period)
+          start_time = end_time - duration
 
           resp = client.get_metric_statistics(
             namespace: "AWS/RDS",
             metric_name: metric_name,
-            dimensions: [{name: "DBInstanceIdentifier", value: db_instance_identifier}],
-            start_time: (end_time - duration).iso8601,
+            dimensions: [{name: "DBInstanceIdentifier", value: aws_db_instance_identifier}],
+            start_time: start_time.iso8601,
             end_time: end_time.iso8601,
             period: period,
             statistics: ["Average"]
@@ -61,30 +74,213 @@ module PgHero
           resp[:datapoints].sort_by { |d| d[:timestamp] }.each do |d|
             data[d[:timestamp]] = d[:average]
           end
+
+          add_missing_data(data, start_time, end_time, period) if series
+
           data
         else
           raise NotEnabled, "System stats not enabled"
         end
       end
 
-      def system_stats_enabled?
-        !!((defined?(Aws) || defined?(AWS)) && db_instance_identifier)
+      def azure_stats(metric_name, duration: nil, period: nil, offset: nil, series: false)
+        # TODO DRY with RDS stats
+        duration = (duration || 1.hour).to_i
+        period = (period || 1.minute).to_i
+        offset = (offset || 0).to_i
+        end_time = Time.at(((Time.now - offset).to_f / period).ceil * period)
+        start_time = end_time - duration
+
+        interval =
+          case period
+          when 60
+            "PT1M"
+          when 300
+            "PT5M"
+          when 900
+            "PT15M"
+          when 1800
+            "PT30M"
+          when 3600
+            "PT1H"
+          else
+            raise Error, "Unsupported period"
+          end
+
+        client = Azure::Monitor::Profiles::Latest::Mgmt::Client.new
+        timespan = "#{start_time.iso8601}/#{end_time.iso8601}"
+        results = client.metrics.list(
+          azure_resource_id,
+          metricnames: metric_name,
+          aggregation: "Average",
+          timespan: timespan,
+          interval: interval
+        )
+
+        data = {}
+        result = results.value.first
+        if result
+          result.timeseries.first.data.each do |point|
+            data[point.time_stamp.to_time] = point.average
+          end
+        end
+
+        add_missing_data(data, start_time, end_time, period) if series
+
+        data
       end
 
-      def access_key_id
-        ENV["PGHERO_ACCESS_KEY_ID"] || ENV["AWS_ACCESS_KEY_ID"]
+      private
+
+      def gcp_stats(metric_name, duration: nil, period: nil, offset: nil, series: false)
+        require "google/cloud/monitoring/v3"
+
+        # TODO DRY with RDS stats
+        duration = (duration || 1.hour).to_i
+        period = (period || 1.minute).to_i
+        offset = (offset || 0).to_i
+        end_time = Time.at(((Time.now - offset).to_f / period).ceil * period)
+        start_time = end_time - duration
+
+        # validate input since we need to interpolate below
+        raise Error, "Invalid metric name" unless metric_name =~ /\A[a-z\/_]+\z/i
+        raise Error, "Invalid database id" unless gcp_database_id =~ /\A[a-z\-:]+\z/i
+
+        # we handle three situations:
+        # 1. google-cloud-monitoring-v3
+        # 2. google-cloud-monitoring >= 1
+        # 3. google-cloud-monitoring < 1
+
+        # for situations 1 and 2
+        # Google::Cloud::Monitoring.metric_service is documented
+        # but doesn't work for situation 1
+        if defined?(Google::Cloud::Monitoring::V3::MetricService::Client)
+          client = Google::Cloud::Monitoring::V3::MetricService::Client.new
+
+          interval = Google::Cloud::Monitoring::V3::TimeInterval.new
+          interval.end_time = Google::Protobuf::Timestamp.new(seconds: end_time.to_i)
+          # subtract period to make sure we get first data point
+          interval.start_time = Google::Protobuf::Timestamp.new(seconds: (start_time - period).to_i)
+
+          aggregation = Google::Cloud::Monitoring::V3::Aggregation.new
+          # may be better to use ALIGN_NEXT_OLDER for space stats to show most recent data point
+          # stick with average for now to match AWS
+          aggregation.per_series_aligner = Google::Cloud::Monitoring::V3::Aggregation::Aligner::ALIGN_MEAN
+          aggregation.alignment_period = period
+
+          results = client.list_time_series({
+            name: "projects/#{gcp_database_id.split(":").first}",
+            filter: "metric.type = \"cloudsql.googleapis.com/database/#{metric_name}\" AND resource.label.database_id = \"#{gcp_database_id}\"",
+            interval: interval,
+            view: Google::Cloud::Monitoring::V3::ListTimeSeriesRequest::TimeSeriesView::FULL,
+            aggregation: aggregation
+          })
+        else
+          require "google/cloud/monitoring"
+
+          client = Google::Cloud::Monitoring::Metric.new
+
+          interval = Google::Monitoring::V3::TimeInterval.new
+          interval.end_time = Google::Protobuf::Timestamp.new(seconds: end_time.to_i)
+          # subtract period to make sure we get first data point
+          interval.start_time = Google::Protobuf::Timestamp.new(seconds: (start_time - period).to_i)
+
+          aggregation = Google::Monitoring::V3::Aggregation.new
+          # may be better to use ALIGN_NEXT_OLDER for space stats to show most recent data point
+          # stick with average for now to match AWS
+          aggregation.per_series_aligner = Google::Monitoring::V3::Aggregation::Aligner::ALIGN_MEAN
+          aggregation.alignment_period = period
+
+          results = client.list_time_series(
+            "projects/#{gcp_database_id.split(":").first}",
+            "metric.type = \"cloudsql.googleapis.com/database/#{metric_name}\" AND resource.label.database_id = \"#{gcp_database_id}\"",
+            interval,
+            Google::Monitoring::V3::ListTimeSeriesRequest::TimeSeriesView::FULL,
+            aggregation: aggregation
+          )
+        end
+
+        data = {}
+        result = results.first
+        if result
+          result.points.each do |point|
+            time = Time.at(point.interval.start_time.seconds)
+            value = point.value.double_value
+            value *= 100 if metric_name == "cpu/utilization"
+            data[time] = value
+          end
+        end
+
+        add_missing_data(data, start_time, end_time, period) if series
+
+        data
       end
 
-      def secret_access_key
-        ENV["PGHERO_SECRET_ACCESS_KEY"] || ENV["AWS_SECRET_ACCESS_KEY"]
+      def system_stats(metric_key, **options)
+        case system_stats_provider
+        when :aws
+          metrics = {
+            cpu: "CPUUtilization",
+            connections: "DatabaseConnections",
+            replication_lag: "ReplicaLag",
+            read_iops: "ReadIOPS",
+            write_iops: "WriteIOPS",
+            free_space: "FreeStorageSpace"
+          }
+          rds_stats(metrics[metric_key], **options)
+        when :gcp
+          if metric_key == :free_space
+            quota = gcp_stats("disk/quota", **options)
+            used = gcp_stats("disk/bytes_used", **options)
+            free_space(quota, used)
+          else
+            metrics = {
+              cpu: "cpu/utilization",
+              connections: "postgresql/num_backends",
+              replication_lag: "replication/replica_lag",
+              read_iops: "disk/read_ops_count",
+              write_iops: "disk/write_ops_count"
+            }
+            gcp_stats(metrics[metric_key], **options)
+          end
+        when :azure
+          if metric_key == :free_space
+            quota = azure_stats("storage_limit", **options)
+            used = azure_stats("storage_used", **options)
+            free_space(quota, used)
+          else
+            # no read_iops, write_iops
+            # could add io_consumption_percent
+            metrics = {
+              cpu: "cpu_percent",
+              connections: "active_connections",
+              replication_lag: "pg_replica_log_delay_in_seconds"
+            }
+            raise Error, "Metric not supported" unless metrics[metric_key]
+            azure_stats(metrics[metric_key], **options)
+          end
+        else
+          raise NotEnabled, "System stats not enabled"
+        end
       end
 
-      def region
-        ENV["PGHERO_REGION"] || ENV["AWS_REGION"] || (defined?(Aws) && Aws.config[:region]) || "us-east-1"
+      # only use data points included in both series
+      # this also eliminates need to align Time.now
+      def free_space(quota, used)
+        data = {}
+        quota.each do |k, v|
+          data[k] = v - used[k] if v && used[k]
+        end
+        data
       end
 
-      def db_instance_identifier
-        databases[current_database].db_instance_identifier
+      def add_missing_data(data, start_time, end_time, period)
+        time = start_time
+        end_time = end_time
+        while time < end_time
+          data[time] ||= nil
+          time += period
+        end
       end
     end
   end