monitoring_protocols 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea3d4b5a1ff69111426666e3e6c9365db1794ef2
+  data.tar.gz: f1792e58cbf6b9e78cc40d0c1fda80607d3d8914
+SHA512:
+  metadata.gz: 87bc1ec3055c2d0424db2992e6195d8c14bcf06c555785d2fdee3dd74f4944afc4013b0a33235290708bbda1bfd8f35a0b1f337f8b3ef0e23c0562edad355a6d
+  data.tar.gz: 8155810e85f50e3d7f88b6bddbfbe998b2842a20c69fd258e7758723f56073cc8de1f0630893ff027063ef3f9480b8289734871289ece389f1f62587993eb29f

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+*.rbc
+.bundle
+Gemfile.lock
+coverage/
+doc/

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake'
+
+group(:test) do
+  gem 'eetee',          '~> 0.0.9'
+  # gem 'eetee',          path: '/Users/Schmurfy/Dev/personal/gems/eetee'
+  gem 'mocha',          '~> 0.12.0'
+  gem 'factory_girl'
+  gem 'rb-blink1'
+  
+  gem 'simplecov'
+  gem 'guard',          '~> 1.8.1'
+  gem 'rb-fsevent'
+  gem 'growl'
+end

data/Guardfile

@@ -0,0 +1,8 @@
+
+require 'eetee'
+require 'blink1'
+
+guard 'eetee', blink1: true do
+  watch(%r{^lib/monitoring_protocols/(.+)\.rb$})     { |m| "specs/unit/#{m[1]}_spec.rb" }
+  watch(%r{specs/.+\.rb$})
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Julien Ammous
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'bundler/setup'
+require "bundler/gem_tasks"
+
+task :default => :test
+
+task :test do
+
+  # do not generate coverage report under travis
+  unless ENV['TRAVIS']
+
+    require 'simplecov'
+    SimpleCov.command_name "E.T."
+    SimpleCov.start do
+      add_filter ".*_spec"
+      add_filter "/specs/helpers/"
+      add_filter "/example/"
+    end
+  end
+
+  require 'eetee'
+
+  runner = EEtee::Runner.new
+  runner.run_pattern('specs/**/*_spec.rb')
+  runner.report_results()
+
+end

data/lib/monitoring_protocols.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../monitoring_protocols/core', __FILE__)
+
+require File.expand_path('../monitoring_protocols/version', __FILE__)
+require File.expand_path('../monitoring_protocols/struct', __FILE__)
+require File.expand_path('../monitoring_protocols/parser', __FILE__)
+require File.expand_path('../monitoring_protocols/builder', __FILE__)
+
+require File.expand_path('../monitoring_protocols/collectd/msg', __FILE__)
+require File.expand_path('../monitoring_protocols/collectd/builder', __FILE__)
+require File.expand_path('../monitoring_protocols/collectd/parser', __FILE__)
+
+require File.expand_path('../monitoring_protocols/json/parser', __FILE__)
+require File.expand_path('../monitoring_protocols/json/builder', __FILE__)
+
+require File.expand_path('../monitoring_protocols/msgpack/parser', __FILE__)
+
+
+module MonitoringProtocols
+  def self.factory_file
+    File.expand_path('../../specs/factories.rb', __FILE__)
+  end
+end

data/lib/monitoring_protocols/builder.rb

@@ -0,0 +1,10 @@
+module MonitoringProtocols
+  
+  class Builder
+    
+    def initialize(points)
+      @points = points
+    end
+    
+  end
+end

data/lib/monitoring_protocols/collectd/builder.rb

@@ -0,0 +1,96 @@
+module MonitoringProtocols
+  module Collectd
+    
+    class Builder
+      # part type
+      HOST            = 0x0000
+      TIME            = 0x0001
+      PLUGIN          = 0x0002
+      PLUGIN_INSTANCE = 0x0003
+      TYPE            = 0x0004
+      TYPE_INSTANCE   = 0x0005
+      VALUES          = 0x0006
+      INTERVAL        = 0x0007
+      MESSAGE         = 0x0100
+      SEVERITY        = 0x0101
+      
+      # data type
+      COUNTER   = 0
+      GAUGE     = 1
+      DERIVE    = 2
+      ABSOLUTE  = 3
+      
+      
+      attr_accessor :host, :time, :interval
+      attr_accessor :plugin, :plugin_instance
+      attr_accessor :type, :type_instance
+      
+      # Encode a string (type 0, null terminated string)
+      def self.string(type, str)
+        str += "\000"
+        str_size = str.respond_to?(:bytesize) ? str.bytesize : str.size
+        [type, 4 + str_size].pack("nn") + str
+      end
+      
+      # Encode an integer
+      def self.number(type, num)
+        [type, 12].pack("nn") + [num >> 32, num & 0xffffffff].pack("NN")
+      end
+      
+      def self.values(types = [], values = [])
+        # values part header
+        ret = [VALUES, 4 + 2 + (values.size * 9), values.size].pack('nnn')
+        
+        # types
+        ret << types.pack('C*')
+        
+        # and the values
+        values.each.with_index do |v, i|
+          case types[i]
+          when COUNTER, ABSOLUTE, DERIVE
+            ret << [v >> 32, v & 0xffffffff].pack("NN")
+            
+          when GAUGE
+            ret << [v].pack('E')
+            
+          else
+            raise "unknown type: #{types[i]}"
+          end
+        end
+        
+        ret
+      end
+      
+      def initialize
+        @values = []
+        @values_type = []
+      end
+      
+      def add_value(type, value)
+        raise(ArgumentError, "unknown type: #{type}") unless self.class.const_defined?(type.to_s.upcase)
+        data_type = self.class.const_get(type.to_s.upcase)
+        
+        @values_type << data_type
+        @values << value
+      end
+      
+      def build_packet
+        @pkt =  self.class.string(HOST, @host)
+        @pkt << self.class.number(TIME, @time)
+        @pkt << self.class.number(INTERVAL, @interval)
+        @pkt << self.class.string(PLUGIN, @plugin)
+        @pkt << self.class.string(PLUGIN_INSTANCE, @plugin_instance)
+        @pkt << self.class.string(TYPE, @type)
+        @pkt << self.class.string(TYPE_INSTANCE, @type_instance)
+        
+        @pkt << self.class.values(@values_type, @values)
+        
+        @pkt
+      end
+        
+    end
+        
+  end
+  
+  register_builder(:collectd, Collectd::Builder)
+end

data/lib/monitoring_protocols/collectd/msg.rb

@@ -0,0 +1,106 @@
+module MonitoringProtocols
+  module Collectd
+  
+    # 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 NetworkMessage < NetworkMessage
+        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
+        
+        def convert_content
+          common = {
+            time: time,
+            host: host,
+            app_name: plugin,
+            res_name: type,
+            metric_name: type_instance,
+          }
+          
+          if data?
+            ret = DataPoint.new(common.merge!(
+                value: value
+              ))
+          else
+            ret = Notification.new(common.merge!(
+                severity: severity,
+                message: message
+              ))
+          end
+          
+          [ret]
+        end
+        
+      end
+    
+  end  
+end

data/lib/monitoring_protocols/collectd/parser.rb

@@ -0,0 +1,175 @@
+module MonitoringProtocols
+  module Collectd
+    
+    class Parser < Parser
+      
+      # part type
+      HOST            = 0x0000
+      TIME            = 0x0001
+      TIME_HR         = 0X0008
+      PLUGIN          = 0x0002
+      PLUGIN_INSTANCE = 0x0003
+      TYPE            = 0x0004
+      TYPE_INSTANCE   = 0x0005
+      VALUES          = 0x0006
+      INTERVAL        = 0x0007
+      INTERVAL_HR     = 0X0009
+      MESSAGE         = 0x0100
+      SEVERITY        = 0x0101
+      
+      PART_TYPE_AS_STRING = {
+          HOST            => 'host',
+          TIME            => 'time',
+          TIME_HR         => 'time_hr',
+          PLUGIN          => 'plugin',
+          PLUGIN_INSTANCE => 'plugin_instance',
+          TYPE            => 'type',
+          TYPE_INSTANCE   => 'type_instance',
+          VALUES          => 'values',
+          INTERVAL        => 'interval',
+          INTERVAL_HR     => 'interval_hr',
+          MESSAGE         => 'message',
+          SEVERITY        => 'severity'
+        }.freeze
+      
+      STR_FIELDS = [HOST, PLUGIN, PLUGIN_INSTANCE, TYPE, TYPE_INSTANCE, MESSAGE]
+      INT_FIELDS = [TIME, TIME_HR, INTERVAL, INTERVAL_HR, 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)
+        else
+          val, buffer = buffer.unpack("a#{length}a*")
+          raise ParseError, "unknown part: #{type}, data: #{val.inspect}"
+        end
+        
+        # just convert to seconds
+        if (type == TIME_HR)
+          type = TIME
+          val = (val >> 30)
+        end
+        
+        if (type == INTERVAL_HR)
+          type = INTERVAL
+          val = (val >> 30)
+          p [:interval, val]
+        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 = NetworkMessage.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
+      
+      # def initialize
+      #   @buffer = ""
+      #   @last_packet = {}
+      # end
+      
+      # def feed(data)
+      #   ret = []
+        
+      #   @buffer << data
+      #   if @buffer.bytesize >= 4
+      #     pkt, @buffer = self.class.parse_packet(@buffer, @last_packet)
+      #     if pkt.data?
+      #       ret << pkt
+      #       @last_packet = pack
+      #     end
+      #   end
+        
+      #   ret
+      # end
+
+    end
+    
+    
+  end
+  
+  register_parser(:collectd, Collectd::Parser)
+end