notifu 1.2

data/lib/notifu/logger.rb

@@ -0,0 +1,83 @@
+module Notifu
+  class Logger
+
+    attr_reader :syslog_enabled
+    attr_reader :elasticsearch_enabled
+    attr_reader :es
+    attr_reader :syslog
+
+    LEVELS = [ "debug",
+               "info",
+               "notice",
+               "warning",
+               "error",
+               "critical",
+               "alert",
+               "emergency" ]
+
+    def initialize (mod)
+      @syslog_enabled = Notifu::CONFIG[:logging][:syslog][:enabled]
+      @elasticsearch_enabled = Notifu::CONFIG[:logging][:elasticsearch][:enabled]
+
+      @logger = Log4r::Logger.new 'notifu'
+
+      if self.syslog_enabled
+        begin
+          @logger.outputters = Log4r::SyslogOutputter.new "notifu", ident: "notifu-#{mod}"
+          log "info", "Syslog socket opened"
+        rescue
+          @logger.outputters = Log4r::Outputter.stdout
+          log "error", "Failed to open local syslog socket, using STDOUT"
+        end
+      else
+        log "info", "Syslog disabled"
+        @logger.outputters = Log4r::Outputter.stdout
+      end
+
+      if self.elasticsearch_enabled
+        begin
+          @es = Elasticsearch::Client.new hosts: Notifu::CONFIG[:logging][:elasticsearch][:conn], retry_on_failure: false, transport_options: { request: { timeout: Notifu::CONFIG[:logging][:elasticsearch][:timeout] || 10 } }
+          log "info", "Action log output to ElasticSearch - " + Notifu::CONFIG[:logging][:elasticsearch][:conn].to_json
+        rescue
+          @es = false
+          log "error", "Failed to connect to ElasticSearch"
+          exit 1
+        end
+      else
+        log "info", "ElasticSearch action logging disabled"
+        @es = false
+      end
+
+    end
+
+    def action_log (type, event)
+      if self.elasticsearch_enabled && self.es
+        index_name = "notifu-" + Time.now.strftime("%Y.%m.%d").to_s
+        begin
+          self.es.index index: index_name, type: type, body: event
+        rescue Faraday::TimeoutError
+          log "error", "Action log action failed: ElasticSearch timeout"
+          log "info", "Action log: (#{type}) #{event.to_json}"
+        end
+      else
+        log "debug", "Action log: #{type}"
+        log "debug", "Action log: (#{type}) #{event.to_json}"
+      end
+    end
+
+    def log (prio, msg)
+      @logger.send prio.to_sym, msg
+    end
+
+  end
+
+
+  # class LogFormatter < Log4r::Formatter
+  #   def format(event)
+  #     event.to_yaml
+  #   end
+  # end
+
+  # "#{time.utc.iso8601(3)} notifu-sidekiq[#{::Process.pid}]: #{context} (TID-#{Thread.current.object_id.to_s(36)}) #{severity}: #{message}\n"
+
+end

data/lib/notifu/mixins.rb

@@ -0,0 +1,49 @@
+class Object
+  def deep_symbolize_keys
+    return self.inject({}){|memo,(k,v) | memo[k.to_sym] =  v.deep_symbolize_keys; memo} if self.is_a? Hash
+    return self.inject([]){|memo,v     | memo           << v.deep_symbolize_keys; memo} if self.is_a? Array
+    return self
+  end
+end
+class Numeric
+  def duration
+    secs  = self.to_int
+    mins  = secs / 60
+    hours = mins / 60
+    days  = hours / 24
+
+    if days > 0
+      "#{days}d, #{hours % 24}h"
+    elsif hours > 0
+      "#{hours}h, #{mins % 60}min"
+    elsif mins > 0
+      "#{mins}min, #{secs % 60}s"
+    elsif secs >= 0
+      "#{secs}s"
+    end
+  end
+
+  def to_state
+    case self.to_int
+    when 0
+      return "OK"
+    when 1
+      return "WARNING"
+    when 2
+      return "CRITICAL"
+    else
+      return "UNKNOWN [#{self.to_s}]"
+    end
+  end
+end
+
+class String
+  def camelize
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+
+  def to_state
+    return self.to_i.to_state
+  end
+end

data/lib/notifu/model.rb

@@ -0,0 +1,5 @@
+require "notifu/model/contact"
+require "notifu/model/sla"
+require "notifu/model/group"
+require "notifu/model/event"
+require "notifu/model/issue"

data/lib/notifu/model/contact.rb

@@ -0,0 +1,15 @@
+module Notifu
+  module Model
+    class Contact < Ohm::Model
+
+      attribute :name
+      attribute :full_name
+      attribute :cell
+      attribute :mail
+      attribute :jabber
+      index :name
+      unique :name
+
+    end
+  end
+end

data/lib/notifu/model/event.rb

@@ -0,0 +1,52 @@
+module Notifu
+  module Model
+    class Event
+      include Notifu::Util
+      attr_reader :notifu_id
+      attr_reader :host
+      attr_reader :address
+      attr_reader :service
+      attr_reader :occurrences_trigger
+      attr_reader :occurrences_count
+      attr_reader :interval
+      attr_reader :time_last_event
+      attr_reader :time_last_notified
+      attr_reader :time_created
+      attr_reader :sgs
+      attr_reader :action
+      attr_reader :code
+      attr_reader :aspiring_code
+      attr_reader :message
+      attr_reader :api_endpoint
+      attr_reader :duration
+      attr_reader :unsilence
+      attr_reader :refresh
+      attr_accessor :process_result
+
+      def initialize args
+        payload = args.first
+        payload.each { |name, value| instance_variable_set("@#{name}", value) }
+        @time_last_notified = Hash.new.to_json.to_s
+        @time_created = self.time_last_event
+        @aspiring_code = self.code
+        @occurrences_trigger ||= 1
+        @refresh ||= nil
+        @unsilence ||= true
+      end
+
+      def group_sla
+        self.sgs.map { |gs| Hash[:group, gs.split(':')[0], :sla, gs.split(':')[1]] }
+      end
+
+      def data
+        @data ||= Hash[ instance_variables.map { |var| [var.to_s.sub(/^@/,""), instance_variable_get(var)] } ]
+      end
+
+      def update_process_result!(obj)
+        self.process_result ||= JSON.generate(Array.new)
+        self.process_result = JSON.generate(JSON.parse(self.process_result) + [ obj ])
+      end
+
+    end
+  end
+end

data/lib/notifu/model/group.rb

@@ -0,0 +1,14 @@
+module Notifu
+  module Model
+    class Group < Ohm::Model
+
+      attribute :name
+      set :primary, Notifu::Model::Contact
+      set :secondary, Notifu::Model::Contact
+      set :tertiary, Notifu::Model::Contact
+      index :name
+      unique :name
+
+    end
+  end
+end

data/lib/notifu/model/issue.rb

@@ -0,0 +1,51 @@
+module Notifu
+  module Model
+    class Issue < Ohm::Model
+      include Notifu::Util
+      attribute :notifu_id
+      attribute :host
+      attribute :address
+      attribute :service
+      attribute :occurrences_trigger
+      attribute :occurrences_count
+      attribute :interval
+      attribute :refresh
+      attribute :time_last_event
+      attribute :time_last_notified
+      attribute :time_created
+      attribute :sgs
+      attribute :action
+      attribute :code
+      attribute :aspiring_code
+      attribute :message
+      attribute :process_result
+      attribute :api_endpoint
+      attribute :duration
+      attribute :unsilence
+      index :notifu_id
+      index :host
+      index :service
+      unique :notifu_id
+
+
+      def time_last_notified? (group_name, sla_name)
+        begin
+          JSON.parse(self.time_last_notified)["#{group_name}:#{sla_name}"]
+        rescue
+          0
+        end
+      end
+
+      def time_last_notified! (group_name, sla_name, time)
+        obj = JSON.parse(self.time_last_notified)
+        self.time_last_notified = JSON.generate(obj.merge({ "#{group_name}:#{sla_name}" => time }))
+      end
+
+      def create_from_event event
+        event.each { |name, value| instance_variable_set(name, value) }
+        self.save
+      end
+
+    end
+  end
+end

data/lib/notifu/model/sla.rb

@@ -0,0 +1,20 @@
+module Notifu
+  module Model
+    class Sla < Ohm::Model
+
+      attribute :name
+      attribute :timeranges
+      attribute :refresh
+      attribute :actors
+      index :name
+      unique :name
+
+      def timerange_values (now=Time.now)
+        dow = now.wday - 1
+        dow = 6 if dow < 0
+        JSON.parse(self.timeranges)[dow]
+      end
+
+    end
+  end
+end

data/lib/notifu/sensu/handler.rb

@@ -0,0 +1,105 @@
+require 'sensu/redis'
+require 'digest'
+require 'multi_json'
+
+module Sensu::Extension
+  class Notifu < Handler
+
+    def definition
+      {
+        type: 'extension',
+        name: 'notifu'
+      }
+    end
+
+    def name
+      definition[:name]
+    end
+
+    def options
+      return @options if @options
+      @options = {
+        :host    => '127.0.0.1',
+        :port    => 6379,
+        :db      => 2
+      }
+      if @settings[:notifu].is_a?(Hash)
+        @options.merge!(@settings[:notifu])
+      end
+      @options
+    end
+
+    def description
+      'Notifu handler for Sensu Server'
+    end
+
+    def post_init
+
+      if @redis
+        yield(@redis)
+      else
+        Sensu::Redis.connect(options) do |connection|
+          connection.auto_reconnect = false
+          connection.reconnect_on_error = true
+          connection.on_error do |error|
+            @logger.warn(error)
+          end
+          @redis = connection
+        end
+      end
+      @redis.sadd("queues", "processor")
+    end
+
+    def run(event_data)
+      event = MultiJson.load(event_data, { :symbolize_keys => true })
+      notifu_id = Digest::SHA256.hexdigest("#{event[:client][:name]}:#{event[:client][:address]}:#{event[:check][:name]}").to_s[-10,10]
+
+      if event[:check][:name] == "keepalive"
+        sgs = event[:client][:sgs]
+        sgs ||= event[:client][:sla]
+      else
+        sgs = event[:check][:sgs]
+        sgs ||= event[:check][:sla]
+      end
+
+      payload = {
+        notifu_id: notifu_id,
+        host: event[:client][:name],
+        address: event[:client][:address],
+        service: event[:check][:name],
+        occurrences_trigger: event[:check][:occurrences],
+        occurrences_count: event[:occurrences],
+        interval: event[:check][:interval] || 0,
+        time_last_event: event[:check][:executed],
+        sgs: sgs,
+        action: event[:action],
+        code: event[:check][:status],
+        message: event[:check][:output],
+        duration: event[:check][:duration],
+        api_endpoint: "http://" + @settings[:api][:host].to_s + ":" + @settings[:api][:port].to_s
+      }
+
+      job = {
+        'class' => 'Notifu::Processor',
+        'args' => [ payload ],
+        'jid' => SecureRandom.hex(12),
+        'retry' => true,
+        'enqueued_at' => Time.now.to_f
+      }
+
+      begin
+        @redis.lpush("queue:processor", MultiJson.dump(job))
+      rescue Exception => e
+        yield "failed to send event to Notifu #{e.message}", 1
+      end
+
+      yield "sent event to Notifu #{notifu_id}", 0
+    end
+
+    def stop
+      yield
+    end
+
+  end
+end
+

data/lib/notifu/util.rb

@@ -0,0 +1,9 @@
+module Notifu
+  module Util
+
+    def self.option args
+      self.instance_variable_set args.keys.first, args.values.first
+    end
+
+  end
+end

data/lib/notifu/workers/actor.rb

@@ -0,0 +1,60 @@
+require_relative "sidekiq_init"
+
+$logger = Notifu::Logger.new 'actor'
+
+Sidekiq.configure_server do |config|
+  config.redis = { url: Notifu::CONFIG[:redis_queues] }
+  Sidekiq::Logging.logger = Log4r::Logger.new 'sidekiq'
+  Sidekiq::Logging.logger.outputters = Log4r::SyslogOutputter.new 'sidekiq', ident: 'notifu-actor'
+  # Sidekiq::Logging.logger.formatter = Notifu::LogFormatter.new
+  Sidekiq::Logging.logger.level = Log4r::DEBUG
+end
+
+Sidekiq.configure_client do |config|
+  config.redis = { url: Notifu::CONFIG[:redis_queues] }
+end
+
+
+module Notifu
+
+  class Actor
+    include Notifu::Util
+    include Sidekiq::Worker
+
+    attr_accessor :issue
+    attr_accessor :contacts
+
+    class << self
+      attr_accessor :name
+      attr_accessor :desc
+      attr_accessor :retry
+    end
+
+    # `act` function must be defined in child classes
+    # (provides notification actors modularity)
+    #
+    def act
+      exit 1
+    end
+
+    sidekiq_options :queue => "actor-#{self.name}"
+    sidekiq_options :retry => self.retry
+
+    def perform *args
+      sleep 2
+      load_data args
+      act
+    end
+
+    def load_data args
+      self.issue = Notifu::Model::Issue.with(:notifu_id, args[0])
+      self.contacts = args[1].map { |contact| Notifu::Model::Contact.with(:name, contact) }
+    end
+
+  end
+end
+
+# load all actors
+Dir[File.dirname(__FILE__).sub(/\/lib\/workers$/, "/") + 'actors/*.rb'].each do |file|
+  require file
+end