opstat-plugins 0.3.8

data/lib/parsers/hp_pdu.rb

@@ -0,0 +1,36 @@
+module Opstat
+module Parsers
+  class HpPdu
+    include Opstat::Logging
+
+    def snmp_ids
+      @snmp_ids ||= YAML::load_file("#{File.dirname(File.expand_path(__FILE__))}/../data/hp_pdu.yml")
+      @snmp_ids
+    end
+
+    def parse_data(data:, time:)
+      return if data.nil? #TODO EVENT IN db
+      temp = {}
+      begin
+      ids = data.split("\n")
+      ids.each do |id|
+        k, v = id.split(' = ')
+	if self.snmp_ids.has_key?(k)
+	  props = snmp_ids[k]
+	  temp_key = "#{props[:meter_type]}#{props[:pdu]}"
+	  temp[temp_key] ||= {:meter_type => props[:meter_type], :pdu => props[:pdu]}
+	  temp[temp_key][props[:store_key]] = v.split(': ')[-1].to_i
+	end
+      end
+
+      rescue
+	#TODO find best way to deal with that kind of problems
+	#TODO check if timestamp > prev
+        return
+      end
+      reports = temp.values
+      return  reports
+    end
+  end
+end
+end

data/lib/parsers/jvm.rb

@@ -0,0 +1,22 @@
+module Opstat
+module Parsers
+  class Jvm
+    include Opstat::Logging
+
+    def parse_data(data:, time:)
+      return if data.nil? #TODO EVENT IN db
+      
+      begin
+      data.split("\n").each do |line|
+        oplogger.debug "parsing line #{line}"
+      end
+      rescue
+	#TODO find best way to deal with that kind of problems
+	#TODO check if timestamp > prev
+        return
+      end
+      return report
+    end
+  end
+end
+end

data/lib/parsers/load.rb

@@ -0,0 +1,20 @@
+module Opstat
+module Parsers
+  class Load
+    include Opstat::Logging
+
+    def parse_data(data:, time:)
+      data.find{|a| a =~ /^(?<load_1m>\S+)\s+(?<load_5m>\S+)\s+(?<load_15m>\S+)\s+(?<threads_running>\d+)\/(?<threads>\d+).*/}
+      return [] if $~.nil?
+      # TODO add some alert to system - bad input data
+      return [{
+       :load_1m => $~[:load_1m].to_f,
+       :load_5m => $~[:load_5m].to_f,
+       :load_15m => $~[:load_15m].to_f,
+       :threads_running => $~[:threads_running].to_i,
+       :threads => $~[:threads].to_i
+     }]
+    end
+  end
+end
+end

data/lib/parsers/memory.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+
+module Opstat
+module Parsers
+  class Memory
+    include Opstat::Logging
+
+    def parse_data(data:, time:)
+      memory = YAML::load(data.join)
+      oplogger.debug memory
+      begin
+        return [{
+          :total => memory["MemTotal"].split[0].to_i,
+          :free => memory["MemFree"].split[0].to_i,
+          :used => memory["MemTotal"].split[0].to_i - memory["MemFree"].split[0].to_i - (memory["Buffers"].to_i + memory["Cached"].split[0].to_i + memory["SReclaimable"].split[0].to_i - memory["Shmem"].split[0].to_i),
+          :cached => memory["Cached"].split[0].to_i + memory["SReclaimable"].split[0].to_i - memory["Shmem"].split[0].to_i,
+          :buffers => memory["Buffers"].split[0].to_i,
+          :swap_total => memory["SwapTotal"].split[0].to_i,
+          :swap_free => memory["SwapFree"].split[0].to_i,
+          :swap_used => memory["SwapTotal"].split[0].to_i - memory["SwapFree"].split[0].to_i
+        }]
+      rescue Exception => e
+        return []
+      end
+    end
+  end
+end
+end
+

data/lib/parsers/nagios.rb

@@ -0,0 +1,39 @@
+module Opstat
+module Parsers
+  class Nagios
+    include Opstat::Logging
+
+    def parse_data(data:, time:)
+      report = {}
+      begin
+        data.compact.each do |elem|
+          v = elem.strip.split(':')
+	  next if  v.length == 0
+	  next if v.count != 2
+	  key = v[0].strip
+	  val = v[1].strip
+	  report[key] = val
+        end
+      rescue
+      #TODO add errors to gui - bad data
+        return
+      end
+      report["Hosts Up"], report["Hosts Down"], report["Hosts Unreachable"] = report["Hosts Up/Down/Unreach"].split('/')
+      report["Services Ok"], report["Services Warning"], report["Services Unknown"], report["Services Critical"] = report["Services Ok/Warn/Unk/Crit"].split('/')
+      return [{
+            :services_total => report["Total Services"],
+            :hosts_total => report["Total Hosts"],
+            :services_checked => report["Services Checked"],
+            :hosts_checked => report["Hosts Checked"],
+            :services_ok => report["Services Ok"],
+            :services_warning => report["Services Warning"],
+            :services_critical => report["Services Critical"],
+            :services_unknown => report["Services Unknown"],
+            :hosts_up => report["Hosts Up"],
+            :hosts_down => report["Hosts Down"],
+	    :hosts_unreachable => report ["Hosts Unreachable"]
+      }]
+    end
+  end
+end
+end

data/lib/parsers/network.rb

@@ -0,0 +1,37 @@
+module Opstat
+module Parsers
+  class Network
+    include Opstat::Logging
+
+    def parse_data(data:, time:)
+      reports = []
+      interfaces_stats = data[2..-1].map{|u| u.lstrip}.join.split("\n")
+      interfaces_stats.each do |interface_stat|
+	interface, values = interface_stat.split(':')
+	next if values.nil?
+        v = values.split
+        reports << {
+          :OPSTAT_TAG_interface => interface,
+	  :bytes_receive => v[0].to_i,
+	  :packets_receive => v[1].to_i,
+	  :errors_receive => v[2].to_i,
+	  :drop_receive => v[3].to_i,
+	  :fifo_receive => v[4].to_i,
+	  :frame_receive => v[5].to_i,
+	  :compressed_receive => v[6].to_i,
+	  :multicast_receive => v[7].to_i,
+	  :bytes_transmit => v[8].to_i,
+	  :packets_transmit => v[9].to_i,
+	  :errors_transmit => v[10].to_i,
+	  :drop_transmit => v[11].to_i,
+	  :fifo_transmit => v[12].to_i,
+	  :frame_transmit => v[13].to_i,
+	  :compressed_transmit => v[14].to_i,
+	  :multicast_transmit => v[15].to_i
+        }
+      end
+      return reports
+    end
+  end
+end
+end

data/lib/parsers/oracle_fras_sizes.rb

@@ -0,0 +1,25 @@
+module Opstat
+module Parsers
+  class OracleFrasSizes
+    include Opstat::Logging
+
+  #TODO - somehow check plugins version
+    def parse_data(data:, time:)
+      reports = []
+      data.split("\n")[3..-1].each do |line|
+	  tablespace = line.split(/\s+/).delete_if{|t| t.empty?}
+          total = tablespace[1].to_i
+          used = tablespace[2].to_i
+	  free = total - used
+          reports << {
+            :OPSTAT_TAG_path => tablespace[0],
+            :free => free,
+            :used => used,
+            :files => tablespace[3].to_i
+	  }
+      end
+      return reports
+    end
+  end
+end
+end

data/lib/parsers/oracle_sessions.rb

@@ -0,0 +1,20 @@
+module Opstat
+module Parsers
+  class OracleSessions
+    include Opstat::Logging
+
+  #TODO - somehow check plugins version
+    def parse_data(data:, time:)
+      reports = []
+      data.split("\n")[3..-1].each do |line|
+	  tablespace = line.split(/\s+/).delete_if{|t| t.empty?}
+          reports << {
+            :used => tablespace[0].to_i,
+            :free => tablespace[1].to_i
+	  }
+      end
+      return reports
+    end
+  end
+end
+end

data/lib/parsers/oracle_tablespaces_sizes.rb

@@ -0,0 +1,22 @@
+module Opstat
+module Parsers
+  class OracleTablespacesSizes
+    include Opstat::Logging
+
+  #TODO - somehow check plugins version
+    def parse_data(data:, time:)
+      reports = []
+      data.split("\n")[3..-3].each do |line|
+	  tablespace = line.split(/\s+/).delete_if{|t| t.empty?}
+          reports << {
+            :OPSTAT_TAG_tablespace => tablespace[0],
+            :total => tablespace[1].to_i,
+            :used => tablespace[2].to_i,
+            :free => tablespace[3].to_i
+	  }
+      end
+      return reports
+    end
+  end
+end
+end

data/lib/parsers/temper.rb

@@ -0,0 +1,17 @@
+module Opstat
+module Parsers
+  require 'json'
+  class Temper
+    include Opstat::Logging
+
+    def parse_data(data:, time:)
+      #TODO - mesg when empty
+      temperature = data.split(',')[1].to_f
+    temperature = JSON::parse(data)["temperature_celsius"]
+      return [{
+	    :temperature => temperature
+      }]
+    end
+  end
+end
+end

data/lib/parsers/webobjects.rb

@@ -0,0 +1,33 @@
+require 'json'
+
+module Opstat
+module Parsers
+  class Webobjects
+    include Opstat::Logging
+
+    def parse_data(data:, time:)
+      return if data.length == 0
+      reports = []
+      prepared_data = data.gsub('"id"','"instance_id"')
+      webobjects_json_stats = JSON::parse(prepared_data)
+      webobjects_json_stats.select{|s| s['state'] == 'ALIVE'}.each do |instance_stats|
+        webobjects_stats = {
+          'active_sessions': instance_stats['activeSessions'].to_i,
+          'transactions': instance_stats['transactions'].to_i,
+          'average_idle_period': instance_stats['averageIdlePeriod'].to_f,
+          'average_transaction_time': instance_stats['avgTransactionTime'].to_f,
+          'deaths': instance_stats['deaths'].to_i,
+          'refusing_new_sessions': instance_stats['refusingNewSessions'],
+          'auto_recover': instance_stats['autoRecover'].downcase == 'true',
+          'OPSTAT_TAG_wo_instance_id': instance_stats['instance_id'],
+          'OPSTAT_TAG_wo_host': instance_stats['host'],
+          'OPSTAT_TAG_wo_app': instance_stats['name']
+        }
+        reports << webobjects_stats
+      end
+      return reports
+    end
+  end
+end
+end
+

data/lib/parsers/xen.rb

@@ -0,0 +1,39 @@
+module Opstat
+module Parsers
+  class Xen
+    include Opstat::Logging
+
+    def parse_data(data:, time:)
+      return if data.nil?
+      domains = []
+      
+      begin
+      data.split("\n")[1..-1].each do |line|
+        oplogger.debug "parsing line #{line}"
+        domain = {}
+	stats = line.split
+
+	domain['domain'] = stats[0]
+	domain['cpu'] = stats[3].to_i
+	domain['memory'] = stats[4].to_i
+	domain['memory_max'] = stats[6].to_i
+	domain['nettx'] = stats[10].to_i
+	domain['netrx'] = stats[11].to_i
+	domain['vbd_oo'] = stats[13].to_i
+	domain['vbd_rd'] = stats[14].to_i
+	domain['vbd_wr'] = stats[15].to_i
+	domain['vbd_rsect'] = stats[16].to_i
+	domain['vbd_wsect'] = stats[17].to_i
+	domains << domain
+      end
+      rescue
+	#TODO find best way to deal with that kind of problems
+	#TODO check if timestamp > prev
+        return
+      end
+      #TODO batch import?
+      return domains
+    end
+  end
+end
+end

data/lib/plugins/apache2.rb

@@ -0,0 +1,76 @@
+module Opstat
+module Plugins
+
+class Apache2 < Task
+
+  def initialize (name, queue, config)
+    super(name, queue, config)
+    self
+  end
+
+  def parse
+    return @external_plugin[:object].get
+  end
+
+  def set_external_plugin=(external)
+    @external_plugin[:object] = external
+  end
+
+  def external_plugin
+    return @external_plugin
+  end
+end
+
+module UDPExternalPlugins
+  class  Apache2 < EventMachine::Connection
+    include Logging
+    def initialize(options)
+      @log_level = options['log_level'] if options.has_key?('log_level')
+      oplogger.info "Create external plugin"
+      oplogger.debug "External plugin options :#{options}"
+      require 'json'
+      require 'apachelogregex'
+      @log_format = options['log_format']
+      @log_format ||= '%v %h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %I %O'
+      @stat = Hash.new
+      @parser = ApacheLogRegex.new(@log_format)
+    end
+    def post_init
+      oplogger.debug "someone connected!"
+    end
+
+    #TODO - something with parse everty line - skips some correct lines
+    def receive_data data
+      oplogger.debug data
+      line = data.split(': ')[1]
+      parse(line)
+    end
+
+    def unbind
+      oplogger.debug "someone disconnected!"
+    end
+
+  def parse(line)
+    data = @parser.parse(line)
+    if data
+      oplogger.debug data
+      @stat[data['%v'] ] ||= Hash.new
+      @stat[data['%v'] ] [data['%>s']] ||= Hash.new
+      @stat[data['%v'] ] [data['%>s']] [:requests] ||= 0
+      @stat[data['%v'] ] [data['%>s']] [:requests] += 1
+      @stat[data['%v'] ] [data['%>s']] [:bytes_sent] ||= 0
+      @stat[data['%v'] ] [data['%>s']] [:bytes_sent] += data['%O'].to_i
+    end
+  end
+  
+  def get
+    @stat.to_json
+  end
+end
+end
+
+  end
+end
+#TO CHECK - port not used
+# apache log format configured, apache logger configured
+# TODO apachelogregex - installed?

data/lib/plugins/bsdnet.rb

@@ -0,0 +1,13 @@
+module Opstat
+module Plugins
+class Bsdnet < Task
+  def parse
+    io = IO.popen("pfctl -sinfo")
+    report = io.readlines
+    io.close
+    return report
+  end
+end
+end
+end
+#TODO check if stats are activated - set logininterfacep works only for one interface

data/lib/plugins/cpu.rb

@@ -0,0 +1,13 @@
+module Opstat
+module Plugins
+class Cpu < Task
+  STAT_FILE = "/proc/stat"
+
+  def parse
+    report = File.readlines(STAT_FILE)
+    return report
+  end
+
+end
+end
+end

data/lib/plugins/custom_sql_statement.rb

@@ -0,0 +1,24 @@
+require 'active_record'
+
+module Opstat
+module Plugins
+class CustomSqlStatement < Task
+
+  def initialize (name, queue, config)
+    super(name, queue, config)
+    self
+    @db_config = config['db_config']
+    @query - config['sql_query']
+    ActiveRecord::Base.establish_connection @dbconfig
+  end
+
+  def parse
+    report = ActiveRecord::Base.connection.execute(@query)
+    return report
+  end
+
+end
+end
+end
+#need:
+#activerecord gem

data/lib/plugins/disk.rb

@@ -0,0 +1,31 @@
+module Opstat
+module Plugins
+class Disk < Task
+  DISK_IO_STATS_FILE = "/proc/diskstats"
+
+  def initialize (name, queue, config)
+    super(name, queue, config)
+    self
+  end
+
+  #TODO in memory module io.close
+  def parse
+    @count_number += 1
+    report = {}
+    report['disk_space'] = space_usage
+    report['disk_io'] = disk_io_usage
+    return report
+  end
+  def space_usage
+    io = IO.popen('df --output=source,fstype,used,avail,itotal,iused,iavail,target|sed "s#/dev/root#/dev/$(readlink /dev/root)#"')
+    stats = io.readlines
+    io.close
+    return stats
+  end
+  def disk_io_usage
+    stats = File.open(DISK_IO_STATS_FILE).readlines
+    return stats
+  end
+end
+end
+end

data/lib/plugins/facts.rb

@@ -0,0 +1,30 @@
+#set default FACTERDIR - omit libfacter not found on some systems
+facter_paths = ['/usr','/usr/lib']
+facter_paths <<  ENV['FACTERDIR'] unless ENV['FACTERDIR'].nil?
+begin
+  facter_path = facter_paths.pop
+  ENV['FACTERDIR'] = facter_path
+  puts "Try to load facter lib with FACTERDIR path set to #{facter_path}"
+  require 'facter'
+rescue LoadError => e
+  retry if facter_paths.count > 0
+  raise e
+end
+
+module Opstat
+module Plugins
+class Facts < Task
+
+  def initialize (name, queue, config)
+    super(name, queue, config)
+    self
+  end
+
+  #TODO in memory module io.close
+  def parse
+    @count_number += 1
+    return ::Facter.to_hash
+  end
+end
+end
+end

data/lib/plugins/fpm.rb

@@ -0,0 +1,33 @@
+module Opstat
+module Plugins
+class Fpm < Task
+  require 'json'
+
+  def initialize (name, queue, config)
+    super(name, queue, config)
+    @pools = config['pools']
+    self
+  end
+
+  def parse
+    report = []
+    @pools.each_pair do |pool,options|
+      oplogger.debug "getting #{pool} statistics"
+      env = {"REQUEST_METHOD" => options['request_method'], "SCRIPT_NAME" => options['status_url'], "SCRIPT_FILENAME" => options['status_url'], "QUERY_STRING" => 'json'}
+      oplogger.debug "cgi-fcgi environment: #{env.inspect}"
+      fpmIO = IO.popen([env, 'cgi-fcgi','-bind','-connect',options['fcgi_socket'] ])
+      pool_report  = fpmIO.readlines
+      oplogger.debug "#{pool} statistics: #{pool_report}"
+      report << pool_report
+      fpmIO.close
+    end
+    return report
+  end
+
+end
+end
+end
+#TO CHECK -cgi-fcgi installed
+#- pm.status_path  property set in pool configuration
+
+

data/lib/plugins/freeswitch_fifos.rb

@@ -0,0 +1,27 @@
+require 'xmlhasher'
+
+module Opstat
+module Plugins
+class FreeswitchFifos < Task
+  def initialize (name, queue, config)
+    merged_config = default_config.merge(config)
+    super(name, queue, merged_config)
+    @fifo_report_cmd = merged_config['fifo_report_cmd']
+    self
+  end
+
+  def parse
+    @count_number += 1
+    report = `#{@fifo_report_cmd}`
+    return report
+  end
+
+  def default_config
+    { 
+      'fifo_report_cmd' => 'fs_cli -x \'fifo list\''
+    }
+  end
+
+end
+end
+end

data/lib/plugins/haproxy.rb

@@ -0,0 +1,24 @@
+require 'open-uri'
+module Opstat
+module Plugins
+
+class Haproxy < Task
+  def initialize (name, queue, config)
+    super(name, queue, config)
+    @haproxy_url = "#{config['url']}/;up/stats;csv;norefresh'"
+    self
+  end
+    def parse
+      report = []
+      begin
+        source = open(@haproxy_url,open_timeout: 1, read_timeout: 1).each do |line|
+          report << line
+        end
+      rescue
+        nil
+      end
+    return report
+    end
+  end
+end
+end 

data/lib/plugins/haproxy_tables.rb

@@ -0,0 +1,28 @@
+require 'socket'
+
+module Opstat
+module Plugins
+
+class HaproxyTables < Task
+  def initialize (name, queue, config)
+    super(name, queue, config)
+    @haproxy_socket = config['socket']
+    raise ArgumentError, "Socket #{path} doesn't exists or is not a UNIX socket" unless File.exists?(@haproxy_socket) and File.socket?(@haproxy_socket)
+    self
+  end
+
+  def parse
+    report = []
+    begin
+      UNIXSocket.open(@haproxy_socket) do |socket|
+        socket.puts('show table')
+        report = socket.readlines
+      end
+    rescue
+      nil
+    end
+    return report
+  end
+end
+end
+end

data/lib/plugins/hp_pdu.rb

@@ -0,0 +1,28 @@
+require 'yaml'
+module Opstat
+module Plugins
+class HpPdu < Task
+  def initialize (name, queue, config)
+    super(name, queue, config)
+    @snmp_host = config['snmp_host']
+    @snmp_port = config['snmp_port']
+    pwd  = File.dirname(File.expand_path(__FILE__))
+    snmp_ids = YAML::load_file("#{pwd}/../data/hp_pdu.yml").keys.join(' ')
+    @snmp_cmd = "snmpget -c public -v2c #{@snmp_host}:#{@snmp_port} #{snmp_ids}"
+  end
+
+  def parse
+    snmpIO = IO.popen(@snmp_cmd)
+    report  = snmpIO.readlines.join
+    snmpIO.close
+    return report
+  end
+
+end
+end
+end
+
+
+#for test
+# check snmp is installed
+# check port is open - snmp is accessible