riemann-tools 1.0.0 → 1.1.0

data/lib/riemann/tools.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Riemann
   module Tools
     require 'optimist'
@@ -9,36 +11,36 @@ module Riemann
           new.run
         end
 
-        def opt(*a)
-          a.unshift :opt
+        def opt(*args)
+          args.unshift :opt
           @opts ||= []
-          @opts << a
+          @opts << args
         end
 
         def options
           p = Optimist::Parser.new
           @opts.each do |o|
-            p.send *o
+            p.send(*o)
           end
-          Optimist::with_standard_exception_handling(p) do
+          Optimist.with_standard_exception_handling(p) do
             p.parse ARGV
           end
         end
 
-        opt :host, "Riemann host", :default => '127.0.0.1'
-        opt :port, "Riemann port", :default => 5555
-        opt :event_host, "Event hostname", :type => String
-        opt :interval, "Seconds between updates", :default => 5
-        opt :tag, "Tag to add to events", :type => String, :multi => true
-        opt :ttl, "TTL for events", :type => Integer
-        opt :attribute, "Attribute to add to the event", :type => String, :multi => true
-        opt :timeout, "Timeout (in seconds) when waiting for acknowledgements", :default => 30
-        opt :tcp, "Use TCP transport instead of UDP (improves reliability, slight overhead.", :default => true
-        opt :tls, "Use TLS for securing traffic", :default => false
-        opt :tls_key, "TLS Key to use when using TLS", :type => String
-        opt :tls_cert, "TLS Certificate to use when using TLS", :type => String
-        opt :tls_ca_cert, "Trusted CA Certificate when using TLS", :type => String
-        opt :tls_verify, "Verify TLS peer when using TLS", :default => true
+        opt :host, 'Riemann host', default: '127.0.0.1'
+        opt :port, 'Riemann port', default: 5555
+        opt :event_host, 'Event hostname', type: String
+        opt :interval, 'Seconds between updates', default: 5
+        opt :tag, 'Tag to add to events', type: String, multi: true
+        opt :ttl, 'TTL for events', type: Integer
+        opt :attribute, 'Attribute to add to the event', type: String, multi: true
+        opt :timeout, 'Timeout (in seconds) when waiting for acknowledgements', default: 30
+        opt :tcp, 'Use TCP transport instead of UDP (improves reliability, slight overhead.', default: true
+        opt :tls, 'Use TLS for securing traffic', default: false
+        opt :tls_key, 'TLS Key to use when using TLS', type: String
+        opt :tls_cert, 'TLS Certificate to use when using TLS', type: String
+        opt :tls_ca_cert, 'Trusted CA Certificate when using TLS', type: String
+        opt :tls_verify, 'Verify TLS peer when using TLS', default: true
       end
     end
 
@@ -46,14 +48,12 @@ module Riemann
     def options
       @options ||= self.class.options
     end
-    alias :opts :options
+    alias opts options
 
     def attributes
       @attributes ||= Hash[options[:attribute].map do |attr|
-        k,v = attr.split(/=/)
-        if k and v
-          [k,v]
-        end
+        k, v = attr.split(/=/)
+        [k, v] if k && v
       end]
     end
 
@@ -65,9 +65,7 @@ module Riemann
 
       event[:ttl] ||= (options[:ttl] || (options[:interval] * 2))
 
-      if options[:event_host]
-        event[:host] = options[:event_host].dup
-      end
+      event[:host] = options[:event_host].dup if options[:event_host]
 
       event = event.merge(attributes)
 
@@ -76,14 +74,14 @@ module Riemann
 
     def new_riemann_client
       r = Riemann::Client.new(
-        :host    => options[:host],
-        :port    => options[:port],
-        :timeout => options[:timeout],
-        :ssl        => options[:tls],
-        :key_file   => options[:tls_key],
-        :cert_file  => options[:tls_cert],
-        :ca_file    => options[:tls_ca_cert],
-        :ssl_verify => options[:tls_verify],
+        host: options[:host],
+        port: options[:port],
+        timeout: options[:timeout],
+        ssl: options[:tls],
+        key_file: options[:tls_key],
+        cert_file: options[:tls_cert],
+        ca_file: options[:tls_ca_cert],
+        ssl_verify: options[:tls_verify],
       )
       if options[:tcp] || options[:tls]
         r.tcp
@@ -95,15 +93,15 @@ module Riemann
     def riemann
       @riemann ||= new_riemann_client
     end
-    alias :r :riemann
+    alias r riemann
 
     def run
       t0 = Time.now
       loop do
         begin
           tick
-        rescue => e
-          $stderr.puts "#{e.class} #{e}\n#{e.backtrace.join "\n"}"
+        rescue StandardError => e
+          warn "#{e.class} #{e}\n#{e.backtrace.join "\n"}"
         end
 
         # Sleep.
@@ -111,7 +109,6 @@ module Riemann
       end
     end
 
-    def tick
-    end
+    def tick; end
   end
 end

data/riemann-tools.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = 'Collection of utilities which submit events to Riemann,'
   spec.homepage      = 'https://github.com/aphyr/riemann-tools'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
 
   spec.metadata['allowed_push_host'] = 'https://rubygems.org/'
 
@@ -36,4 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'github_changelog_generator'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rake'
+  spec.add_development_dependency 'rubocop-rspec'
 end

data/tools/riemann-aws/{Rakefile.rb → Rakefile}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'rubygems/package_task'
 require 'rdoc/task'

data/tools/riemann-aws/bin/riemann-aws-billing

@@ -1,84 +1,90 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 require 'riemann/tools'
 
 $0 = __FILE__
 
-class Riemann::Tools::AWSBilling
-  include Riemann::Tools
-  require 'fog'
-
-  opt :fog_credentials_file, "Fog credentials file", :type => String
-  opt :fog_credential, "Fog credentials to use", :type => String
+module Riemann
+  module Tools
+    class AWSBilling
+      include Riemann::Tools
+      require 'fog'
 
-  opt :access_key, "AWS access key", :type => String
-  opt :secret_key, "Secret access key", :type => String
-  opt :services, "AWS services: AmazonEC2  AmazonS3  AWSDataTransfer", :type => :strings, :multi => true, :default => ["AmazonEC2", "AmazonS3", "AWSDataTransfer"]
+      opt :fog_credentials_file, 'Fog credentials file', type: String
+      opt :fog_credential, 'Fog credentials to use', type: String
 
-  opt :time_start, "Start time in seconds of the metrics period (2hrs ago default)", :type => Integer, :default => 7200
-  opt :time_end, "End time in seconds of the metrics period ", :type => Integer, :default => 60
+      opt :access_key, 'AWS access key', type: String
+      opt :secret_key, 'Secret access key', type: String
+      opt :services, 'AWS services: AmazonEC2  AmazonS3  AWSDataTransfer', type: :strings, multi: true,
+                                                                           default: %w[AmazonEC2 AmazonS3 AWSDataTransfer]
 
+      opt :time_start, 'Start time in seconds of the metrics period (2hrs ago default)', type: Integer,
+                                                                                         default: 7200
+      opt :time_end, 'End time in seconds of the metrics period ', type: Integer, default: 60
 
-  def initialize
-    if options[:fog_credentials_file]
-      Fog.credentials_path = opts[:fog_credentials_file]
-      Fog.credential = opts[:fog_credential].to_sym
-      @cloudwatch = Fog::AWS::CloudWatch.new
-    else
-      if opts.has_key?('secret_key') and opts.has_key?('access_key')
-        creds = {
-          :aws_secret_access_key => opts[:secret_key],
-          :aws_access_key_id => opts[:access_key]
-        }
-      else
-        creds = { :use_iam_profile => true }
+      def initialize
+        if options[:fog_credentials_file]
+          Fog.credentials_path = opts[:fog_credentials_file]
+          Fog.credential = opts[:fog_credential].to_sym
+          @cloudwatch = Fog::AWS::CloudWatch.new
+        else
+          creds = if opts.key?('secret_key') && opts.key?('access_key')
+                    {
+                      aws_secret_access_key: opts[:secret_key],
+                      aws_access_key_id: opts[:access_key],
+                    }
+                  else
+                    { use_iam_profile: true }
+                  end
+          @cloudwatch = Fog::AWS::CloudWatch.new(creds)
+        end
+        @start_time = (Time.now.utc - opts[:time_start]).iso8601
+        @end_time = (Time.now.utc - opts[:time_end]).iso8601
       end
-      @cloudwatch = Fog::AWS::CloudWatch.new(creds)
-    end
-    @start_time = (Time.now.utc - opts[:time_start]).iso8601
-    @end_time = (Time.now.utc - opts[:time_end]).iso8601
-  end
-
-  def tick
-    opts[:services].each do |service|
-      data = @cloudwatch.get_metric_statistics({
-                                                 'Statistics' => ["Maximum"],
-                                                 'StartTime' => @start_time,
-                                                 'EndTime' => @end_time,
-                                                 'Period' => 3600,
-                                                 'Unit' => "None",
-                                                 'MetricName' => "EstimatedCharges",
-                                                 'Namespace' => "AWS/Billing",
-                                                 'Dimensions' => [
-                                                                  {
-                                                                    'Name' => "ServiceName",
-                                                                    'Value' => service
-                                                                  },
-                                                                  {
-                                                                    'Name' => "Currency",
-                                                                    'Value' => "USD"
-                                                                  }
-                                                                 ]
-                                               }).body['GetMetricStatisticsResult']['Datapoints']
 
+      def tick
+        opts[:services].each do |service|
+          data = @cloudwatch.get_metric_statistics({
+                                                     'Statistics' => ['Maximum'],
+                                                     'StartTime'  => @start_time,
+                                                     'EndTime'    => @end_time,
+                                                     'Period'     => 3600,
+                                                     'Unit'       => 'None',
+                                                     'MetricName' => 'EstimatedCharges',
+                                                     'Namespace'  => 'AWS/Billing',
+                                                     'Dimensions' => [
+                                                       {
+                                                         'Name'  => 'ServiceName',
+                                                         'Value' => service,
+                                                       },
+                                                       {
+                                                         'Name'  => 'Currency',
+                                                         'Value' => 'USD',
+                                                       },
+                                                     ],
+                                                   }).body['GetMetricStatisticsResult']['Datapoints']
 
-      data.each do |metrics|
-        name = "AWScloudwatch.Billing." + service
-        value = metrics["Maximum"]
-        timestamp = metrics["Timestamp"].to_i
+          data.each do |metrics|
+            name = "AWScloudwatch.Billing.#{service}"
+            value = metrics['Maximum']
+            timestamp = metrics['Timestamp'].to_i
 
-        event = {
-          host: nil,
-          service: name,
-          time: timestamp,
-          description: "AWS Estimate Charges for #{service}",
-          tags: ["aws_billing"],
-          state: "ok",
-          metric: value
-        }
+            event = {
+              host: nil,
+              service: name,
+              time: timestamp,
+              description: "AWS Estimate Charges for #{service}",
+              tags: ['aws_billing'],
+              state: 'ok',
+              metric: value,
+            }
 
-        report event
+            report event
+          end
+        end
       end
     end
   end

data/tools/riemann-aws/bin/riemann-aws-rds-status

@@ -1,54 +1,68 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 require 'riemann/tools'
 
 $0 = __FILE__ # Let's not expose our AWS keys in the process list
 
-class Riemann::Tools::AWS
-  include Riemann::Tools
-  require 'fog'
-  require 'date'
-  require 'time'
-  require 'json'
-
-  opt :access_key, "AWS access key", :type => String
-  opt :secret_key, "Secret access key", :type => String
-  opt :region, "AWS region", :type => String, :default => 'eu-west-1'
-  opt :dbinstance_identifier, "DBInstanceIdentifier", :type => String
-  def initialize
-    abort "FATAL: specify a DB instance name, see --help for usage" unless opts[:dbinstance_identifier]
-    if opts[:access_key] and opts[:secret_key]
-      creds = {
-        :aws_access_key_id => opts[:access_key],
-        :aws_secret_access_key => opts[:secret_key]
-      }
-    else
-      creds = { :use_iam_profile => true }
-    end
-    creds['region'] = opts[:region]
-    @cloudwatch = Fog::AWS::CloudWatch.new(creds)
-  end
+module Riemann
+  module Tools
+    class AWS
+      include Riemann::Tools
+      require 'fog'
+      require 'date'
+      require 'time'
+      require 'json'
 
-  def tick
-    time = Time.new
-    ['DatabaseConnections', 'FreeableMemory', 'FreeStorageSpace', 'NetworkReceiveThroughput', 'NetworkTransmitThroughput', 'ReadThroughput', 'CPUUtilization'].each do |metric|
-      result = @cloudwatch.get_metric_statistics({"Namespace" => 'AWS/RDS', "MetricName" => "#{metric}", "Statistics" => 'Average', "Dimensions" => [{"Name" => "DBInstanceIdentifier", "Value" => "#{opts[:dbinstance_identifier]}"}], "StartTime" => (time-120).to_time.iso8601, "EndTime" => time.to_time.iso8601, "Period" => 60})
-      metricsResult = result.data[:body]['GetMetricStatisticsResult']
-      if (metricsResult['Datapoints'].length>0)
-        datapoint = metricsResult['Datapoints'][0]
-        ev = {:metric => datapoint['Average'],
-              :service => "#{opts[:dbinstance_identifier]}.#{metric} (#{datapoint['Unit']})",
-              :description => JSON.dump(metricsResult),
-              :state => "ok",
-              :ttl => 300}
-
-
-        report ev
+      opt :access_key, 'AWS access key', type: String
+      opt :secret_key, 'Secret access key', type: String
+      opt :region, 'AWS region', type: String, default: 'eu-west-1'
+      opt :dbinstance_identifier, 'DBInstanceIdentifier', type: String
+      def initialize
+        abort 'FATAL: specify a DB instance name, see --help for usage' unless opts[:dbinstance_identifier]
+        creds = if opts[:access_key] && opts[:secret_key]
+                  {
+                    aws_access_key_id: opts[:access_key],
+                    aws_secret_access_key: opts[:secret_key],
+                  }
+                else
+                  { use_iam_profile: true }
+                end
+        creds['region'] = opts[:region]
+        @cloudwatch = Fog::AWS::CloudWatch.new(creds)
       end
 
+      def tick
+        time = Time.new
+        %w[DatabaseConnections FreeableMemory FreeStorageSpace NetworkReceiveThroughput
+           NetworkTransmitThroughput ReadThroughput CPUUtilization].each do |metric|
+          result = @cloudwatch.get_metric_statistics(
+            'Namespace'  => 'AWS/RDS',
+            'MetricName' => metric.to_s,
+            'Statistics' => 'Average',
+            'Dimensions' => [{ 'Name' => 'DBInstanceIdentifier', 'Value' => opts[:dbinstance_identifier].to_s }],
+            'StartTime'  => (time - 120).to_time.iso8601,
+            'EndTime'    => time.to_time.iso8601, 'Period' => 60,
+          )
+          metrics_result = result.data[:body]['GetMetricStatisticsResult']
+          next unless metrics_result['Datapoints'].length.positive?
+
+          datapoint = metrics_result['Datapoints'][0]
+          ev = {
+            metric: datapoint['Average'],
+            service: "#{opts[:dbinstance_identifier]}.#{metric} (#{datapoint['Unit']})",
+            description: JSON.dump(metrics_result),
+            state: 'ok',
+            ttl: 300,
+          }
+
+          report ev
+        end
+      end
     end
   end
 end
 
-Riemann::Tools::AWS.run
+Riemann::Tools::AWS.run

data/tools/riemann-aws/bin/riemann-aws-sqs-status

@@ -1,42 +1,48 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 require 'riemann/tools'
 
 $0 = __FILE__ # Let's not expose our AWS keys in the process list
 
-class Riemann::Tools::AWS
-  include Riemann::Tools
-  require 'fog'
+module Riemann
+  module Tools
+    class AWS
+      include Riemann::Tools
+      require 'fog'
 
-  opt :access_key, "AWS access key", :type => String
-  opt :secret_key, "Secret access key", :type => String
-  opt :region, "AWS region", :type => String, :default => 'us-east-1'
-  opt :queue, "SQS Queue name", :type => String
-  def initialize
-    if opts.has_key?('access_key') and opts.has_key?('secret_key')
-      creds = {
-        :aws_access_key_id => opts[:access_key],
-        :aws_secret_access_key => opts[:secret_key]
-      }
-    else
-      creds = { :use_iam_profile => true }
-    end
-    creds['region'] = opts[:region]
-    @sqs = Fog::AWS::SQS.new(creds)
-    response = @sqs.list_queues({'QueueNamePrefix' => opts[:queue]})
-    @queue_url = response[:body]['QueueUrls'].first
-  end
+      opt :access_key, 'AWS access key', type: String
+      opt :secret_key, 'Secret access key', type: String
+      opt :region, 'AWS region', type: String, default: 'us-east-1'
+      opt :queue, 'SQS Queue name', type: String
+      def initialize
+        creds = if opts.key?('access_key') && opts.key?('secret_key')
+                  {
+                    aws_access_key_id: opts[:access_key],
+                    aws_secret_access_key: opts[:secret_key],
+                  }
+                else
+                  { use_iam_profile: true }
+                end
+        creds['region'] = opts[:region]
+        @sqs = Fog::AWS::SQS.new(creds)
+        response = @sqs.list_queues({ 'QueueNamePrefix' => opts[:queue] })
+        @queue_url = response[:body]['QueueUrls'].first
+      end
 
-  def tick
-    response = @sqs.get_queue_attributes(@queue_url, 'All')
-    ['ApproximateNumberOfMessages', 'ApproximateNumberOfMessagesNotVisible'].each do |attr|
-      msg = {
-        metric: response[:body]['Attributes'][attr],
-        service: "#{opts[:queue]} #{attr}",
-        state: 'ok'
-      }
-      report msg
+      def tick
+        response = @sqs.get_queue_attributes(@queue_url, 'All')
+        %w[ApproximateNumberOfMessages ApproximateNumberOfMessagesNotVisible].each do |attr|
+          msg = {
+            metric: response[:body]['Attributes'][attr],
+            service: "#{opts[:queue]} #{attr}",
+            state: 'ok',
+          }
+          report msg
+        end
+      end
     end
   end
 end

data/tools/riemann-aws/bin/riemann-aws-status

@@ -1,68 +1,80 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 require 'riemann/tools'
 
-$0 = __FILE__  # Let's not expose our AWS keys in the process list
+$0 = __FILE__ # Let's not expose our AWS keys in the process list
 
-class Riemann::Tools::AWS
-  include Riemann::Tools
-  require 'fog'
-  require 'date'
+module Riemann
+  module Tools
+    class AWS
+      include Riemann::Tools
+      require 'fog'
+      require 'date'
 
-  opt :access_key, "AWS access key", :type => String
-  opt :secret_key, "Secret access key", :type => String
-  opt :region, "AWS region", :type => String, :default => 'eu-west-1'
+      opt :access_key, 'AWS access key', type: String
+      opt :secret_key, 'Secret access key', type: String
+      opt :region, 'AWS region', type: String, default: 'eu-west-1'
 
-  opt :retirement_critical, "Number of days before retirement. Defaults to 2", :default => 2
-  opt :event_warning, "Number of days before event. Defaults to nil (i.e. when the event appears)", :default => nil
+      opt :retirement_critical, 'Number of days before retirement. Defaults to 2', default: 2
+      opt :event_warning, 'Number of days before event. Defaults to nil (i.e. when the event appears)', default: nil
 
-  def initialize
-    if opts.has_key?('secret_key') and opts.has_key?('access_key')
-      creds = {
-        :aws_secret_access_key => opts[:secret_key],
-        :aws_access_key_id => opts[:access_key]
-      }
-    else
-      creds = { :use_iam_profile => true }
-    end
-    creds['region'] = opts[:region]
-    creds['provider'] = 'AWS'
-    @compute = Fog::Compute.new(creds)
-  end
+      def initialize
+        creds = if opts.key?('secret_key') && opts.key?('access_key')
+                  {
+                    aws_secret_access_key: opts[:secret_key],
+                    aws_access_key_id: opts[:access_key],
+                  }
+                else
+                  { use_iam_profile: true }
+                end
+        creds['region'] = opts[:region]
+        creds['provider'] = 'AWS'
+        @compute = Fog::Compute.new(creds)
+      end
 
-  def tick
-    instance_status = @compute.describe_instance_status.body["instanceStatusSet"]
-    status = instance_status.inject({}) do |acc,i|
-      acc[i.delete("instanceId")] = i
-      acc
-    end
+      def tick
+        # XXX: needs work:
+        #   * instance_status and status seems unused
+        #   * where is inject comming from
+        # It looks line the only needed line for the 2 next paragraph is the one that assigns hosts.
+        instance_status = @compute.describe_instance_status.body['instanceStatusSet']
+        status = instance_status.each_with_object({}) do |i, acc|
+          acc[i.delete('instanceId')] = i
+        end
 
-    hosts = @compute.servers.select { |s| s.state == "running" }
-      inject([status, {}]) do |(status, acc), host|
-        acc[host.private_dns_name] = status.delete(host.id); [status, acc]
-      end[1]
+        hosts = @compute.servers.select { |s| s.state == 'running' }
+        inject([status, {}]) do |(astatus, acc), host|
+          acc[host.private_dns_name] = astatus.delete(host.id)
+          [astatus, acc]
+        end[1]
 
-    hosts.each do |host, status|
-      status['eventsSet'].each do |event|
-        before, after = ['notBefore', 'notAfter'].map { |k| Date.parse event[k].to_s if event[k] }
+        hosts.each do |host, host_status|
+          host_status['eventsSet'].each do |event|
+            before, _after = %w[notBefore notAfter].map { |k| Date.parse event[k].to_s if event[k] }
 
-        ev = {:host => host,
-              :service => "aws_instance_status",
-              :description => "#{event['code']}\n\nstart #{event['notBefore']}\nend #{event['notAfter']}\n\n#{event['description']}",
-              :state => "ok",
-              :ttl => 300}
+            ev = {
+              host: host,
+              service: 'aws_instance_status',
+              description: "#{event['code']}\n\nstart #{event['notBefore']}\nend #{event['notAfter']}\n\n#{event['description']}",
+              state: 'ok',
+              ttl: 300,
+            }
 
-        ev2 = if (event['code'] == 'instance-retirement') and
-          Date.today >= before-opts[:retirement_critical]
-          {:state => "critical"}
-        elsif opts[:event_warning] and Date.today >= before-opts[:event_warning]
-          {:state => "warning"}
-        else
-          {:state => "warning"}
-        end
+            ev2 = if (event['code'] == 'instance-retirement') &&
+                     (Date.today >= before - opts[:retirement_critical])
+                    { state: 'critical' }
+                  elsif opts[:event_warning] && (Date.today >= before - opts[:event_warning])
+                    { state: 'warning' }
+                  else
+                    { state: 'warning' }
+                  end
 
-        report ev.merge(ev2)
+            report ev.merge(ev2)
+          end
+        end
       end
     end
   end