pghero 2.8.3 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0ef604cc8c9d99ad4c990aff2b2ee6686dcfe8ba43e1b57a5babab2a4f3613d
-  data.tar.gz: d1d6e6b002e0f0ba4c574ecf9cdc4b6953ea89e03215f05529a217fac1228f8e
+  metadata.gz: 47c3b581297903d9228470aeaaf0d292037a607a972f7555c40aca2384db8c70
+  data.tar.gz: a6f3cba27dd2034de0a24e855c6047966548d7253ead84d6a19395c0d23609dc
 SHA512:
-  metadata.gz: 6999c79d2cf479bce29e06e7dda24e635e95173281ee7231c9af1c777871df3d8b271e38b4adb4baa8ca508aaeeb2f07f8c61ae2cf66ca475e1dc0b6603d34e6
-  data.tar.gz: 12fa2e5b15cb1150c51e4076a6c1c68bf55a429de833ed9809a92c46d18a945766a08b348bf4398d893521cd20e297b9c97b3418c0565a259a3c01a077645252
+  metadata.gz: '08dd24651f52597743f937956dffca4784589ed9075e2c03cb3319e3d9cc73a71d2eb3409a37e3823b53e23cd1940a50739e95e5357b441ec4b942a6a7a2346c'
+  data.tar.gz: ca28bc463f7095cebd7e09907aa1e5c1eccd0ab32b288b0963da05344bfcaa292353d8e284636c6d8a642e36514c43419f916bedcfeebe1caca62cdfad3dd3d2

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 3.0.0 (2022-09-13)
+
+- Changed `capture_query_stats` to only reset stats for current database in Postgres 12+
+- Changed `reset_query_stats` to only reset stats for current database (use `reset_instance_query_stats` to reset stats for entire instance)
+- Added `visualize_url` option to config
+- Removed `access_key_id`, `secret_access_key`, `region`, and `db_instance_identifier` methods (use `aws_` prefixed methods instead)
+- Dropped support for Linux packages for EOL versions
+- Dropped support for Ruby < 2.7 and Rails < 6
+- Dropped support for pg_query < 2
+- Dropped support for aws-sdk < 2
+
 ## 2.8.3 (2022-05-01)
 
 - Added support for `google-apis-monitoring_v3`

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2021 Andrew Kane, 2008-2014 Heroku (initial queries)
+Copyright (c) 2014-2022 Andrew Kane, 2008-2014 Heroku (initial queries)
 
 MIT License
 

data/app/controllers/pg_hero/home_controller.rb

@@ -84,7 +84,7 @@ module PgHero
       @space_stats_enabled = @database.space_stats_enabled? && !@only_tables
       if @space_stats_enabled
         space_growth = @database.space_growth(days: @days, relation_sizes: @relation_sizes)
-        @growth_bytes_by_relation = Hash[ space_growth.map { |r| [[r[:schema], r[:relation]], r[:growth_bytes]] } ]
+        @growth_bytes_by_relation = space_growth.to_h { |r| [[r[:schema], r[:relation]], r[:growth_bytes]] }
         if params[:sort] == "growth"
           @relation_sizes.sort_by! { |r| s = @growth_bytes_by_relation[[r[:schema], r[:relation]]]; [s ? 0 : 1, -s.to_i, r[:schema], r[:relation]] }
         end
@@ -184,7 +184,7 @@ module PgHero
           @chart2_data = [{name: "Value", data: query_hash_stats.map { |r| [r[:captured_at].change(sec: 0), r[:average_time].round(1)] }, library: chart_library_options}]
           @chart3_data = [{name: "Value", data: query_hash_stats.map { |r| [r[:captured_at].change(sec: 0), r[:calls]] }, library: chart_library_options}]
 
-          @origins = Hash[query_hash_stats.group_by { |r| r[:origin].to_s }.map { |k, v| [k, v.size] }]
+          @origins = query_hash_stats.group_by { |r| r[:origin].to_s }.to_h { |k, v| [k, v.size] }
           @total_count = query_hash_stats.size
         end
 
@@ -192,11 +192,11 @@ module PgHero
         @tables.sort!
 
         if @tables.any?
-          @row_counts = Hash[@database.table_stats(table: @tables).map { |i| [i[:table], i[:estimated_rows]] }]
+          @row_counts = @database.table_stats(table: @tables).to_h { |i| [i[:table], i[:estimated_rows]] }
           @indexes_by_table = @database.indexes.group_by { |i| i[:table] }
         end
       else
-        render_text "Unknown query"
+        render_text "Unknown query", status: :not_found
       end
     end
 
@@ -217,9 +217,9 @@ module PgHero
       @period = (params[:period] || 60.seconds).to_i
 
       if @duration / @period > 1440
-        render_text "Too many data points"
+        render_text "Too many data points", status: :bad_request
       elsif @period % 60 != 0
-        render_text "Period must be a multiple of 60"
+        render_text "Period must be a multiple of 60", status: :bad_request
       end
     end
 
@@ -369,7 +369,11 @@ module PgHero
     end
 
     def reset_query_stats
-      @database.reset_query_stats
+      if @database.server_version_num >= 120000
+        @database.reset_query_stats
+      else
+        @database.reset_instance_query_stats
+      end
       redirect_backward notice: "Query stats reset"
     rescue ActiveRecord::StatementInvalid
       redirect_backward alert: "The database user does not have permission to reset query stats"
@@ -445,12 +449,13 @@ module PgHero
     end
 
     def check_api
-      render_text "No support for Rails API. See https://github.com/pghero/pghero for a standalone app." if Rails.application.config.try(:api_only)
+      if Rails.application.config.try(:api_only)
+        render_text "No support for Rails API. See https://github.com/pghero/pghero for a standalone app.", status:  :internal_server_error
+      end
     end
 
-    # TODO return error status code
-    def render_text(message)
-      render plain: message
+    def render_text(message, status:)
+      render plain: message, status: status
     end
 
     def ensure_query_stats

data/app/views/pg_hero/home/explain.html.erb

@@ -12,7 +12,7 @@
 
   <% if @explanation %>
     <% if @visualize %>
-      <p>Paste the output below into the <%= link_to "Postgres Explain Visualizer", "https://tatiyants.com/pev/#/plans/new", target: "_blank" %></p>
+      <p>Paste the output below into the <%= link_to "explain visualizer", PgHero.visualize_url, target: "_blank" %></p>
     <% end %>
     <pre><code><%= @explanation %></code></pre>
     <% unless @visualize %>

data/lib/pghero/database.rb

@@ -118,12 +118,6 @@ module PgHero
       @filter_data
     end
 
-    # TODO remove in next major version
-    alias_method :access_key_id, :aws_access_key_id
-    alias_method :secret_access_key, :aws_secret_access_key
-    alias_method :region, :aws_region
-    alias_method :db_instance_identifier, :aws_db_instance_identifier
-
     private
 
     # check adapter lazily
@@ -148,7 +142,6 @@ module PgHero
 
       # resolve spec
       if !url && config["spec"]
-        raise Error, "Spec requires Rails 6+" unless PgHero.spec_supported?
         config_options = {env_name: PgHero.env, PgHero.spec_name_key => config["spec"], PgHero.include_replicas_key => true}
         resolved = ActiveRecord::Base.configurations.configs_for(**config_options)
         raise Error, "Spec not found: #{config["spec"]}" unless resolved

data/lib/pghero/methods/basic.rb

@@ -45,7 +45,7 @@ module PgHero
           if ActiveRecord::VERSION::STRING.to_f >= 6.1
             result = result.map(&:symbolize_keys)
           else
-            result = result.map { |row| Hash[row.map { |col, val| [col.to_sym, result.column_types[col].send(:cast_value, val)] }] }
+            result = result.map { |row| row.to_h { |col, val| [col.to_sym, result.column_types[col].send(:cast_value, val)] } }
           end
           if filter_data
             query_columns.each do |column|

data/lib/pghero/methods/connections.rb

@@ -53,7 +53,7 @@ module PgHero
             2 DESC, 1
         SQL
 
-        Hash[states.map { |s| [s[:state], s[:connections]] }]
+        states.to_h { |s| [s[:state], s[:connections]] }
       end
 
       def connection_sources

data/lib/pghero/methods/maintenance.rb

@@ -1,7 +1,7 @@
 module PgHero
   module Methods
     module Maintenance
-      # https://www.postgresql.org/docs/9.1/static/routine-vacuuming.html#VACUUM-FOR-WRAPAROUND
+      # https://www.postgresql.org/docs/current/routine-vacuuming.html#VACUUM-FOR-WRAPAROUND
       # "the system will shut down and refuse to start any new transactions
       # once there are fewer than 1 million transactions left until wraparound"
       # warn when 10,000,000 transactions left

data/lib/pghero/methods/query_stats.rb

@@ -56,10 +56,9 @@ module PgHero
         true
       end
 
-      # TODO scope by database in PgHero 3.0
-      # (add database: database_name to options)
       def reset_query_stats(**options)
-        reset_instance_query_stats(**options)
+        raise PgHero::Error, "Use reset_instance_query_stats to pass database" if options.delete(:database)
+        reset_instance_query_stats(**options, database: database_name)
       end
 
       # resets query stats for the entire instance
@@ -121,7 +120,7 @@ module PgHero
         server_version_num >= 90400
       end
 
-      # resetting query stats will reset across the entire Postgres instance
+      # resetting query stats will reset across the entire Postgres instance in Postgres < 12
       # this is problematic if multiple PgHero databases use the same Postgres instance
       #
       # to get around this, we capture queries for every Postgres database before we
@@ -147,16 +146,15 @@ module PgHero
         # nothing to do
         return if query_stats.empty?
 
-        # 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
+        # reset individual databases for Postgres 12+ instance
+        if server_version_num >= 120000
           query_stats.each do |db_id, db_query_stats|
-            if reset_query_stats(database: mapping[db_id], raise_errors: raise_errors)
+            if reset_instance_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)
+          if reset_instance_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

data/lib/pghero/methods/sequences.rb

@@ -115,7 +115,7 @@ module PgHero
         end
 
         # then populate attributes
-        readable = Hash[sequence_attributes.map { |s| [[s[:schema], s[:sequence]], s[:readable]] }]
+        readable = sequence_attributes.to_h { |s| [[s[:schema], s[:sequence]], s[:readable]] }
         sequences.each do |sequence|
           sequence[:readable] = readable[[sequence[:schema], sequence[:sequence]]] || false
         end

data/lib/pghero/methods/settings.rb

@@ -30,7 +30,7 @@ module PgHero
       private
 
       def fetch_settings(names)
-        Hash[names.map { |name| [name, select_one("SHOW #{name}")] }]
+        names.to_h { |name| [name, select_one("SHOW #{name}")] }
       end
     end
   end

data/lib/pghero/methods/space.rb

@@ -49,7 +49,7 @@ module PgHero
       def space_growth(days: 7, relation_sizes: nil)
         if space_stats_enabled?
           relation_sizes ||= self.relation_sizes
-          sizes = Hash[ relation_sizes.map { |r| [[r[:schema], r[:relation]], r[:size_bytes]] } ]
+          sizes = relation_sizes.to_h { |r| [[r[:schema], r[:relation]], r[:size_bytes]] }
           start_at = days.days.ago
 
           stats = select_all_stats <<-SQL
@@ -92,7 +92,7 @@ module PgHero
       def relation_space_stats(relation, schema: "public")
         if space_stats_enabled?
           relation_sizes ||= self.relation_sizes
-          sizes = Hash[ relation_sizes.map { |r| [[r[:schema], r[:relation]], r[:size_bytes]] } ]
+          sizes = relation_sizes.map { |r| [[r[:schema], r[:relation]], r[:size_bytes]] }.to_h
           start_at = 30.days.ago
 
           stats = select_all_stats <<-SQL

data/lib/pghero/methods/suggested_indexes.rb

@@ -2,7 +2,7 @@ module PgHero
   module Methods
     module SuggestedIndexes
       def suggested_indexes_enabled?
-        defined?(PgQuery) && Gem::Version.new(PgQuery::VERSION) >= Gem::Version.new("0.9.0") && query_stats_enabled?
+        defined?(PgQuery) && Gem::Version.new(PgQuery::VERSION) >= Gem::Version.new("2") && query_stats_enabled?
       end
 
       # TODO clean this mess
@@ -104,7 +104,7 @@ module PgHero
         # TODO get schema from query structure, then try search path
         schema = PgHero.connection_config(connection_model)[:schema] || "public"
         if tables.any?
-          row_stats = Hash[table_stats(table: tables, schema: schema).map { |i| [i[:table], i[:estimated_rows]] }]
+          row_stats = table_stats(table: tables, schema: schema).to_h { |i| [i[:table], i[:estimated_rows]] }
           col_stats = column_stats(table: tables, schema: schema).group_by { |i| i[:table] }
         end
 
@@ -126,7 +126,7 @@ module PgHero
             total_rows = row_stats[table].to_i
             index[:rows] = total_rows
 
-            ranks = Hash[col_stats[table].to_a.map { |r| [r[:column], r] }]
+            ranks = col_stats[table].to_a.to_h { |r| [r[:column], r] }
             columns = (where + sort).map { |c| c[:column] }.uniq
 
             if columns.any?
@@ -135,7 +135,7 @@ module PgHero
                 sort = sort.first(first_desc + 1) if first_desc
                 where = where.sort_by { |c| [row_estimates(ranks[c[:column]], total_rows, total_rows, c[:op]), c[:column]] } + sort
 
-                index[:row_estimates] = Hash[where.map { |c| ["#{c[:column]} (#{c[:op] || "sort"})", row_estimates(ranks[c[:column]], total_rows, total_rows, c[:op]).round] }]
+                index[:row_estimates] = where.to_h { |c| ["#{c[:column]} (#{c[:op] || "sort"})", row_estimates(ranks[c[:column]], total_rows, total_rows, c[:op]).round] }
 
                 # no index needed if less than 500 rows
                 if total_rows >= 500
@@ -202,68 +202,33 @@ module PgHero
           return {error: "Parse error"}
         end
 
-        if PgQuery::VERSION.to_i >= 2
-          return {error: "Unknown structure"} unless tree.stmts.size == 1
-
-          tree = tree.stmts.first.stmt
-
-          table = parse_table_v2(tree) rescue nil
-          unless table
-            error =
-              case tree.node
-              when :insert_stmt
-                "INSERT statement"
-              when :variable_set_stmt
-                "SET statement"
-              when :select_stmt
-                if (tree.select_stmt.from_clause.first.join_expr rescue false)
-                  "JOIN not supported yet"
-                end
-              end
-            return {error: error || "Unknown structure"}
-          end
-
-          select = tree[tree.node.to_s]
-          where = (select.where_clause ? parse_where_v2(select.where_clause) : []) rescue nil
-          return {error: "Unknown structure"} unless where
-
-          sort = (select.sort_clause ? parse_sort_v2(select.sort_clause) : []) rescue []
-
-          {table: table, where: where, sort: sort}
-        else
-          # TODO remove support for pg_query < 2 in PgHero 3.0
-
-          return {error: "Unknown structure"} unless tree.size == 1
-
-          tree = tree.first
-
-          # pg_query 1.0.0
-          tree = tree["RawStmt"]["stmt"] if tree["RawStmt"]
-
-          table = parse_table(tree) rescue nil
-          unless table
-            error =
-              case tree.keys.first
-              when "InsertStmt"
-                "INSERT statement"
-              when "VariableSetStmt"
-                "SET statement"
-              when "SelectStmt"
-                if (tree["SelectStmt"]["fromClause"].first["JoinExpr"] rescue false)
-                  "JOIN not supported yet"
-                end
+        return {error: "Unknown structure"} unless tree.stmts.size == 1
+
+        tree = tree.stmts.first.stmt
+
+        table = parse_table(tree) rescue nil
+        unless table
+          error =
+            case tree.node
+            when :insert_stmt
+              "INSERT statement"
+            when :variable_set_stmt
+              "SET statement"
+            when :select_stmt
+              if (tree.select_stmt.from_clause.first.join_expr rescue false)
+                "JOIN not supported yet"
               end
-            return {error: error || "Unknown structure"}
-          end
+            end
+          return {error: error || "Unknown structure"}
+        end
 
-          select = tree.values.first
-          where = (select["whereClause"] ? parse_where(select["whereClause"]) : []) rescue nil
-          return {error: "Unknown structure"} unless where
+        select = tree[tree.node.to_s]
+        where = (select.where_clause ? parse_where(select.where_clause) : []) rescue nil
+        return {error: "Unknown structure"} unless where
 
-          sort = (select["sortClause"] ? parse_sort(select["sortClause"]) : []) rescue []
+        sort = (select.sort_clause ? parse_sort(select.sort_clause) : []) rescue []
 
-          {table: table, where: where, sort: sort}
-        end
+        {table: table, where: where, sort: sort}
       end
 
       # TODO better row estimation
@@ -300,7 +265,7 @@ module PgHero
         end
       end
 
-      def parse_table_v2(tree)
+      def parse_table(tree)
         case tree.node
         when :select_stmt
           tree.select_stmt.from_clause.first.range_var.relname
@@ -311,24 +276,13 @@ module PgHero
         end
       end
 
-      def parse_table(tree)
-        case tree.keys.first
-        when "SelectStmt"
-          tree["SelectStmt"]["fromClause"].first["RangeVar"]["relname"]
-        when "DeleteStmt"
-          tree["DeleteStmt"]["relation"]["RangeVar"]["relname"]
-        when "UpdateStmt"
-          tree["UpdateStmt"]["relation"]["RangeVar"]["relname"]
-        end
-      end
-
       # TODO capture values
-      def parse_where_v2(tree)
+      def parse_where(tree)
         aexpr = tree.a_expr
 
         if tree.bool_expr
           if tree.bool_expr.boolop == :AND_EXPR
-            tree.bool_expr.args.flat_map { |v| parse_where_v2(v) }
+            tree.bool_expr.args.flat_map { |v| parse_where(v) }
           else
             raise "Not Implemented"
           end
@@ -342,27 +296,7 @@ module PgHero
         end
       end
 
-      # TODO capture values
-      def parse_where(tree)
-        aexpr = tree["A_Expr"]
-
-        if tree["BoolExpr"]
-          if tree["BoolExpr"]["boolop"] == 0
-            tree["BoolExpr"]["args"].flat_map { |v| parse_where(v) }
-          else
-            raise "Not Implemented"
-          end
-        elsif aexpr && ["=", "<>", ">", ">=", "<", "<=", "~~", "~~*", "BETWEEN"].include?(aexpr["name"].first["String"]["str"])
-          [{column: aexpr["lexpr"]["ColumnRef"]["fields"].last["String"]["str"], op: aexpr["name"].first["String"]["str"]}]
-        elsif tree["NullTest"]
-          op = tree["NullTest"]["nulltesttype"] == 1 ? "not_null" : "null"
-          [{column: tree["NullTest"]["arg"]["ColumnRef"]["fields"].last["String"]["str"], op: op}]
-        else
-          raise "Not Implemented"
-        end
-      end
-
-      def parse_sort_v2(sort_clause)
+      def parse_sort(sort_clause)
         sort_clause.map do |v|
           {
             column: v.sort_by.node.column_ref.fields.last.string.str,
@@ -371,15 +305,6 @@ module PgHero
         end
       end
 
-      def parse_sort(sort_clause)
-        sort_clause.map do |v|
-          {
-            column: v["SortBy"]["node"]["ColumnRef"]["fields"].last["String"]["str"],
-            direction: v["SortBy"]["sortby_dir"] == 2 ? "desc" : "asc"
-          }
-        end
-      end
-
       def column_stats(schema: nil, table: nil)
         select_all <<-SQL
           SELECT

data/lib/pghero/methods/system.rb

@@ -5,9 +5,8 @@ module PgHero
         !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))
+        if aws_db_instance_identifier
           :aws
         elsif gcp_database_id
           :gcp
@@ -42,18 +41,13 @@ module PgHero
 
       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
-            aws_options[:access_key_id] = access_key_id
-            aws_options[:secret_access_key] = secret_access_key
+          aws_options = {region: aws_region}
+          if aws_access_key_id
+            aws_options[:access_key_id] = aws_access_key_id
+            aws_options[:secret_access_key] = aws_secret_access_key
           end
 
-          client =
-            if defined?(Aws)
-              Aws::CloudWatch::Client.new(aws_options)
-            else
-              AWS::CloudWatch.new(aws_options).client
-            end
+          client = Aws::CloudWatch::Client.new(aws_options)
 
           duration = (duration || 1.hour).to_i
           period = (period || 1.minute).to_i

data/lib/pghero/methods/users.rb

@@ -2,11 +2,15 @@ module PgHero
   module Methods
     module Users
       # documented as unsafe to pass user input
-      # TODO quote in 3.0, but still not officially supported
+      # identifiers are now quoted, but still not officially supported
       def create_user(user, password: nil, schema: "public", database: nil, readonly: false, tables: nil)
         password ||= random_password
         database ||= PgHero.connection_config(connection_model)[:database]
 
+        user = quote_ident(user)
+        schema = quote_ident(schema)
+        database = quote_ident(database)
+
         commands =
           [
             "CREATE ROLE #{user} LOGIN PASSWORD #{quote(password)}",
@@ -42,10 +46,14 @@ module PgHero
       end
 
       # documented as unsafe to pass user input
-      # TODO quote in 3.0, but still not officially supported
+      # identifiers are now quoted, but still not officially supported
       def drop_user(user, schema: "public", database: nil)
         database ||= PgHero.connection_config(connection_model)[:database]
 
+        user = quote_ident(user)
+        schema = quote_ident(schema)
+        database = quote_ident(database)
+
         # thanks shiftb
         commands =
           [
@@ -77,9 +85,9 @@ module PgHero
         SecureRandom.base64(40).delete("+/=")[0...24]
       end
 
-      def table_grant_commands(privilege, tables, user)
+      def table_grant_commands(privilege, tables, quoted_user)
         tables.map do |table|
-          "GRANT #{privilege} ON TABLE #{table} TO #{user}"
+          "GRANT #{privilege} ON TABLE #{quote_ident(table)} TO #{quoted_user}"
         end
       end
     end

data/lib/pghero/version.rb

@@ -1,3 +1,3 @@
 module PgHero
-  VERSION = "2.8.3"
+  VERSION = "3.0.0"
 end

data/lib/pghero.rb

@@ -53,15 +53,15 @@ module PgHero
 
   class << self
     extend Forwardable
-    def_delegators :primary_database, :access_key_id, :analyze, :analyze_tables, :autoindex, :autovacuum_danger,
+    def_delegators :primary_database, :aws_access_key_id, :analyze, :analyze_tables, :autoindex, :autovacuum_danger,
       :best_index, :blocked_queries, :connections, :connection_sources, :connection_states, :connection_stats,
-      :cpu_usage, :create_user, :database_size, :db_instance_identifier, :disable_query_stats, :drop_user,
+      :cpu_usage, :create_user, :database_size, :aws_db_instance_identifier, :disable_query_stats, :drop_user,
       :duplicate_indexes, :enable_query_stats, :explain, :historical_query_stats_enabled?, :index_caching,
       :index_hit_rate, :index_usage, :indexes, :invalid_constraints, :invalid_indexes, :kill, :kill_all, :kill_long_running_queries,
       :last_stats_reset_time, :long_running_queries, :maintenance_info, :missing_indexes, :query_stats,
       :query_stats_available?, :query_stats_enabled?, :query_stats_extension_enabled?, :query_stats_readable?,
-      :rds_stats, :read_iops_stats, :region, :relation_sizes, :replica?, :replication_lag, :replication_lag_stats,
-      :reset_query_stats, :reset_stats, :running_queries, :secret_access_key, :sequence_danger, :sequences, :settings,
+      :rds_stats, :read_iops_stats, :aws_region, :relation_sizes, :replica?, :replication_lag, :replication_lag_stats,
+      :reset_query_stats, :reset_stats, :running_queries, :aws_secret_access_key, :sequence_danger, :sequences, :settings,
       :slow_queries, :space_growth, :ssl_used?, :stats_connection, :suggested_indexes, :suggested_indexes_by_query,
       :suggested_indexes_enabled?, :system_stats_enabled?, :table_caching, :table_hit_rate, :table_stats,
       :total_connections, :transaction_id_danger, :unused_indexes, :unused_tables, :write_iops_stats
@@ -86,12 +86,22 @@ module PgHero
       @password ||= config["password"] || ENV["PGHERO_PASSWORD"]
     end
 
+    # config pattern for https://github.com/ankane/pghero/issues/424
     def stats_database_url
-      @stats_database_url ||= config["stats_database_url"] || ENV["PGHERO_STATS_DATABASE_URL"]
+      @stats_database_url ||= (file_config || {})["stats_database_url"] || ENV["PGHERO_STATS_DATABASE_URL"]
+    end
+
+    def visualize_url
+      @visualize_url ||= config["visualize_url"] || ENV["PGHERO_VISUALIZE_URL"] || "https://tatiyants.com/pev/#/plans/new"
     end
 
     def config
-      @config ||= begin
+      @config ||= file_config || default_config
+    end
+
+    # private
+    def file_config
+      unless defined?(@file_config)
         require "erb"
         require "yaml"
 
@@ -102,40 +112,48 @@ module PgHero
         config = YAML.load(ERB.new(File.read(path)).result) if config_file_exists
         config ||= {}
 
-        if config[env]
-          config[env]
-        elsif config["databases"] # preferred format
-          config
-        elsif config_file_exists
-          raise "Invalid config file"
-        else
-          databases = {}
-
-          if !ENV["PGHERO_DATABASE_URL"] && spec_supported?
-            ActiveRecord::Base.configurations.configs_for(env_name: env, include_replicas_key => true).each do |db|
-              databases[db.send(spec_name_key)] = {"spec" => db.send(spec_name_key)}
-            end
+        @file_config =
+          if config[env]
+            config[env]
+          elsif config["databases"] # preferred format
+            config
+          elsif config_file_exists
+            raise "Invalid config file"
+          else
+            nil
           end
+      end
 
-          if databases.empty?
-            databases["primary"] = {
-              "url" => ENV["PGHERO_DATABASE_URL"] || connection_config(ActiveRecord::Base)
-            }
-          end
+      @file_config
+    end
 
-          if databases.size == 1
-            databases.values.first.merge!(
-              "db_instance_identifier" => ENV["PGHERO_DB_INSTANCE_IDENTIFIER"],
-              "gcp_database_id" => ENV["PGHERO_GCP_DATABASE_ID"],
-              "azure_resource_id" => ENV["PGHERO_AZURE_RESOURCE_ID"]
-            )
-          end
+    # private
+    def default_config
+      databases = {}
 
-          {
-            "databases" => databases
-          }
+      unless ENV["PGHERO_DATABASE_URL"]
+        ActiveRecord::Base.configurations.configs_for(env_name: env, include_replicas_key => true).each do |db|
+          databases[db.send(spec_name_key)] = {"spec" => db.send(spec_name_key)}
         end
       end
+
+      if databases.empty?
+        databases["primary"] = {
+          "url" => ENV["PGHERO_DATABASE_URL"] || connection_config(ActiveRecord::Base)
+        }
+      end
+
+      if databases.size == 1
+        databases.values.first.merge!(
+          "aws_db_instance_identifier" => ENV["PGHERO_DB_INSTANCE_IDENTIFIER"],
+          "gcp_database_id" => ENV["PGHERO_GCP_DATABASE_ID"],
+          "azure_resource_id" => ENV["PGHERO_AZURE_RESOURCE_ID"]
+        )
+      end
+
+      {
+        "databases" => databases
+      }
     end
 
     # ensure we only have one copy of databases
@@ -206,11 +224,6 @@ module PgHero
       end
     end
 
-    # private
-    def spec_supported?
-      ActiveRecord::VERSION::MAJOR >= 6
-    end
-
     # private
     def connection_config(model)
       ActiveRecord::VERSION::STRING.to_f >= 6.1 ? model.connection_db_config.configuration_hash : model.connection_config

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pghero
 version: !ruby/object:Gem::Version
-  version: 2.8.3
+  version: 3.0.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-02 00:00:00.000000000 Z
+date: 2022-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,16 +16,16 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '6'
 description:
-email: andrew@chartkick.com
+email: andrew@ankane.org
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -116,7 +116,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="