cloudscale 0.0.6 → 0.0.7

data/lib/cloudscale/plugins/mongo/mongo_server_status.rb

@@ -1,4 +1,4 @@
-#require "#{File.dirname(__FILE__)}/../preops/plugin_mongodb_preop"
+require "#{File.dirname(__FILE__)}/preops/mongodb_preop"
 require "#{File.dirname(__FILE__)}/../plugin"
 
 ##
@@ -9,164 +9,141 @@ require "#{File.dirname(__FILE__)}/../plugin"
 module Cloudscale
   module Plugins
     class MongoServerStatus < Plugins::Plugin
-      
-      attr_accessor :db
-      attr_reader :menu_generalInformation, :menu_idxCounter, :menu_globalLock, :menu_opCounter, :menu_memory, :menu_network,
-      :indexCountersBtreeHits, :indexCountersBtreeAccesses, :indexCountersBtreeMisses, :globalLockLockTime,
-      :globalLockTotalTime, :opcountersInsert, :opcountersQuery, :opcountersUpdate, :opcountersDelete, :opcountersGetMore,
-      :generalInformation, :memBits, :memResident, :memVirtual, :memMapped, :memMappedWithJournal,
-      :networkBytesIn, :networkBytesOut, :networkNumOfRequests
-      def log
-        @log = Logger.new(STDOUT)
-      end
-  
+      attr_reader :db
+
       def is_enabled
-        false
+        Preops::MongodbPreop.instance.is_enabled
       end
-  
+
       def initialize
         super
         if is_enabled
-          menus = Plugins::PluginMenus.load_hash()
-          @menu_generalInformation = load_menu(menus["mongodb-server-stats"], "generalInformation")
-          @menu_idxCounter = load_menu(menus["mongodb-server-stats"], "indexCounters")
-          @menu_globalLock = load_menu(menus["mongodb-server-stats"], "globalLock")
-          @menu_opCounter = load_menu(menus["mongodb-server-stats"], "opCounters")
-          @menu_memory = load_menu(menus["mongodb-server-stats"], "memory")
-          @menu_network = load_menu(menus["mongodb-server-stats"], "network")
-          
-          @db = Plugins::PluginPreop.instance.db
-          components = Plugins::PluginComponents.load_hash()
-          @indexCountersBtreeHits = load_metric(components["mongodb-server-stats"], "indexCountersBtreeHits")        
-          @indexCountersBtreeAccesses = load_metric(components["mongodb-server-stats"], "indexCountersBtreeAccesses")
-          @indexCountersBtreeMisses = load_metric(components["mongodb-server-stats"], "indexCountersBtreeMisses")
-          
-          @globalLockLockTime = load_metric(components["mongodb-server-stats"], "globalLockLockTime")
-          @globalLockTotalTime = load_metric(components["mongodb-server-stats"], "globalLockTotalTime")
-    
-          @opcountersInsert = load_metric(components["mongodb-server-stats"], "opcountersInsert")
-          @opcountersQuery = load_metric(components["mongodb-server-stats"], "opcountersQuery")
-          @opcountersUpdate = load_metric(components["mongodb-server-stats"], "opcountersUpdate")
-          @opcountersDelete = load_metric(components["mongodb-server-stats"], "opcountersDelete")
-          @opcountersGetMore = load_metric(components["mongodb-server-stats"], "opcountersGetMore")
-    
-          @generalInformation = load_metric(components["mongodb-server-stats"], "generalInformation")
-    
-          @memBits = load_metric(components["mongodb-server-stats"], "memBits")
-          @memResident = load_metric(components["mongodb-server-stats"], "memResident")
-          @memVirtual = load_metric(components["mongodb-server-stats"], "memVirtual")
-          @memMapped = load_metric(components["mongodb-server-stats"], "memMapped")
-          @memMappedWithJournal = load_metric(components["mongodb-server-stats"], "memMappedWithJournal")
-    
-          @networkBytesIn = load_metric(components["mongodb-server-stats"], "networkBytesIn")
-          @networkBytesOut = load_metric(components["mongodb-server-stats"], "networkBytesOut")
-          @networkNumOfRequests = load_metric(components["mongodb-server-stats"], "networkNumOfRequests")
+          @db = Preops::MongodbPreop.instance.db
         end
       end
-  
-      def collect(agentInstanceId)
+
+      def collect()
+        registry = Monitor::Registry.instance
+        metrics = Metrics::Agent.new
         log.info("Calling Collect on MongoServerStatus")
-        report_index_counters(agentInstanceId)
-        report_global_lock_times(agentInstanceId)
-        report_op_counters(agentInstanceId)
-        report_general_information(agentInstanceId)
-        report_memory(agentInstanceId)
-        report_network(agentInstanceId)
+        report_index_counters(registry, metrics)
+        report_global_lock_times(registry, metrics)
+        report_op_counters(registry, metrics)
+        report_general_information(registry, metrics)
+        report_memory(registry, metrics)
+        report_network(registry, metrics)
       end
-  
-      def report_memory(agentInstanceId)
+
+      def report_memory(registry, metrics)
         stats = @db.command('serverStatus' => 1)
-        report(memBits, menu_memory, stats['mem']['bits'], false, agentInstanceId, "memBitsChart",
-        "Memory bits", "Memory bits across collections in the database", "area", "Time", "Count", "c",  nil)
-  
-        report(memResident, menu_memory, stats['mem']['resident'], false, agentInstanceId, "memResidentChart",
-        "Memory resident", "Memory resident across collections in the database", "area", "Time", "Count", "c",  nil)
-  
-        report(memVirtual, menu_memory, stats['mem']['virtual'], false, agentInstanceId, "memVirtualChart",
-        "Memory virtual", "Memory virtual across collections in the database", "area", "Time", "Count", "c",  nil)
-  
-        report(memMapped, menu_memory, stats['mem']['mapped'], false, agentInstanceId, "memMappedChart",
-        "Memory mapped", "Memory mapped across collections in the database", "area", "Time", "Count", "c",  nil)
-  
-        report(memMappedWithJournal, menu_memory, stats['mem']['mappedWithJournal'], false, agentInstanceId, "memMappedWithJournalChart",
-        "Memory mapped with Journal", "Memory mapped with Journal across collections in the database", "area", "Time", "Count", "c",  nil)
-  
+        registry.metrics["mongo.mem.bits"] = metrics.gauge :mem_bits do
+          { :value => stats['mem']['bits'] }
+        end
+
+        registry.metrics["mongo.mem.resident"] = metrics.gauge :mem_resident do
+          { :value => stats['mem']['resident'] }
+        end
+
+        registry.metrics["mongo.mem.virtual"] = metrics.gauge :mem_virtual do
+          { :value => stats['mem']['virtual'] }
+        end
+
+        registry.metrics["mongo.mem.mapped"] = metrics.gauge :mem_mapped do
+          { :value => stats['mem']['mapped'] }
+        end
+
+        registry.metrics["mongo.mem.mappedWithJournal"] = metrics.gauge :mem_mappedWithJournal do
+          { :value => stats['mem']['mappedWithJournal'] }
+        end
       end
-  
-      def report_network(agentInstanceId)
+
+      def report_network(registry, metrics)
         stats = @db.command('serverStatus' => 1)
-  
-        report(networkBytesIn, menu_network, stats['network']['bytesIn'], true, agentInstanceId, "networkBytesInChart",
-        "Network Bytes in", "Network Bytes in", "area", "Time", "Count", "B",  "s")
-  
-        report(networkBytesOut, menu_network, stats['network']['bytesOut'], true, agentInstanceId, "networkBytesOutChart",
-        "Network Bytes out", "Network Bytes out", "area", "Time", "Count", "B",  "s")
-  
-        report(networkNumOfRequests, menu_network, stats['network']['numRequests'], true, agentInstanceId, "networkNumOfRequests",
-        "Number of Requests", "Number of Requests", "area", "Time", "Count", "c",  "s")
+
+        registry.metrics["mongo.network.bytes.in"] = metrics.gauge :mem_bytesIn do
+          { :value => stats['mem']['bytesIn'] }
+        end
+
+        registry.metrics["mongo.network.bytes.out"] = metrics.gauge :mem_bytesOut do
+          { :value => stats['mem']['bytesOut'] }
+        end
+
+        registry.metrics["mongo.network.num.requests"] = metrics.gauge :mem_numRequests do
+          { :value => stats['mem']['numRequests'] }
+        end
       end
-  
-      def report_general_information(agentInstanceId)
+
+      def report_general_information(registry, metrics)
         stats = @db.command('serverStatus' => 1)
-  
-        body = Array.new
-        body.push(["Host", stats['host']])
-        body.push(["Version", stats['version']])
-        body.push(["Uptime", stats['uptime']])
-        body.push(["Local time", stats['localTime']])
-        body.push(["Connections currently", stats['connections']['current']])
-        body.push(["Connections available", stats['connections']['available']])
-        mongo_general_inf_table = Monitor::Table.new("generalInformationMonGo", "MongoDB General Information", nil, body, "compact")
-        mongo_general_inf_table.caption = "General Information regarding your MongoDB Instance"
-  
-        persist_table(mongo_general_inf_table, agentInstanceId, menu_generalInformation)
+
+        registry.metrics["mongo.general.uptime"] = metrics.gauge :general_uptime do
+          { :value => stats['uptime'] }
+        end
+
+        registry.metrics["mongo.general.connections.currently"] = metrics.gauge :general_connections_current do
+          { :value => stats['connections']['current'] }
+        end
+
+        registry.metrics["mongo.general.connections.available"] = metrics.gauge :general_connections_available do
+          { :value => stats['connections']['available'] }
+        end
       end
-  
-      def report_op_counters(agentInstanceId)
+
+      def report_op_counters(registry, metrics)
         stats = @db.command('serverStatus' => 1)
-        report(opcountersInsert, menu_opCounter, stats['opcounters']['insert'], true, agentInstanceId, "opcountersInsertChart",
-        "Operation Counter Inserts", "Operation Counter Inserts across collections in the database", "area", "Time", "Count", "c",  "s")
-  
-        report(opcountersQuery, menu_opCounter, stats['opcounters']['query'], true, agentInstanceId, "opcountersQueryChart",
-        "Operation Counter Query", "Operation Counter Query across collections in the database", "area", "Time", "Count", "c",  "s")
-  
-        report(opcountersUpdate, menu_opCounter, stats['opcounters']['update'], true, agentInstanceId, "opcountersUpdateChart",
-        "Operation Counter Update", "Operation Counter Update across collections in the database", "area", "Time", "Count", "c",  "s")
-  
-        report(opcountersDelete, menu_opCounter, stats['opcounters']['delete'], true, agentInstanceId, "opcountersDeleteChart",
-        "Operation Counter Delete", "Operation Counter Delete across collections in the database", "area", "Time", "Count", "c",  "s")
-  
-        report(opcountersGetMore, menu_opCounter, stats['opcounters']['getmore'], true, agentInstanceId, "opcountersGetMoreChart",
-        "Operation Counter Get More", "Operation Counter Get More across collections in the database", "area", "Time", "Count", "c",  "s")
-  
+
+        registry.metrics["mongo.opcounts.insert"] = metrics.gauge :opcounters_inserts do
+          { :value => stats['opcounters']['insert'] }
+        end
+
+        registry.metrics["mongo.opcounts.query"] = metrics.gauge :opcounters_query do
+          { :value => stats['opcounters']['query'] }
+        end
+
+        registry.metrics["mongo.opcounts.update"] = metrics.gauge :opcounters_update do
+          { :value => stats['opcounters']['update'] }
+        end
+
+        registry.metrics["mongo.opcounts.delete"] = metrics.gauge :opcounters_delete do
+          { :value => stats['opcounters']['delete'] }
+        end
+
+        registry.metrics["mongo.opcounts.getmore"] = metrics.gauge :opcounters_getmore do
+          { :value => stats['opcounters']['getmore'] }
+        end
       end
-  
-      def report_index_counters(agentInstanceId)
+
+      def report_index_counters(registry, metrics)
         stats = @db.command('serverStatus' => 1)
-  
+
         if (stats["indexCounters"] and stats["indexCounters"]["btree"])
-          report(indexCountersBtreeAccesses, menu_idxCounter, stats['indexCounters']['btree']['accesses'], true, agentInstanceId, "btreeAccessesChart",
-          "Number of btree accesses", "Number of btree accesses across all collections in the database" , "area", "Time", "Count", "c", "s")
-  
-          report(indexCountersBtreeMisses, menu_idxCounter, stats['indexCounters']['btree']['misses'], true, agentInstanceId, "btreeMissesChart",
-          "Number of btree misses", "Number of btree misses across all collections in the database" , "area", "Time", "Count", "c", "s")
-  
-          report(indexCountersBtreeHits, menu_idxCounter, stats['indexCounters']['btree']['hits'], true, agentInstanceId, "btreeHitsChart",
-          "Number of btree hits", "Number of btree hits across all collections in the database" , "area", "Time", "Count", "c", "s")
+          registry.metrics["mongo.index.counters.btree.accesses"] = metrics.gauge :counters_btree_accesses do
+            { :value => stats['indexCounters']['btree']['accesses'] }
+          end
+
+          registry.metrics["mongo.index.counters.btree.misses"] = metrics.gauge :counters_btree_misses do
+            { :value => stats['indexCounters']['btree']['misses'] }
+          end
+
+          registry.metrics["mongo.index.counters.btree.hits"] = metrics.gauge :counters_btree_hits do
+            { :value => stats['indexCounters']['btree']['hits'] }
+          end
         end
       end
-  
-      def report_global_lock_times(agentInstanceId)
+
+      def report_global_lock_times(registry, metrics)
         stats = @db.command('serverStatus' => 1)
         if stats['globalLock']
-          report(globalLockLockTime, menu_globalLock, stats['globalLock']['lockTime'], false, agentInstanceId, "globalLockLockTimeChart",
-          "Globallock Lock Time", "The global lock time across collections in the database" , "area", "Time", "", "s",  nil)
-  
-          report(globalLockTotalTime, menu_globalLock, stats['globalLock']['totalTime'], false, agentInstanceId, "globalLockTotalTimeChart",
-          "Number of btree hits", "The global lock time in total across collections in the database" , "area", "Time", "", "s", nil)
+          registry.metrics["mongo.global.lock.time"] = metrics.gauge :global_lock_time do
+            { :value => stats['globalLock']['lockTime'] }
+          end
+
+          registry.metrics["mongo.global.lock.total.time"] = metrics.gauge :global_lock_total_time do
+            { :value => stats['globalLock']['totalTime'] }
+          end
         end
       end
-  
+
     end
   end
-end
+end

data/lib/cloudscale/plugins/mongo/preops/mongodb_preop.rb

@@ -0,0 +1,113 @@
+require "logger"
+begin
+  require "mongo"
+rescue LoadError
+  puts "WARNING: Load error Mongo needs to be installed via bundler"
+end
+require "singleton"
+require "#{File.dirname(__FILE__)}/../../preops/plugin_preop"
+
+##
+#
+# @author Johannes Hiemer.
+#
+##
+module Cloudscale
+  module Preops
+    class MongodbPreop < Preops::PluginPreop
+      include Singleton
+
+      def is_enabled
+        true
+      end
+
+      attr_accessor :db, :connection
+      @@options = {
+        :"mongo-host" => {
+          :argument => "--mongo-host",
+          :description => "Host for your MongoDB Instance (e.g. host.mongodb.com)",
+          :required => true,
+          :value => nil
+        },
+        :"mongo-port" => {
+          :argument => "--mongo-port",
+          :description => "Port for your MongoDB Instance (Standard 27017)",
+          :required => false,
+          :value => 27017
+        },
+        :"mongo-db" => {
+          :argument => "--mongo-db",
+          :description => "Database of your MongoDB instance",
+          :required => true,
+          :value => nil
+        },
+        :"mongo-ssl" => {
+          :argument => "--mongo-ssl",
+          :description => "Usage SSL of your MongoDB instance",
+          :required => false,
+          :value => false
+        },
+        :"mongo-username" => {
+          :argument => "--mongo-username",
+          :description => "Username for your MongoDB instance",
+          :required => false,
+          :value => nil
+        },
+        :"mongo-password" => {
+          :argument => "--mongo-password",
+          :description => "Password for your MongoDB instance",
+          :required => false,
+          :value => nil
+        },
+        :"mongo-connect-timeout" => {
+          :argument => "--mongo-connect-timeout",
+          :description => "Connection Timeout for your MongoDB instance",
+          :required => false,
+          :value => 30
+        },
+        :"mongo-op-timeout" => {
+          :argument => "--mongo-timeout",
+          :description => "Operation Timeout for your MongoDB instance",
+          :required => false,
+          :value => 30
+        }
+      }
+
+      def options
+        @@options
+      end
+
+      def initialize
+        self.init
+        if defined? Mongo
+          begin Mongo
+            @connection = Mongo::Connection.new(options[:host][:value], options[:port][:value])
+          rescue Mongo::ConnectionFailure
+            puts "Unable to connect to the MongoDB Daemon.",
+            "Please ensure it is running on #{@host}:#{@port}\n\nException Message: #{$!.message}. Also confirm if SSL should be enabled or disabled."
+          end
+
+          if @connection != nil
+            begin
+              @db = @connection.db(options[:db][:value])
+              if (@username != nil)
+                @db.authenticate(options[:username][:value], options[:password][:value])
+              end
+            rescue Exception
+              puts "Unable to authenticate to MongoDB Database." << $!.message
+            end
+          end
+        end
+      end
+
+      def connection
+        @connection
+      end
+
+      def db
+        @db
+      end
+
+    end
+  end
+end

data/lib/cloudscale/plugins/os/preops/{plugin_preop.rb → os_preop.rb}

@@ -1,7 +1,6 @@
-require "optparse"
 require "logger"
 require "csigar"
-require "#{File.dirname(__FILE__)}/../../../monitor/agent/preops/preop"
+require "#{File.dirname(__FILE__)}/../../preops/plugin_preop"
 
 ##
 #
@@ -9,7 +8,7 @@ require "#{File.dirname(__FILE__)}/../../../monitor/agent/preops/preop"
 #
 ##
 module Cloudscale
-  module Plugins
+  module Preops
     class NullLogger < Logger
       def initialize
       end
@@ -19,7 +18,7 @@ module Cloudscale
       end
     end
 
-    class PluginPreop < Preops::Preop
+    class OsPreop < Preops::PluginPreop
       include Singleton
       @@options = {
       }
@@ -28,6 +27,10 @@ module Cloudscale
         @@options
       end
 
+      def is_enabled
+        true
+      end
+
       def register
         init_charts("#{File.dirname(__FILE__)}/../data/os_chart.json")
         init_menus("#{File.dirname(__FILE__)}/../data/os_menu.json")

data/lib/cloudscale/plugins/os/sigar_cpu_perc.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/preops/plugin_preop"
+require "#{File.dirname(__FILE__)}/preops/os_preop"
 require "#{File.dirname(__FILE__)}/../plugin"
 
 ##
@@ -11,13 +11,13 @@ module Cloudscale
     class SigarCpuPerc < Plugins::Plugin
 
       def is_enabled
-        true
+        Preops::OsPreop.instance.is_enabled
       end
 
       def initialize
         super
         if is_enabled
-          @sigar = Plugins::PluginPreop.instance.sigar
+          @sigar = Preops::OsPreop.instance.sigar
         end
       end