pghero 1.2.4 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ff54cb7718c9fa71235f8cd8902d892b22fa846
-  data.tar.gz: 8063771e39db3713fcdc24b2e7ec9ad6d79b99fa
+  metadata.gz: 5de5f457151a5d2e77e515b117225033f2f5153b
+  data.tar.gz: fa0a4eea1887464cc49e376aa5675610819f92fb
 SHA512:
-  metadata.gz: 5abef652a9cf1bf074cb3ebf13ca92a15985ceb9d398bc648865345ae24297f7a6034b59f32265390eb88f314ca8174e04669b2552120eb5f396ebf5db41d281
-  data.tar.gz: af7042728d2272c44a2a9986b5c61892aa20955eb6513655cf3d8c5b05237dfec7d2f6b2a2f61a8af5215b23d87a03c179351230796f8bbb6540a6f4c10d72c1
+  metadata.gz: af9c72a1eaf428e6c2b7b43a5df732f848633e5f1fa4835c697ff801384fd3b8920d43516a7a5fef9f212b46ee70b9f33ef81e7557fa78b1d086d7e180321aab
+  data.tar.gz: 2a687404ad19e82ee2bd7517cd7a81837fe9ea469110028f2fe656b82849977ad139c5407b52168678dfd006e547a316ebc886f953e7db034ea8daae99eb79b4

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.3.0
+
+- Added query hash for better query stats grouping
+- Added sequence danger check
+- Added `capture_query_stats` option to config
+
 ## 1.2.4
 
 - Fixed user methods

data/app/controllers/pg_hero/home_controller.rb

@@ -31,6 +31,7 @@ module PgHero
         end
       @unused_indexes = PgHero.unused_indexes.select { |q| q["index_scans"].to_i == 0 }
       @invalid_indexes = PgHero.invalid_indexes
+      @duplicate_indexes = PgHero.duplicate_indexes if params[:duplicate_indexes]
       @good_cache_rate = @table_hit_rate >= PgHero.cache_hit_rate_threshold.to_f / 100 && @index_hit_rate >= PgHero.cache_hit_rate_threshold.to_f / 100
       @query_stats_available = PgHero.query_stats_available?
       @total_connections = PgHero.total_connections
@@ -42,6 +43,7 @@ module PgHero
       @transaction_id_danger = PgHero.transaction_id_danger(threshold: 1500000000)
       set_suggested_indexes((params[:min_average_time] || 20).to_f, (params[:min_calls] || 50).to_i)
       @show_migrations = PgHero.show_migrations
+      @sequence_danger = PgHero.sequence_danger(threshold: params[:sequence_threshold])
     end
 
     def index_usage

data/app/views/layouts/pg_hero/application.html.erb

@@ -422,6 +422,7 @@
             <li class="<%= controller.action_name == "space" ? "active" : "" %>"><%= link_to "Space", space_path %></li>
             <li class="<%= controller.action_name == "connections" ? "active" : "" %>"><%= link_to "Connections", connections_path %></li>
             <li class="<%= controller.action_name == "live_queries" ? "active" : "" %>"><%= link_to "Live Queries", live_queries_path %></li>
+            <li class="<%= controller.action_name == "maintenance" ? "active" : "" %>"><%= link_to "Maintenance", maintenance_path %></li>
             <li class="<%= controller.action_name == "explain" ? "active" : "" %>"><%= link_to "Explain", explain_path %></li>
             <li class="<%= controller.action_name == "tune" ? "active" : "" %>"><%= link_to "Tune", tune_path %></li>
           </ul>

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

@@ -15,7 +15,7 @@
         <td><%= query["pid"] %></td>
         <td><%= query["state"] %></td>
         <td><%= query["started_at"] ? "#{number_with_delimiter(((now - Time.parse(query["started_at"])) * 1000).round)} ms" : nil %></td>
-        <td><%= query["source"] %></td>
+        <td><%= query["source"] %> <span class="text-muted"><%= query["user"] %></span></td>
         <td class="text-right">
           <%= button_to "Explain", explain_path(query: query["query"]), form: {target: "_blank"}, class: "btn btn-info" %>
           <%= button_to "Kill", kill_path(pid: query["pid"]), class: "btn btn-danger" %>

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

@@ -38,6 +38,13 @@
       Vacuuming healthy
     <% end %>
   </div>
+  <div class="alert alert-<%= @sequence_danger.empty? ? "success" : "warning" %>">
+    <% if @sequence_danger.any? %>
+      <%= pluralize(@sequence_danger.size, "columns") %> approaching overflow
+    <% else %>
+      No columns near overflow
+    <% end %>
+  </div>
   <div class="alert alert-<%= @invalid_indexes.empty? ? "success" : "warning" %>">
     <% if @invalid_indexes.any? %>
       <%= pluralize(@invalid_indexes.size, "invalid index", "invalid indexes") %>
@@ -45,6 +52,15 @@
       No invalid indexes
     <% end %>
   </div>
+  <% if @duplicate_indexes %>
+    <div class="alert alert-<%= @duplicate_indexes.empty? ? "success" : "warning" %>">
+      <% if @duplicate_indexes.any? %>
+        <%= pluralize(@duplicate_indexes.size, "duplicate index", "duplicate indexes") %>
+      <% else %>
+        No duplicate indexes
+      <% end %>
+    </div>
+  <% end %>
   <% if PgHero.suggested_indexes_enabled? %>
     <div class="alert alert-<%= @suggested_indexes.empty? ? "success" : "warning" %>">
       <% if @suggested_indexes.any? %>
@@ -139,6 +155,37 @@
   </div>
 <% end %>
 
+<% if @sequence_danger.any? %>
+  <div class="content">
+    <h2>Columns Near Overflow</h2>
+    <p>Consider changing the column type to support a larger range of values.</p>
+    <table class="table">
+      <thead>
+        <tr>
+          <th>Column</th>
+          <th style="width: 20%;">Type</th>
+          <th style="width: 20%;">Values Left</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% @sequence_danger.sort_by { |s| [s["table"], s["column"]] }.each do |query| %>
+          <tr>
+            <td>
+              <%= query["table"] %>.<%= query["column"] %>
+            </td>
+            <td>
+              <span class="text-muted"><%= query["column_type"] %></span>
+            </td>
+            <td>
+              <%= number_with_delimiter(query["max_value"].to_i - query["last_value"].to_i) %>
+            </td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+<% end %>
+
 <% if @invalid_indexes.any? %>
   <div class="content">
     <h1>Invalid Indexes</h1>
@@ -162,6 +209,49 @@
   </div>
 <% end %>
 
+<% if @duplicate_indexes && @duplicate_indexes.any? %>
+  <div class="content">
+    <h1>Duplicate Indexes</h1>
+
+    <p>
+      These indexes exist, but aren’t needed. Remove them
+      <% if @show_migrations %>
+      <a href="javascript: void(0);" onclick="document.getElementById('migration2').style.display = 'block';">with a migration</a>
+      <% end %>
+      for faster writes.
+    </p>
+
+    <div id="migration2" style="display: none;">
+      <pre>rails g migration remove_unneeded_indexes</pre>
+      <p>And paste</p>
+      <pre style="overflow: scroll; white-space: pre; word-break: normal;"><% @duplicate_indexes.each do |query| %>
+remove_index <%= query["unneeded_index"]["table"].to_sym.inspect %>, name: <%= query["unneeded_index"]["name"].to_s.inspect %><% end %></pre>
+    </div>
+
+    <table class="table">
+      <thead>
+        <tr>
+          <th>Details</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% @duplicate_indexes.each do |index| %>
+          <% unneeded_index = index["unneeded_index"] %>
+          <% covering_index = index["covering_index"] %>
+          <tr>
+            <td style="padding-top: 15px; padding-bottom: 5px;">
+              On <%= unneeded_index["table"] %>
+              <pre><%= unneeded_index["name"] %> (<%= unneeded_index["columns"].join(", ") %>)</pre>
+              is covered by
+              <pre><%= covering_index["name"] %> (<%= covering_index["columns"].join(", ") %>)</pre>
+            </td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+<% end %>
+
 <% if @suggested_indexes.any? %>
   <div class="content">
     <h1>Suggested Indexes</h1>

data/guides/Rails.md

@@ -242,6 +242,23 @@ Minimum connections for high connections warning
 PgHero.total_connections_threshold = 100 # default
 ```
 
+## Upgrading
+
+### 1.3.0
+
+For better query stats grouping with Postgres 9.4+, create a migration with:
+
+```ruby
+add_column :pghero_query_stats, :query_hash, :integer, limit: 8
+```
+
+If you get an error with `queryid`, recreate the `pg_stat_statements` extension.
+
+```sql
+DROP EXTENSION pg_stat_statements;
+CREATE EXTENSION pg_stat_statements;
+```
+
 ## Bonus
 
 - See where queries come from with [Marginalia](https://github.com/basecamp/marginalia) - comments appear on the Live Queries tab.

data/lib/generators/pghero/templates/query_stats.rb

@@ -3,6 +3,7 @@ class <%= migration_class_name %> < ActiveRecord::Migration
     create_table :pghero_query_stats do |t|
       t.text :database
       t.text :query
+      t.integer :query_hash, limit: 8
       t.float :total_time
       t.integer :calls, limit: 8
       t.timestamp :captured_at

data/lib/pghero.rb

@@ -18,6 +18,7 @@ require "pghero/methods/maintenance"
 require "pghero/methods/queries"
 require "pghero/methods/query_stats"
 require "pghero/methods/replica"
+require "pghero/methods/sequences"
 require "pghero/methods/space"
 require "pghero/methods/suggested_indexes"
 require "pghero/methods/system"
@@ -47,6 +48,7 @@ module PgHero
   extend Methods::Queries
   extend Methods::QueryStats
   extend Methods::Replica
+  extend Methods::Sequences
   extend Methods::Space
   extend Methods::SuggestedIndexes
   extend Methods::System

data/lib/pghero/methods/basic.rb

@@ -99,6 +99,14 @@ module PgHero
       def quote_table_name(value)
         connection.quote_table_name(value)
       end
+
+      def unquote(part)
+        if part && part.start_with?('"')
+          part[1..-2]
+        else
+          part
+        end
+      end
     end
   end
 end

data/lib/pghero/methods/indexes.rb

@@ -133,7 +133,7 @@ module PgHero
           ORDER BY
             1, 2
         SQL
-        ).map { |v| v["columns"] = v["columns"].sub(") WHERE (", " WHERE ").split(", "); v }
+        ).map { |v| v["columns"] = v["columns"].sub(") WHERE (", " WHERE ").split(", ").map { |c| unquote(c) }; v }
       end
 
       def duplicate_indexes

data/lib/pghero/methods/kill.rb

@@ -19,6 +19,7 @@ module PgHero
           WHERE
             pid <> pg_backend_pid()
             AND query <> '<insufficient privilege>'
+            AND datname = current_database()
         SQL
         true
       end

data/lib/pghero/methods/queries.rb

@@ -10,13 +10,15 @@ module PgHero
             age(now(), xact_start) AS duration,
             waiting,
             query,
-            xact_start AS started_at
+            xact_start AS started_at,
+            usename AS user
           FROM
             pg_stat_activity
           WHERE
             query <> '<insufficient privilege>'
             AND state <> 'idle'
             AND pid <> pg_backend_pid()
+            AND datname = current_database()
           ORDER BY
             query_start DESC
         SQL
@@ -31,7 +33,8 @@ module PgHero
             age(now(), xact_start) AS duration,
             waiting,
             query,
-            xact_start AS started_at
+            xact_start AS started_at,
+            usename AS user
           FROM
             pg_stat_activity
           WHERE
@@ -39,6 +42,7 @@ module PgHero
             AND state <> 'idle'
             AND pid <> pg_backend_pid()
             AND now() - query_start > interval '#{long_running_query_sec.to_i} seconds'
+            AND datname = current_database()
           ORDER BY
             query_start DESC
         SQL
@@ -63,6 +67,7 @@ module PgHero
             pg_stat_activity.query <> '<insufficient privilege>'
             AND pg_locks.mode = 'ExclusiveLock'
             AND pg_stat_activity.pid <> pg_backend_pid()
+            AND pg_stat_activity.datname = current_database()
           ORDER BY
             pid,
             query_start

data/lib/pghero/methods/query_stats.rb

@@ -2,20 +2,21 @@ module PgHero
   module Methods
     module QueryStats
       def query_stats(options = {})
-        current_query_stats = (options[:historical] && options[:end_at] && options[:end_at] < Time.now ? [] : current_query_stats(options)).index_by { |q| q["query"] }
-        historical_query_stats = (options[:historical] ? historical_query_stats(options) : []).index_by { |q| q["query"] }
+        current_query_stats = (options[:historical] && options[:end_at] && options[:end_at] < Time.now ? [] : current_query_stats(options)).index_by { |q| q["query_hash"] }
+        historical_query_stats = (options[:historical] ? historical_query_stats(options) : []).index_by { |q| q["query_hash"] }
         current_query_stats.default = {}
         historical_query_stats.default = {}
 
         query_stats = []
-        (current_query_stats.keys + historical_query_stats.keys).uniq.each do |query|
+        (current_query_stats.keys + historical_query_stats.keys).uniq.each do |query_hash|
           value = {
-            "query" => query,
-            "total_minutes" => current_query_stats[query]["total_minutes"].to_f + historical_query_stats[query]["total_minutes"].to_f,
-            "calls" => current_query_stats[query]["calls"].to_i + historical_query_stats[query]["calls"].to_i
+            "query" => current_query_stats[query_hash]["query"] || historical_query_stats[query_hash]["query"],
+            "query_hash" => query_hash,
+            "total_minutes" => current_query_stats[query_hash]["total_minutes"].to_f + historical_query_stats[query_hash]["total_minutes"].to_f,
+            "calls" => current_query_stats[query_hash]["calls"].to_i + historical_query_stats[query_hash]["calls"].to_i
           }
           value["average_time"] = value["total_minutes"] * 1000 * 60 / value["calls"]
-          value["total_percent"] = value["total_minutes"] * 100.0 / (current_query_stats[query]["all_queries_total_minutes"].to_f + historical_query_stats[query]["all_queries_total_minutes"].to_f)
+          value["total_percent"] = value["total_minutes"] * 100.0 / (current_query_stats[query_hash]["all_queries_total_minutes"].to_f + historical_query_stats[query_hash]["all_queries_total_minutes"].to_f)
           query_stats << value
         end
         sort = options[:sort] || "total_minutes"
@@ -61,24 +62,56 @@ module PgHero
         end
       end
 
+      # resetting query stats will reset across the entire Postgres instance
+      # 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
+      # reset query stats for the Postgres instance with the `capture_query_stats` option
       def capture_query_stats
-        config["databases"].keys.each do |database|
+        # get database names
+        pg_databases = {}
+        supports_query_hash = {}
+        config["databases"].each do |k, _|
+          with(k) do
+            pg_databases[k] = execute("SELECT current_database()").first["current_database"]
+            supports_query_hash[k] = supports_query_hash?
+          end
+        end
+
+        config["databases"].reject { |_, v| v["capture_query_stats"] && v["capture_query_stats"] != true }.each do |database, _|
           with(database) do
+            mapping = {database => pg_databases[database]}
+            config["databases"].select { |_, v| v["capture_query_stats"] == database }.each do |k, _|
+              mapping[k] = pg_databases[k]
+            end
+
             now = Time.now
-            query_stats = self.query_stats(limit: 1000000)
-            if query_stats.any? && reset_query_stats
-              values =
-                query_stats.map do |qs|
-                  [
-                    database,
-                    qs["query"],
-                    qs["total_minutes"].to_f * 60 * 1000,
-                    qs["calls"],
-                    now
-                  ].map { |v| quote(v) }.join(",")
-                end.map { |v| "(#{v})" }.join(",")
-
-              stats_connection.execute("INSERT INTO pghero_query_stats (database, query, total_time, calls, captured_at) VALUES #{values}")
+            query_stats = {}
+            mapping.each do |db, pg_database|
+              query_stats[db] = self.query_stats(limit: 1000000, database: pg_database)
+            end
+
+            if query_stats.any? { |_, v| v.any? } && reset_query_stats
+              query_stats.each do |db, db_query_stats|
+                if db_query_stats.any?
+                  values =
+                    db_query_stats.map do |qs|
+                      values = [
+                        db,
+                        qs["query"],
+                        qs["total_minutes"].to_f * 60 * 1000,
+                        qs["calls"],
+                        now
+                      ]
+                      values << qs["query_hash"] if supports_query_hash[db]
+                      values.map { |v| quote(v) }.join(",")
+                    end.map { |v| "(#{v})" }.join(",")
+
+                  columns = %w[database query total_time calls captured_at]
+                  columns << "query_hash" if supports_query_hash[db]
+                  stats_connection.execute("INSERT INTO pghero_query_stats (#{columns.join(", ")}) VALUES #{values}")
+                end
+              end
             end
           end
         end
@@ -115,22 +148,25 @@ module PgHero
         if query_stats_enabled?
           limit = options[:limit] || 100
           sort = options[:sort] || "total_minutes"
+          database = options[:database] ? quote(options[:database]) : "current_database()"
           select_all <<-SQL
             WITH query_stats AS (
               SELECT
                 query,
-                (total_time / 1000 / 60) as total_minutes,
-                (total_time / calls) as average_time,
+                #{supports_query_hash? ? "queryid" : "md5(query)"} AS query_hash,
+                (total_time / 1000 / 60) AS total_minutes,
+                (total_time / calls) AS average_time,
                 calls
               FROM
                 pg_stat_statements
               INNER JOIN
                 pg_database ON pg_database.oid = pg_stat_statements.dbid
               WHERE
-                pg_database.datname = current_database()
+                pg_database.datname = #{database}
             )
             SELECT
               query,
+              query_hash,
               total_minutes,
               average_time,
               calls,
@@ -153,20 +189,23 @@ module PgHero
           stats_connection.select_all squish <<-SQL
             WITH query_stats AS (
               SELECT
-                query,
-                (SUM(total_time) / 1000 / 60) as total_minutes,
-                (SUM(total_time) / SUM(calls)) as average_time,
-                SUM(calls) as calls
+                #{supports_query_hash? ? "query_hash" : "md5(query)"} AS query_hash,
+                MAX(query) AS query,
+                (SUM(total_time) / 1000 / 60) AS total_minutes,
+                (SUM(total_time) / SUM(calls)) AS average_time,
+                SUM(calls) AS calls
               FROM
                 pghero_query_stats
               WHERE
                 database = #{quote(current_database)}
+                #{supports_query_hash? ? "AND query_hash IS NOT NULL" : ""}
                 #{options[:start_at] ? "AND captured_at >= #{quote(options[:start_at])}" : ""}
                 #{options[:end_at] ? "AND captured_at <= #{quote(options[:end_at])}" : ""}
               GROUP BY
-                query
+                1
             )
             SELECT
+              query_hash,
               query,
               total_minutes,
               average_time,
@@ -183,6 +222,19 @@ module PgHero
           []
         end
       end
+
+      def supports_query_hash?
+        @supports_query_hash ||= {}
+        if @supports_query_hash[current_database].nil?
+          @supports_query_hash[current_database] = server_version >= 90400 && historical_query_stats_enabled? && PgHero::QueryStats.column_names.include?("query_hash")
+        end
+        @supports_query_hash[current_database]
+      end
+
+      def server_version
+        @server_version ||= {}
+        @server_version[current_database] ||= select_all("SHOW server_version_num").first["server_version_num"].to_i
+      end
     end
   end
 end

data/lib/pghero/methods/sequences.rb

@@ -0,0 +1,37 @@
+module PgHero
+  module Methods
+    module Sequences
+      def sequences
+        sequences = select_all <<-SQL
+          SELECT
+            sequence_schema AS schema,
+            table_name AS table,
+            column_name AS column,
+            c.data_type AS column_type,
+            CASE WHEN c.data_type = 'integer' THEN 2147483647::bigint ELSE maximum_value::bigint END AS max_value,
+            sequence_name AS sequence
+          FROM
+            information_schema.columns c
+          INNER JOIN
+            information_schema.sequences iss ON iss.sequence_name = regexp_replace(c.column_default, '^nextval\\(''(.*)''\\:\\:regclass\\)$', '\\1')
+          WHERE
+            column_default LIKE 'nextval%'
+            AND table_catalog = current_database()
+          ORDER BY
+            sequence_name ASC
+        SQL
+
+        select_all(sequences.map { |s| "SELECT last_value FROM #{s["sequence"]}" }.join(" UNION ALL ")).each_with_index do |row, i|
+          sequences[i]["last_value"] = row["last_value"]
+        end
+
+        sequences
+      end
+
+      def sequence_danger(options = {})
+        threshold = (options[:threshold] || 0.9).to_f
+        sequences.select { |s| s["last_value"].to_i / s["max_value"].to_f > threshold }.sort_by { |s| s["max_value"].to_i - s["last_value"].to_i }
+      end
+    end
+  end
+end

data/lib/pghero/methods/suggested_indexes.rb

@@ -274,11 +274,17 @@ module PgHero
         if tree["BOOLEXPR"]
           if tree["BOOLEXPR"]["boolop"] == 0
             tree["BOOLEXPR"]["args"].flat_map { |v| parse_where(v) }
+          else
+            raise "Not Implemented"
           end
         elsif tree["AEXPR AND"]
           left = parse_where(tree["AEXPR AND"]["lexpr"])
           right = parse_where(tree["AEXPR AND"]["rexpr"])
-          left + right if left && right
+          if left && right
+            left + right
+          else
+            raise "Not Implemented"
+          end
         elsif aexpr && ["=", "<>", ">", ">=", "<", "<=", "~~", "~~*", "BETWEEN"].include?(aexpr["name"].first)
           [{column: aexpr["lexpr"]["COLUMNREF"]["fields"].last, op: aexpr["name"].first}]
         elsif tree["AEXPR IN"] && ["=", "<>"].include?(tree["AEXPR IN"]["name"].first)
@@ -286,6 +292,8 @@ module PgHero
         elsif tree["NULLTEST"]
           op = tree["NULLTEST"]["nulltesttype"] == 1 ? "not_null" : "null"
           [{column: tree["NULLTEST"]["arg"]["COLUMNREF"]["fields"].last, op: op}]
+        else
+          raise "Not Implemented"
         end
       end
 

data/lib/pghero/methods/system.rb

@@ -25,9 +25,9 @@ module PgHero
         if system_stats_enabled?
           client =
             if defined?(Aws)
-              Aws::CloudWatch::Client.new(access_key_id: access_key_id, secret_access_key: secret_access_key)
+              Aws::CloudWatch::Client.new(access_key_id: access_key_id, secret_access_key: secret_access_key, region: region)
             else
-              AWS::CloudWatch.new(access_key_id: access_key_id, secret_access_key: secret_access_key).client
+              AWS::CloudWatch.new(access_key_id: access_key_id, secret_access_key: secret_access_key, region: region).client
             end
 
           now = Time.now
@@ -62,6 +62,10 @@ module PgHero
         ENV["PGHERO_SECRET_ACCESS_KEY"] || ENV["AWS_SECRET_ACCESS_KEY"]
       end
 
+      def region
+        ENV["PGHERO_REGION"] || ENV["AWS_REGION"] || (defined?(Aws) && Aws.config[:region]) || "us-east-1"
+      end
+
       def db_instance_identifier
         databases[current_database].db_instance_identifier
       end

data/lib/pghero/version.rb

@@ -1,3 +1,3 @@
 module PgHero
-  VERSION = "1.2.4"
+  VERSION = "1.3.0"
 end

data/test/best_index_test.rb

@@ -130,6 +130,15 @@ class BestIndexTest < Minitest::Test
     assert_no_index "Unknown structure", "SELECT NOW()"
   end
 
+  def test_where_or
+    assert_no_index "Unknown structure", "SELECT FROM users WHERE login_attempts = 0 OR login_attempts = 1"
+  end
+
+  def test_where_nested_or
+    assert_no_index "Unknown structure", "SELECT FROM users WHERE city_id = 1 AND (login_attempts = 0 OR login_attempts = 1)"
+  end
+
+
   def test_multiple_tables
     assert_no_index "JOIN not supported yet", "SELECT * FROM users INNER JOIN cities ON cities.id = users.city_id"
   end

data/test/gemfiles/activerecord41.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in pghero.gemspec
+gemspec path: "../.."
+
+gem "activerecord", "~> 4.1.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pghero
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.3.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-06 00:00:00.000000000 Z
+date: 2016-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -162,6 +162,7 @@ files:
 - lib/pghero/methods/queries.rb
 - lib/pghero/methods/query_stats.rb
 - lib/pghero/methods/replica.rb
+- lib/pghero/methods/sequences.rb
 - lib/pghero/methods/space.rb
 - lib/pghero/methods/suggested_indexes.rb
 - lib/pghero/methods/system.rb
@@ -173,6 +174,7 @@ files:
 - pghero.gemspec
 - test/best_index_test.rb
 - test/explain_test.rb
+- test/gemfiles/activerecord41.gemfile
 - test/suggested_indexes_test.rb
 - test/test_helper.rb
 homepage: https://github.com/ankane/pghero
@@ -208,6 +210,7 @@ test_files:
 - guides/Suggested-Indexes.md
 - test/best_index_test.rb
 - test/explain_test.rb
+- test/gemfiles/activerecord41.gemfile
 - test/suggested_indexes_test.rb
 - test/test_helper.rb
 has_rdoc: