cloudscale 0.0.1

data/lib/cloudscale/plugins/plugin.rb

@@ -0,0 +1,98 @@
+require "fsdb"
+require "yaml/store"
+require "logger"
+require "ruby-metrics"
+require "#{File.dirname(__FILE__)}/../monitor/agent/init_charts"
+require "#{File.dirname(__FILE__)}/../monitor/agent/init_menus"
+require "#{File.dirname(__FILE__)}/../monitor/model/constants/agent_instance_store"
+require "#{File.dirname(__FILE__)}/../rest/rest_client"
+
+##
+#
+# @author Johannes Hiemer.
+#
+##
+module Cloudscale
+  module Plugins
+    class Plugin
+      attr_accessor :log, :plugins, :rest_client
+
+      @plugins = Set.new
+
+      def log
+        @log = Logger.new(STDOUT)
+      end
+
+      def initialize()
+        @rest_client = RestClientWrapper.instance
+      end
+
+      def self.reset(agentInstanceId)
+        resetRestEndpoint('coredatas', agentInstanceId, 'Coredata')
+        resetRestEndpoint('tables', agentInstanceId, 'Table')
+        resetRestEndpoint('charts', agentInstanceId, 'Chart')
+
+        Monitor::InitCharts.remove_charts()
+        Monitor::InitMenus.remove_menus()
+
+        remove_measurements(agentInstanceId)
+        remove_agenInstance(agentInstanceId)
+      end
+
+      def self.remove(agentInstanceId)
+        reset(agentInstanceId)
+
+        resetRestEndpoint('components', agentInstanceId, 'Components')
+        resetRestEndpoint('agentInstanceMenus', agentInstanceId, 'Agent Insntance Menus')
+
+        Constants::AgentInstance.remove()
+      end
+
+      def self.resetRestEndpoint(entityRel, agentInstanceId, entityName)
+        rest_client = RestClientWrapper.instance
+        entities = rest_client.searchAny(entityRel,"findByAgentInstanceId",
+                        { :agentInstanceId => agentInstanceId })
+
+        puts "Found #{entityName} elements for Agent (#{agentInstanceId}): #{entities["content"].length.to_s}"
+        puts "    Starting to delete all elements..."
+
+        entities["content"].each do  | entity |
+          rest_client.delete(entityRel, RestClientWrapper.load_entity_id(entity))
+        end
+
+        puts "    Deleting all elements was successful \n\n"
+      end
+
+      def self.remove_agenInstance(agentInstanceId)
+        rest_client = RestClientWrapper.instance
+        puts "Removing AgentInstance completely:\n\n"
+
+        agent_instance = rest_client.searchOne('agentInstances',
+                'findByAgentInstanceId', { :id => agentInstanceId })
+
+        rest_client.delete('agentInstances', RestClientWrapper.load_entity_id(agent_instance))
+
+        puts "    Deleting AgentInstance was successful \n\n"
+      end
+
+      def self.remove_measurements(agentInstanceId)
+        rest_client = RestClientWrapper.instance
+        puts "Removing Measurement elements for Agent (#{agentInstanceId}):\n\n"
+        puts "    Starting to delete all elements..."
+
+        rest_client.customDelete("measurements", "removeByAgentInstanceId", { :agentInstanceId => agentInstanceId })
+
+        puts "    Deleting all elements was successful \n\n"
+      end
+
+      def self.plugins
+        @plugins
+      end
+
+      def self.inherited(klass)
+        @plugins << klass
+      end
+
+    end
+  end
+end

data/lib/cloudscale/plugins/postgres/postgres_server_status.rb

@@ -0,0 +1,143 @@
+#require "#{File.dirname(__FILE__)}/../preops/plugin_postgres_preop"
+require "#{File.dirname(__FILE__)}/../plugin"
+
+##
+#
+# @author Johannes Hiemer.
+#
+##
+module Cloudscale
+  module Plugins
+    class PostgresServerStatus < Plugins::Plugin
+      attr_reader :menu_generalInformationm, :menu_numBackends, :menu_transactionInformation, :menu_bulkOps, :menu_rowStats,
+        :numBackends, :xactCommit, :xactRollback, :xactTotal, :blksRead, :blksHit,
+        :generalInformation, :rowsSelectIdx, :rowsSelectScan, :rowInserts, :rowUpdated, :rowDeleted, :rowTotal
+      def log
+        @log = Logger.new(STDOUT)
+      end
+  
+      def is_enabled
+        false
+      end
+  
+      def initialize
+        super
+        if is_enabled
+          menus = Plugins::PluginMenus.load_hash()
+          @menu_generalInformation = load_menu(menus["pgDatabaseStats"], "generalInformation")
+          @menu_numBackends = load_menu(menus["pgDatabaseStats"], "numBackends")
+          @menu_transactionInformation = load_menu(menus["pgDatabaseStats"], "transactionInformation")
+          @menu_bulkOps = load_menu(menus["pgDatabaseStats"], "bulkOps")
+          @menu_rowStats = load_menu(menus["pgTableStats"], "rowStats")
+                    
+          @connection = Plugins::PostgresDbWrapper.instance.connection
+          components = Plugins::PluginComponents.load_hash()
+          @numBackends = load_metric(components["pgDatabaseStats"], "numBackends")        
+          @xactCommit = load_metric(components["pgDatabaseStats"], "xactCommit")
+          @xactRollback = load_metric(components["pgDatabaseStats"], "xactRollback")
+          @xactTotal = load_metric(components["pgDatabaseStats"], "xactTotal")
+          @blksRead = load_metric(components["pgDatabaseStats"], "blksRead")
+          @blksHit = load_metric(components["pgDatabaseStats"], "blksHit")
+            
+          @generalInformation = load_metric(components["pgDatabaseStats"], "generalInformation")
+            
+          @rowsSelectIdx = load_metric(components["pgTableStats"], "rowsSelectIdx")
+          @rowsSelectScan = load_metric(components["pgTableStats"], "rowsSelectScan")
+          @rowInserts = load_metric(components["pgTableStats"], "rowInserts")
+          @rowUpdated = load_metric(components["pgTableStats"], "rowUpdated")
+          @rowDeleted = load_metric(components["rowDeleted"], "rowDeleted")
+          @rowTotal = load_metric(components["rowTotal"], "rowTotal")
+            
+        end
+      end
+  
+      def collect(agentInstanceId)
+        log.info("Calling Collect on MongoServerStatus")
+        report_general_information(agentInstanceId)
+        report_database_stats(agentInstanceId)
+        report_table_stats(agentInstanceId)
+      end
+  
+      def report_database_stats(agentInstanceId)
+        result = @connection.exec('SELECT sum(idx_tup_fetch) AS "rows_select_idx",
+                  sum(seq_tup_read) AS "rows_select_scan",
+                  sum(n_tup_ins) AS "rows_insert",
+                  sum(n_tup_upd) AS "rows_update",
+                  sum(n_tup_del) AS "rows_delete",
+                  (sum(idx_tup_fetch) + sum(seq_tup_read) + sum(n_tup_ins) + sum(n_tup_upd) + sum(n_tup_del)) AS "rows_total"
+                  FROM pg_stat_all_tables;')  
+        row = result[0]
+        
+        report(rowsSelectIdx, menu_rowStats, row['rows_select_idx'], false, agentInstanceId, "rowsSelectIdxChart",
+            "Select indexes", "Select indexes across all tables in the database", "area", "Time", "Count", "c",  nil) 
+        
+        report(rowsSelectScan, menu_rowStats, row['rows_select_scan'], false, agentInstanceId, "rowsSelectScanChart",
+            "Row select scan", "Row select scans across all tables in the database", "area", "Time", "Count", "c",  nil)
+        
+        report(rowInserts, menu_rowStats, row['rows_insert'], false, agentInstanceId, "rowInsertsChart",
+            "Row inserts", "Row inserts across all tables in the database", "area", "Time", "Count", "c",  nil)
+            
+        report(rowUpdated, menu_rowStats, row['rows_update'], false, agentInstanceId, "rowUpdatedChart",
+            "Row updates", "Row updates across all tables in the database", "area", "Time", "Count", "c",  nil)
+            
+        report(rowDeleted, menu_rowStats, row['rows_delete'], false, agentInstanceId, "rowDeletedChart",
+            "Row deletes", "Row deletes across all tables in the database", "area", "Time", "Count", "c",  nil)
+        
+        report(rowTotal, menu_rowStats, row['rows_total'], false, agentInstanceId, "rowTotalChart",
+            "Rows affected", "Rows affected across all tables in the database", "area", "Time", "Count", "c",  nil)
+      end
+  
+      def report_table_stats(agentInstanceId)
+        result = @connection.exec('SELECT sum(numbackends) AS "numbackends",
+                    sum(xact_commit) AS "xact_commit",
+                    sum(xact_rollback) AS "xact_rollback",
+                    sum(xact_commit+xact_rollback) AS "xact_total",
+                    sum(blks_read) AS "blks_read",
+                    sum(blks_hit) AS "blks_hit"
+             FROM pg_stat_database;')
+        row = result[0]
+        
+        report(xactCommit, menu_transactionInformation, row['xact_commit'], false, agentInstanceId, "xactCommitChart",
+            "Transaction commits", "Transaction commits across all tables in the database", "area", "Time", "Count", "c",  nil)
+        
+        report(xactRollback, menu_transactionInformation, row['xact_rollback'], false, agentInstanceId, "xactRollbackChart",
+            "Transaction rollback", "Transaction rollback across all tables in the database", "area", "Time", "Count", "c",  nil)
+            
+        report(xactTotal, menu_transactionInformation, row['xact_total'], false, agentInstanceId, "xactTotalChart",
+            "Transactions total", "Transactions total across all tables in the database", "area", "Time", "Count", "c",  nil)
+            
+        report(blksRead, menu_bulkOps, row['blks_read'], false, agentInstanceId, "blksReadChart",
+            "Bulk reads", "Bulk reads across all tables in the database", "area", "Time", "Count", "c",  nil)
+        
+        report(blksHit, menu_bulkOps, row['blks_hit'], false, agentInstanceId, "blksHitChart",
+            "Bulk hits", "Bulk hits across all tables in the database", "area", "Time", "Count", "c",  nil)
+      end
+  
+      def report_general_information(agentInstanceId)
+        result = @connection.exec('SELECT datid,
+                 datname, pid, usesysid, usename, 
+                 client_addr, client_hostname, 
+                 client_port, backend_start, state, waiting
+                 FROM pg_stat_activity;')
+        row = result[0]
+        
+        body = Array.new
+        body.push(["DatId", row['datid']])
+        body.push(["Datname", row['datname']])
+        body.push(["Pid", row['pid']])
+        body.push(["Use Sysid", row['usesysid']])
+        body.push(["usename", row['usename']])
+        body.push(["client_addr", row['client_addr']])
+        body.push(["client_hostname", row['client_hostname']])
+        body.push(["client_port", row['client_port']])
+        body.push(["backend_start", row['backend_start']])
+        body.push(["state", row['state']])
+        body.push(["waiting", row['waiting']])
+        mongo_general_inf_table = Monitor::Table.new("generalInformationPostgres", "Postgres General Information", nil, body, "compact")
+        mongo_general_inf_table.caption = "General Information regarding your Postgres Instance"
+  
+        persist_table(mongo_general_inf_table, agentInstanceId, menu_generalInformation)
+      end
+    end
+  end
+end

data/lib/cloudscale/plugins/preops/plugin_mongodb_preop.rb

@@ -0,0 +1,105 @@
+require "logger"
+#require "mongo"
+require "singleton"
+require "#{File.dirname(__FILE__)}/../../monitor/agent/preops/preop"
+
+##
+#
+# @author Johannes Hiemer.
+#
+##
+module Cloudscale
+  module Plugins
+    class PluginMongodbPreop < Preops::Preop
+      include Singleton
+      
+      attr_accessor :db, :connection
+      @@options = {
+        :host => {
+          :argument => "--host",
+          :description => "Host for your MongoDB Instance (e.g. host.mongodb.com)",
+          :required => true,
+          :value => nil     
+        },
+        :port => {
+          :argument => "--port",
+          :description => "Port for your MongoDB Instance (Standard 27017)",
+          :required => false,
+          :value => 27017
+        },        
+        :db => {
+          :argument => "--db",
+          :description => "Database of your MongoDB instance",
+          :required => true,
+          :value => nil
+        },
+        :ssl => {
+          :argument => "--ssl",
+          :description => "Usage SSL of your MongoDB instance",
+          :required => false,
+          :value => false
+        },     
+        :username => {
+          :argument => "--username",
+          :description => "Username for your MongoDB instance",
+          :required => false,
+          :value => nil
+        },
+        :password => {
+          :argument => "--password",
+          :description => "Password for your MongoDB instance",
+          :required => false,
+          :value => nil
+        },
+        :connect_timeout => {
+          :argument => "--connect_timeout",
+          :description => "Connection Timeout for your MongoDB instance",
+          :required => false,
+          :value => 30
+        },
+        :op_timeout => {
+          :argument => "--op_timeout",
+          :description => "Operation TImeout for your MongoDB instance",
+          :required => false,
+          :value => 30
+        }
+      }
+      
+      def options      
+        @@options
+      end
+  
+      def initialize
+        self.init
+        begin
+          @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
+    
+        # Try to connect to the database
+        if (@connection != nil)
+          @db = @connection.db(options[:db][:value])
+        end
+  
+        begin
+          if (@username != nil)
+            @db.authenticate(options[:username][:value], options[:password][:value])
+          end
+        rescue Mongo::AuthenticationError
+          puts "Unable to authenticate to MongoDB Database." << $!.message
+        end
+      end
+      
+      def connection
+        @connection
+      end
+      
+      def db
+        @db
+      end
+  
+    end
+  end
+end

data/lib/cloudscale/plugins/preops/plugin_postgres_preop.rb

@@ -0,0 +1,70 @@
+require "logger"
+#require "pg"
+require "singleton"
+require "#{File.dirname(__FILE__)}/../../monitor/agent/preops/preop"
+
+##
+#
+# @author Johannes Hiemer.
+#
+##
+module Cloudscale
+  module Plugins
+    class PluginPostgresPreop < Preops::Preop
+      include Singleton
+      
+      @@options = {
+          :host => {
+          :argument => "--host",
+          :description => "Host for your Postgres Instance (e.g. host.instance.com)",
+          :required => true,
+          :value => nil     
+        },
+        :port => {
+          :argument => "--port",
+          :description => "Port for your Postgres Instance (Standard 5432)",
+          :required => false,
+          :value => 5432
+        },        
+        :db => {
+          :argument => "--db",
+          :description => "Database of your Postgres instance",
+          :required => true,
+          :value => nil
+        },   
+        :username => {
+          :argument => "--username",
+          :description => "Username for your Postgres instance",
+          :required => false,
+          :value => nil
+        },
+        :password => {
+          :argument => "--password",
+          :description => "Password for your Postgres instance",
+          :required => false,
+          :value => nil
+        }
+      }
+      
+      def options      
+        @@options
+      end
+  
+      def initialize
+        self.init
+        begin
+          @connection = PG.connect(:host => options[:host][:value], :user => options[:username][:value], 
+            :password => options[:password][:value], 
+            :port => options[:port][:value].to_i, :dbname => options[:db][:value])
+        rescue PGError => e
+          puts e.message
+        end
+      end
+  
+      def connection
+        @connection
+      end
+  
+    end
+  end
+end

data/lib/cloudscale/registry.rb

@@ -0,0 +1,48 @@
+require "singleton"
+require "securerandom"
+require "#{File.dirname(__FILE__)}/monitor/model/constants/agent_instance_store"
+
+##
+#
+# @author Johannes Hiemer.
+#
+##
+module Cloudscale
+  module Monitor
+    class Registry
+      include Singleton
+
+      attr_accessor :agent_instance_id, :metrics, :generated_instance_id,
+        :stored_agent_instance, :stored_agent
+
+      def initialize()
+        @metrics = Hash.new
+        @generated_instance_id = SecureRandom.hex
+        @stored_agent_instance = Constants::AgentInstance.load
+        @stored_agent = Constants::Agent.load
+      end
+
+      def metrics
+        @metrics
+      end
+
+      def agent_instance_id
+        instance_id = Constants::AgentInstance.load["agentInstanceId"]
+        if (instance_id == nil)
+          return @generated_instance_id
+        else
+          return instance_id
+        end
+      end
+
+      def stored_agent
+        @stored_agent
+      end
+
+      def stored_agent_instance
+        @stored_agent_instance
+      end
+
+    end
+  end
+end