solanum 0.2.0 → 1.0.0

data/lib/solanum/output/print.rb

@@ -0,0 +1,18 @@
+class Solanum
+class Output
+class Print
+  def initialize(args)
+  end
+
+  def write_events(events)
+    events.each do |event|
+      puts "%-40s %5s (%s) %s" % [
+        event['service'], event['metric'],
+        event['state'].nil? ? "--" : event['state'],
+        event.inspect
+      ]
+    end
+  end
+end
+end
+end

data/lib/solanum/output/riemann.rb

@@ -0,0 +1,20 @@
+require 'riemann/client'
+
+class Solanum
+class Output
+class Riemann
+
+  def initialize(args)
+    @client = Riemann::Client.new(host: args[:host], port: args[:port])
+  end
+
+  def write_events(events)
+    # OPTIMIZE: batch events?
+    events.each do |event|
+      @client << event
+    end
+  end
+
+end
+end
+end

data/lib/solanum/schedule.rb

@@ -0,0 +1,55 @@
+# Schedule management class.
+class Solanum
+class Schedule
+
+  def initialize
+    @lock = Mutex.new
+    @timetable = []
+  end
+
+
+  # Peek at the next scheduled entry.
+  def peek_next
+    @lock.synchronize do
+      @timetable.first
+    end
+  end
+
+
+  # Time to spend waiting until the next scheduled entry. Returns a number of
+  # seconds, or nil if the schedule is empty.
+  def next_wait
+    entry = peek_next
+    if entry
+      next_time, next_id = *entry
+      duration = next_time - Time.now
+      #puts "Next scheduled run for #{next_id} at #{next_time} in #{duration} seconds" # DEBUG
+      duration
+    end
+  end
+
+
+  # Try to get the next ready entry. Returns the id if it is ready and removes
+  # it from the scheudle, otherwise nil if no entries are ready to run.
+  def pop_ready!
+    @lock.synchronize do
+      if @timetable.first && Time.now >= @timetable.first[0]
+        entry = @timetable.shift
+        entry[1]
+      end
+    end
+  end
+
+
+  # Schedule the given id for later running. Returns the scheduled entry.
+  def insert!(time, id)
+    entry = [time, id]
+    @lock.synchronize do
+      @timetable << entry
+      @timetable.sort_by! {|e| e[0] }
+    end
+    entry
+  end
+
+end
+end

data/lib/solanum/source.rb

@@ -1,116 +1,23 @@
-require 'solanum/matcher'
+class Solanum
+class Source
+  attr_reader :type, :period, :attributes
 
-# This class represents a source of data, whether read from command output,
-# a file on the system, or just calculated from other values. Each source
-# may have multiple matchers, which will be run against the input data to
-# produce metrics. Each matcher sees the _whole_ input.
-#
-# Author:: Greg Look
-class Solanum::Source
-  attr_reader :config, :matchers
-
-  # Creates a new Source
-  def initialize(config)
-    @config = config
-    @matchers = []
-  end
-
-  # Collect input and process it with the defined matchers to produce some
-  # output measurements. The current set of metrics collected in this cycle
-  # will be passed to the measure function.
-  def collect(current_metrics)
-    input = read_input!
-    metrics = {}
-
-    unless input.nil?
-      @matchers.each do |matcher|
-        measurements = matcher.call(input)
-        metrics.merge!(measurements) if measurements
-      end
-    end
-
-    metrics
+  def initialize(opts)
+    @type = opts['type']
+    @period = (opts['period'] || 10).to_i
+    @attributes = opts['attributes']
   end
 
-  private
 
-  # Collect input data from the given source.
-  def read_input!
-    nil
+  def collect!
+    raise "Not Yet Implemented"
   end
 
-  # Declares a matcher for a single line of input.
-  def match(pattern, options={}, &block)
-    raise "pattern must be provided" if pattern.nil?
-
-    commands = 0
-    commands += 1 if options[:record]
-    commands += 1 if block_given?
-    raise "Must specify :record or provide a block to execute" if commands == 0
-    raise "Only one of :record or a block should be provided" if commands > 1
 
-    if options[:record]
-      block = lambda do |matches|
-        value = matches[1]
-        value = value.send(options[:cast]) if options[:cast]
-        value *= options[:scale] if options[:scale]
-        {options[:record] => value}
-      end
-    end
-
-    @matchers << Solanum::Matcher::LinePattern.new(block, pattern)
-  end
-
-  # Declares a matcher for JSON input.
-  def json(&block)
-    @matchers << Solanum::Matcher::JSONReader.new(block)
+  def next_run(from=Time.now)
+    jitter = 0.95 + 0.10*rand
+    from + jitter*@period
   end
 
-
-
-  ### SOURCE TYPES ###
-
-  public
-
-  class File < Solanum::Source
-    def read_input!
-      # Check that file exists and is readable.
-      raise "File does not exist: #{@config}" unless ::File.exists? @config
-      raise "File is not readable: #{@config}" unless ::File.readable? @config
-
-      # Read lines from the file.
-      ::File.read(@config)
-    end
-  end
-
-  class Command < Solanum::Source
-    def read_input!
-      # Locate absolute command path.
-      command, args = @config.split(/\s/, 2)
-      abs_command =
-        if ::File.executable? command
-          command
-        else
-          %x{which #{command} 2> /dev/null}.chomp
-        end
-
-      # Check that command exists and is executable.
-      raise "Command #{command} not found" unless ::File.exist? abs_command
-      raise "Command #{abs_command} not executable" unless ::File.executable? abs_command
-
-      # Run command for output.
-      input = %x{#{abs_command} #{args}}
-      raise "Error executing command: #{abs_command} #{args}" unless $?.success?
-
-      input
-    end
-  end
-
-  class Compute < Solanum::Source
-    def collect(current_metrics)
-      # Compute metrics directly, but don't let the block change the existing
-      # metrics in-place.
-      @config.call(current_metrics.dup.freeze)
-    end
-  end
+end
 end

data/lib/solanum/source/certificate.rb

@@ -0,0 +1,88 @@
+require 'openssl'
+require 'socket'
+require 'solanum/source'
+require 'solanum/util'
+
+class Solanum::Source::Certificate < Solanum::Source
+  attr_reader :host, :port, :ca_cert, :expiry_states
+
+
+  def initialize(opts)
+    super(opts)
+    @host = opts['host'] or raise "No host provided"
+    @port = opts['port'] || 443
+    @hostname = opts['hostname'] || @host
+    @ca_cert = opts['ca_cert']
+    @expiry_states = opts['expiry_states'] || {}
+  end
+
+
+  def connect
+    # Configure context.
+    ctx = OpenSSL::SSL::SSLContext.new
+    #ctx.verify_hostname = true  # Only in ruby 2.x?
+
+    if @ca_cert
+      ctx.ca_file = @ca_cert
+      ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    end
+
+    # Open socket connection.
+    sock = TCPSocket.new(@host, @port)
+    ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
+    ssl.sync_close = true
+    ssl.hostname = @hostname
+    ssl.connect
+
+    yield ssl if block_given?
+  ensure
+    if ssl
+      ssl.close
+    elsif sock
+      sock.close
+    end
+  end
+
+
+  # Collect metric events.
+  def collect!
+    events = []
+    prefix = "certificate #{@hostname}"
+
+    begin
+      connect do |ssl|
+        cert = ssl.peer_cert
+
+        # Connect okay.
+        events << {
+          service: "#{prefix} connect",
+          metric: 1,
+          state: 'ok',
+          description: "Certificate for #{@hostname} verified successfully",
+        }
+
+        # Certificate expiration time.
+        #puts cert.inspect
+        expiry = cert.not_after - Time.now
+        expiry_days = expiry/86400
+        events << {
+          service: "#{prefix} expiry",
+          metric: expiry_days,
+          state: state_under(@expiry_states, expiry_days),
+          description: "Certificate for #{@hostname} expires in #{duration_str(expiry)}",
+        }
+      end
+    rescue => e
+      # Connect error.
+      events << {
+        service: "#{prefix} connect",
+        metric: 1,
+        state: 'critical',
+        description: "Error connecting to #{@hostname}: #{e}",
+      }
+    end
+
+    events
+  end
+
+end

data/lib/solanum/source/cpu.rb

@@ -0,0 +1,119 @@
+require 'solanum/source'
+require 'solanum/util'
+
+class Solanum::Source::Cpu < Solanum::Source
+  attr_reader :detailed, :per_core, :usage_states
+
+  STAT_FILE = '/proc/stat'
+  STATES = %w{user nice system idle iowait irqhard irqsoft}
+
+
+  def initialize(opts)
+    super(opts)
+    @last = nil
+    @detailed = opts['detailed'] || false
+    @per_core = opts['per_core'] || false
+    @usage_states = opts['usage_states'] || {}
+  end
+
+
+  # Calculate cpu utilization from the cumulative time spent in
+  # 'jiffies' (1/100 sec) since system boot.
+  def parse_info(line)
+    fields = line.chomp.split(' ')
+    name = fields.shift
+    data = Hash.new(0)
+    STATES.each_with_index do |state, i|
+      data[state] = fields[i].to_i
+    end
+    return name, data
+  end
+
+
+  # Collect metric events.
+  def collect!
+    # Parse lines from usage stats.
+    lines = File.readlines(STAT_FILE).take_while {|l| l.start_with? 'cpu' }
+    totals = {}
+    lines.each do |line|
+      name, data = parse_info(line)
+      totals[name] = data
+    end
+
+    # Need at least one run to start reporting accurate metrics.
+    unless @last
+      @last = totals
+      return []
+    end
+
+    # Calculate diffs from previous measurements.
+    diffs = {}
+    totals.each do |name, data|
+      diffs[name] = Hash.new(0)
+      data.each do |state, jiffies|
+        last = @last[name] && @last[name][state]
+        diffs[name][state] = jiffies - last if last
+      end
+    end
+    @last = totals
+
+    # Convert diffs to relative percentages.
+    diffs.each do |name, diff|
+      elapsed = diff.values.reduce(&:+)
+      diff.keys.each do |state|
+        diff[state] = diff[state].to_f/elapsed
+      end
+    end
+
+    # Generate metric events.
+    events = []
+
+    # aggregate cpu usage
+    usage = 1.0 - diffs['cpu']['idle']
+    events << {
+      service: 'cpu usage',
+      metric: usage,
+      state: state_over(@usage_states, usage),
+    }
+
+    # detailed aggregate cpu state metrics
+    if @detailed
+      diffs['cpu'].each do |state, usage|
+        events << {
+          service: 'cpu state',
+          metric: usage,
+          cpu_state: state,
+        }
+      end
+    end
+
+    # even more detailed per-core usage
+    if @per_core
+      diffs.each do |name, diff|
+        next if name == 'cpu'
+
+        usage = 1.0 - diff['idle']
+        events << {
+          service: 'cpu core usage',
+          metric: usage,
+          state: state_over(@usage_states, usage),
+          cpu_core: name,
+        }
+
+        if @detailed
+          diff.each do |state, usage|
+            events << {
+              service: 'cpu core state',
+              metric: usage,
+              cpu_core: name,
+              cpu_state: state,
+            }
+          end
+        end
+      end
+    end
+
+    events
+  end
+
+end

data/lib/solanum/source/diskstats.rb

@@ -0,0 +1,118 @@
+require 'solanum/source'
+
+class Solanum::Source::Diskstats < Solanum::Source
+  attr_reader :devices
+
+  STAT_FILE = '/proc/diskstats'
+
+  FIELDS = %w{
+    major minor name
+    reads_completed reads_merged read_sectors read_time
+    writes_completed writes_merged write_sectors write_time
+    io_active io_time io_weighted_time
+  }
+
+
+  def initialize(opts)
+    super(opts)
+    @devices = opts['devices'] || []
+    @detailed = opts['detailed'] || false
+    @last = {}
+  end
+
+
+  def parse_stats(line)
+    columns = line.strip.split(/\s+/)
+    columns = columns.take(3) + columns.drop(3).map(&:to_i)
+    Hash[FIELDS.zip(columns)]
+  end
+
+
+  def collect!
+    events = []
+
+    File.readlines(STAT_FILE).each do |line|
+      stats = parse_stats(line)
+      device = stats['name']
+
+      if @devices.include?(device) || (@devices.empty? && device =~ /^sd[a-z]$/)
+        if @last[device]
+          diff = Hash.new(0)
+          FIELDS.drop(3).each do |field|
+            diff[field] = stats[field] - @last[device][field]
+          end
+          prefix = "diskstats #{device}"
+
+          # Reads
+
+          events << {
+            service: "#{prefix} read sectors",
+            metric: diff['read_sectors'],
+          }
+
+          events << {
+            service: "#{prefix} read time",
+            metric: diff['read_time'],
+          }
+
+          if @detailed
+            events << {
+              service: "#{prefix} read completed",
+              metric: diff['reads_completed'],
+            }
+
+            events << {
+              service: "#{prefix} read merged",
+              metric: diff['reads_merged'],
+            }
+          end
+
+          # Writes
+
+          events << {
+            service: "#{prefix} write sectors",
+            metric: diff['write_sectors'],
+          }
+
+          events << {
+            service: "#{prefix} write time",
+            metric: diff['write_time'],
+          }
+
+          if @detailed
+            events << {
+              service: "#{prefix} write completed",
+              metric: diff['writes_completed'],
+            }
+
+            events << {
+              service: "#{prefix} write merged",
+              metric: diff['writes_merged'],
+            }
+          end
+
+          # IO
+
+          events << {
+            service: "#{prefix} io active",
+            metric: diff['io_active'],
+          }
+
+          events << {
+            service: "#{prefix} io time",
+            metric: diff['io_time'],
+          }
+
+          events << {
+            service: "#{prefix} io weighted-time",
+            metric: diff['io_weighted_time'],
+          }
+        end
+        @last[device] = stats
+      end
+    end
+
+    events
+  end
+
+end