panoptimon 0.0.2

data/collectors/process/process

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'json'
+class Array; def to_h; Hash[self]; end; end
+
+opt = JSON::parse(ARGV[0], {symbolize_names: true})
+
+pgrep = ['pgrep']
+
+checks = opt[:checks]
+
+# could match a process with more than one check, so keep track
+names = Hash.new {|h,k| h[k] = []}
+found = {}
+checks.each {|n,o|
+  args = [
+    o[:user] ? ['-u', o[:user]] : [],
+    o[:full] ? ['-f', o[:full]] : o[:pattern] ? o[:pattern] : []
+  ].flatten
+  raise "must have some process characteristic for #{n}" \
+    unless args.length > 0
+  cmd = pgrep + ['-d,'] + args
+  got = begin; IO.popen(cmd).readline.chomp.split(/,/); rescue; []; end
+  got.each {|pid| names[pid].push(n)}
+  found[n] = {count: got.length}
+}
+
+ps = ['ps']
+fields = %w(pid time etime thcount pcpu ni pri vsz rss command)
+fieldcount = fields.length
+
+cnv = {}.tap {|it|
+  to_i = ->(x) {x.to_i}; to_f = ->(x) {x.to_f};
+  to_sec = ->(x) { d = 0; d = $1 if x.sub!(/^\d+-/, '');
+    (h,h,m,s) = x.match(/^(?:(\d+):)?(\d+):(\d+)/).to_a
+    h ||= 0
+    d.to_i * 24 * 60**2 + h.to_i * 60**2 + m.to_i * 60 + s.to_i}
+  it.merge!({
+    pcpu: to_f, time: to_sec, etime: to_sec,
+    thcount: to_i, pri: to_i, rss: to_i, ni: to_i, vsz: to_i
+  })
+}
+
+IO.popen(ps + ['-ww', '-o', fields.join(','), '-p', names.keys.join(',')]).
+  readlines.drop(1).each {|l|
+    f = l.chomp.sub(/^\s+/, '').split(/\s+/, fieldcount)
+    h = (0..fieldcount-1).map {|i| [fields[i].to_sym, f[i]]}.to_h
+    pid = h.delete(:pid)
+    inf = %w(command).map {|k| [k, h.delete(k.to_sym)]}.to_h
+    cnv.each {|k,v| h[k] = v[h[k]]}
+    names[pid].each {|n|
+      i = found[n][:i] ||= 0; found[n][:i] += 1
+      found[n][i] = h
+      _info = found[n][:_info] ||= Hash.new {|h,k| h[k] = []}
+      inf.each {|k,v| _info[k].push(v)}
+    }
+  } if names.keys.length > 0
+
+found.each {|k,v| v.delete(:i)} # cleanup
+
+puts JSON::generate(found)

data/collectors/process/process.json

@@ -0,0 +1,7 @@
+{
+  "checks" : {
+    "sshd" : { "full" : "^/usr/sbin/sshd" },
+    "root shells" : { "pattern" : "^(ba)?sh", "user" : "root" },
+    "daemons" : { "user" : "daemon,nobody,www-data" }
+  }
+}

data/collectors/service/README.md

@@ -0,0 +1,51 @@
+upstart: `initctl list`
+
+```none
+qemu-kvm start/running
+rc stop/waiting
+rsyslog start/running, process 1237
+network-interface (lo) start/running
+```
+
+daemontools: `svstat /service/\*` (aside: `ps -eo %a | grep '[s]vscan ' | cut -d' ' -f2 | sort -u`)
+
+```none
+
+/service/chef-client: up (pid 14971) 1197 seconds
+/service/hubot: up (pid 6583) 8895 seconds
+/service/resmon: up (pid 633) 4131042 seconds
+/service/syslog-ng: up (pid 632) 4131042 seconds
+/service/mail-in:  down 3 seconds, normally up
+```
+
+systemd: `systemctl list-units --full --type=service --all`, `systemctl show NAME NAME NAME ...`
+
+## Config
+
+```json
+{
+  interval: 60
+  flaptime: 30,
+  since: 900,
+  services: {
+    init: { foo : { status_cmd : "..."} },
+    systemd: {
+      sshd : {...}
+    },
+    daemontools: {
+      "-monitor" : ["/service/*"], # probably all you need
+      "-options" : { "svstat" : ["..."] },
+      "chef-client" : { },
+      "syslog-ng" : {"path" : "/service/syslog-ng"}, # is the default
+    }
+  }
+}
+```
+
+## Output
+
+* up: seconds the service has been up (negative if it has been shutdown)
+* flaps: number of flaps (runs under 'flaptime') within the 'since' horizon
+
+  services|daemontools|syslog-ng|up => $seconds
+  services|daemontools|syslog-ng|flaps => $n

data/collectors/service/samples/.gitignore

@@ -0,0 +1 @@
+replay.counter

data/collectors/service/samples/data/disconnect

@@ -0,0 +1,11 @@
+up (pid 3655) 30392 seconds
+up (pid 3655) 30452 seconds
+up (pid 3655) 30512 seconds
+up (pid 3655) 30572 seconds
+down 3 seconds, normally up
+down 63 seconds, normally up
+down 123 seconds, normally up
+down 183 seconds, normally up
+down 243 seconds, normally up
+down 303 seconds, normally up
+down 363 seconds, normally up

data/collectors/service/samples/data/flappy

@@ -0,0 +1,7 @@
+up (pid 3657) 132 seconds
+up (pid 3657) 192 seconds
+up (pid 3657) 252 seconds
+up (pid 3658) 25 seconds
+up (pid 3659) 27 seconds
+up (pid 3660) 22 seconds
+up (pid 3661) 12 seconds

data/collectors/service/samples/data/solid

@@ -0,0 +1,18 @@
+up (pid 3656) 30032 seconds
+up (pid 3656) 30092 seconds
+up (pid 3656) 30152 seconds
+up (pid 3656) 30212 seconds
+up (pid 3656) 30272 seconds
+up (pid 3656) 30332 seconds
+up (pid 3656) 30392 seconds
+up (pid 3656) 30452 seconds
+up (pid 3656) 30512 seconds
+up (pid 3656) 30572 seconds
+up (pid 3656) 30632 seconds
+up (pid 3656) 30692 seconds
+up (pid 3656) 30752 seconds
+up (pid 3656) 30812 seconds
+up (pid 3656) 30872 seconds
+up (pid 3656) 30932 seconds
+up (pid 3656) 30992 seconds
+up (pid 3656) 31052 seconds

data/collectors/service/samples/replay

@@ -0,0 +1,27 @@
+#!/usr/bin/env perl
+
+use v5.10;
+use warnings;
+use strict;
+
+my $countfile = __FILE__ . '.counter';
+
+my $count = 1 + do {
+  open(my $fh, '<', $countfile) or die "cannot open '$countfile' - $!";
+  chomp(my $c = <$fh>);
+  $c;
+};
+
+my %data = map({ my $file = $_;
+  open(my $fh, '<', $file) or die "cannot open '$file' - $!";
+  chomp(my @lines = <$fh>);
+  $count = 1 if @lines < $count and warn "resetting\n";
+  ($file => \@lines);
+} @ARGV);
+
+say {
+  open(my $fh, '>', $countfile) or die "cannot open '$countfile' - $!";
+  $fh
+} $count;
+
+say "$_: $data{$_}[$count - 1]" for keys %data; 

data/collectors/service/service

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+# Copyright (C) 2012 Sourcefire, Inc.
+
+require 'json'
+require 'pathname'
+
+$stdout.sync = true # persistent process
+opt = JSON::parse(ARGV[0], {symbolize_names: true})
+opt.merge!( interval: 60, flaptime: 30, since: 900 ) {|k,a,b| a}
+
+class MatchData; def to_h
+  Hash[self.names.map {|n| [n.to_sym, self[n]]}]
+end; end
+class Array; def to_h; Hash[self]; end; end
+
+handler = {
+  daemontools: ->(srv){
+    o = srv.delete(:'-options') || {}
+    mon = srv.delete(:'-monitor')
+    cmd = [o[:svstat] || 'svstat'].flatten
+    fn = mon.map {|n| Pathname.glob(n.to_s)}.flatten.
+        map {|p| [p.to_s, p.basename.to_s.to_sym]}.to_h.
+      merge(
+        srv.keys.map {|n| [n, srv[n][:path] || '/service/' + n]}.to_h)
+    ->() {
+      p = IO.popen(cmd + fn.keys.map{|k| k.to_s})
+      stat = p.readlines
+      p.close
+      stat.map {|l| l.chomp!
+        info = l.match(%r{
+          \A(?<key>\S+):\s+
+          (?<state>up|down)
+          (?:\s+\(pid\s+(?<pid>\d+)\))?\s+
+          (?<duration>\d+)\s+seconds
+          (?:,\s+normally\s(?<normally>\S+))?
+        }x) or raise "cannot parse #{l}"
+        info = info.to_h 
+        name = fn[info.delete(:key)]
+        [name, info]
+      }.to_h
+    }
+  },
+}
+
+services = Hash[opt[:services].map {|k,v|
+  how = handler[k] or raise "unknown service type #{k}"; [k, how[v]]}]
+
+class AFlap
+  def initialize (opts = {})
+    @since    = opts[:since] || 900
+    @flaptime = opts[:flaptime] || 5
+    @history = {}
+  end
+  def log (k, i)
+    l = @history[k] ||= []
+    t = Time.now
+    l.shift while(l.length > 0 and l[0][:time] < t - @since)
+    logged = {
+      time: t,
+      duration: i[:duration].to_i,
+      up: (i[:state] == 'up' ? true : false)
+    }
+    l.push(logged)
+    count = 0;
+    l.reverse.each {|i|
+      break if i[:duration] > @flaptime or not(i[:up])
+      count +=1}
+    {flaps: count, up: (logged[:up] ? 1 : -1) * logged[:duration]}
+  end
+end
+
+hist = AFlap.new(opt)
+while true
+  metrics = services.map {|k,v|
+    data = v[].map {|n,i|
+      [n, hist.log("#{k}|#{n}", i)]
+    }.to_h
+    [k, data]
+  }.to_h
+  puts JSON::generate(metrics)
+  sleep(opt[:interval])
+  if opt[:limit]
+    opt[:limit] -= 1
+    break if opt[:limit] == 0
+  end
+end

data/collectors/service/service.json

@@ -0,0 +1,7 @@
+{
+  "interval" : 60,
+  "flaptime" : 30, "since" : 900,
+  "services" : {
+    "daemontools" : { "-monitor" : ["/service/*"] }
+  }
+}

data/collectors/smtp/lib/panoptimon-collector-smtp/smtp.rb

@@ -0,0 +1,30 @@
+require "socket"
+require "timeout"
+
+module Panoptimon
+  module Collector
+    class SMTP
+
+      attr_reader :host, :port, :timeout
+      def initialize(args={})
+        args.each { |k,v| instance_variable_set("@#{k}", v) }
+      end
+
+      def collect
+        c = begin
+          Timeout::timeout(timeout) {
+            code = TCPSocket.new(host, port).gets.split.first
+            {status: code.to_i}
+          }
+        rescue Timeout::Error
+          {timeout: true}
+        rescue
+          {error: true, _info: {error: "#{$!.class}: #{$!}"}}
+        end
+
+        return c
+      end
+    end
+  end
+end
+

data/collectors/smtp/lib/panoptimon-collector-smtp.rb

@@ -0,0 +1 @@
+require 'panoptimon-collector-smtp/smtp'

data/collectors/smtp/smtp

@@ -0,0 +1,27 @@
+#! /usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'json'
+require 'panoptimon-collector-smtp'
+
+ARGV[0] or raise "arguments required"
+conf = JSON.parse(ARGV[0], {symbolize_names: true})
+
+defaults = {
+  port:    conf[:default_port] || 25,
+  timeout: conf[:default_timeout] || 3,
+}
+
+raise "must have 'hosts' value in config" unless conf[:hosts]
+setup = conf[:hosts].map {|h|
+  o = defaults.merge(h.is_a?(Hash) ? h : {host: h})
+  o[:host] or raise "must have 'host' attribute in entry #{o.inspect}"
+  o[:name] ||= o[:host]
+  o
+}
+
+output = Hash[setup.map {|o|
+  warn "o: #{o.inspect}"
+  [o[:name], Panoptimon::Collector::SMTP.new(o).collect]
+}]
+puts JSON.generate(output)

data/collectors/smtp/smtp.json

@@ -0,0 +1,10 @@
+{
+  "hosts": [
+    "smtp.gmail.com",
+    {"host": "localhost", "port": "235"}
+  ],
+  "default_port" : 587,
+  "default_timeout" : 7,
+
+  "interval" : 240
+}

data/collectors/socket/README.md

@@ -0,0 +1,36 @@
+### Description
+
+Connect to arbitrary TCP & UNIX sockets and match output. Input is expected to be an Array of TCP & UNIX checks as the following describes.
+
+
+``` json
+{
+  "checks": {
+    "haproxy": {
+      "path": "/var/run/haproxy/stats",
+      "timeout": 10,
+      "query": "show info",
+      "match": ".*"
+    },
+    "cloudysunday": {
+      "path": "localhost",
+      "port": 22,
+      "timeout": 5,
+      "match": "SSH"
+    }
+  }
+}
+```
+
+### Check Attributes
+
+**Path:** Describes the endpoint of a given socket.  This will
+automatically determine the type (TCP vs Unix) of check.
+
+**Timeout:** Number of seconds to connect/query a given socket and return.
+
+**Match:** Parse the output ensuring it includes the given match string.
+
+**Query (Unix Only):** Input to a given a socket.
+
+**Port (TCP Only):** Port to connect to (default: 80).

data/collectors/socket/lib/panoptimon-collector-socket/socket.rb

@@ -0,0 +1,38 @@
+require 'panoptimon-collector-socket/tcp'
+require 'panoptimon-collector-socket/unix'
+
+module Panoptimon
+  module Collector
+    class Socket
+      attr_accessor :path, :timeout, :match
+
+      def initialize(options={})
+        @path    = options[:path]    || defaults[:path]
+        @match   = options[:match]   || defaults[:match]
+        @timeout = options[:timeout] || defaults[:timeout]
+        return options
+      end
+
+      # dispatching constructor
+      def self.construct(options={})
+        (options[:path] =~ %r{^/} ? Unix : TCP).new(options)
+      end
+
+      def defaults
+        {match:   '.*'}
+      end
+
+      def run
+        out = begin
+          a = Timeout::timeout(timeout.to_i) { get_banner }
+          {status: a.match(match) ? true : false}
+        rescue Timeout::Error
+          {timeout: true}
+        end
+
+        out
+      end
+
+    end
+  end
+end

data/collectors/socket/lib/panoptimon-collector-socket/tcp.rb

@@ -0,0 +1,34 @@
+require 'uri'
+require 'socket'
+require 'timeout'
+require 'panoptimon-collector-socket/socket'
+
+module Panoptimon
+  module Collector
+    class Socket
+      class TCP < Panoptimon::Collector::Socket
+        attr_accessor :host, :port
+
+        def initialize(options={})
+          opt = defaults.merge(options)
+          super(opt)
+          @port  = opt[:port]
+          @host = @path.match('\w+:\/\/') ? URI(@path).host : @path
+        end
+
+        def defaults
+          super.merge({
+             path:    'http://localhost',
+             port:    80,
+             timeout: 10,
+          })
+        end
+
+        def get_banner
+          TCPSocket.new(host, port).recv(100)
+        end
+
+      end
+    end
+  end
+end

data/collectors/socket/lib/panoptimon-collector-socket/unix.rb

@@ -0,0 +1,28 @@
+module Panoptimon
+  module Collector
+    class Socket
+      class Unix < Panoptimon::Collector::Socket
+        attr_accessor :query
+
+        def initialize(options={})
+          opt = super(defaults.merge(options))
+          @query = opt[:query]
+          opt
+        end
+
+        def defaults
+          super.merge({
+            path:    '/var/run/haproxy/stats',
+            query:   'show info',
+            timeout: 5
+          })
+        end
+
+        def get_banner
+          UNIXSocket.new(@path).puts(query).readlines.join('')
+        end
+
+      end
+    end
+  end
+end

data/collectors/socket/lib/panoptimon-collector-socket.rb

@@ -0,0 +1,3 @@
+require 'panoptimon-collector-socket/socket'
+require 'panoptimon-collector-socket/tcp'
+require 'panoptimon-collector-socket/unix'

data/collectors/socket/socket

@@ -0,0 +1,13 @@
+#! /usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+
+require 'json'
+require 'panoptimon-collector-socket'
+
+raise 'Input must be provided!' unless ARGV[0]
+
+config = JSON.parse(ARGV[0], symbolize_names: true)
+puts Hash[config[:checks].map do |check, info|
+  [check, Panoptimon::Collector::Socket.construct(info).run]
+end].to_json

data/collectors/socket/socket.json

@@ -0,0 +1,16 @@
+{
+  "checks": {
+    "haproxy": {
+      "path": "/var/run/haproxy/stats",
+      "timeout": 10,
+      "query": "show info",
+      "match": ".*"
+    },
+    "ssh": {
+      "path": "localhost",
+      "port": 22,
+      "timeout": 5,
+      "match": "SSH"
+    }
+  }
+}

data/collectors/socket/tests/tcp_spec.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'rspec'
+require 'panoptimon-collector-socket'
+
+describe('basic test') {
+  it('works') {
+    socket = Panoptimon::Collector::Socket::TCP.new(
+      path:  'localhost',
+      port:  22,
+      match: 'SSH'
+    )
+    socket.host.should == 'localhost'
+    socket.port.should == 22
+    socket.match.should == 'SSH'
+    ans = socket.run
+    ans.class.should == Hash
+    ans[:status].should == true
+  }
+}
+

data/collectors/socket/tests/unix_spec.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'rspec'
+require 'panoptimon-collector-socket'
+
+describe('basic test') {
+  it('works') {
+    socket = Panoptimon::Collector::Socket::Unix.new(
+      path:  '/tmp/sockpuppet',
+      query: 'show info')
+    socket.path.class.should == String
+    socket.path.should =~ %r{^/\w+}
+    socket.query.should == 'show info'
+
+    yo = nil
+    socket.stub(:get_banner) { yo = "foo\nbar\nbaz" }
+    ans = socket.run
+    yo.should == "foo\nbar\nbaz"
+    ans[:status].should == true
+  }
+  it('does matching too') {
+    socket = Panoptimon::Collector::Socket::Unix.new(
+      path:  '/tmp/sockpuppet',
+      query: 'show info',
+      match: 'frobnosticate',
+    )
+    socket.path.class.should == String
+    socket.path.should =~ %r{^/\w+}
+    socket.query.should == 'show info'
+
+    socket.stub(:get_banner) { "foo\nbar\nbaz" }
+    ans = socket.run
+    ans[:status].should == false
+  }
+}

data/collectors/ssh/README.md

@@ -0,0 +1,27 @@
+# Configuration
+
+```json
+{
+  "hosts" : [
+    "localhost",
+    {"name" : "example", "host": "ssh.example.com",
+      "port": 17, "timeout": 7},
+  ],
+  "default_port"    : 22,
+  "default_timeout" : 3,
+
+  "interval" : 60,
+  "timeout"  : 25,
+}
+```
+
+# Output
+
+```json
+{
+  "ssh|localhost|ok" : true, # whether connected or not
+  "ssh|localhost|_info" : {"banner" : "SSH-2.0-OpenSSH_5.9p1 Debian-5ubuntu1"},
+  "ssh|example|ok" : true,
+  ...
+}
+```

data/collectors/ssh/ssh

@@ -0,0 +1,41 @@
+#! /usr/bin/env ruby
+
+require 'json'
+
+conf = ARGV[0] ? JSON.parse(ARGV[0], {symbolize_names: true}) : {}
+
+defaults = {
+  port:    conf[:default_port] || 22,
+  timeout: conf[:default_timeout] || 4,
+}
+
+conf[:hosts] or raise "hosts config required"
+
+setup = conf[:hosts].map {|h|
+  opt = h.is_a?(Hash) ? h : {host: h}
+  raise "host is required" unless opt[:host]
+  opt = defaults.merge(opt)
+  opt[:name] ||= opt[:host]
+  opt
+}
+
+require 'socket'
+require 'timeout'
+get = ->(args) {
+  warn args[:host]
+  data = {_info: {}}
+  begin
+    data[:_info][:banner] = timeout(args[:timeout]) {
+      TCPSocket.open(args[:host], args[:port]).readline
+    }.chomp
+    data[:ok] = true
+  rescue TimeoutError
+    data[:ok] = false
+  end
+  data
+}
+
+output = Hash[setup.map {|opt| [opt[:name], get[opt]]}]
+puts JSON.generate(output)
+
+

data/collectors/ssh/ssh.json

@@ -0,0 +1,3 @@
+{
+  "hosts": ["localhost"]
+}