pghero 2.4.2 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33927c2c6b6d2c286f872adb99d7095f836108872c4f9af3ca180d6a70cb0b48
-  data.tar.gz: 8f2f7565269047b8a351bd712a931e26febc1b6bd96f21b3c1f81ece50807f8d
+  metadata.gz: 252b8c1bb7580d67b149ef865f97b99a89fbd9aecb640a92f5ebf8a532d7c10b
+  data.tar.gz: 87a9df921265875867cb9d9b0dcd92fa6d6855075818129a8b5bf47337277354
 SHA512:
-  metadata.gz: 76dd17666d9842cad4a540c519df850cf784d97eeccd9792ff853d90a633628b5615459521bc2f5b382e75ffe35b52023e4cf8cfdbabc2924154a6feb7d8c94e
-  data.tar.gz: c0c5ba7f1823182241ca7c8365969a5f661f2abca55551832ee3e64d61eabb5432ad7dcb3e2b9f81b972c125d80bf22f5a55e2ef13a471889fe393b1976d1e10
+  metadata.gz: 9b1f75f5ef19ee10da7ee815aca9ee7933fa89ae78046e495417f7c863f383172fba28bfb00605ac8810a2bb5a9895ae478a3f182ba36204080151f84ad9e2a6
+  data.tar.gz: 6fc630bd5f46fbecb5b6194d58726397c8f28a812e7ceabe12784ed6892bd7f7609646cba22e57c34ab817be40b37e251384f5ba23a32e82199db7620f4dc009

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.5.0 (2020-05-24)
+
+- Added system stats for Google Cloud SQL and Azure Database
+- Added experimental `filter_data` option
+- Localized times on maintenance page
+- Improved connection pooling
+- Improved error message for non-Postgres connections
+- Fixed more deprecation warnings in Ruby 2.7
+
 ## 2.4.2 (2020-04-16)
 
 - Added `connections` method

data/README.md

@@ -12,15 +12,19 @@ A performance dashboard for Postgres
 
 [![Screenshot](https://pghero.dokkuapp.com/assets/pghero-f8abe426e6bf54bb7dba87b425bb809740ebd386208bcd280a7e802b053a1023.png)](https://pghero.dokkuapp.com/)
 
+:tangerine: Battle-tested at [Instacart](https://www.instacart.com/opensource)
+
+[![Build Status](https://travis-ci.org/ankane/pghero.svg?branch=master)](https://travis-ci.org/ankane/pghero) [![Docker Pulls](https://img.shields.io/docker/pulls/ankane/pghero)](https://hub.docker.com/repository/docker/ankane/pghero)
+
 ## Installation
 
-PgHero is available as a Rails engine, Linux package, and Docker image.
+PgHero is available as a Docker image, Linux package, and Rails engine.
 
 Select your preferred method of installation to get started.
 
-- [Rails](guides/Rails.md)
-- [Linux](guides/Linux.md)
 - [Docker](guides/Docker.md)
+- [Linux](guides/Linux.md)
+- [Rails](guides/Rails.md)
 
 ## Related Projects
 
@@ -31,10 +35,17 @@ Select your preferred method of installation to get started.
 
 ## Credits
 
-A big thanks to [Craig Kerstiens](http://www.craigkerstiens.com/2013/01/10/more-on-postgres-performance/) and [Heroku](https://blog.heroku.com/archives/2013/5/10/more_insight_into_your_database_with_pgextras) for the initial queries and [Bootswatch](https://github.com/thomaspark/bootswatch) for the theme :clap:
+A big thanks to [Craig Kerstiens](http://www.craigkerstiens.com/2013/01/10/more-on-postgres-performance/) and [Heroku](https://blog.heroku.com/archives/2013/5/10/more_insight_into_your_database_with_pgextras) for the initial queries and [Bootswatch](https://github.com/thomaspark/bootswatch) for the theme.
 
-Know a bit about PostgreSQL? [Suggestions](https://github.com/ankane/pghero/issues) are greatly appreciated.
+## History
 
-:tangerine: Battle-tested at [Instacart](https://www.instacart.com/opensource)
+View the [changelog](https://github.com/ankane/pghero/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
 
-[![Build Status](https://travis-ci.org/ankane/pghero.svg?branch=master)](https://travis-ci.org/ankane/pghero)
+- [Report bugs](https://github.com/ankane/pghero/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/pghero/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features

data/app/assets/javascripts/pghero/application.js

@@ -59,7 +59,7 @@ function initSlider() {
         html = "Now";
       }
     } else {
-      html = months[time.getMonth()] + " " + time.getDate() + ", " + pad(time.getHours()) + ":" + pad(time.getMinutes());
+      html = time.getDate() + " " + months[time.getMonth()] + " " + pad(time.getHours()) + ":" + pad(time.getMinutes());
     }
     $(selector).html(html);
   }

data/app/controllers/pg_hero/home_controller.rb

@@ -13,6 +13,11 @@ module PgHero
     before_action :ensure_query_stats, only: [:queries]
 
     if PgHero.config["override_csp"]
+      # note: this does not take into account asset hosts
+      # which can be a string with %d or a proc
+      # https://api.rubyonrails.org/classes/ActionView/Helpers/AssetUrlHelper.html
+      # users should set CSP manually if needed
+      # see https://github.com/ankane/pghero/issues/297
       after_action do
         response.headers["Content-Security-Policy"] = "default-src 'self' 'unsafe-inline'"
       end
@@ -198,6 +203,11 @@ module PgHero
         "1 week" => {duration: 1.week, period: 30.minutes},
         "2 weeks" => {duration: 2.weeks, period: 1.hours}
       }
+      if @database.system_stats_provider == :azure
+        # doesn't support 10, just 5 and 15
+        @periods["1 day"][:period] = 15.minutes
+      end
+
       @duration = (params[:duration] || 1.hour).to_i
       @period = (params[:period] || 60.seconds).to_i
 
@@ -209,22 +219,36 @@ module PgHero
     end
 
     def cpu_usage
-      render json: [{name: "CPU", data: @database.cpu_usage(system_params).map { |k, v| [k, v.round] }, library: chart_library_options}]
+      render json: [{name: "CPU", data: @database.cpu_usage(**system_params).map { |k, v| [k, v ? v.round : v] }, library: chart_library_options}]
     end
 
     def connection_stats
-      render json: [{name: "Connections", data: @database.connection_stats(system_params), library: chart_library_options}]
+      render json: [{name: "Connections", data: @database.connection_stats(**system_params), library: chart_library_options}]
     end
 
     def replication_lag_stats
-      render json: [{name: "Lag", data: @database.replication_lag_stats(system_params), library: chart_library_options}]
+      render json: [{name: "Lag", data: @database.replication_lag_stats(**system_params), library: chart_library_options}]
     end
 
     def load_stats
-      render json: [
-        {name: "Read IOPS", data: @database.read_iops_stats(system_params).map { |k, v| [k, v.round] }, library: chart_library_options},
-        {name: "Write IOPS", data: @database.write_iops_stats(system_params).map { |k, v| [k, v.round] }, library: chart_library_options}
-      ]
+      stats =
+        case @database.system_stats_provider
+        when :azure
+          [
+            {name: "IO Consumption", data: @database.azure_stats("io_consumption_percent", **system_params), library: chart_library_options}
+          ]
+        when :gcp
+          [
+            {name: "Read Ops", data: @database.read_iops_stats(**system_params).map { |k, v| [k, v ? v.round : v] }, library: chart_library_options},
+            {name: "Write Ops", data: @database.write_iops_stats(**system_params).map { |k, v| [k, v ? v.round : v] }, library: chart_library_options}
+          ]
+        else
+          [
+            {name: "Read IOPS", data: @database.read_iops_stats(**system_params).map { |k, v| [k, v ? v.round : v] }, library: chart_library_options},
+            {name: "Write IOPS", data: @database.write_iops_stats(**system_params).map { |k, v| [k, v ? v.round : v] }, library: chart_library_options}
+          ]
+        end
+      render json: stats
     end
 
     def free_space_stats
@@ -311,6 +335,7 @@ module PgHero
       @title = "Maintenance"
       @maintenance_info = @database.maintenance_info
       @time_zone = PgHero.time_zone
+      @show_dead_rows = params[:dead_rows]
     end
 
     def kill
@@ -393,7 +418,8 @@ module PgHero
     def system_params
       {
         duration: params[:duration],
-        period: params[:period]
+        period: params[:period],
+        series: true
       }.delete_if { |_, v| v.nil? }
     end
 
@@ -421,6 +447,7 @@ module PgHero
       render_text "No support for Rails API. See https://github.com/pghero/pghero for a standalone app." if Rails.application.config.try(:api_only)
     end
 
+    # TODO return error status code
     def render_text(message)
       render plain: message
     end

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

@@ -30,7 +30,9 @@
           <% end %>
         </td>
         <td class="text-right">
-          <%= button_to "Explain", explain_path, params: {query: query[:query]}, form: {target: "_blank"}, class: "btn btn-info" %>
+          <% unless @database.filter_data %>
+            <%= button_to "Explain", explain_path, params: {query: query[:query]}, form: {target: "_blank"}, class: "btn btn-info" %>
+          <% end %>
           <%= button_to "Kill", kill_path(pid: query[:pid]), class: "btn btn-danger" %>
         </td>
       </tr>

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

@@ -7,6 +7,9 @@
         <th>Table</th>
         <th style="width: 20%;">Last Vacuum</th>
         <th style="width: 20%;">Last Analyze</th>
+        <% if @show_dead_rows %>
+          <th style="width: 20%;">Dead Rows</th>
+        <% end %>
       </tr>
     </thead>
     <tbody>
@@ -21,7 +24,7 @@
           <td>
             <% time = [table[:last_autovacuum], table[:last_vacuum]].compact.max %>
             <% if time %>
-              <%= time.in_time_zone(@time_zone).strftime("%-m/%-e %l:%M %P") %>
+              <%= l time.in_time_zone(@time_zone), format: :short %>
             <% else %>
               <span class="text-muted">Unknown</span>
             <% end %>
@@ -29,11 +32,22 @@
           <td>
             <% time = [table[:last_autoanalyze], table[:last_analyze]].compact.max %>
             <% if time %>
-              <%= time.in_time_zone(@time_zone).strftime("%-m/%-e %l:%M %P") %>
+              <%= l time.in_time_zone(@time_zone), format: :short %>
             <% else %>
               <span class="text-muted">Unknown</span>
             <% end %>
           </td>
+          <% if @show_dead_rows %>
+            <td>
+              <% if table[:live_rows] != 0 %>
+                <%# use live rows only for denominator to make it easier to compare with autovacuum_vacuum_scale_factor %>
+                <%# it's not a true percentage, since it can go above 100% %>
+                <%= (100.0 * table[:dead_rows] / table[:live_rows]).round %>%
+              <% else %>
+                <span class="text-muted">Unknown</span>
+              <% end %>
+            </td>
+          <% end %>
         </tr>
       <% end %>
     </tbody>

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

@@ -18,7 +18,8 @@
     </tbody>
   </table>
 
-  <p>Check out <%= link_to "PgTune", "https://pgtune.leopard.in.ua/", target: "_blank" %> for recommendations. DB version is <%= @database.server_version.split(" ").first.split(".").first(2).join(".") %>.</p>
+  <% version_parts = @database.server_version.split(" ").first.split(".") %>
+  <p>Check out <%= link_to "PgTune", "https://pgtune.leopard.in.ua/", target: "_blank" %> for recommendations. DB version is <%= version_parts[0].to_i >= 10 ? version_parts[0] : version_parts.first(2).join(".") %>.</p>
 </div>
 
 <% if @autovacuum_settings %>

data/lib/generators/pghero/templates/config.yml.tt

@@ -3,6 +3,11 @@ databases:
     # Database URL (defaults to app database)
     # url: <%%= ENV["DATABASE_URL"] %>
 
+    # System stats
+    # aws_db_instance_identifier: my-instance
+    # gcp_database_id: my-project:my-instance
+    # azure_resource_id: my-resource-id
+
   # Add more databases
   # other:
   #   url: <%%= ENV["OTHER_DATABASE_URL"] %>
@@ -33,7 +38,9 @@ databases:
 # stats_database_url: <%%= ENV["PGHERO_STATS_DATABASE_URL"] %>
 
 # AWS configuration (defaults to app AWS config)
-# also need aws_db_instance_identifier with each database
 # aws_access_key_id: ...
 # aws_secret_access_key: ...
 # aws_region: us-east-1
+
+# Filter data from queries (experimental)
+# filter_data: true

data/lib/pghero.rb

@@ -34,9 +34,11 @@ module PgHero
   class Error < StandardError; end
   class NotEnabled < Error; end
 
+  MUTEX = Mutex.new
+
   # settings
   class << self
-    attr_accessor :long_running_query_sec, :slow_query_ms, :slow_query_calls, :explain_timeout_sec, :total_connections_threshold, :cache_hit_rate_threshold, :env, :show_migrations, :config_path
+    attr_accessor :long_running_query_sec, :slow_query_ms, :slow_query_calls, :explain_timeout_sec, :total_connections_threshold, :cache_hit_rate_threshold, :env, :show_migrations, :config_path, :filter_data
   end
   self.long_running_query_sec = (ENV["PGHERO_LONG_RUNNING_QUERY_SEC"] || 60).to_i
   self.slow_query_ms = (ENV["PGHERO_SLOW_QUERY_MS"] || 20).to_i
@@ -47,6 +49,7 @@ module PgHero
   self.env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
   self.show_migrations = true
   self.config_path = ENV["PGHERO_CONFIG_PATH"] || "config/pghero.yml"
+  self.filter_data = ENV["PGHERO_FILTER_DATA"].to_s.size > 0
 
   class << self
     extend Forwardable
@@ -117,7 +120,9 @@ module PgHero
           if databases.empty?
             databases["primary"] = {
               "url" => ENV["PGHERO_DATABASE_URL"] || ActiveRecord::Base.connection_config,
-              "db_instance_identifier" => ENV["PGHERO_DB_INSTANCE_IDENTIFIER"]
+              "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
 
@@ -128,14 +133,20 @@ module PgHero
       end
     end
 
+    # ensure we only have one copy of databases
+    # so there's only one connection pool per database
     def databases
-      @databases ||= begin
-        Hash[
-          config["databases"].map do |id, c|
-            [id.to_sym, PgHero::Database.new(id, c)]
-          end
-        ]
+      unless defined?(@databases)
+        # only use mutex on initialization
+        MUTEX.synchronize do
+          # return if another process initialized while we were waiting
+          return @databases if defined?(@databases)
+
+          @databases = config["databases"].map { |id, c| [id.to_sym, Database.new(id, c)] }.to_h
+        end
       end
+
+      @databases
     end
 
     def primary_database

data/lib/pghero/database.rb

@@ -23,6 +23,11 @@ module PgHero
     def initialize(id, config)
       @id = id
       @config = config || {}
+
+      # preload model to ensure only one connection pool
+      # this doesn't actually start any connections
+      @adapter_checked = false
+      @connection_model = build_connection_model
     end
 
     def name
@@ -73,8 +78,43 @@ module PgHero
       config["aws_region"] || PgHero.config["aws_region"] || ENV["PGHERO_REGION"] || ENV["AWS_REGION"] || (defined?(Aws) && Aws.config[:region]) || "us-east-1"
     end
 
+    # environment variable is only used if no config file
     def aws_db_instance_identifier
-      @db_instance_identifier ||= config["aws_db_instance_identifier"] || config["db_instance_identifier"]
+      @aws_db_instance_identifier ||= config["aws_db_instance_identifier"] || config["db_instance_identifier"]
+    end
+
+    # environment variable is only used if no config file
+    def gcp_database_id
+      @gcp_database_id ||= config["gcp_database_id"]
+    end
+
+    # environment variable is only used if no config file
+    def azure_resource_id
+      @azure_resource_id ||= config["azure_resource_id"]
+    end
+
+    # must check keys for booleans
+    def filter_data
+      unless defined?(@filter_data)
+        @filter_data =
+          if config.key?("filter_data")
+            config["filter_data"]
+          elsif PgHero.config.key?("filter_data")
+            PgHero.config.key?("filter_data")
+          else
+            PgHero.filter_data
+          end
+
+        if @filter_data
+          begin
+            require "pg_query"
+          rescue LoadError
+            raise Error, "pg_query required for filter_data"
+          end
+        end
+      end
+
+      @filter_data
     end
 
     # TODO remove in next major version
@@ -85,27 +125,46 @@ module PgHero
 
     private
 
+    # check adapter lazily
     def connection_model
-      @connection_model ||= begin
-        url = config["url"]
-        if !url && config["spec"]
-          raise Error, "Spec requires Rails 6+" unless PgHero.spec_supported?
-          resolved = ActiveRecord::Base.configurations.configs_for(env_name: PgHero.env, spec_name: config["spec"], include_replicas: true)
-          raise Error, "Spec not found: #{config["spec"]}" unless resolved
-          url = resolved.config
+      unless @adapter_checked
+        # rough check for Postgres adapter
+        # keep this message generic so it's useful
+        # when empty url set in Docker image pghero.yml
+        unless @connection_model.connection.adapter_name =~ /postg/i
+          raise Error, "Invalid connection URL"
         end
-        Class.new(PgHero::Connection) do
-          def self.name
-            "PgHero::Connection::Database#{object_id}"
-          end
-          case url
-          when String
-            url = "#{url}#{url.include?("?") ? "&" : "?"}connect_timeout=5" unless url.include?("connect_timeout=")
-          when Hash
-            url[:connect_timeout] ||= 5
-          end
-          establish_connection url if url
+        @adapter_checked = true
+      end
+
+      @connection_model
+    end
+
+    # just return the model
+    # do not start a connection
+    def build_connection_model
+      url = config["url"]
+
+      # resolve spec
+      if !url && config["spec"]
+        raise Error, "Spec requires Rails 6+" unless PgHero.spec_supported?
+        resolved = ActiveRecord::Base.configurations.configs_for(env_name: PgHero.env, spec_name: config["spec"], include_replicas: true)
+        raise Error, "Spec not found: #{config["spec"]}" unless resolved
+        url = resolved.config
+      end
+
+      Class.new(PgHero::Connection) do
+        def self.name
+          "PgHero::Connection::Database#{object_id}"
+        end
+
+        case url
+        when String
+          url = "#{url}#{url.include?("?") ? "&" : "?"}connect_timeout=5" unless url.include?("connect_timeout=")
+        when Hash
+          url[:connect_timeout] ||= 5
         end
+        establish_connection url if url
       end
     end
   end

data/lib/pghero/methods/basic.rb

@@ -32,13 +32,34 @@ module PgHero
 
       private
 
-      def select_all(sql, conn = nil)
+      def select_all(sql, conn: nil, query_columns: [])
         conn ||= connection
         # squish for logs
         retries = 0
         begin
           result = conn.select_all(add_source(squish(sql)))
-          result.map { |row| Hash[row.map { |col, val| [col.to_sym, result.column_types[col].send(:cast_value, val)] }] }
+          result = result.map { |row| Hash[row.map { |col, val| [col.to_sym, result.column_types[col].send(:cast_value, val)] }] }
+          if filter_data
+            query_columns.each do |column|
+              result.each do |row|
+                begin
+                  row[column] = PgQuery.normalize(row[column])
+                rescue PgQuery::ParseError
+                  # try replacing "interval $1" with "$1::interval"
+                  # see https://github.com/lfittl/pg_query/issues/169 for more info
+                  # this is not ideal since it changes the query slightly
+                  # we could skip normalization
+                  # but this has a very small chance of data leakage
+                  begin
+                    row[column] = PgQuery.normalize(row[column].gsub(/\binterval\s+(\$\d+)\b/i, "\\1::interval"))
+                  rescue PgQuery::ParseError
+                    row[column] = "<unable to filter data>"
+                  end
+                end
+              end
+            end
+          end
+          result
         rescue ActiveRecord::StatementInvalid => e
           # fix for random internal errors
           if e.message.include?("PG::InternalError") && retries < 2
@@ -51,8 +72,8 @@ module PgHero
         end
       end
 
-      def select_all_stats(sql)
-        select_all(sql, stats_connection)
+      def select_all_stats(sql, **options)
+        select_all(sql, **options, conn: stats_connection)
       end
 
       def select_all_size(sql)
@@ -63,12 +84,12 @@ module PgHero
         result
       end
 
-      def select_one(sql, conn = nil)
-        select_all(sql, conn).first.values.first
+      def select_one(sql, conn: nil)
+        select_all(sql, conn: conn).first.values.first
       end
 
       def select_one_stats(sql)
-        select_one(sql, stats_connection)
+        select_one(sql, conn: stats_connection)
       end
 
       def execute(sql)

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
@@ -33,7 +35,7 @@ module PgHero
       # from https://wiki.postgresql.org/wiki/Lock_Monitoring
       # 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

@@ -166,7 +166,7 @@ module PgHero
         if query_stats_enabled?
           limit ||= 100
           sort ||= "total_minutes"
-          select_all <<-SQL
+          query = <<-SQL
             WITH query_stats AS (
               SELECT
                 LEFT(query, 10000) AS query,
@@ -200,6 +200,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 +213,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 +249,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

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 require AWS 2+ automatically
+      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,14 +74,180 @@ 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
+
+      private
+
+      def gcp_stats(metric_name, duration: nil, period: nil, offset: nil, series: false)
+        require "google/cloud/monitoring"
+
+        # 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
+
+        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
+
+        # 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
+
+        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
+        )
+
+        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 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
+
+      # 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 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

data/lib/pghero/version.rb

@@ -1,3 +1,3 @@
 module PgHero
-  VERSION = "2.4.2"
+  VERSION = "2.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pghero
 version: !ruby/object:Gem::Version
-  version: 2.4.2
+  version: 2.5.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-16 00:00:00.000000000 Z
+date: 2020-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord