riemann-monitors 0.0.1

data/bin/riemann-diskstats

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::Diskstats
+  include Riemann::Monitors
+
+  opt :devices, "Devices to monitor", :type => :strings, :default => nil
+  opt :ignore_devices, "Devices to ignore", :type => :strings, :default =>nil
+
+  def initialize
+    @old_state = nil
+  end
+
+  def state
+    f = File.read('/proc/diskstats')
+    state = f.split("\n").reject { |d| d =~ /(ram|loop)/ }.inject({}) do |s, line|
+      if line =~ /^(?:\s+\d+){2}\s+([\w\d\-]+) (.*)$/
+        dev = $1
+
+        ['reads reqs',
+        'reads merged',
+        'reads sector',
+        'reads time',
+        'writes reqs',
+        'writes merged',
+        'writes sector',
+        'writes time',
+        'io reqs',
+        'io time',
+        'io weighted'
+        ].map do |service|
+          "#{dev} #{service}"
+        end.zip(
+          $2.split(/\s+/).map { |str| str.to_i }
+        ).each do |service, value|
+          s[service] = value
+        end
+      end
+
+      s
+    end
+
+    # Filter interfaces
+    if is = opts[:devices]
+      state = state.select do |service, value|
+        is.include? service.split(' ').first
+      end
+    end
+
+    if ign = opts[:ignore_devices]
+      state = state.reject do |service, value|
+        ign.include? service.split(' ').first
+      end
+    end
+
+    state
+  end
+
+  def tick
+    state = self.state
+
+    if @old_state
+      state.each do |service, metric|
+
+        if service =~ /io reqs$/
+          report(
+            :service => "diskstats " + service,
+            :metric => metric,
+            :state => "ok"
+          )
+        else
+          delta = metric - @old_state[service]
+
+          report(
+            :service => "diskstats " + service,
+            :metric => (delta.to_f / opts[:interval]),
+            :state => "ok"
+          )
+        end
+
+        if service =~ /io time$/
+          report(:service => "diskstats " + service.gsub(/time/, 'util'),
+                 :metric => (delta.to_f / (opts[:interval]*1000)),
+                 :state => "ok")
+        end
+      end
+    end
+
+    @old_state = state
+  end
+
+end
+
+Riemann::Monitors::Diskstats.run

data/bin/riemann-fd

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+# Reports current file descriptor use to riemann.
+# By default reports the total system fd usage, can also report usage of individual processes
+
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::Health
+  include Riemann::Monitors
+
+  opt :fd_sys_warning, "open file descriptor threshold for system", :default => 800
+  opt :fd_sys_critical, "open file descriptor critical threshold for system", :default => 900
+  opt :fd_proc_warning, "open file descriptor threshold for process", :default => 800
+  opt :fd_proc_critical, "open file descriptor critical threshold for process", :default => 900
+  opt :processes, "list of processes to measure fd usage in addition to system total", :type => :ints
+
+  def initialize
+    @limits = {
+      :fd => {:critical => opts[:fd_sys_critical], :warning => opts[:fd_sys_warning]},
+      :process => {:critical => opts[:fd_proc_critical], :warning => opts[:fd_proc_warning]},
+    }
+    ostype = `uname -s`.chomp.downcase
+    puts "WARNING: OS '#{ostype}' not explicitly supported. Falling back to Linux" unless ostype == "linux"
+    @fd = method :linux_fd
+  end
+
+  def alert(service, state, metric, description)
+    report(
+      :service => service.to_s,
+      :state => state.to_s,
+      :metric => metric.to_f,
+      :description => description
+    )
+  end
+
+  def linux_fd
+    sys_used = Integer(`lsof | wc -l`)
+    if sys_used > @limits[:fd][:critical]
+      alert "fd sys", :critical, sys_used, "system is using #{sys_used} fds"
+    elsif sys_used > @limits[:fd][:warning]
+      alert "fd sys", :warning, sys_used, "system is using #{sys_used} fds"
+    else
+      alert "fd sys", :ok, sys_used, "system is using #{sys_used} fds"
+    end
+
+    unless opts[:processes].nil?
+      opts[:processes].each do |process|
+        used = Integer(`lsof -p #{process} | wc -l`)
+        name, pid = `ps axo comm,pid | grep -w #{process}`.split
+        if used > @limits[:process][:critical]
+          alert "fd #{name} #{process}", :critical, used, "process #{name} #{process} is using #{used} fds"
+        elsif used > @limits[:process][:warning]
+          alert "fd #{name} #{process}", :warning, used, "process #{name} #{process} is using #{used} fds"
+        else
+          alert "fd #{name} #{process}", :ok, used, "process #{name} #{process} is using #{used} fds"
+        end
+      end
+    end
+  end
+
+  def tick
+    @fd.call
+  end
+end
+
+Riemann::Monitors::Health.run

data/bin/riemann-freeswitch

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Monitors::FreeSWITCH
+  include Riemann::Monitors
+
+  opt :calls_warning, "Calls warning threshold", :default => 100
+  opt :calls_critical, "Calls critical threshold", :default => 300
+  opt :pid_file, "FreeSWITCH daemon pidfile", :type => String, :default => "/var/run/freeswitch/freeswitch.pid"
+
+  def initialize
+    @limits = {
+      :calls => {:critical => opts[:calls_critical], :warning => opts[:calls_warning]}
+    }
+  end
+
+  def dead_proc?(pid)
+    begin
+      Process.getpgid(pid)
+      false
+    rescue Errno::ESRCH
+      true
+    end
+  end
+
+  def alert(service, state, metric, description)
+    report(
+      :service => service.to_s,
+      :state => state.to_s,
+      :metric => metric.to_f,
+      :description => description
+    )
+  end
+
+  def exec_with_timeout(cmd, timeout)
+    pid = Process.spawn(cmd, {[:err,:out] => :close, :pgroup => true})
+    begin
+      Timeout.timeout(timeout) do
+        Process.waitpid(pid, 0)
+        $?.exitstatus == 0
+      end
+    rescue Timeout::Error
+      Process.kill(15, -Process.getpgid(pid))
+      puts "Killed pid: #{pid}"
+      false
+    end
+  end
+
+  def tick
+    # Determine how many current calls I have according to FreeSWITCH
+    fs_calls = %x[fs_cli -x "show calls count"| grep -Po '^\\d+'].to_i
+
+    # Determine how many current channels I have according to FreeSWITCH
+    fs_channels = %x[fs_cli -x "show channels count"| grep -Po '^\\d+'].to_i
+
+    # Determine how many conferences I have according to FreeSWITCH
+    fs_conferences = %x[fs_cli -x "conference list"| grep -Pco '^Conference'].to_i
+
+    # Try to read pidfile. If it fails use Devil's dummy PID
+    begin
+      fs_pid = File.read(opts[:pid_file]).to_i
+    rescue
+      puts "Couldn't read pidfile: #{opts[:pid_file]}"
+      fs_pid = -666
+    end
+
+    fs_threads = fs_pid > 0 ? %x[ps huH p #{fs_pid} | wc -l].to_i : 0
+
+    # Submit calls to riemann
+    if fs_calls > @limits[:calls][:critical]
+      alert "FreeSWITCH current calls", :critical, fs_calls, "Number of calls are #{fs_calls}"
+    elsif fs_calls > @limits[:calls][:warning]
+      alert "FreeSWITCH current calls", :warning, fs_calls, "Number of calls are #{fs_calls}"
+    else
+      alert "FreeSWITCH current calls", :ok, fs_calls, "Number of calls are #{fs_calls}"
+    end
+
+    # Submit channels to riemann
+    if fs_channels > @limits[:calls][:critical]
+      alert "FreeSWITCH current channels", :critical, fs_channels, "Number of channels are #{fs_channels}"
+    elsif fs_channels > @limits[:calls][:warning]
+      alert "FreeSWITCH current channels", :warning, fs_channels, "Number of channels are #{fs_channels}"
+    else
+      alert "FreeSWITCH current channels", :ok, fs_channels, "Number of channels are #{fs_channels}"
+    end
+
+    # Submit conferences to riemann
+    if fs_conferences > @limits[:calls][:critical]
+      alert "FreeSWITCH current conferences", :critical, fs_conferences, "Number of conferences are #{fs_conferences}"
+    elsif fs_conferences > @limits[:calls][:warning]
+      alert "FreeSWITCH current conferences", :warning, fs_conferences, "Number of conferences are #{fs_conferences}"
+    else
+      alert "FreeSWITCH current conferences", :ok, fs_conferences, "Number of conferences are #{fs_conferences}"
+    end
+
+    # Submit threads to riemann
+    if fs_threads
+      alert "FreeSWITCH current threads", :ok, fs_threads, "Number of threads are #{fs_threads}"
+    end
+
+    # Submit status to riemann
+    if dead_proc?(fs_pid)
+      alert "FreeSWITCH status", :critical, -1, "FreeSWITCH service status: not running"
+    else
+      alert "FreeSWITCH status", :ok, nil, "FreeSWITCH service status: running"
+    end
+
+    # Submit CLI status to riemann using timeout in case it's unresponsive
+    if exec_with_timeout("fs_cli -x status", 2)
+      alert "FreeSWITCH CLI status", :ok, nil, "FreeSWITCH CLI status: responsive"
+    else
+      alert "FreeSWITCH CLI status", :critical, -1, "FreeSWITCH CLI status: not responding"
+    end
+
+  end
+end
+
+Riemann::Monitors::FreeSWITCH.run

data/bin/riemann-haproxy

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+# Gathers haproxy CSV statistics and submits them to Riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Monitors::Haproxy
+  include Riemann::Monitors
+  require 'net/http'
+  require 'csv'
+
+  opt :stats_url, "Full url to haproxy stats (eg: https://user:password@host.com:9999/stats)", :required => true, :type => :string
+
+  def initialize
+    @uri = URI(opts[:stats_url]+';csv')
+  end
+
+  def tick
+    csv = CSV.parse(get_csv.body.split("# ")[1], { :headers => true })
+    csv.each do |row|
+      row = row.to_hash
+      ns  = "haproxy #{row['pxname']} #{row['svname']}"
+      row.each do |property, metric|
+        unless (property.nil? || property == 'pxname' || property == 'svname')
+          report(
+            :host    => @uri.host,
+            :service => "#{ns} #{property}",
+            :metric  => metric.to_f,
+            :tags    => ['haproxy']
+          )
+        end
+      end
+
+      report(
+        :host    => @uri.host,
+        :service => "#{ns} state",
+        :state   => (['UP', 'OPEN'].include?(row['status']) ? 'ok' : 'critical'),
+        :tags    => ['haproxy']
+      )
+    end
+  end
+
+  def get_csv
+    http = Net::HTTP.new(@uri.host, @uri.port)
+    http.use_ssl = true if @uri.scheme == 'https'
+    http.start do |h|
+      get = Net::HTTP::Get.new(@uri.request_uri)
+      unless @uri.userinfo.nil?
+        userinfo = @uri.userinfo.split(":")
+        get.basic_auth userinfo[0], userinfo[1]
+      end
+      h.request get
+    end
+  end
+
+end
+
+Riemann::Monitors::Haproxy.run

data/bin/riemann-health

@@ -0,0 +1,289 @@
+#!/usr/bin/env ruby
+
+# Reports current CPU, disk, load average, and memory use to riemann.
+
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::Health
+  include Riemann::Monitors
+
+  opt :cpu_warning, "CPU warning threshold (fraction of total jiffies)", :default => 0.9
+  opt :cpu_critical, "CPU critical threshold (fraction of total jiffies)", :default => 0.95
+  opt :disk_warning, "Disk warning threshold (fraction of space used)", :default => 0.9
+  opt :disk_critical, "Disk critical threshold (fraction of space used)", :default => 0.95
+  opt :load_warning, "Load warning threshold (load average / core)", :default => 3
+  opt :load_critical, "Load critical threshold (load average / core)", :default => 8
+  opt :memory_warning, "Memory warning threshold (fraction of RAM)", :default => 0.85
+  opt :memory_critical, "Memory critical threshold (fraction of RAM)", :default => 0.95
+  opt :checks, "A list of checks to run.", :type => :strings, :default => ['cpu', 'load', 'memory', 'disk']
+
+  def initialize
+    @limits = {
+      :cpu => {:critical => opts[:cpu_critical], :warning => opts[:cpu_warning]},
+      :disk => {:critical => opts[:disk_critical], :warning => opts[:disk_warning]},
+      :load => {:critical => opts[:load_critical], :warning => opts[:load_warning]},
+      :memory => {:critical => opts[:memory_critical], :warning => opts[:memory_warning]}
+    }
+    case (@ostype = `uname -s`.chomp.downcase)
+    when 'darwin'
+      @cores = `sysctl -n hw.ncpu`.to_i
+      @cpu = method :darwin_cpu
+      @disk = method :disk
+      @load = method :darwin_load
+      @memory = method :darwin_memory
+      darwin_top
+    when 'freebsd'
+      @cores = `sysctl -n hw.ncpu`.to_i
+      @cpu = method :freebsd_cpu
+      @disk = method :disk
+      @load = method :freebsd_load
+      @memory = method :freebsd_memory
+    else
+      @cores = cores
+      puts "WARNING: OS '#{@ostype}' not explicitly supported. Falling back to Linux" unless @ostype == "linux"
+      @cpu = method :linux_cpu
+      @disk = method :disk
+      @load = method :linux_load
+      @memory = method :linux_memory
+    end
+
+    opts[:checks].each do |check|
+      case check
+      when "disk"
+        @disk_enabled = true
+      when "load"
+        @load_enabled = true
+      when "cpu"
+        @cpu_enabled = true
+      when "memory"
+        @memory_enabled = true
+      end
+    end
+  end
+
+  def alert(service, state, metric, description)
+    report(
+      :service => service.to_s,
+      :state => state.to_s,
+      :metric => metric.to_f,
+      :description => description
+    )
+  end
+
+  def cores
+    i = 0;
+    File.read("/proc/cpuinfo").split(/\n\n/).inject({}) do |cores, p|
+      physical_id = p[/physical id\s+:\s+(\d+)/, 1]
+      core_id = p[/core id\s+:\s+(\d+)/, 1]
+      if physical_id and core_id
+        cores["#{physical_id}:#{core_id}"] = true
+      elsif physical_id
+        cores["#{physical_id}:"] = true
+      else
+        cores[i += 1] = true;
+      end
+
+      cores
+    end.size
+  end
+
+  def report_pct(service, fraction, report)
+    if fraction
+      if fraction > @limits[service][:critical]
+        alert service, :critical, fraction, "#{sprintf("%.2f", fraction * 100)}% #{report}"
+      elsif fraction > @limits[service][:warning]
+        alert service, :warning, fraction, "#{sprintf("%.2f", fraction * 100)}% #{report}"
+      else
+        alert service, :ok, fraction, "#{sprintf("%.2f", fraction * 100)}% #{report}"
+      end
+    end
+  end
+
+  def linux_cpu
+    new = File.read('/proc/stat')
+    unless new[/cpu\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/]
+      alert 'cpu', :unknown, nil, "/proc/stat doesn't include a CPU line"
+      return false
+    end
+    u2, n2, s2, i2 = [$1, $2, $3, $4].map { |e| e.to_i }
+
+    if @old_cpu
+      u1, n1, s1, i1 = @old_cpu
+
+      used = (u2+n2+s2) - (u1+n1+s1)
+      total = used + i2-i1
+      fraction = used.to_f / total
+
+      report_pct :cpu, fraction, "user+nice+system\n\n#{`ps -eo pcpu,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+    end
+
+    @old_cpu = [u2, n2, s2, i2]
+  end
+
+  def linux_load
+    load = File.read('/proc/loadavg').split(/\s+/)[0].to_f / @cores
+    if load > @limits[:load][:critical]
+      alert "load", :critical, load, "1-minute load average/core is #{load}"
+    elsif load > @limits[:load][:warning]
+      alert "load", :warning, load, "1-minute load average/core is #{load}"
+    else
+      alert "load", :ok, load, "1-minute load average/core is #{load}"
+    end
+  end
+
+  def linux_memory
+    m = File.read('/proc/meminfo').split(/\n/).inject({}) { |info, line|
+      x = line.split(/:?\s+/)
+      # Assume kB...
+      info[x[0]] = x[1].to_i
+      info
+    }
+
+    free = m['MemFree'].to_i + m['Buffers'].to_i + m['Cached'].to_i
+    total = m['MemTotal'].to_i
+    fraction = 1 - (free.to_f / total)
+
+    report_pct :memory, fraction, "used\n\n#{`ps -eo pmem,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+  end
+
+  def freebsd_cpu
+    u2, n2, s2, t2, i2 = `sysctl -n kern.cp_time 2>/dev/null`.split.map{ |e| e.to_i } #FreeBSD has 5 cpu stats
+
+    if @old_cpu
+      u1, n1, s1, t1, i1 = @old_cpu
+
+      used = (u2+n2+s2+t2) - (u1+n1+s1+t1)
+      total = used + i2-i1
+      fraction = used.to_f / total
+
+      report_pct :cpu, fraction, "user+nice+sytem+interrupt\n\n#{`ps -axo pcpu,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+    end
+
+    @old_cpu = [u2, n2, s2, t2, i2]
+  end
+
+  def freebsd_load
+    m = `uptime`.split(':')[-1].chomp.gsub(/\s+/,'').split(',')
+    load = m[0].to_f / @cores
+    if load > @limits[:load][:critical]
+      alert "load", :critical, load, "1-minute load average/core is #{load}"
+    elsif load > @limits[:load][:warning]
+      alert "load", :warning, load, "1-minute load average/core is #{load}"
+    else
+      alert "load", :ok, load, "1-minute load average/core is #{load}"
+    end
+  end
+
+  def freebsd_memory
+    meminfo = `sysctl -n vm.stats.vm.v_page_count vm.stats.vm.v_wire_count vm.stats.vm.v_active_count 2>/dev/null`.chomp.split
+    fraction = (meminfo[1].to_f + meminfo[2].to_f) / meminfo[0].to_f
+
+    report_pct :memory, fraction, "used\n\n#{`ps -axo pmem,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+  end
+
+  def darwin_top
+    raw = `top -l 1 | grep -i "^\\(cpu\\|physmem\\|load\\)"`.chomp
+    @topdata = {:stamp => Time.now.to_i }
+    raw.each_line do |ln|
+      if ln.match(/Load Avg: [0-9.]+, [0-9.]+, ([0-9.])+/i)
+        @topdata[:load] = $1.to_f
+      elsif ln.match(/CPU usage: [0-9.]+% user, [0-9.]+% sys, ([0-9.]+)% idle/i)
+        @topdata[:cpu] = 1  - ($1.to_f / 100)
+      elsif mdat = ln.match(/PhysMem: ([0-9]+)([BKMGT]) wired, ([0-9]+)([BKMGT]) active, ([0-9]+)([BKMGT]) inactive, ([0-9]+)([BKMGT]) used, ([0-9]+)([BKMGT]) free/i)
+        wired = mdat[1].to_i * (1024 ** "BKMGT".index(mdat[2]))
+        active = mdat[3].to_i * (1024 ** "BKMGT".index(mdat[4]))
+        inactive = mdat[5].to_i * (1024 ** "BKMGT".index(mdat[6]))
+        used = mdat[7].to_i * (1024 ** "BKMGT".index(mdat[8]))
+        free = mdat[9].to_i * (1024 ** "BKMGT".index(mdat[10]))
+        @topdata[:memory] = (wired + active + used).to_f / (wired + active + used + inactive + free)
+      # This is for OSX Mavericks which
+      # uses a different format for top
+      # Example: PhysMem: 4662M used (1328M wired), 2782M unused.
+      elsif mdat = ln.match(/PhysMem: ([0-9]+)([BKMGT]) used \(([0-9]+)([BKMGT]) wired\), ([0-9]+)([BKMGT]) unused/i)
+        used  = mdat[1].to_i * (1024 ** "BKMGT".index(mdat[2]))
+        wired = mdat[3].to_i * (1024 ** "BKMGT".index(mdat[4]))
+        unused = mdat[5].to_i * (1024 ** "BKMGT".index(mdat[6]))
+        @topdata[:memory] = (used).to_f / (used + unused)
+      end
+    end
+  end
+
+  def darwin_cpu
+    darwin_top unless (Time.now.to_i - @topdata[:stamp]) < opts[:interval]
+    unless @topdata[:cpu]
+      alert 'cpu', :unknown, nil, "unable to get CPU stats from top"
+      return false
+    end
+    report_pct :cpu,  @topdata[:cpu], "usage\n\n#{`ps -eo pcpu,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+  end
+
+  def darwin_load
+    darwin_top unless (Time.now.to_i - @topdata[:stamp]) < opts[:interval]
+    unless @topdata[:load]
+      alert 'load', :unknown, nil, "unable to get load ave from top"
+      return false
+    end
+    metric = @topdata[:load] / @cores
+    if metric > @limits[:load][:critical]
+      alert "load", :critical, metric, "1-minute load average per core is #{metric}"
+    elsif metric > @limits[:load][:warning]
+      alert "load", :warning, metric, "1-minute load average per core is #{metric}"
+    else
+      alert "load", :ok, metric, "1-minute load average per core is #{metric}"
+    end
+  end
+
+  def darwin_memory
+    darwin_top unless (Time.now.to_i - @topdata[:stamp]) < opts[:interval]
+    unless @topdata[:memory]
+      alert 'memory', :unknown, nil, "unable to get memory data from top"
+      return false
+    end
+    report_pct :memory,  @topdata[:memory], "usage\n\n#{`ps -eo pmem,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+  end
+
+  def df
+    case @ostype
+    when 'darwin', 'freebsd'
+      `df -P -t noiso9660`
+    else
+      `df -P --exclude-type=iso9660`
+    end
+  end
+
+  def disk
+    df.split(/\n/).each do |r|
+      f = r.split(/\s+/)
+      next if f[0] == 'Filesystem'
+      next unless f[0] =~ /\// # Needs at least one slash in the mount path
+
+      # Calculate capacity
+      x = f[4].to_f/100
+
+      if x > @limits[:disk][:critical]
+        alert "disk #{f[5]}", :critical, x, "#{f[4]} used"
+      elsif x > @limits[:disk][:warning]
+        alert "disk #{f[5]}", :warning, x, "#{f[4]} used"
+      else
+        alert "disk #{f[5]}", :ok, x, "#{f[4]} used"
+      end
+    end
+  end
+
+  def tick
+    if @cpu_enabled
+      @cpu.call
+    end
+    if @memory_enabled
+      @memory.call
+    end
+    if @disk_enabled
+      @disk.call
+    end
+    if @load_enabled
+      @load.call
+    end
+  end
+end
+
+Riemann::Monitors::Health.run

data/bin/riemann-httpstatus

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+# Checks the status of an HTTP request and submits it to Riemann
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::HTTPStatus
+  include Riemann::Monitors
+  require "net/http"
+  require "uri"
+
+  opt :uri, "Target URI", type: String, default: 'http://localhost/'
+  opt :sitename, "Site name (abbreviation for identifying uri)", type: String
+  opt :method, "HTTP Method (get, head)", type: String, default: "head"
+
+  def initialize
+    @uri = URI.parse(opts[:uri])
+    @sitename = opts[:sitename]&.gsub(/\//, '_') if opts.has_key?(:sitename)
+    @servicename = ["http", opts[:method], @sitename].join("/")
+    @verbclass = case opts[:method]
+    when /\Aget\z/i
+      Net::HTTP::Get
+    when /\Ahead\z/i
+      Net::HTTP::Head
+    else
+      raise "This script only makes sense with get and head methods. You might want a custom script."
+    end
+  end
+
+  def tick
+    response, roundtrip = get_connection()
+    unless (response).nil?
+      metrics = {service: @servicename,
+                 description: @sitename,
+                 tags:  ["http"]}
+      c = response.code&.to_i
+      if !c.nil?
+        metrics[:state] = "ok"
+        metrics[:metric] = c
+      end
+      if !roundtrip.nil?
+        metrics[:roundtrip] = roundtrip
+      end
+      if !response.body.nil? && @verbclass != Net::HTTP::Head
+        metrics[:body_length] = response.body.length
+      end
+      report(metrics)
+    end
+  end
+
+  def get_connection()
+    response = nil
+    roundtrip = nil
+    begin
+      p1 = Time.now
+      Net::HTTP.start(@uri.host, @uri.port) do |http|
+        http.open_timeout = opts[:timeout]
+        request = @verbclass.new(@uri)
+        response = http.request(request)
+        response.read_body
+      end
+      p2 = Time.now
+      roundtrip = p2 - p1
+    rescue => e
+      report(:service     => @servicename,
+             :state       => "critical",
+             :description => "http connection failure: #{e.class} - #{e.message}",
+             :tags        => ["http", "action"])
+    end
+    [response, roundtrip]
+  end
+end
+
+Riemann::Monitors::HTTPStatus.run