riemann-tools 1.1.1 → 1.4.0

data/lib/riemann/tools/varnish.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'riemann/tools'
+
+# Reports varnish stats to Riemann.
+module Riemann
+  module Tools
+    class Varnish
+      include Riemann::Tools
+
+      opt :varnish_host, 'Varnish hostname', default: `hostname`.chomp
+
+      def initialize
+        cmd = 'varnishstat -V'
+        Open3.popen3(cmd) do |_stdin, _stdout, stderr, _wait_thr|
+          @ver = /varnishstat \(varnish-(\d+)/.match(stderr.read)[1].to_i
+        end
+
+        @vstats = if @ver >= 4
+                    ['MAIN.sess_conn',
+                     'MAIN.sess_drop ',
+                     'MAIN.client_req',
+                     'MAIN.cache_hit',
+                     'MAIN.cache_miss',]
+                  else
+                    %w[client_conn
+                       client_drop
+                       client_req
+                       cache_hit
+                       cache_miss]
+                  end
+      end
+
+      def tick
+        stats = if @ver >= 4
+                  `varnishstat -1 -f #{@vstats.join(' -f ')}`
+                else
+                  `varnishstat -1 -f #{@vstats.join(',')}`
+                end
+        stats.each_line do |stat|
+          m = stat.split
+          report(
+            host: opts[:varnish_host].dup,
+            service: "varnish #{m[0]}",
+            metric: m[1].to_f,
+            state: 'ok',
+            description: m[3..].join(' ').to_s,
+            tags: ['varnish'],
+          )
+        end
+      end
+    end
+  end
+end

data/lib/riemann/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Riemann
   module Tools # :nodoc:
-    VERSION = '1.1.1'
+    VERSION = '1.4.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/zpool.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+require 'riemann/tools'
+
+module Riemann
+  module Tools
+    class Zpool
+      include Riemann::Tools
+
+      def tick
+        output, status = Open3.capture2e('zpool status -x')
+
+        state = if status.success?
+                  case output
+                  when "all pools are healthy\n" then 'ok'
+                  when /state: (DEGRADED|FAULTED)/ then 'critical'
+                  else
+                    'warning'
+                  end
+                else
+                  'critical'
+                end
+
+        report(
+          service: 'zpool health',
+          description: output,
+          state: state,
+        )
+      rescue Errno::ENOENT => e
+        report(
+          service: 'zpool health',
+          description: e.message,
+          state: 'critical',
+        )
+      end
+    end
+  end
+end

data/lib/riemann/tools.rb

@@ -3,7 +3,7 @@
 module Riemann
   module Tools
     require 'optimist'
-    require 'riemann/client'
+    require 'riemann/tools/riemann_client_wrapper'
 
     def self.included(base)
       base.instance_eval do
@@ -72,26 +72,8 @@ module Riemann
       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
 

data/riemann-tools.gemspec

@@ -23,7 +23,15 @@ 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/mdstat_parser.y',
+        'lib/riemann/tools/uptime_parser.y',
+      ] +
+      [
+        'lib/riemann/tools/mdstat_parser.tab.rb',
+        'lib/riemann/tools/uptime_parser.tab.rb',
+      ]
   end
   spec.bindir        = 'bin'
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -34,6 +42,7 @@ 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'

data/tools/riemann-aws/Rakefile

@@ -11,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'
@@ -22,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

@@ -3,91 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-require 'riemann/tools'
+require 'riemann/tools/aws/billing'
 
-$0 = __FILE__
-
-module Riemann
-  module Tools
-    class 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: %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
-          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
-
-      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
-  end
-end
-
-Riemann::Tools::AWSBilling.run
+Riemann::Tools::Aws::Billing.run

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

@@ -3,66 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-require 'riemann/tools'
+require 'riemann/tools/aws/rds_status'
 
-$0 = __FILE__ # Let's not expose our AWS keys in the process list
-
-module Riemann
-  module Tools
-    class 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]
-        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::RdsStatus.run

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

@@ -3,48 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-require 'riemann/tools'
+require 'riemann/tools/aws/sqs_status'
 
-$0 = __FILE__ # Let's not expose our AWS keys in the process list
-
-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
-        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')
-        %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
-
-Riemann::Tools::AWS.run
+Riemann::Tools::Aws::SqsStatus.run

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

@@ -3,81 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-require 'riemann/tools'
+require 'riemann/tools/aws/status'
 
-$0 = __FILE__ # Let's not expose our AWS keys in the process list
-
-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 :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
-        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
-        # 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 |(astatus, acc), host|
-          acc[host.private_dns_name] = astatus.delete(host.id)
-          [astatus, acc]
-        end[1]
-
-        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,
-            }
-
-            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)
-          end
-        end
-      end
-    end
-  end
-end
-
-Riemann::Tools::AWS.run
+Riemann::Tools::Aws::Status.run