snmp2mkr 0.1.0

data/lib/snmp2mkr/config_types/vhost_discovery_rule_collection.rb

@@ -0,0 +1,26 @@
+require 'snmp2mkr/config_types/base'
+require 'snmp2mkr/config_types/vhost_discovery_rule'
+
+module Snmp2mkr
+  module ConfigTypes
+    class VhostDiscoveryRuleCollection < Base
+      def setup(hash)
+        if !hash.kind_of?(Hash) || hash.any? { |k,v| !k.kind_of?(String) }
+          raise TypeError, "#{self.class} must be given a Hash<String, Object)>"
+        end
+
+        @value = hash.map { |k, v| [k, VhostDiscoveryRule.new(v)] }.to_h
+      end
+
+      def [](k)
+        @value[k]
+      end
+
+      def collect_children
+        @value.values
+      end
+
+      attr_reader :value
+    end
+  end
+end

data/lib/snmp2mkr/discoverer.rb

@@ -0,0 +1,104 @@
+require 'logger'
+require 'snmp2mkr/config_types/oid'
+require 'snmp2mkr/mib'
+require 'snmp2mkr/oid'
+require 'snmp2mkr/vhost'
+
+module Snmp2mkr
+  class Discoverer
+    def initialize(host, host_manager: nil, logger: Logger.new(File::NULL), mib: Mib.default)
+      @host = host
+      @host_manager = host_manager
+      @logger = logger
+      @mib = mib
+    end
+
+    def inspect
+      "#<#{self.class}:#{'%x' % __id__}, #{host.name.inspect}>"
+    end
+
+    attr_reader :host, :host_manager, :logger, :mib
+
+    def perform!
+      if host_manager
+        host_manager.set_vhosts(host.name, vhosts)
+      end
+
+      vhosts
+    end
+
+    def vhosts
+      @vhosts ||= [
+        primary_vhost,
+        *discover_vhosts(host.vhost_discoveries),
+      ]
+    end
+
+    def primary_vhost
+      @primary_vhost ||= Vhost.new(
+        name: host.name,
+        roles: host.definition.roles,
+        metrics: host.metric_definitions + discover_metrics(host.metric_discoveries),
+        mib: mib
+      )
+    end
+
+    def snmp_trees
+      @snmp_trees ||= host.snmp do |snmp|
+        oids = [*host.metric_discoveries.values, *host.vhost_discoveries.values].
+          compact.
+          flat_map { |_| _.keys.values.map(&:evaluate) }.
+          uniq.
+          map { |_| Snmp2mkr::Oid.new(mib.name_to_oid(_), name: _) }.
+          uniq.
+          sort_by { |_| -_.to_a.size }
+
+        oids.map do |oid|
+          [oid.to_s, snmp.subtree(oid).to_a]
+        end.to_h
+      end
+    end
+
+    private
+
+    def discover_metrics(rules)
+      rules.each_value.flat_map do |rule|
+        rule_keys = rule.keys.map { |k, confoid| [k, Snmp2mkr::Oid.new(confoid.evaluate, mib: mib)] }
+        primary_oid = rule_keys.first.last.to_s
+
+        snmp_trees[primary_oid].flat_map do |index_vb|
+          index = index_vb.oid.index_of(primary_oid)
+          keys = rule_keys.map do |k, oid|
+            [k, snmp_trees[oid.to_s].find{ |vb| vb.oid.index_of(oid) == index }.value.to_s]
+          end.to_h
+          keys['index'] = index
+
+          rule.metrics.bind_context(keys).evaluate.values
+        end
+      end
+    end
+
+    def discover_vhosts(rules)
+      rules.each.flat_map do |rule_name, rule|
+        rule_keys = rule.keys.map { |k, confoid| [k, Snmp2mkr::Oid.new(confoid.evaluate, mib: mib)] }
+        primary_oid = rule_keys.first.last.to_s
+
+        snmp_trees[primary_oid].flat_map do |index_vb|
+          index = index_vb.oid.index_of(primary_oid)
+          keys = rule_keys.map do |k, oid|
+            [k, snmp_trees[oid.to_s].find{ |vb| vb.oid.index_of(oid) == index }.value.to_s]
+          end.to_h
+          keys['index'] = index
+
+          bind_rule = rule.bind_context(keys)
+          Vhost.new(
+            name: bind_rule.name.evaluate,
+            roles: bind_rule.roles.map(&:evaluate),
+            metrics: bind_rule.metrics.evaluate.values,
+            discovery_name: rule_name,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/snmp2mkr/engine.rb

@@ -0,0 +1,196 @@
+require 'thread'
+
+require 'mackerel/client'
+
+require 'snmp2mkr/host_manager'
+require 'snmp2mkr/metrics_state_holder'
+require 'snmp2mkr/mib'
+
+require 'snmp2mkr/engine_threads/timer'
+require 'snmp2mkr/engine_threads/sender'
+require 'snmp2mkr/engine_threads/worker'
+
+require 'snmp2mkr/discoverer'
+require 'snmp2mkr/collector'
+require 'snmp2mkr/host_updater'
+
+module Snmp2mkr
+  class Engine
+    def initialize(config, log_level: 'info', logdev: $stdout)
+      @config = config
+      @log_level = log_level
+      @logdev = logdev
+
+      @shutdown = nil
+      @logger = new_logger('engine')
+
+      @mib = Mib.new(
+        load_path: config.mib_load_path,
+        modules: config.mib_no_default_modules ? config.mib_modules : [*Mib::DEFAULT_MODULES, *config.mib_modules],
+      )
+
+      @host_manager = nil
+      @metrics_state_holder = nil
+
+      @worker_queue = nil
+      @sender_queue = nil
+
+      @timer = nil
+      @worker_threads = nil
+      @sender_threads = nil
+    end
+
+    attr_reader :logger, :config, :host_manager, :metrics_state_holder, :mib
+
+    def new_logger(progname)
+      Logger.new(@logdev).tap { |_| _.progname = progname; _.level = @log_level }
+    end
+
+    def prepare
+      @host_manager = HostManager.new(persist_file: config.persist_file.evaluate)
+      @metrics_state_holder = MetricsStateHolder.new
+
+      load_hosts
+      initial_discover
+    end
+
+    def load_hosts
+      config.hosts.evaluate.each do |name, hostdef|
+        host = Snmp2mkr::Host.new(hostdef, template_collection: config.templates)
+        logger.info "Loaded host: #{host.inspect}"
+        host_manager.add_host host
+      end
+    end
+
+    def initial_discover
+      host_manager.each_host do |host|
+        logger.info "Initial discovery of #{host.inspect}"
+        Snmp2mkr::Discoverer.new(host, host_manager: host_manager).perform!
+      end
+      logger.info "Initial discovery completed"
+    end
+
+    def start(signals: false)
+      raise 'already ran' unless @shutdown.nil?
+      @shutdown = false
+
+      prepare
+
+      @worker_queue = Queue.new
+      @sender_queue = Queue.new
+
+      @timer = EngineThreads::Timer.new(logger: new_logger('timer'))
+
+      @worker_threads = 2.times.map do
+        EngineThreads::Worker.new(queue: @worker_queue, logger: new_logger('worker'))
+      end
+
+      @sender_threads = 2.times.map do
+        EngineThreads::Sender.new(
+          mackerel: Mackerel::Client.new(mackerel_api_key: config.api_key.evaluate),
+          host_manager: host_manager,
+          queue: @sender_queue,
+          logger: new_logger('sender'),
+        )
+      end
+
+      @worker_threads.each(&:start)
+      @sender_threads.each(&:start)
+
+      @timer.start
+
+      handle_signals if signals
+
+      initial_host_update
+      load_timer
+    end
+
+    def handle_signals
+      r,w = IO.pipe
+      handler_th = Thread.new(r) { |io|
+        io.gets
+        stop
+        io.gets
+        logger.warn "Force shut down"
+        exit
+      }
+      handler = proc do
+        w.puts "quit"
+      end
+      trap(:INT, handler)
+      trap(:TERM, handler)
+      handler_th.abort_on_exception = true
+    end
+
+    def initial_host_update
+      host_updater_logger = new_logger('host_updater')
+      host_manager.each_host do |host|
+        @worker_queue << HostUpdater.new(host, sender_queue: @sender_queue, logger: host_updater_logger)
+      end
+    end
+
+    def load_timer
+      discoverer_logger = new_logger('discoverer')
+      host_updater_logger = new_logger('host_updater')
+      collector_logger = new_logger('collector')
+
+      host_manager.each_host do |host|
+        @timer.add(host.definition.discover_interval) do
+          next if @shutdown
+          @worker_queue << Discoverer.new(host, host_manager: host_manager,  logger: discoverer_logger)
+          @worker_queue << HostUpdater.new(host, sender_queue: @sender_queue, logger: host_updater_logger)
+        end
+
+        @timer.add(host.definition.interval) do
+          next if @shutdown
+          @worker_queue << Collector.new(host, metrics_state_holder: metrics_state_holder, host_manager: host_manager, sender_queue: @sender_queue, logger: collector_logger)
+        end
+      end
+    end
+
+    def stop
+      logger.info "Shutting down..."
+      @shutdown = true
+      @timer.stop
+      @worker_queue.close
+      @sender_queue.close
+    end
+
+    def wait
+      @timer.join
+      [*@worker_threads, *@sender_threads].each(&:join)
+    end
+
+    def wait_stop
+      logger.debug "Waiting timer to stop"
+      @timer.join
+      logger.debug "timer stopped"
+
+      logger.debug "Waiting workers to stop"
+      @worker_threads.each { |th|
+        logger.debug "Waiting #{th.inspect}"
+        th.join
+      }
+      logger.debug "Waiting senders to stop"
+      @sender_threads.each { |th|
+        logger.debug "Waiting #{th.inspect}"
+        th.join
+      }
+    end
+
+    def run!(signals: true)
+      start(signals: signals)
+      wait
+    end
+
+    def shutdown!
+      stop
+      wait
+    end
+
+    def init
+      discovery
+      load_timer
+    end
+  end
+end

data/lib/snmp2mkr/engine_threads/sender.rb

@@ -0,0 +1,92 @@
+require 'mackerel/client'
+require 'snmp2mkr/mackerel_ext'
+
+module Snmp2mkr
+  module EngineThreads
+    class Sender
+      def initialize(mackerel:, host_manager:, queue:, logger: Logger.new($stdout))
+        @mackerel = mackerel
+        @host_manager = host_manager
+        @queue = queue
+        @logger = logger
+        @thread = nil
+      end
+
+      attr_reader :mackerel, :host_manager, :queue, :logger, :thread
+
+      def running?
+        @thread && @thread.alive?
+      end
+
+      def join
+        return unless running?
+        @thread.join
+      end
+
+      def start
+        return if running?
+        @thread = Thread.new(&method(:main_loop))
+      end
+
+      def main_loop
+        while job = queue.pop
+          process job
+        end
+      rescue Exception => e
+        logger.error "#{e.inspect}\n\t#{e.backtrace.join("\n\t")}"
+        sleep 1
+        retry
+      end
+
+      def process(job)
+        logger.debug "sending #{job.inspect}"
+
+        case job
+        when Snmp2mkr::SendRequests::Metrics
+          send_metrics job
+        when Snmp2mkr::SendRequests::HostInformation
+          update_host job
+        else
+          raise TypeError, "Invalid send_request: #{job.class}"
+        end
+      end
+
+      def update_host(job)
+        host_id = get_host_id(job.vhost)
+
+        host = {
+          name: job.vhost.name,
+          meta: job.meta,
+          interfaces: job.interfaces,
+        }
+        logger.debug "Update host (#{job.vhost.name}, #{host_id}): #{host.to_json}"
+        resp = mackerel.put_host(host_id, host)
+        logger.debug "Mackerel response (update_host #{host_id.inspect}): #{resp.inspect}"
+      end
+
+      def send_metrics(job)
+        metric_values = job.metric_values.map do |mv|
+          {
+            hostId: get_host_id(mv[:vhost]),
+            name: mv[:name],
+            time: mv[:time].to_i,
+            value: mv[:value]
+          }
+        end
+
+        logger.debug "Posting metrics #{job.inspect}: #{metric_values.inspect}"
+        resp = mackerel.post_metrics(metric_values)
+        logger.debug "Mackerel response (#{job.inspect}): #{resp.inspect}"
+      end
+
+      def get_host_id(vhost)
+        host_manager.set_mackerel_host_id_safe(vhost) do
+          logger.debug "Registering #{vhost.name.inspect}"
+          mackerel.post_host(name: vhost.name, meta: {})['id'].tap do |host_id|
+            logger.info "Registered #{vhost.name.inspect} as #{host_id.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snmp2mkr/engine_threads/timer.rb

@@ -0,0 +1,80 @@
+module Snmp2mkr
+  module EngineThreads
+    class Timer
+      Entry = Struct.new(:interval, :hook, :last)
+
+      def initialize(logger: Logger.new($stdout))
+        @shutdown = false
+        @entries = []
+        @logger = logger
+        @thread = nil
+      end
+
+      attr_reader :entries, :logger, :thread
+
+      def add(interval, &hook)
+        entry = Entry.new(interval, hook, now - interval + rand(15))
+        logger.info "Added timer #{entry.inspect}"
+        @entries << entry
+      end
+
+      def running?
+        @thread && @thread.alive?
+      end
+
+      def join
+        return unless running?
+        @thread.join
+      end
+
+      def start
+        return if running?
+        @shutdown = false
+        @thread = Thread.new(&method(:main_loop))
+      end
+
+      def stop
+        return unless running?
+        @shutdown = true
+      end
+
+      def main_loop
+        logger.info "timer started"
+        loop do
+          break if @shutdown
+          tick
+          sleep 1
+        end
+        logger.info "timer shutdown"
+      rescue Exception => e
+        logger.error "#{e.inspect}\n\t#{e.backtrace.join("\n\t")}"
+        retry
+      end
+
+      def tick
+        t = now
+        @entries.each do |entry|
+          kick(entry) if (now - entry.last) > entry.interval
+        end
+      end
+
+      def kick(entry)
+        logger.debug "timer kick entry #{entry.inspect}"
+        entry.last = now
+        Thread.new do
+          begin
+            entry.hook.call
+          rescue Exception => e
+            logger.error "#{e.inspect}\n\t#{e.backtrace.join("\n\t")}"
+          end
+        end
+      end
+
+      private
+
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end