kstats-node 1.0.0 → 1.0.1

data/.gitignore

@@ -20,3 +20,4 @@ tmp
 *.o
 *.a
 mkmf.log
+test/db

data/bin/kstats-node

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+
+class Time
+  def to_db
+    strftime "%Y%m%d%H%M%S"
+  end
+end
+
+require 'optparse'
+require 'yaml'
+require 'kstats/node'
+require 'json'
+
+options = {}
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: kstats-node [options]"
+
+  opts.on('-h', '--help', 'Show help screen'){ puts opts; exit }
+
+  opts.on('-c', '--config CONF', 'Set configuration file') do |config|
+    options[:config] = config
+  end
+end
+
+optparse.parse!
+require 'sinatra'
+
+#Parse the configuration file:
+config = YAML::load(File.read(options[:config]))
+Kstats::Node::CONFIG.merge!(config)
+
+Kstats::Node::Database.init
+
+get '/probes/list' do
+  Kstats::Node::Probe.list.to_json
+end
+
+#Display data for daily infos
+get '/probe/:id/:target' do
+  now = Time.now
+
+  case params[:target]
+  when 'tick'
+    start = now - (60*60*24)
+  when 'weekly'
+    start = now - 7*(60*60*24)
+  when 'monthly'
+    start = now - 30*(60*60*24)
+  when 'yearly'
+    start = now - 365*(60*60*24)
+  else
+    return 403
+  end
+
+
+  data =Kstats::Node::Database.db.execute(
+    "SELECT probe_key, date, probe_value FROM probe_data WHERE period_type=? AND probe_id = ? AND date >= ? ORDER BY date ASC",
+    params[:target],
+    params[:id],
+    start.to_s
+  )
+
+  datas = {}
+  data.each do |record|
+    key, date, value = record
+    datas[key] ||= []
+    datas[key] << [Time.parse(date), value]
+  end
+
+  datas.each do |key, value|
+    datas[key] =   Kstats::Node::Helper.generate_array(value, start, (now-start)/60, 288)
+  end
+
+  {
+    start_at: start,
+    format: Kstats::Node::Probe.get_format(params[:id]),
+    data: datas
+  }.to_json
+end
+
+Kstats::Node::Worker.launch!

data/kstats-node.gemspec

@@ -12,6 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Provide a simple way to make probe on system values, and monitorign theses values.}
   spec.homepage      = ""
   spec.license       = "MIT"
+  spec.executables << 'kstats-node'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }

data/lib/kstats/node/config.rb

@@ -0,0 +1,5 @@
+module Kstats
+  module Node
+    CONFIG={}
+  end
+end

data/lib/kstats/node/database.rb

@@ -0,0 +1,43 @@
+require 'sqlite3'
+
+module Kstats
+  module Node
+    module Database
+      class << self
+        attr_reader :db
+
+        def init
+          @db = SQLite3::Database.new( Kstats::Node::CONFIG['db_dir'] )
+          @db.execute [
+            "CREATE TABLE IF NOT EXISTS probe_data (id INTEGER PRIMARY KEY ASC, date DATETIME, period_type STRING, probe_id STRING, probe_key STRING, probe_value NUMBER)",
+            "CREATE INDEX IF NOT EXISTS probe_data_period_type ON probe_data(period_type)",
+            "CREATE INDEX IF NOT EXISTS probe_data_date ON probe_data(date)",
+            "CREATE INDEX IF NOT EXISTS probe_data_probe_id ON probe_data(probe_id)",
+            "CREATE INDEX IF NOT EXISTS probe_data_probe_key ON probe_data(probe_key)"
+            ].join(";")
+        end
+
+        def execute query
+          @db.execute(query)
+        end
+
+        def save_probes_data probes, type
+          time = Time.now
+
+          probes.each do |name, values|
+            @db.close
+            @db = SQLite3::Database.new( Kstats::Node::CONFIG['db_dir'] )
+
+            sql = <<SQL
+INSERT INTO probe_data (date, period_type, probe_id, probe_key, probe_value)
+VALUES (?, ?, ?, ?, ?)
+SQL
+            values.each do |probe_key, probe_value|
+              @db.execute(sql, time.to_s, type.to_s, name.to_s, probe_key.to_s, probe_value)
+            end
+          end
+        end
+      end #<< self
+    end #Class
+  end #Node
+end #Kstats

data/lib/kstats/node/helper.rb

@@ -0,0 +1,42 @@
+module Kstats
+  module Node
+    module Helper
+      #Entry:
+      # Data from probe with:
+      #   0: Date of the pick
+      #   1: Value of the pick
+      # Output:
+      #   An array with value of average of each points
+      def self.generate_array data, start, period, nb_points
+        out_array = Array.new nb_points
+
+        for i in 0...nb_points
+          out_array[i] = [0.0, 0.0] # value and coef.
+        end
+
+        data.each do |x|
+          #Position of the data over the period:
+          poz = (x[0] - start)/60 # In minutes
+          poz = poz / period.to_f # In percent between [0..1]
+
+          next if poz < 0.0 || poz > 1.0
+
+          p1,p2,f = (poz * nb_points).floor, (poz*nb_points).ceil, (poz*nb_points).abs.modulo(1)
+
+          if f>0.5
+            output = out_array[p1]
+          else
+            output = out_array[p2]
+          end
+
+          unless output.nil?
+            output[0] = (x[1] + output[1]*output[0]) / ( output[1] + 1)
+            output[1] += 1
+          end
+        end
+
+        out_array.map{ |x| x[0].round(3) }
+      end
+    end
+  end
+end

data/lib/kstats/node/probe.rb

@@ -0,0 +1,165 @@
+module Kstats
+  module Node
+    class Probe
+
+      class << self
+        attr_accessor :registered
+
+        def register name, &block
+          @registered << Probe.new(name).from_dsl(&block)
+        end
+
+        def get_format probe
+          probe = @fixed_registered.select{|x| x.id == probe }.first
+          if probe.nil?
+            return nil
+          else
+            {
+              type: probe.type,
+              variables: probe.variables.inject({}){ |h, x|
+                h[x.name] = {}
+                h[x.name][:desc] = x.desc
+                h[x.name][:color] = x.color
+                h
+              }
+            }
+          end
+        end
+
+        def reload_and_test!
+          @fixed_registered = @registered
+          @registered = []
+
+          dir = Kstats::Node::CONFIG['probes_dir']
+
+          Dir[File.join(dir, "*.rb")].each do |probe_file|
+            begin
+              load(probe_file)
+            rescue => e
+              puts "Unable to load #{probe_file}: #{e}"
+              puts "*\t#{e.backtrace.join("\n*\t")}"
+            end
+          end
+
+          probes = {}
+
+            @registered.each do |probe|
+              begin
+                probes[probe.id] = probe.test
+              rescue => e
+                puts "Exception for probe #{probe.id} : #{e.message}"
+                puts "*\t#{e.backtrace.join("\n*\t")}"
+              end
+            end
+
+          @fixed_registered  = @registered
+
+          probes
+        end
+
+        def list
+          probe_categories = {}
+          @fixed_registered.each do |probe|
+            probe_categories[probe.category] ||= []
+            probe_categories[probe.category] << { name: probe.name, id: probe.id }
+          end
+
+          probe_categories
+        end
+      end
+
+      class Variable
+        attr_reader :name
+        attr_accessor :desc, :color, :probe
+
+        def initialize name, parent
+          @name = name
+          @parent = parent
+        end
+
+        def command
+          @parent.command
+        end
+
+        def test
+          instance_eval(&probe)
+        end
+
+        def from_dsl &block
+          dsl = DSL.new(self)
+          dsl.instance_eval(&block)
+
+          return self
+        end
+
+        class DSL
+          def initialize variable
+            @variable = variable
+          end
+
+          def desc val
+            @variable.desc = val
+          end
+
+          def color val
+            @variable.color = val
+          end
+
+          def probe &val
+            @variable.probe = val
+          end
+        end
+      end
+
+      attr_reader :id
+      attr_accessor :variables, :category, :name, :type, :command, :command_block
+
+      def initialize id
+        @variables = []
+        @id = id
+      end
+
+      def from_dsl &block
+        DSL.new(self).instance_eval(&block)
+
+        return self
+      end
+
+      def add_variable var
+        @variables << var
+      end
+
+      def test
+        @command = self.command_block.call unless self.command_block.nil?
+
+        @variables.inject({}){|h, x| h[x.name] = x.test; h }
+      end
+
+      class DSL
+        def initialize probe
+          @probe = probe
+        end
+
+        def category val
+          @probe.category = val
+        end
+
+        def name val
+          @probe.name = val
+        end
+
+        def command &block
+          @probe.command_block = block
+        end
+
+        def type val
+          @probe.type = val
+        end
+
+        def variable name, &block
+          @probe.add_variable Variable.new(name, @probe).from_dsl(&block)
+        end
+      end
+    end
+  end
+end

data/lib/kstats/node/version.rb

@@ -1,5 +1,5 @@
 module Kstats
   module Node
-    VERSION = "1.0.0"
+    VERSION = "1.0.1"
   end
 end

data/lib/kstats/node/worker.rb

@@ -0,0 +1,46 @@
+module Kstats
+  module Node
+    class Worker
+      def self.launch!
+        insert_month = 0
+        insert_week = 0
+        insert_year = 0
+
+        thread = Thread.new do
+          begin
+            begin
+              puts "New probe tick."
+              probes = Kstats::Node::Probe.reload_and_test!
+
+              if insert_month == 0
+                insert_month = 30
+                Database.save_probes_data(probes, :monthly)
+              end
+
+              if insert_week == 0
+                insert_week = 7
+                Database.save_probes_data(probes, :weekly)
+              end
+
+              if insert_year == 0
+                insert_year = 365
+                Database.save_probes_data(probes, :yearly)
+              end
+
+              insert_month  -= 1
+              insert_week   -= 1
+              insert_year   -= 1
+
+              Database.save_probes_data(probes, :tick)
+            rescue Exception => e
+              puts e.message
+              puts e.backtrace
+            end
+            sleep(300)
+          end while true
+        end
+
+      end
+    end
+  end
+end

data/test/conf.yml

@@ -0,0 +1,2 @@
+probes_dir: test/probes
+db_dir: test/db/test.sqlite3

data/test/probes/cpu.rb

@@ -0,0 +1,32 @@
+Kstats::Node::Probe.register 'cpu' do
+  category 'Hardware'
+  name 'CPU usage'
+
+  type :curve
+
+  command{ `cat /proc/loadavg`.split(/\s/).map(&:to_f) }
+
+  variable :load_avg_1mn do
+    desc 'Load average (1mn)'
+    color '#0000FF'
+    probe do
+      command[0]
+    end
+  end
+
+  variable :load_avg_5mn do
+    desc 'Load average (5mn)'
+    color '#00FF00'
+    probe do
+      command[1]
+    end
+  end
+
+  variable :load_avg_15mn do
+    desc 'Load average (15mn)'
+    color '#FF0000'
+    probe do
+      command[2]
+    end
+  end
+end

data/test/probes/disk.rb

@@ -0,0 +1,35 @@
+Kstats::Node::Probe.register 'disk' do
+  category 'Hardware'
+  name 'Disk usage'
+
+  type :curve
+
+  _self = self
+  instance_eval do
+    def parsedf
+      disks = `df`.split(/\n/).map do |x|
+        x.split(/\s+/)
+      end
+
+      disks.reject!{|x| x[0] == 'udev' ||  x[0] == 'none' || x[0] == 'tmpfs' || x[0] == 'Filesystem' }
+      disks.map!{|x| {name: x[0], space: 100*(x[2].to_f/x[1].to_f) }}
+    end
+  end
+
+  parsedf.each do |infos|
+    var = infos[:name]
+
+    variable var do
+      desc "Filling of `#{infos[:name]}`"
+      color "#0000FF"
+      probe do
+        val = _self.parsedf.select{|x| x[:name] == var }.first[:space]
+
+        puts val
+
+        val
+      end
+    end
+  end
+
+end

data/test/probes/memory.rb

@@ -0,0 +1,37 @@
+Kstats::Node::Probe.register 'hwmem' do
+  category 'Hardware'
+  name 'Memory usage'
+
+  type :curve
+
+  command do
+    cmd = `cat /proc/meminfo`
+    lines = cmd.split(/\n/)
+
+    memtotal = lines.select{|x| x =~ /MemTotal/ }.first.gsub(/[^0-9]/, '').to_f
+    active = lines.select{|x| x =~ /Active/ }.first.gsub(/[^0-9]/, '').to_f
+    inactive = lines.select{|x| x =~ /Inactive/ }.first.gsub(/[^0-9]/, '').to_f
+    memfree = lines.select{|x| x =~ /MemFree/ }.first.gsub(/[^0-9]/, '').to_f
+    swaptotal = lines.select{|x| x =~ /SwapTotal/ }.first.gsub(/[^0-9]/, '').to_f
+    swapfree = lines.select{|x| x =~ /SwapFree/ }.first.gsub(/[^0-9]/, '').to_f
+
+    [memtotal, active, inactive, memfree, swaptotal, swapfree]
+  end
+
+  variable :mem_load do
+    desc 'Memory load (%)'
+    color '#0000FF'
+    probe do
+      1-(command[3]/command[0])
+    end
+  end
+
+  variable :swap_load do
+    desc 'Swap load (%)'
+    color '#FF0000'
+
+    probe do
+      1-(command[5]/command[4])
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kstats-node
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -79,7 +79,8 @@ description: Provide a simple way to make probe on system values, and monitorign
   values.
 email:
 - yacine@kosmogo.com
-executables: []
+executables:
+- kstats-node
 extensions: []
 extra_rdoc_files: []
 files:
@@ -88,9 +89,19 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/kstats-node
 - kstats-node.gemspec
 - lib/kstats/node.rb
+- lib/kstats/node/config.rb
+- lib/kstats/node/database.rb
+- lib/kstats/node/helper.rb
+- lib/kstats/node/probe.rb
 - lib/kstats/node/version.rb
+- lib/kstats/node/worker.rb
+- test/conf.yml
+- test/probes/cpu.rb
+- test/probes/disk.rb
+- test/probes/memory.rb
 homepage: ''
 licenses:
 - MIT
@@ -116,5 +127,9 @@ rubygems_version: 1.8.28
 signing_key: 
 specification_version: 3
 summary: Node for the project kstats
-test_files: []
+test_files:
+- test/conf.yml
+- test/probes/cpu.rb
+- test/probes/disk.rb
+- test/probes/memory.rb
 has_rdoc: