rrd-grapher 1.0.0

data/lib/rrd-grapher/notifier/alarms.rb

@@ -0,0 +1,79 @@
+
+module RRDNotifier
+  ##
+  # An active alarm.
+  # 
+  class Alarm
+    # the packet which triggered the alarm
+    attr_accessor :packet
+    
+    def initialize(p)
+      @packet = p
+    end
+    
+    def method_missing(m, *args)
+      if packet
+        packet.send(m, *args)
+      end
+    end
+  end
+  
+  class AlarmTooHigh < Alarm
+    def reason; :too_high; end
+    
+    attr_accessor :threshold
+    
+    def initialize(p, threshold)
+      super(p)
+      @threshold = threshold
+    end
+    
+    def is_same?(threshold)
+      @threshold == threshold
+    end
+  end
+  
+  class AlarmTooLow < AlarmTooHigh
+    def reason; :too_low; end
+  end
+  
+  class AlarmMissingData < Alarm
+    def reason; :missing_data; end
+    
+    ##
+    # Time allowed between updates.
+    attr_accessor :allowed_interval
+    
+    ##
+    # When was this measure last updated ?
+    attr_accessor :last_update
+    
+    def initialize(p, allowed_interval ,last_update)
+      super(p)
+      @allowed_interval = allowed_interval
+      @last_update = last_update
+    end
+    
+    def is_same?(allowed_interval ,last_update)
+      (@allowed_interval == allowed_interval) &&
+      (@last_update == last_update)
+    end
+  end
+  
+  class AlarmClockDrift < Alarm
+    def reason; :clock_drift; end
+    
+    # difference in seconds between our clock
+    # and the one of the host
+    attr_accessor :allowed_drift
+    
+    def initialize(p, allowed_drift)
+      super(p)
+      @allowed_drift = allowed_drift
+    end
+    
+    def is_same?(drift)
+      @allowed_drift == drift
+    end
+  end
+end

data/lib/rrd-grapher/notifier/collectdrb.rb

@@ -0,0 +1,86 @@
+#
+# This file was not written by me but it did not come with a license
+# and I cannot find itw owner so if you know the author let me know.
+#
+class Collectd
+  # Encode a string (type 0, null terminated string)
+  def self.string(type, str)
+    str += "\000"
+    [type, str.length+4].pack("nn") + str
+  end
+
+  # Encode an integer
+  def self.number(type, num)
+    [type, 12].pack("nn") + [num >> 32, num & 0xffffffff].pack("NN")
+  end
+
+  # Create a collectd collection object tied to a specific destination server and port.
+  # The host parameter is the hostname sent to collectd, typically `hostname -f`.strip
+  # The use of the interval is unclear, it's simply sent to collectd with every packet...
+  def initialize(host, interval)
+    @interval = interval
+    @host = host || %x{hostname -s}.strip
+    start
+  end
+
+  # Start a fresh packet, this is usually not called directly. Issues a time marker using either
+  # the passed time (unix time integer) or the same time as the previous packet (useful when
+  # overrunning from one packet to the next)
+  def start(time=nil)
+    @pkt = Collectd.string(0, @host)
+    @pkt << Collectd.number(1, Time.new.to_i)
+    @pkt << Collectd.number(7, @interval)
+    @plugin = @plugin_instance = @tipe = @tipe_instance = nil
+  end
+  # Send the current packet
+  def flush
+    raise "need to be redefined"
+  end
+  # Check the length of the current packet and flush it if we reach a high-water mark
+  def chk
+    if @pkt.size > 900 # arbitrary flush, 1024 is the max allowed
+      flush
+      #sleep(0.01) # don't overwhelm output buffers
+      start
+    end
+  end
+  
+  def force_send
+    flush
+    start
+  end
+
+  # Issue time, plugin, plugin_instance, type, and type_instance markers. These are not typically called
+  # directly
+  def time(t)            @pkt << Collectd.number(1, @time = t)            unless @time == t; end
+  def plugin(p)          @pkt << Collectd.string(2, @plugin = p)          unless @plugin == p; end
+  def plugin_instance(p) @pkt << Collectd.string(3, @plugin_instance = p) unless @plugin_instance == p; end
+  def tipe(p)            @pkt << Collectd.string(4, @tipe = p)            unless @tipe == p; end
+  def tipe_instance(p)   @pkt << Collectd.string(5, @tipe_instance = p)   unless @tipe_instance == p; end
+
+  # Send a data point consisting of one or multiple values. Multiple values are used for RRDs with multiple
+  # data series (DS's in RRD terms). An examples of a multi-valued RRDs in the collectd types is disk_write
+  # with a 'read' and a 'write' value.
+  # Arguments: pl=plugin, pi=plugin_instance, t=type, ti=type_instance, values: array of [type, value]
+  # Eg.: values('disk', 'sda0', 'disk', 'ops', [[:counter, 1034], [:counter, 345]])
+  @@type_code = {:gauge => 1, :counter => 0, :derive => 2, :absolute => 3}
+  def values(pl, pi, t, ti, values)
+    chk
+    plugin(pl); plugin_instance(pi)
+    tipe(t); tipe_instance(ti)
+    @pkt << [6, 4+2+values.size*9, values.size].pack("nnn")
+    @pkt << values.map{|t,v| [@@type_code[t]].pack("C")}.join
+    @pkt << values.map{|t,v| t == :gauge ? [v].pack("E") : [v>>32, v & 0xffffffff].pack("NN")}.join
+  end
+
+  # Send a data point with one or multiple gauge values
+  def gauge   (pl, pi, t, ti, value) values(pl, pi, t, ti, Array(value).map{|v| [:gauge, v]}); end
+  # Send a data point with one or multiple counter values
+  def counter (pl, pi, t, ti, value) values(pl, pi, t, ti, Array(value).map{|v| [:counter, v]}); end
+  # Send a data point with one or multiple derive values
+  def derive  (pl, pi, t, ti, value) values(pl, pi, t, ti, Array(value).map{|v| [:derive, v]}); end
+  # Send a data point with one or multiple absolute values
+  def absolute(pl, pi, t, ti, value) values(pl, pi, t, ti, Array(value).map{|v| [:absolute, v]}); end
+
+  def to_s; @pkt; end
+end

data/lib/rrd-grapher/notifier/data_struct.rb

@@ -0,0 +1,46 @@
+
+class DataStruct
+
+  def initialize(*args)
+    merge_data_from(*args)
+  end
+  
+  ##
+  # Merge new data in the structure.
+  # 
+  # @param [Object,Hash] opts_or_obj Source
+  # @param [Array] only_fields an array of symbol
+  #   specifying which fields to copy
+  # @param [Boolean] allow_nil If false nil values from
+  #   the source will not be copied in object
+  # 
+  def merge_data_from(opts_or_obj = {}, only_fields = nil, allow_nil = false)
+    self.class.attributes.select{|attr_name| selected_field?(attr_name, only_fields) }.each do |attr_name|
+      v = opts_or_obj.is_a?(Hash) ? (opts_or_obj[attr_name.to_s] || opts_or_obj[attr_name]) : opts_or_obj.send(attr_name)
+      if allow_nil || !v.nil?
+        send("#{attr_name}=", v)
+      end
+    end
+  end
+  
+  def selected_field?(field, list)
+    list.nil? || list.include?(field.to_sym)
+  end
+
+
+  class <<self  
+    def properties(*names)
+      names.each do |name|
+        attr_accessor(name)
+        (@attributes ||= []) << name
+      end
+    end
+    
+    alias :property :properties
+
+    def attributes
+      @attributes
+    end
+  end
+
+end

data/lib/rrd-grapher/notifier/default_user_handler.rb

@@ -0,0 +1,36 @@
+
+module RRDNotifier
+  module DefaultNotificationHandler
+    def self.dispatch_notification(notification)
+      puts "[#{ev.time.strftime('%H:%m:%S')} - #{ev.host}] #{ev.severity} "
+      puts %{
+        Host: {ev.host}
+        Plugin: #{ev.plugin}
+        Type: #{ev.type}
+        TypeInstance: #{ev.type_instance}
+        Severity: #{ev.severity}
+        Current Value: #{ev.value}
+        Warning thresholds: #{ev.warn_min} - #{ev.warn_max}
+        Failure thresholds: #{ev.failure_min} - #{ev.failure_max}
+      }
+    end
+    
+    ##
+    # A new alarm was triggered
+    # 
+    # @param [Alarm] alarm the alarm
+    # 
+    def self.alarm_started(alarm)
+      puts "an alarm was started: #{alarm.inspect}"
+    end
+    
+    ##
+    # An alarm was stopped
+    # 
+    # @param [Alarm] alarm the alarm
+    #
+    def self.alarm_stopped(alarm)
+      puts "an alarm was stopped: #{alarm.inspect}"
+    end
+  end
+end

data/lib/rrd-grapher/notifier/parsers/bindata_parser.rb

@@ -0,0 +1,144 @@
+
+require 'bindata'
+
+require File.expand_path('../../structures', __FILE__)
+
+module RRDNotifier
+  module BindataParser
+  
+    # part type
+    HOST            = 0x0000
+    TIME            = 0x0001
+    PLUGIN          = 0x0002
+    PLUGIN_INSTANCE = 0x0003
+    TYPE            = 0x0004
+    TYPE_INSTANCE   = 0x0005
+    VALUES          = 0x0006
+    INTERVAL        = 0x0007
+    MESSAGE         = 0x0100
+    SEVERITY        = 0x0101
+  
+    PART_TYPE_AS_STRING = {
+        'host'              => HOST,
+        'time'              => TIME,
+        'plugin'            => PLUGIN,
+        'plugin_instance'   => PLUGIN_INSTANCE,
+        'type'              => TYPE,
+        'type_instance'     => TYPE_INSTANCE,
+        'values'            => VALUES,
+        'interval'          => INTERVAL,
+        'message'           => MESSAGE,
+        'severity'          => SEVERITY
+      }.freeze
+  
+    class ValuePartData < BinData::Record
+      COUNTER   = 0
+      GAUGE     = 1
+      DERIVE    = 2
+      ABSOLUTE  = 3
+    
+      attr_accessor :types
+        
+      endian :big
+
+      choice :val, :selection => proc{ types[index] }, :choices => {
+          COUNTER   => :uint64,
+          GAUGE     => :double_le,
+          DERIVE    => :int64,
+          ABSOLUTE  => :uint64
+        }
+    
+    end
+  
+    class ValuePart < BinData::Record
+      endian :big
+  
+      int16 :values_count
+      array :types, :type => :uint8, :initial_length => proc{ values_count }
+      array :vals, :type => [:value_part_data, {:types => :types}], :initial_length => proc{ values_count }
+    
+    end
+  
+  
+  
+    class Part < BinData::Record
+      endian  :big
+        
+      uint16  :part_type
+      uint16  :part_length
+      
+      STR_FIELDS = [HOST, PLUGIN, PLUGIN_INSTANCE, TYPE, TYPE_INSTANCE, MESSAGE]
+      INT_FIELDS = [TIME, INTERVAL, SEVERITY]
+      
+      int64       :integer_value, :onlyif => proc{ INT_FIELDS.include?(part_type) }
+      string      :string_value,  :onlyif => proc{ STR_FIELDS.include?(part_type) }, :length => proc{ part_length - 4 }, :trim_padding => true
+      value_part  :vals,          :onlyif => proc { part_type == BindataParser::VALUES }
+      
+      def get_value
+        case
+        when STR_FIELDS.include?(part_type) then  string_value
+        when INT_FIELDS.include?(part_type) then  integer_value
+        else
+          vals.vals.map(&:val)
+        end
+      end
+      
+    end
+  
+    class Packet < BinData::Record
+      array :parts, :type => :part, :read_until => :complete
+    
+      def method_missing(m, *args)
+        type = PART_TYPE_AS_STRING[m.to_s]
+        if type
+          p = parts.detect{|p| p.part_type == type }
+          p.get_value if p
+        end
+      end
+      
+      def has_part?(type)
+        parts.detect{|p| p.part_type == type }
+      end
+      
+      def complete
+        eof ||
+        has_part?(VALUES) ||
+        has_part?(MESSAGE)
+      end
+    end
+    
+    class Reader < BinData::Record
+      array :packets, :type => :packet, :read_until => :eof
+    end
+    
+    COMPRESSED_FIELDS = [
+        :host,
+        :time,
+        :interval
+      ].freeze
+  
+    def self.parse(data)
+      ret = []
+      reader = Reader.new
+      packets = reader.read(data).packets
+      last_packet = {}
+      
+      if packets.size >= 1
+        
+        packets.each_with_index do |packet, i|
+          
+          p = RRDNotifier::Packet.new(last_packet)
+          p.merge_data_from(packet)
+          
+          last_packet = p if p.data?
+          
+          ret << p
+        end
+        
+      end
+      
+      ret
+    end
+
+  end
+end

data/lib/rrd-grapher/notifier/parsers/ruby_parser.rb

@@ -0,0 +1,134 @@
+require File.expand_path('../../structures', __FILE__)
+
+module RRDNotifier
+  
+  module RubyParser
+    
+    # part type
+    HOST            = 0x0000
+    TIME            = 0x0001
+    PLUGIN          = 0x0002
+    PLUGIN_INSTANCE = 0x0003
+    TYPE            = 0x0004
+    TYPE_INSTANCE   = 0x0005
+    VALUES          = 0x0006
+    INTERVAL        = 0x0007
+    MESSAGE         = 0x0100
+    SEVERITY        = 0x0101
+    
+    PART_TYPE_AS_STRING = {
+        HOST            => 'host',
+        TIME            => 'time',
+        PLUGIN          => 'plugin',
+        PLUGIN_INSTANCE => 'plugin_instance',
+        TYPE            => 'type',
+        TYPE_INSTANCE   => 'type_instance',
+        VALUES          => 'values',
+        INTERVAL        => 'interval',
+        MESSAGE         => 'message',
+        SEVERITY        => 'severity'
+      }.freeze
+    
+    STR_FIELDS = [HOST, PLUGIN, PLUGIN_INSTANCE, TYPE, TYPE_INSTANCE, MESSAGE]
+    INT_FIELDS = [TIME, INTERVAL, SEVERITY]
+    
+    COUNTER   = 0x00
+    GAUGE     = 0x01
+    DERIVE    = 0x02
+    ABSOLUTE  = 0x03
+    
+    def self.parse_part_header(buffer)
+      type, length, rest = buffer.unpack('nna*')
+      [type, length - 4, rest]
+    end
+    
+    INT64_MAX = (1 << 63)
+    INT64_SIGN_BIT = (1 << 64)
+    
+    # uint to int
+    # "val = val - #{1 << nbits} if (val >= #{1 << (nbits - 1)})"
+    def self.parse_int64(buffer, signed = false)
+      # [v>>32, v & 0xffffffff].pack("NN")}.join
+      
+      hi, lo, buffer = buffer.unpack("NNa*")
+      n = (hi << 32 | lo)
+      
+      if signed && (n >= INT64_MAX)
+        n = n - INT64_SIGN_BIT
+      end
+      
+      [n, buffer]
+    end
+    
+    def self.parse_part(buffer)
+      type, length, buffer = parse_part_header(buffer)
+      case
+      when INT_FIELDS.include?(type)  then  val, buffer = parse_int64(buffer)        
+      when STR_FIELDS.include?(type)  then  val, buffer = buffer.unpack("Z#{length}a*")
+      when type == VALUES             then  val, buffer = parse_part_values(length, buffer)
+      end
+            
+      [
+        PART_TYPE_AS_STRING[type],
+        val,
+        buffer
+      ]
+    end
+    
+    def self.parse_part_values(length, buffer)
+      # first we need to read the types of all the values
+      values_count, buffer = buffer.unpack("na*")
+      *types, buffer = buffer.unpack("C#{values_count}a*")
+      values = types.map! do |type|
+        case type
+        when COUNTER, ABSOLUTE  then  val, buffer = parse_int64(buffer)
+        when GAUGE              then  val, buffer = buffer.unpack("Ea*")
+        when DERIVE             then  val, buffer = parse_int64(buffer, true)
+        end
+        
+        val
+      end
+      
+      [values, buffer]
+    end
+    
+    COPY_FIELDS = [
+        :time,
+        :host,
+        :plugin,
+        :plugin_instance,
+        :type,
+        :type_instance,
+        :interval
+      ].freeze
+    
+    def self.parse_packet(buffer, initial_values = {})
+      packet = Packet.new(initial_values, COPY_FIELDS)
+      
+      begin
+        type, value, buffer = parse_part(buffer)
+        packet.send("#{type}=", value)
+      end until packet.message || packet.values
+      
+      [packet, buffer]
+    end
+    
+    def self.parse(buffer)
+      packets = []
+      last_packet = {}
+      
+      # 4 = part header size
+      while buffer.bytesize >= 4
+        packet, buffer = parse_packet(buffer, last_packet)
+        packets << packet
+        
+        last_packet = packet if packet.data?
+      end
+      
+      packets
+    end
+    
+    
+  end
+  
+end

data/lib/rrd-grapher/notifier/structures.rb

@@ -0,0 +1,80 @@
+
+require File.expand_path('../data_struct', __FILE__)
+
+module RRDNotifier
+  # from collectd source code
+  # plugin.h
+  # 
+  ### notification:
+  # int severity;
+  # cdtime_t time;
+  # char message[NOTIF_MAX_MSG_LEN];
+  # char host[DATA_MAX_NAME_LEN];
+  # char plugin[DATA_MAX_NAME_LEN];
+  # char plugin_instance[DATA_MAX_NAME_LEN];
+  # char type[DATA_MAX_NAME_LEN];
+  # char type_instance[DATA_MAX_NAME_LEN];
+  # 
+  ### data
+  # value_t *values;
+  # int values_len;
+  # cdtime_t time;
+  # cdtime_t interval;
+  # char host[DATA_MAX_NAME_LEN];
+  # char plugin[DATA_MAX_NAME_LEN];
+  # char plugin_instance[DATA_MAX_NAME_LEN];
+  # char type[DATA_MAX_NAME_LEN];
+  # char type_instance[DATA_MAX_NAME_LEN];
+  # 
+  class Packet < DataStruct
+      properties :time,
+        :host,
+        :plugin,
+        :plugin_instance,
+        :type,
+        :type_instance,
+        
+        # data
+        :interval,
+        :values,
+        
+        # notification
+        :message,
+        :severity
+      
+      def notification?
+        !self.message.nil?
+      end
+      
+      def data?
+        self.message.nil?
+      end
+      
+      def value(index = 0)
+        values[index]
+      end
+      
+      def plugin_display
+        if plugin_instance && !plugin_instance.empty?
+          "#{plugin}/#{plugin_instance}"
+        else
+          plugin
+        end
+      end
+
+      def type_display
+        if type_instance &&  !type_instance.empty?
+          "#{type}/#{type_instance}"
+        else
+          type
+        end
+      end
+      ##
+      # return a unique id for the measured data.
+      # 
+      def measure_id
+        "#{host}-#{plugin_display}-#{type_display}"
+      end
+      
+  end
+end

data/lib/rrd-grapher/notifier.rb

@@ -0,0 +1,87 @@
+
+require 'eventmachine'
+
+require File.expand_path('../notifier/parsers/ruby_parser', __FILE__)
+require File.expand_path('../notifier/alarm_manager', __FILE__)
+
+module RRDNotifier
+  
+  class Server < EM::Connection
+    
+    ##
+    # Called by eventmachine when the connection is created.
+    # 
+    # @param [String,nil] redirect_to Redirect to this host any packet received
+    # 
+    def initialize(alarm_manager, on_init_block = nil, redirect_to = nil)
+      @alarm_manager = alarm_manager
+      @on_init_block = on_init_block
+      @redirect_to = redirect_to ? redirect_to.split(':') : nil
+    end
+    
+    ##
+    # Start the notifier handler, it will open an UDP socket
+    # to which collectd should send its data using the network module.
+    # 
+    # @param [Hash] opts options hash
+    # @option opts [String] :host UDP address to bind on (default: 127.0.0.1)
+    # @option opts [Integer] :port UDP port to bind on
+    # @option opts [Object] :notification_handler This object 
+    # @option opts [String] :redirect_to Retransmit packets once received to
+    #   this <host>:<port>
+    # 
+    def self.start(opts = {}, &block)
+      host = opts.delete(:host) || '127.0.0.1'
+      port = opts.delete(:port) || 10000
+      redirect_to = opts.delete(:redirect_to)
+      
+      if redirect_to
+        # TODO: make it separate from redirect_to ?
+        opts.merge!(:send_monitoring_to => redirect_to)
+      end
+      
+      alarm_manager = AlarmManager.new(opts)
+      
+      unless opts.empty?
+        raise "Unknown arguments: #{opts}"
+    
+      end
+      EM::open_datagram_socket(host, port, Server, alarm_manager, block, redirect_to)
+    end
+    
+    
+    ##
+    # Register a new monitoring alert.
+    # @see AlertManager::register_alert
+    # 
+    def register_alarm(*args)
+      @alarm_manager.register_alarm(*args)
+    end
+    
+    
+# Eventmachine callbacks
+    
+    def post_init
+      @on_init_block.call(self) if @on_init_block
+    end
+    
+    ##
+    # EventMachine callback called when a packet is available
+    # 
+    # @param [String] data data received
+    # 
+    def receive_data(data)
+      if packets = RubyParser::parse(data)
+        packets.each do |p|
+          @alarm_manager.packet_received(p)
+        end
+      end
+      
+      if @redirect_to
+        send_datagram(data, @redirect_to[0], @redirect_to[1])
+      end
+      
+    end
+  end
+  
+end