riemann-tools 0.2.7 → 0.2.8

data/bin/riemann-aws-billing

@@ -1,79 +0,0 @@
-#!/usr/bin/env ruby
-require 'fog'
-
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-$0 = __FILE__
-
-class Riemann::Tools::AWSBilling
-  include Riemann::Tools
-
-  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
-      @cloudwatch = Fog::AWS::CloudWatch.new(:aws_secret_access_key => opts[:secret_key], :aws_access_key_id => opts[:access_key])
-      @start_time = (Time.now.utc - opts[:time_start]).iso8601
-      @end_time = (Time.now.utc - opts[:time_end]).iso8601
-    end
-  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

data/bin/riemann-aws-rds-status

@@ -1,48 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-require 'fog'
-require 'date'
-require 'time'
-require 'json'
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-$0 = __FILE__ # Let's not expose our AWS keys in the process list
-
-class Riemann::Tools::AWS
-  include Riemann::Tools
-
-  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]
-    @cloudwatch = Fog::AWS::CloudWatch.new(:aws_access_key_id => opts[:access_key],
-                                           :aws_secret_access_key => opts[:secret_key],
-                                           :region => opts[:region])
-  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']
-      puts JSON.dump(metricsResult)
-      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

data/bin/riemann-aws-status

@@ -1,64 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-require 'fog'
-require 'date'
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-$0 = __FILE__  # Let's not expose our AWS keys in the process list
-
-class Riemann::Tools::AWS
-  include Riemann::Tools
-  
-  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
-    @compute = Fog::Compute.new(:aws_access_key_id => opts[:access_key],
-                                :aws_secret_access_key => opts[:secret_key],
-                                :region => opts[:region],
-                                :provider => 'AWS')
-  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

data/bin/riemann-elasticsearch

@@ -1,91 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::Elasticsearch
-  include Riemann::Tools
-
-  require 'faraday'
-  require 'json'
-  require 'uri'
-
-  opt :read_timeout, 'Faraday read timeout', type: :int, default: 2
-  opt :open_timeout, 'Faraday open timeout', type: :int, default: 1
-  opt :path_prefix, 'Elasticsearch path prefix for proxied installations e.g. "els" for target http://localhost/els/_cluster/health', default: "/"
-  opt :es_host, 'Elasticsearch host', default: "localhost"
-  opt :es_port, 'Elasticsearch port', type: :int, default: 9200
-
-
-  # Handles HTTP connections and GET requests safely
-  def safe_get(uri)
-      # Handle connection timeouts
-      response = nil
-      begin
-        connection = Faraday.new(uri)
-        response = connection.get do |req|
-          req.options[:timeout] = options[:read_timeout]
-          req.options[:open_timeout] = options[:open_timeout]
-        end
-      rescue => e
-        report(:host => uri.host,
-          :service => "elasticsearch health",
-          :state => "critical",
-          :description => "HTTP connection error: #{e.class} - #{e.message}"
-        )
-      end
-      response
-  end
-
-  def health_url
-    path_prefix = options[:path_prefix]
-    path_prefix[0] = '' if path_prefix[0]=='/'
-    path_prefix[path_prefix.length-1] = '' if path_prefix[path_prefix.length-1]=='/'
-    "http://#{options[:es_host]}:#{options[:es_port]}#{path_prefix.length>0?'/':''}#{path_prefix}/_cluster/health"
-  end
-
-  def tick
-    uri = URI(health_url)
-    response = safe_get(uri)
-
-    return if response.nil?
-
-    if response.status != 200
-        report(:host => uri.host,
-          :service => "elasticsearch health",
-          :state => "critical",
-          :description => "HTTP connection error: #{response.status} - #{response.body}"
-        )
-    else
-      # Assuming that a 200 will give json
-      json = JSON.parse(response.body)
-      cluster_name = json.delete("cluster_name")
-      cluster_status = json.delete("status")
-      state = case cluster_status
-      when "green"
-        "ok"
-      when "yellow"
-        "warning"
-      when "red"
-        "critical"
-      end
-
-      report(:host => uri.host,
-             :service => "elasticsearch health",
-             :state => state,
-             :description => "Elasticsearch cluster: #{cluster_name} - #{cluster_status}")
-
-      json.each_pair do |k,v|
-        report(:host => uri.host,
-               :service => "elasticsearch #{k}",
-               :metric => v,
-               :description => "Elasticsearch cluster #{k}"
-        )
-
-      end
-    end
-  end
-
-
-
-end
-Riemann::Tools::Elasticsearch.run

data/bin/riemann-elb-metrics

@@ -1,154 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-$0 = __FILE__
-
-class Riemann::Tools::ELBMetrics
-  include Riemann::Tools
-
-  require 'fog'
-  require 'time'
-
-  opt :fog_credentials_file, "Fog credentials file", :type => String
-  opt :fog_credential, "Fog credentials to use", :type => String
-  opt :aws_access, "AWS Access Key", :type => String
-  opt :aws_secret, "AWS Secret Key", :type => String
-  opt :aws_region, "AWS Region", :type => String, :default => "eu-west-1"
-  opt :aws_azs, "List of AZs to aggregate against", :type => :strings, :default => [ "all_az" ]
-  opt :elbs, "List of ELBs to pull metrics from", :type => :strings, :required => true
-
-  def standard_metrics
-    # ELB metric types, from:
-    # http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html#elb-metricscollected
-    metric_options = {
-      "Latency" => {
-        "Unit" => "Seconds",
-        "Statistics" => ["Maximum", "Minimum", "Average" ]
-      },
-      "RequestCount" => {
-        "Unit" => "Count",
-        "Statistics" => [ "Sum" ]
-      },
-      "HealthyHostCount" => {
-        "Units" => "Count",
-        "Statistics" => [ "Minimum", "Maximum", "Average" ]
-      },
-      "UnHealthyHostCount" => {
-        "Units" => "Count",
-        "Statistics" => [ "Minimum", "Maximum", "Average" ]
-      },
-      "HTTPCode_ELB_4XX" => {
-        "Units" => "Count",
-        "Statistics" => [ "Sum" ]
-      },
-      "HTTPCode_ELB_5XX" => {
-        "Units" => "Count",
-        "Statistics" => [ "Sum" ]
-      },
-      "HTTPCode_Backend_2XX" => {
-        "Units" => "Count",
-        "Statistics" => [ "Sum" ]
-      },
-      "HTTPCode_Backend_3XX" => {
-        "Units" => "Count",
-        "Statistics" => [ "Sum" ]
-      },
-      "HTTPCode_Backend_4XX" => {
-        "Units" => "Count",
-        "Statistics" => [ "Sum" ]
-      },
-      "HTTPCode_Backend_5XX" => {
-        "Units" => "Count",
-        "Statistics" => [ "Sum" ]
-      }
-    }
-
-    metric_options
-  end
-
-  def base_metrics
-    # get last 60 seconds
-    start_time = (Time.now.utc - 60).iso8601
-    end_time = Time.now.utc.iso8601
-
-    # The base query that all metrics would get
-    metric_base = {
-      "Namespace" => "AWS/ELB",
-      "StartTime" => start_time,
-      "EndTime" => end_time,
-      "Period" => 60,
-    }
-
-    metric_base
-  end
-
-
-  def tick
-    if options[:fog_credentials_file]
-      Fog.credentials_path = options[:fog_credentials_file]
-      Fog.credential = options[:fog_credential].to_sym
-      connection = Fog::AWS::CloudWatch.new
-    else
-      connection = Fog::AWS::CloudWatch.new({
-        :aws_access_key_id => options[:aws_access],
-        :aws_secret_access_key => options[:aws_secret],
-        :region => options[:aws_region]
-      })
-    end
-
-    options[:elbs].each do |lb|
-
-      metric_options = standard_metrics
-      metric_base_options = base_metrics
-
-      options[:aws_azs].each do |az|
-        metric_options.keys.sort.each do |metric_type|
-          merged_options = metric_base_options.merge(metric_options[metric_type])
-          merged_options["MetricName"] = metric_type
-          if az == "all_az"
-            merged_options["Dimensions"] = [ { "Name" => "LoadBalancerName", "Value" => lb } ]
-          else
-            merged_options["Dimensions"] = [
-              { "Name" => "LoadBalancerName", "Value" => lb },
-              { "Name" => "AvailabilityZone" , "Value" => az}
-            ]
-          end
-
-          result = connection.get_metric_statistics(merged_options)
-
-          # "If no response codes in the category 2XX-5XX range are sent to clients within 
-          # the given time period, values for these metrics will not be recorded in CloudWatch"
-          #next if result.body["GetMetricStatisticsResult"]["Datapoints"].empty? && metric_type =~ /[2345]XX/
-          #
-          # BUG:
-          # Metrics are reported every 60 seconds, but sometimes there isn't one there yet.
-          # We can skip that, or do something else?
-          next if result.body["GetMetricStatisticsResult"]["Datapoints"].empty?
-
-          # We should only ever have a single data point
-          result.body["GetMetricStatisticsResult"]["Datapoints"][0].keys.sort.each do |stat_type|
-            next if stat_type == "Unit"
-            next if stat_type == "Timestamp"
-
-            unit = result.body["GetMetricStatisticsResult"]["Datapoints"][0]["Unit"]
-            metric = result.body["GetMetricStatisticsResult"]["Datapoints"][0][stat_type]
-            event = Hash.new
-            event = {
-              host: lb,
-              service: "elb.#{az}.#{metric_type}.#{stat_type}",
-              ttl: 60,
-              description: "#{lb} #{metric_type} #{stat_type} (#{unit})",
-              tags: [ "production", "elb_metrics" ],
-              metric: metric
-            }
-
-            report(event)
-          end
-        end
-      end
-    end
-  end
-end
-
-Riemann::Tools::ELBMetrics.run

data/bin/riemann-munin

@@ -1,36 +0,0 @@
-#!/usr/bin/env ruby
-
-# Gathers munin statistics and submits them to Riemann.
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::Munin
-  include Riemann::Tools
-  require 'munin-ruby'
-
-  def initialize
-    @munin = ::Munin::Node.new
-  end
-
-  def tick
-    services = opts[:services] || @munin.list
-    services.each do |service|
-      @munin.fetch(service).each do |service, parts|
-        parts.each do |part, metric|
-          report(
-            :service => "#{service} #{part}",
-            :metric => metric.to_f,
-            :state => 'ok',
-            :tags => ['munin']
-          )
-        end
-      end
-    end
-  end
-  
-  opt :munin_host, "Munin hostname", :default => 'localhost'
-  opt :munin_port, "Munin port", :default => 4949
-  opt :services, "Munin services to translate (if not specified, all services are relayed)", :type => :strings
-end
-  
-Riemann::Tools::Munin.run