riemann-tools 1.0.0 → 1.2.0

data/lib/riemann/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Riemann
   module Tools # :nodoc:
-    VERSION = '1.0.0'
+    VERSION = '1.2.0'
   end
 end

data/lib/riemann/tools/zookeeper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Gathers zookeeper STATS and submits them to Riemann.
+module Riemann
+  module Tools
+    class Zookeeper
+      include Riemann::Tools
+      require 'socket'
+
+      opt :zookeeper_host, 'Zookeeper hostname', default: 'localhost'
+      opt :zookeeper_port, 'Zookeeper port', default: 2181
+
+      def tick
+        sock = TCPSocket.new(opts[:zookeeper_host], opts[:zookeeper_port])
+        sock.sync = true
+        sock.print('mntr')
+        sock.flush
+
+        loop do
+          stats = sock.gets
+
+          break if stats.nil?
+
+          m = stats.match(/^(\w+)\t+(.*)/)
+
+          report(
+            host: opts[:zookeeper_host].dup,
+            service: "zookeeper #{m[1]}",
+            metric: m[2].to_f,
+            state: 'ok',
+            tags: ['zookeeper'],
+          )
+        end
+        sock.close
+      end
+    end
+  end
+end

data/lib/riemann/tools.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Riemann
   module Tools
     require 'optimist'
-    require 'riemann/client'
+    require 'riemann/tools/riemann_client_wrapper'
 
     def self.included(base)
       base.instance_eval do
@@ -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,45 +65,25 @@ 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)
 
       riemann << event
     end
 
-    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],
-      )
-      if options[:tcp] || options[:tls]
-        r.tcp
-      else
-        r
-      end
-    end
-
     def riemann
-      @riemann ||= new_riemann_client
+      @riemann ||= RiemannClientWrapper.instance.configure(options)
     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 +91,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/'
 
@@ -23,7 +23,9 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) } -
+      ['lib/riemann/tools/uptime_parser.y'] +
+      ['lib/riemann/tools/uptime_parser.tab.rb']
   end
   spec.bindir        = 'bin'
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -34,6 +36,10 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'riemann-client', '~> 1.0'
 
   spec.add_development_dependency 'github_changelog_generator'
+  spec.add_development_dependency 'racc'
   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'
@@ -9,10 +11,8 @@ ENV['COPYFILE_DISABLE'] = 'true'
 
 # Gemspec
 gemspec = Gem::Specification.new do |s|
-  s.rubyforge_project = 'riemann-aws'
-
   s.name = 'riemann-aws'
-  s.version = '0.1.4'
+  s.version = '0.1.5'
   s.author = 'Kyle Kingsbury'
   s.email = 'aphyr@aphyr.com'
   s.homepage = 'https://github.com/riemann/riemann-tools'
@@ -20,15 +20,14 @@ gemspec = Gem::Specification.new do |s|
   s.summary = 'Submits AWS stats to riemann.'
   s.license = 'MIT'
 
-  s.add_dependency 'riemann-tools', '>= 0.2.13'
-  s.add_dependency 'fog', '>= 1.4.0'
-  s.add_dependency 'json'
+  s.add_runtime_dependency 'riemann-tools', '~> 1.0', '>= 1.1.1'
+  s.add_runtime_dependency 'fog-aws', '~> 3.14', '>= 3.14.0'
+  s.add_runtime_dependency 'json', '~> 2.6', '>=2.6.2'
 
-  s.files = FileList['bin/*', 'LICENSE', 'README.md'].to_a
+  s.files = FileList['bin/*', 'lib/**/*.rb', 'LICENSE', 'README.md'].to_a
   s.executables |= Dir.entries('bin/')
-  s.has_rdoc = false
 
-  s.required_ruby_version = '>= 1.8.7'
+  s.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
 end
 
 Gem::PackageTask.new gemspec do |p|

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

@@ -1,87 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-require 'riemann/tools'
+Process.setproctitle($PROGRAM_NAME)
 
-$0 = __FILE__
+require 'riemann/tools/aws/billing'
 
-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
-
-  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 :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 }
-      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']
-
-
-      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
-        }
-
-        report event
-      end
-    end
-  end
-end
-
-Riemann::Tools::AWSBilling.run
+Riemann::Tools::Aws::Billing.run

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

@@ -1,54 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-require 'riemann/tools'
+Process.setproctitle($PROGRAM_NAME)
 
-$0 = __FILE__ # Let's not expose our AWS keys in the process list
+require 'riemann/tools/aws/rds_status'
 
-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
-
-  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
-      end
-
-    end
-  end
-end
-
-Riemann::Tools::AWS.run
+Riemann::Tools::Aws::RdsStatus.run

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

@@ -1,44 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-require 'riemann/tools'
+Process.setproctitle($PROGRAM_NAME)
 
-$0 = __FILE__ # Let's not expose our AWS keys in the process list
+require 'riemann/tools/aws/sqs_status'
 
-class Riemann::Tools::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
-
-  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
-    end
-  end
-end
-
-Riemann::Tools::AWS.run
+Riemann::Tools::Aws::SqsStatus.run

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

@@ -1,71 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-require 'riemann/tools'
+Process.setproctitle($PROGRAM_NAME)
 
-$0 = __FILE__  # Let's not expose our AWS keys in the process list
+require 'riemann/tools/aws/status'
 
-class Riemann::Tools::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 :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 tick
-    instance_status = @compute.describe_instance_status.body["instanceStatusSet"]
-    status = instance_status.inject({}) do |acc,i|
-      acc[i.delete("instanceId")] = i
-      acc
-    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.each do |host, status|
-      status['eventsSet'].each do |event|
-        before, after = ['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}
-
-        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
-
-        report ev.merge(ev2)
-      end
-    end
-  end
-end
-
-Riemann::Tools::AWS.run
+Riemann::Tools::Aws::Status.run