clear_skies 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e7f3e39ee746e315e437e4b03ec2cfd661acfdd
-  data.tar.gz: 571c9c8882415e687f3c25518225f251503e0117
+  metadata.gz: 9b28817b1d9a2d115177165c9b1a2ab8d44aeb43
+  data.tar.gz: 2033b9f62ed98513dc3eb01c3a3ab88d682d2860
 SHA512:
-  metadata.gz: cabc3a1ffd842b584c9d7d4435e4102492bcc63383c9fb079c96da59a625f0078fa2a300b4a0f1e6fc258a9cd479fd17be3d1c2647cbb097a3c4c60c38deb947
-  data.tar.gz: 2c135a5330dd5da45997494e0c3f50a41222c45250d1e81ef3c9fbb62a47c3d8c1cfe051d41fda6af28ffa35245eb7212c400e947fa5fc034a2369ea3567155f
+  metadata.gz: 86fbbf4d79173b447bd66d5539263ede10256bf23c129397b032ebed7e035560ee899f3b067165327ac149f44636f234cf0aa5519479bf7d6132c44774685fe4
+  data.tar.gz: 4333fa6071ffeb618af49418fa01e644cf4729b4bf7ec996c45c5b1bdaf8cd99d81739ecc0f51ff7166b98b1792156b3ef7d6e257e3dac0a7214943ff21b143e

data/README.md

@@ -32,7 +32,7 @@ The SDK searches the following locations for a region:
 To run the exporter simple do:
     $ clear_skies metrics_file
 
-The metrics_file is a ruby script that registers the metrics you wish to export.
+The `metrics_file` is a ruby script that registers the metrics you wish to export.
 
 ``` ruby
 # To grab a generic cloudwatch metric use the following method:
@@ -40,12 +40,12 @@ ClearSkies::Gauge.register(namespace, metric_name,dimensions, statistics) do |la
   labels[:extra] = "label"
   labels[:instance_id] == "something specific"
 end
-
+```
 If you pass a block, it will be called for each dimension retrieved.  The block will be passed a hash of all computed labels, and you may add more if you wish.  If the blocks value is false, that dimension will be skipped.
 
 
 ### RDS Metrics
-There is a helper class for grabbing RDS metrics.  It behaves the same as ClearSkies::Gauge, except that it automatically adds the vpc_id and tags as labels.
+There is a helper class for grabbing RDS metrics.  It behaves the same as `ClearSkies::Gauge`, except that it automatically adds the `vpc_id` and tags as labels.
 
 ``` ruby
 # To grab an RDS metric
@@ -53,7 +53,7 @@ ClearSkies::RDSGauge.register("ReadThroughput", ["DBInstanceIdentifier"], ["Aver
 ```
 
 ### ELB Metrics
-There is a helper class for grabbing ELB metrics.  It behaves the same as ClearSkies::Gauge, except that it automatically adds the vpc_id and tags as labels.
+There is a helper class for grabbing ELB metrics.  It behaves the same as `ClearSkies::Gauge`, except that it automatically adds the `vpc_id` and tags as labels.
 
 ``` ruby
 # To grab an ELB metric
@@ -61,7 +61,7 @@ ClearSkies::ELBGauge.register("Latency", ["LoadBalancerName"], ["Average", "p90"
 ```
 
 ### ElasticBeanstalk Metrics
-There is a helper class for grabbing ElasticBeanstalk metrics.  It behaves the same as ClearSkies::Gauge, except that it automatically adds vpc_id and application_name as labels.
+There is a helper class for grabbing ElasticBeanstalk metrics.  It behaves the same as `ClearSkies::Gauge`, except that it automatically adds `vpc_id` and `application_name` as labels.
 
 ``` ruby
 # To grab an ELB metric

data/clear_skies.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "puma"
   spec.add_dependency "aws-sdk"
+  spec.add_dependency "redis"
   spec.add_dependency "greek_fire", ">= 0.3.0"
   spec.add_dependency "awesome_print"
 

data/exe/clear_skies

@@ -30,7 +30,5 @@ ARGV.each do |config|
   load config
 end
 
-Aws::CloudWatch::Client.add_plugin(ClearSkies::RequestCounterPlugin)
-GreekFire::Counter.register("cloudwatch_requests_total") { ClearSkies::RequestCounter.count }
 
 Rack::Handler::Puma.run ClearSkies::App, options

data/lib/clear_skies.rb

@@ -7,8 +7,9 @@ require "greek_fire"
 require "aws-sdk"
 
 require "clear_skies/app"
-require "clear_skies/metrics/gauge"
-require "clear_skies/metrics/rds_gauge"
-require "clear_skies/metrics/elb_gauge"
-require "clear_skies/metrics/elastic_beanstalk_gauge"
-require "clear_skies/request_counter"
+require "clear_skies/cloud_watch/gauge"
+require "clear_skies/cloud_watch/rds_gauge"
+require "clear_skies/cloud_watch/elb_gauge"
+require "clear_skies/cloud_watch/elastic_beanstalk_gauge"
+require "clear_skies/cloud_watch/request_counter"
+require "clear_skies/redis/report"

data/lib/clear_skies/cloud_watch/elastic_beanstalk_gauge.rb

@@ -0,0 +1,45 @@
+module ClearSkies
+  module CloudWatch
+    class ElasticBeanstalkGauge < ClearSkies::CloudWatch::Gauge
+      def self.client
+        @client ||= Aws::ElasticBeanstalk::Client.new
+      end
+      def initialize(metric_name, dimension, statistics, description: nil, &block)
+        super("AWS/ElasticBeanstalk", metric_name, dimension, statistics, description: description, &block)
+      end
+
+      def application_name(environment_name)
+        ElasticBeanstalkGauge.client.describe_environments({environment_names: [environment_name] }).environments.first&.application_name
+      end
+
+      def vpc_id(application_name, environment_name)
+        config = ElasticBeanstalkGauge.client.describe_configuration_settings({ application_name: application_name, environment_name: environment_name }).
+            configuration_settings.find { |config| config.application_name == application_name && config.environment_name == environment_name}
+        option =  config.option_settings.find { |option| option.namespace == "aws:ec2:vpc" && option.option_name == "VPCId"}
+        option.value if option
+      end
+
+
+      def labels_from_metric(metric)
+        labels = super(metric)
+
+        if labels.has_key?( "environment_name") && !(Rails.cache.fetch("#{labels["environment_name"]}_skip"))
+          application_name = Rails.cache.fetch("#{labels["environment_name"]}_application_name", expires_in: 1.hour) do
+            application_name(labels["environment_name"])
+          end
+          if application_name
+            labels["application_name"] =  application_name
+
+            labels["vpc_id"] = Rails.cache.fetch("#{labels["environment_name"]}_vpc_id_") do
+              vpc_id(labels["application_name"], labels["environment_name"])
+            end
+          end
+        else
+          Rails.cache.write("#{labels["environment_name"]}_skip", true, expires_in: 1.hour, race_condition_ttl: 60.seconds)
+        end
+
+        return labels
+      end
+    end
+  end
+end

data/lib/clear_skies/cloud_watch/elb_gauge.rb

@@ -0,0 +1,44 @@
+module ClearSkies
+  module CloudWatch
+    class ELBGauge < ClearSkies::CloudWatch::Gauge
+      def self.client
+        @client ||= Aws::ElasticLoadBalancing::Client.new
+      end
+      def initialize(metric_name, dimension, statistics, description: nil, &block)
+        super("AWS/ELB", metric_name, dimension, statistics, description: description, &block)
+      end
+
+      def tags(load_balancer_name)
+        labels = {}
+        ELBGauge.client.
+            describe_tags({load_balancer_names: [load_balancer_name]}).
+            tag_descriptions.
+            select {|doc| doc.load_balancer_name == load_balancer_name}.each do |tag_description|
+          tag_description.tags.each do |tag|
+            labels[tag.key.downcase] = tag.value
+          end
+        end
+        labels
+      end
+
+      def labels_from_metric(metric)
+        labels = super(metric)
+
+        if labels.has_key?( "load_balancer_name") && !(Rails.cache.fetch("#{labels["load_balancer_name"]}_skip"))
+
+          labels["vpc_id"] = Rails.cache.fetch("#{labels["load_balancer_name"]}_vpc_id_") do
+            ELBGauge.client.describe_load_balancers(load_balancer_names: [labels["load_balancer_name"]]).load_balancer_descriptions.first.vpc_id
+          end
+
+          labels.merge!(Rails.cache.fetch("#{labels["load_balancer_name"]}_tags_", expires_in: 1.hour, race_condition_ttl: 60.seconds) do
+            tags(labels["load_balancer_name"])
+          end)
+        end
+        labels
+      rescue Aws::ElasticLoadBalancing::Errors::LoadBalancerNotFound
+        Rails.cache.write("#{labels["load_balancer_name"]}_skip", true, expires_in: 1.hour, race_condition_ttl: 60.seconds)
+        return labels
+      end
+    end
+  end
+end

data/lib/clear_skies/cloud_watch/gauge.rb

@@ -0,0 +1,70 @@
+
+module ClearSkies
+  module CloudWatch
+    class Gauge < GreekFire::Gauge
+      include ActiveModel::Conversion
+
+      def self.register(*args, &block)
+        GreekFire::Metric.register(self.new(*args, &block))
+      end
+
+      def initialize(namespace, metric_name, dimensions, statistics, description:nil, &block)
+        super("#{namespace.underscore.gsub("/", "_")}_#{metric_name.underscore}", description: description)
+        @namespace = namespace
+        @metric_name = metric_name
+        @dimensions = dimensions
+        @statistics = statistics.select { |stat| ["SampleCount", "Average", "Sum", "Minimum", "Maximum"].include?(stat.to_s) }
+        @extended_statistics = statistics - @statistics
+
+        @block = block
+      end
+
+      def self.cloudwatch_client
+        @client ||= Aws::CloudWatch::Client.new
+      end
+
+      def aws_metrics
+         Aws::CloudWatch::Resource.new(client: Gauge.cloudwatch_client).metrics(
+            namespace: @namespace,
+            metric_name: @metric_name,
+            dimensions: @dimensions.map {|dimension| {name: dimension} }
+        ).select { |metrics| metrics.dimensions.count == @dimensions.count }
+      end
+
+      def labels_from_metric(metric)
+        metric.dimensions.inject(ActiveSupport::HashWithIndifferentAccess.new) do |labels, dimension|
+          labels[dimension.name.underscore] = dimension.value
+          labels
+        end
+      end
+
+      def metrics
+        aws_metrics.map do |metric|
+          labels = labels_from_metric(metric)
+
+          next unless @block.call(labels) if @block
+
+          stats = metric.get_statistics(
+              start_time: Time.now.advance(minutes: -6),
+              end_time: Time.now.advance(minutes: -5),
+              period: 1,
+              statistics: @statistics,
+              extended_statistics: @extended_statistics,
+              dimensions: metric.dimensions
+          )
+
+          stats.datapoints.map do |datapoint|
+            datapoint.to_h.select {|k, v| ![:unit, :timestamp].include?(k) }.map do |key, value|
+              if (key == :extended_statistics)
+                value.map {|e_key, e_value| GreekFire::Metric.new(name, labels.merge({statistic: e_key}), e_value)}
+              else
+                GreekFire::Metric.new(name, labels.merge({statistic: key}), value)
+              end
+            end
+          end
+
+        end.flatten.compact
+      end
+    end
+  end
+end

data/lib/clear_skies/cloud_watch/rds_gauge.rb

@@ -0,0 +1,37 @@
+module ClearSkies
+  module CloudWatch
+    class RDSGauge < ClearSkies::CloudWatch::Gauge
+      def initialize(metric_name, dimension, statistics, description: nil, &block)
+        super("AWS/RDS", metric_name, dimension, statistics, description: description, &block)
+      end
+
+      def tags(db)
+        labels = {}
+        db.client.list_tags_for_resource(resource_name: db.db_instance_arn).tag_list.each do |tag|
+          labels[tag.key.downcase] = tag.value
+        end
+        labels
+      end
+
+      def labels_from_metric(metric)
+        labels = super(metric)
+
+        if labels.has_key?( "db_instance_identifier") && !(Rails.cache.fetch("#{labels["db_instance_identifier"]}_skip"))
+          db = Aws::RDS::DBInstance.new(labels["db_instance_identifier"])
+
+          labels["vpc_id"] = Rails.cache.fetch("#{labels["db_instance_identifier"]}_vpc_id_") do
+            db.db_subnet_group.vpc_id
+          end
+
+          labels.merge!(Rails.cache.fetch("#{labels["db_instance_identifier"]}_tags_", expires_in: 1.hour, race_condition_ttl: 60.seconds) do
+            tags(db)
+          end)
+        end
+        labels
+      rescue Aws::RDS::Errors::DBInstanceNotFound
+        Rails.cache.write("#{labels["db_instance_identifier"]}_skip", true, expires_in: 1.hour, race_condition_ttl: 60.seconds)
+        return labels
+      end
+    end
+  end
+end

data/lib/clear_skies/cloud_watch/request_counter.rb

@@ -0,0 +1,37 @@
+module ClearSkies
+  module CloudWatch
+    class RequestCounter < Seahorse::Client::Handler
+      @mutex = Mutex.new
+      def self.increment
+        @mutex.synchronize do
+          @count ||= 0
+          @count += 1
+        end
+      end
+
+      def self.count
+        @count ||= 0
+        @count
+      end
+
+      def initialize(handler)
+        @handler = handler
+      end
+
+      def call(context)
+        RequestCounter.increment
+        @handler.call(context)
+      end
+    end
+
+    class RequestCounterPlugin < Seahorse::Client::Plugin
+
+      def add_handlers(handlers, config)
+        handlers.add(RequestCounter, step: :validate)
+      end
+
+    end
+  end
+end
+
+Aws::CloudWatch::Client.add_plugin(ClearSkies::CloudWatch::RequestCounterPlugin)

data/lib/clear_skies/redis/report.rb

@@ -0,0 +1,52 @@
+require 'redis'
+module ClearSkies
+  module Redis
+    class Report
+      def self.register(host, port, extra_labels=nil)
+        extra_labels = Hash.new unless extra_labels
+
+        r = ClearSkies::Redis::Report.new(host, port)
+        databases = Proc.new { ::Redis.new(:host => host, :port => port).info.keys.map {|k| k =~ /^db/ && k.sub("db", "")}.compact }
+
+        GreekFire::Gauge.register("redis_keys",                        labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).keys }
+        GreekFire::Gauge.register("redis_last_save",                   labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).last_save }
+        GreekFire::Gauge.register("redis_uptime",                      labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).uptime }
+        GreekFire::Gauge.register("redis_connected_clients",           labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).connected_clients }
+        GreekFire::Gauge.register("redis_blocked_clients",             labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).blocked_clients }
+        GreekFire::Gauge.register("redis_used_memory",                 labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).used_memory }
+        GreekFire::Gauge.register("redis_mem_fragmentation_ratio",     labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).mem_fragmentation_ratio }
+        GreekFire::Gauge.register("redis_rdb_changes_since_last_save", labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).rdb_changes_since_last_save }
+        GreekFire::Gauge.register("redis_rdb_last_bgsave_time_sec",    labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).rdb_last_bgsave_time_sec }
+        GreekFire::Counter.register("redis_total_commands_processed",  labels: {"database" => databases} ) { | labels| labels.merge!(extra_labels);r.redis_metrics(labels).total_commands_processed }
+      end
+
+
+      def redis_metrics(labels)
+        cache_key = "redis_stats_#{@host}_#{@port}_#{labels["database"]}"
+        Rails.cache.fetch(cache_key, expires_in: 1.second) do
+          redis = ::Redis.new(host: @host, port: @port, db: labels["database"])
+          redis_info = redis.info
+          metrics = OpenStruct.new
+
+          metrics.keys = redis.dbsize
+          metrics.last_save = Time.now.to_i - redis.lastsave
+          metrics.uptime = redis_info["uptime_in_seconds"].to_f
+          metrics.connected_clients =  redis_info["connected_clients"].to_i
+          metrics.blocked_clients =  redis_info["blocked_clients"].to_i
+          metrics.used_memory =  redis_info["used_memory"].to_f
+          metrics.mem_fragmentation_ratio =  redis_info["mem_fragmentation_ratio"].to_f
+          metrics.rdb_changes_since_last_save =  redis_info["rdb_changes_since_last_save"].to_f
+          metrics.rdb_last_bgsave_time_sec =  redis_info["rdb_last_bgsave_time_sec"].to_f
+          metrics.total_commands_processed =  redis_info["total_commands_processed"].to_f
+          metrics
+        end
+      end
+
+      private
+      def initialize(host, port)
+        @host = host
+        @port = port
+      end
+    end
+  end
+end

data/lib/clear_skies/version.rb

@@ -1,3 +1,3 @@
 module ClearSkies
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clear_skies
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Constantine
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-17 00:00:00.000000000 Z
+date: 2017-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puma
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: greek_fire
   requirement: !ruby/object:Gem::Requirement
@@ -116,11 +130,12 @@ files:
 - exe/clear_skies
 - lib/clear_skies.rb
 - lib/clear_skies/app.rb
-- lib/clear_skies/metrics/elastic_beanstalk_gauge.rb
-- lib/clear_skies/metrics/elb_gauge.rb
-- lib/clear_skies/metrics/gauge.rb
-- lib/clear_skies/metrics/rds_gauge.rb
-- lib/clear_skies/request_counter.rb
+- lib/clear_skies/cloud_watch/elastic_beanstalk_gauge.rb
+- lib/clear_skies/cloud_watch/elb_gauge.rb
+- lib/clear_skies/cloud_watch/gauge.rb
+- lib/clear_skies/cloud_watch/rds_gauge.rb
+- lib/clear_skies/cloud_watch/request_counter.rb
+- lib/clear_skies/redis/report.rb
 - lib/clear_skies/version.rb
 homepage: https://github.com/omadahealth/clear_skies
 licenses:

data/lib/clear_skies/metrics/elastic_beanstalk_gauge.rb

@@ -1,41 +0,0 @@
-module ClearSkies
-  class ElasticBeanstalkGauge < ClearSkies::Gauge
-    def self.client
-      @client ||= Aws::ElasticBeanstalk::Client.new
-    end
-    def initialize(metric_name, dimension, statistics, description: nil, &block)
-      super("AWS/ElasticBeanstalk", metric_name, dimension, statistics, description: description, &block)
-    end
-
-    def application_name(environment_name)
-      ElasticBeanstalkGauge.client.describe_environments({environment_names: [environment_name] }).environments.first.application_name
-    end
-
-    def vpc_id(application_name, environment_name)
-      config = ElasticBeanstalkGauge.client.describe_configuration_settings({ application_name: application_name, environment_name: environment_name }).
-          configuration_settings.find { |config| config.application_name == application_name && config.environment_name == environment_name}
-      option =  config.option_settings.find { |option| option.namespace == "aws:ec2:vpc" && option.option_name == "VPCId"}
-      option.value if option
-    end
-
-
-    def labels_from_metric(metric)
-      labels = super(metric)
-
-      if labels.has_key?( "environment_name") && !(Rails.cache.fetch("#{labels["environment_name"]}_skip"))
-
-        labels["application_name"] =  Rails.cache.fetch("#{labels["environment_name"]}_application_name", expires_in: 1.hour) do
-          application_name(labels["environment_name"])
-        end
-
-        labels["vpc_id"] = Rails.cache.fetch("#{labels["environment_name"]}_vpc_id_") do
-          vpc_id(labels["application_name"], labels["environment_name"])
-        end
-      end
-      labels
-    rescue Aws::RDS::Errors::DBInstanceNotFound
-      Rails.cache.write("#{labels["environment_name"]}_skip", true, expires_in: 1.hour, race_condition_ttl: 60.seconds)
-      return labels
-    end
-  end
-end

data/lib/clear_skies/metrics/elb_gauge.rb

@@ -1,42 +0,0 @@
-module ClearSkies
-  class ELBGauge < ClearSkies::Gauge
-    def self.client
-      @client ||= Aws::ElasticLoadBalancing::Client.new
-    end
-    def initialize(metric_name, dimension, statistics, description: nil, &block)
-      super("AWS/ELB", metric_name, dimension, statistics, description: description, &block)
-    end
-
-    def tags(load_balancer_name)
-      labels = {}
-      ELBGauge.client.
-          describe_tags({load_balancer_names: [load_balancer_name]}).
-          tag_descriptions.
-          select {|doc| doc.load_balancer_name == load_balancer_name}.each do |tag_description|
-        tag_description.tags.each do |tag|
-          labels[tag.key.downcase] = tag.value
-        end
-      end
-      labels
-    end
-
-    def labels_from_metric(metric)
-      labels = super(metric)
-
-      if labels.has_key?( "load_balancer_name") && !(Rails.cache.fetch("#{labels["load_balancer_name"]}_skip"))
-
-        labels["vpc_id"] = Rails.cache.fetch("#{labels["load_balancer_name"]}_vpc_id_") do
-          ELBGauge.client.describe_load_balancers(load_balancer_names: [labels["load_balancer_name"]]).load_balancer_descriptions.first.vpc_id
-        end
-
-        labels.merge!(Rails.cache.fetch("#{labels["load_balancer_name"]}_tags_", expires_in: 1.hour, race_condition_ttl: 60.seconds) do
-          tags(labels["load_balancer_name"])
-        end)
-      end
-      labels
-    rescue Aws::RDS::Errors::DBInstanceNotFound
-      Rails.cache.write("#{labels["load_balancer_name"]}_skip", true, expires_in: 1.hour, race_condition_ttl: 60.seconds)
-      return labels
-    end
-  end
-end

data/lib/clear_skies/metrics/gauge.rb

@@ -1,72 +0,0 @@
-
-module ClearSkies
-  class Gauge < GreekFire::Gauge
-    include ActiveModel::Conversion
-
-    def self.register(*args, &block)
-      GreekFire::Metric.register(self.new(*args, &block))
-    end
-
-    def to_partial_path
-      GreekFire::Gauge._to_partial_path
-    end
-
-    def initialize(namespace, metric_name, dimensions, statistics, description:nil, &block)
-      super("#{namespace.underscore.gsub("/", "_")}_#{metric_name.underscore}", description: description)
-      @namespace = namespace
-      @metric_name = metric_name
-      @dimensions = dimensions
-      @statistics = statistics.select { |stat| ["SampleCount", "Average", "Sum", "Minimum", "Maximum"].include?(stat.to_s) }
-      @extended_statistics = statistics - @statistics
-
-      @block = block
-    end
-
-    def self.cloudwatch_client
-      @client ||= Aws::CloudWatch::Client.new
-    end
-
-    def aws_metrics
-       Aws::CloudWatch::Resource.new(client: Gauge.cloudwatch_client).metrics(
-          namespace: @namespace,
-          metric_name: @metric_name,
-          dimensions: @dimensions.map {|dimension| {name: dimension} }
-      ).select { |metrics| metrics.dimensions.count == @dimensions.count }
-    end
-
-    def labels_from_metric(metric)
-      metric.dimensions.inject(ActiveSupport::HashWithIndifferentAccess.new) do |labels, dimension|
-        labels[dimension.name.underscore] = dimension.value
-        labels
-      end
-    end
-
-    def metrics
-      aws_metrics.map do |metric|
-        labels = labels_from_metric(metric)
-
-        next unless @block.call(labels) if @block
-
-        stats = metric.get_statistics(
-            start_time: Time.now.advance(minutes: -6),
-            end_time: Time.now.advance(minutes: -5),
-            period: 1,
-            statistics: @statistics,
-            extended_statistics: @extended_statistics,
-            dimensions: metric.dimensions
-        )
-
-        stats.datapoints.map do |datapoint|
-          datapoint.to_h.select {|k, v| ![:unit, :timestamp].include?(k) }.map do |key, value|
-            if (key == :extended_statistics)
-              value.map {|e_key, e_value| GreekFire::Metric.new(name, labels.merge({statistic: e_key}), e_value)}
-            else
-              GreekFire::Metric.new(name, labels.merge({statistic: key}), value)
-            end
-          end
-        end
-
-      end.flatten.compact
-    end
-  end
-end

data/lib/clear_skies/metrics/rds_gauge.rb

@@ -1,35 +0,0 @@
-module ClearSkies
-  class RDSGauge < ClearSkies::Gauge
-    def initialize(metric_name, dimension, statistics, description: nil, &block)
-      super("AWS/RDS", metric_name, dimension, statistics, description: description, &block)
-    end
-
-    def tags(db)
-      labels = {}
-      db.client.list_tags_for_resource(resource_name: db.db_instance_arn).tag_list.each do |tag|
-        labels[tag.key.downcase] = tag.value
-      end
-      labels
-    end
-
-    def labels_from_metric(metric)
-      labels = super(metric)
-
-      if labels.has_key?( "db_instance_identifier") && !(Rails.cache.fetch("#{labels["db_instance_identifier"]}_skip"))
-        db = Aws::RDS::DBInstance.new(labels["db_instance_identifier"])
-
-        labels["vpc_id"] = Rails.cache.fetch("#{labels["db_instance_identifier"]}_vpc_id_") do
-          db.db_subnet_group.vpc_id
-        end
-
-        labels.merge!(Rails.cache.fetch("#{labels["db_instance_identifier"]}_tags_", expires_in: 1.hour, race_condition_ttl: 60.seconds) do
-          tags(db)
-        end)
-      end
-      labels
-    rescue Aws::RDS::Errors::DBInstanceNotFound
-      Rails.cache.write("#{labels["db_instance_identifier"]}_skip", true, expires_in: 1.hour, race_condition_ttl: 60.seconds)
-      return labels
-    end
-  end
-end

data/lib/clear_skies/request_counter.rb

@@ -1,34 +0,0 @@
-module ClearSkies
-
-  class RequestCounter < Seahorse::Client::Handler
-    @mutex = Mutex.new
-    def self.increment
-      @mutex.synchronize do
-        @count ||= 0
-        @count += 1
-      end
-    end
-
-    def self.count
-      @count ||= 0
-      @count
-    end
-
-    def initialize(handler)
-      @handler = handler
-    end
-
-    def call(context)
-      RequestCounter.increment
-      @handler.call(context)
-    end
-  end
-
-  class RequestCounterPlugin < Seahorse::Client::Plugin
-
-    def add_handlers(handlers, config)
-      handlers.add(RequestCounter, step: :validate)
-    end
-
-  end
-end