solanum 0.2.0 → 1.0.0

data/lib/solanum/source/load.rb

@@ -0,0 +1,44 @@
+require 'solanum/source'
+require 'solanum/util'
+
+class Solanum::Source::Load < Solanum::Source
+  attr_reader :load_states
+
+  STAT_FILE = '/proc/loadavg'
+
+
+  def initialize(opts)
+    super(opts)
+    @load_states = opts['load_states'] || {}
+  end
+
+
+  def collect!
+    events = []
+
+    loadavg = File.read(STAT_FILE).chomp.split(' ')
+
+    load1m = loadavg[0].to_f
+
+    events << {
+      service: 'process load',
+      metric: load1m,
+      state: state_over(@load_states, load1m),
+    }
+
+    running, count = *loadavg[3].split('/')
+
+    events << {
+      service: 'process running',
+      metric: running.to_i,
+    }
+
+    events << {
+      service: 'process count',
+      metric: count.to_i,
+    }
+
+    events
+  end
+
+end

data/lib/solanum/source/memory.rb

@@ -0,0 +1,70 @@
+require 'solanum/source'
+require 'solanum/util'
+
+class Solanum::Source::Memory < Solanum::Source
+  attr_reader :thresholds, :swap_thresholds
+
+
+  def initialize(opts)
+    super(opts)
+    @thresholds = opts['thresholds'] || {}
+    @swap_thresholds = opts['swap_thresholds'] || {}
+  end
+
+
+  def collect!
+    events = []
+
+    meminfo = Hash.new(0)
+    File.readlines('/proc/meminfo').each do |line|
+      measure, quantity = *line.chomp.split(/: +/)
+      value, unit = *quantity.split(' ')
+      meminfo[measure] = value.to_i
+    end
+
+    mem_total = meminfo['MemTotal'].to_f
+    record_usage = lambda do |type|
+      if meminfo[type]
+        usage_pct = meminfo[type]/mem_total.to_f
+        events << {
+          service: "memory #{type.downcase}",
+          metric: usage_pct,
+        }
+      end
+    end
+
+    total_used = mem_total - meminfo['MemFree']
+    mem_used = total_used - meminfo['Buffers'] - meminfo['Cached']
+    usage = mem_used/mem_total
+    events << {
+      service: 'memory usage',
+      metric: usage,
+      state: state_over(@thresholds, usage),
+    }
+
+    events << {
+      service: 'memory buffers',
+      metric: meminfo['Buffers']/mem_total
+    }
+
+    cached = meminfo['Cached'] + meminfo['SReclaimable'] - meminfo['Shmem']
+    events << {
+      service: 'memory cached',
+      metric: cached/mem_total
+    }
+
+    if meminfo['SwapTotal'] && meminfo['SwapTotal'] > 0
+      swap_total = meminfo['SwapTotal']
+      swap_free = meminfo['SwapFree']
+      usage = 1.0 - swap_free/swap_total.to_f
+      events << {
+        service: 'swap usage',
+        metric: usage,
+        state: state_over(@swap_thresholds, usage),
+      }
+    end
+
+    events
+  end
+
+end

data/lib/solanum/source/network.rb

@@ -0,0 +1,65 @@
+require 'solanum/source'
+
+# bytes - The total number of bytes of data transmitted or received by the interface.
+# packets - The total number of packets of data transmitted or received by the interface.
+# errs - The total number of transmit or receive errors detected by the device driver.
+# drop - The total number of packets dropped by the device driver.
+# fifo - The number of FIFO buffer errors.
+# frame - The number of packet framing errors.
+# colls - The number of collisions detected on the interface.
+# compressed - The number of compressed packets transmitted or received by the device driver. (This appears to be unused in the 2.2.15 kernel.)
+# carrier - The number of carrier losses detected by the device driver.
+# multicast - The number of multicast frames transmitted or received by the device driver.
+class Solanum::Source::Network < Solanum::Source
+  attr_reader :interfaces, :detailed
+
+  STAT_FILE = '/proc/net/dev'
+
+  FIELDS = %w{
+    rx_bytes rx_packets rx_errs rx_drop rx_fifo rx_frame rx_compressed rx_multicast
+    tx_bytes tx_packets tx_errs tx_drop tx_fifo tx_colls tx_carrier tx_compressed
+  }
+
+  SIMPLE_FIELDS = %w{rx_bytes rx_packets tx_bytes tx_packets}
+
+
+  def initialize(opts)
+    super(opts)
+    @interfaces = opts['interfaces'] || []
+    @detailed = opts['detailed'] || false
+    @last = {}
+  end
+
+
+  def parse_stats(line)
+    columns = line.strip.split(/\s+/)
+    iface = columns.shift.chomp(':')
+    return iface, Hash[FIELDS.zip(columns.map(&:to_i))]
+  end
+
+
+  def collect!
+    events = []
+
+    File.readlines(STAT_FILE).drop(2).each do |line|
+      iface, stats = parse_stats(line)
+
+      if @interfaces.empty? || @interfaces.include?(iface)
+        if @last[iface]
+          FIELDS.each do |field|
+            next unless @detailed || SIMPLE_FIELDS.include?(field)
+            diff = stats[field] - @last[iface][field]
+            events << {
+              service: "net #{iface} #{field.gsub('_', ' ')}",
+              metric: diff,
+            }
+          end
+        end
+        @last[iface] = stats
+      end
+    end
+
+    events
+  end
+
+end

data/lib/solanum/source/uptime.rb

@@ -0,0 +1,28 @@
+require 'solanum/source'
+require 'solanum/util'
+
+class Solanum::Source::Uptime < Solanum::Source
+
+  STAT_FILE = '/proc/uptime'
+
+
+  def initialize(opts)
+    super(opts)
+  end
+
+
+  def collect!
+    events = []
+
+    uptime = File.read(STAT_FILE).split(' ').first.to_f
+
+    events << {
+      service: 'uptime',
+      metric: uptime,
+      description: "Up for #{duration_str(uptime)}",
+    }
+
+    events
+  end
+
+end

data/lib/solanum/util.rb

@@ -0,0 +1,40 @@
+# Return a human-friendly duration string for the given duration in seconds.
+def duration_str(duration)
+  days = (duration/86400).to_i
+  hours = ((duration % 86400)/3600).to_i
+  minutes = ((duration % 3600)/60).to_i
+  seconds = (duration % 60).to_i
+  hms = "%02d:%02d:%02d" % [hours, minutes, seconds]
+
+  if 0 < days
+    "#{days} days, #{hms}"
+  else
+    hms
+  end
+end
+
+
+# Calculate the state of a metric by comparing it to the given thresholds. The
+# metric is compared to each threshold in turn, largest to smallest. The first
+# threshold the metric is larger than is returned, or the 'min_sate' is
+# returned.
+def state_over(thresholds, metric, min_state='ok')
+  thresholds.sort_by {|e| -e[1] }.each do |threshold_entry|
+    key, threshold = *threshold_entry
+    return key if threshold <= metric
+  end
+  return min_state
+end
+
+
+# Calculate the state of a metric by comparing it to the given thresholds. The
+# metric is compared to each threshold in turn, smallest to largest. The first
+# threshold the metric is smaller than is returned, or the 'max_state' is
+# returned.
+def state_under(thresholds, metric, max_state='ok')
+  thresholds.sort_by {|e| e[1] }.each do |threshold_entry|
+    key, threshold = *threshold_entry
+    return key if threshold > metric
+  end
+  return max_state
+end

metadata

@@ -1,64 +1,79 @@
 --- !ruby/object:Gem::Specification
 name: solanum
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
+  prerelease: 
 platform: ruby
 authors:
 - Greg Look
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-28 00:00:00.000000000 Z
+date: 2017-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: riemann-client
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: 0.2.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: 0.2.6
 description: 
-email: greg@greg-look.net
+email: greg@greglook.net
 executables:
 - solanum
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/solanum/config.rb
-- lib/solanum/matcher.rb
 - lib/solanum/source.rb
+- lib/solanum/schedule.rb
+- lib/solanum/config.rb
+- lib/solanum/source/cpu.rb
+- lib/solanum/source/memory.rb
+- lib/solanum/source/diskstats.rb
+- lib/solanum/source/uptime.rb
+- lib/solanum/source/network.rb
+- lib/solanum/source/load.rb
+- lib/solanum/source/certificate.rb
+- lib/solanum/output/print.rb
+- lib/solanum/output/riemann.rb
+- lib/solanum/util.rb
 - lib/solanum.rb
 - bin/solanum
 - README.md
 homepage: https://github.com/greglook/solanum
 licenses:
 - Public Domain
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.9.1
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
-summary: DSL for custom monitoring configuration
+specification_version: 3
+summary: Extensible monitoring daemon
 test_files: []
+has_rdoc: 

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: e9ebaaa5f2e140d9a0b2d821bc685a363f103ea1
-  data.tar.gz: 4fc6fbb8e60b919d8a9d1d8c8d36d557a80269ca
-SHA512:
-  metadata.gz: 30e99d6aa3fba2cf78f4ba69bde44e799212ca457a7de325ee40585e111c237188b3b1d0770c642a86641da5c253eab09a64310ae4a39fc2f7be6cee19a7d4f6
-  data.tar.gz: 254e37a291a4e3925e3a0e38cb7fde12f4a177508ba0354ed6ba035d2844fd086411ed040eedb63d421f51f2841f4d9277d9b8b32a26f232497f547a2a7e0160

data/lib/solanum/matcher.rb

@@ -1,70 +0,0 @@
-require 'json'
-
-# A matcher takes in an input string and returns a hash of measurement names to
-# numeric values.
-#
-# Author:: Greg Look
-class Solanum::Matcher
-  attr_reader :fn
-
-  # Creates a new Matcher which will run the given function on input.
-  def initialize(fn)
-    raise "function must be provided" if fn.nil?
-    @fn = fn
-  end
-
-  # Attempts to match the given input, returning a hash of metrics.
-  def call(input)
-    {}
-  end
-
-
-  ### MATCHER TYPES ###
-
-  public
-
-  # LinePattern matchers define a regular expression which is tested against
-  # each line of input. The given function is called for **each** matched line,
-  # and the resulting measurements are merged together.
-  class LinePattern < Solanum::Matcher
-    def initialize(fn, pattern)
-      super fn
-      raise "pattern must be provided" if pattern.nil?
-      @pattern = pattern
-    end
-
-    def call(input)
-      raise "No input provided!" if input.nil?
-      lines = input.split("\n")
-      metrics = {}
-
-      lines.each do |line|
-        begin
-          if @pattern === line
-            measurements = @fn.call($~)
-            metrics.merge!(measurements) if measurements
-          end
-        rescue => e
-          STDERR.puts("Error calculating metrics from line match: #{e.inspect}")
-        end
-      end
-
-      metrics
-    end
-  end
-
-
-  # JsonReader matches a JSON-formatted input string and passes the parsed
-  # object to the block body.
-  class JSONReader < Solanum::Matcher
-    def call(input)
-      begin
-        json = JSON.parse(input)
-        @fn.call(json)
-      rescue => e
-        STDERR.puts("Error matching JSON input: #{e.inspect}")
-        {}
-      end
-    end
-  end
-end