prometheus-splash 0.5.2 → 0.8.0

data/lib/splash/config/setup.rb

@@ -1,13 +1,18 @@
-
 # coding: utf-8
 
-
+# Base Splash module
 module Splash
+
+  # moudle for Configuration utilities
   module ConfigUtilities
     include Splash::Constants
     include Splash::Helpers
+
+
     # Setup action method for installing Splash
-    # @return [Integer] an errorcode value
+    # @param [Hash] options
+    # @option options [Symbol] :preserve flag to preserve config file during setup
+    # @return [Hash] An Exiter case hash (:splash_setup_success or :splash_setup_error)
     def setupsplash(options = {})
       conf_in_path = search_file_in_gem "prometheus-splash", "config/splash.yml"
       full_res = 0

data/lib/splash/constants.rb

@@ -1,23 +1,31 @@
 # coding: utf-8
+
+# base Splash module / namespace
 module Splash
+
+  # Constants namespace
   module Constants
-    VERSION = "0.5.2"
+
+    # Current splash version
+    VERSION = "0.8.0"
 
     # the path to th config file, not overridable by config
     CONFIG_FILE = "/etc/splash.yml"
     # the default execution trace_path if backend file
     TRACE_PATH="/var/run/splash"
+    # the default pid file path
+    PID_PATH="/var/run"
 
 
     # default scheduling criteria for log monitoring
     DAEMON_LOGMON_SCHEDULING={ :every => '20s'}
-    # default scheduling criteria for log metrics notifications
-    DAEMON_METRICS_SCHEDULING={ :every => '20s'}
+    # default scheduling criteria for  metrics notifications
+    DAEMON_METRICS_SCHEDULING={ :every => '15s'}
+    # default scheduling criteria for process monitoring
+    DAEMON_PROCMON_SCHEDULING={ :every => '20s'}
 
     # the display name of daemon in proc info (ps/top)
     DAEMON_PROCESS_NAME="Splash : daemon."
-    # the default pid file path
-    DAEMON_PID_PATH="/var/run"
     # the default pid file name
     DAEMON_PID_FILE="splash.pid"
     # the default sdtout trace file
@@ -34,10 +42,14 @@ module Splash
     # type of licence
     LICENSE="BSD-2-Clause"
 
-    # the default prometheus pushgateway host
-    PROMETHEUS_PUSHGATEWAY_HOST = "localhost"
-    # the default prometheus pushgateway port
-    PROMETHEUS_PUSHGATEWAY_PORT = "9091"
+    # the default prometheus pushgateway URL
+    PROMETHEUS_PUSHGATEWAY_URL = 'http://localhost:9091/'
+
+    # the default prometheus Alertmanager URL
+    PROMETHEUS_ALERTMANAGER_URL = 'http://localhost:9092/'
+
+    # the default prometheus URL
+    PROMETHEUS_URL = "http://localhost:9090/"
 
     # the default path fo execution report template
     EXECUTION_TEMPLATE="/etc/splash_execution_report.tpl"
@@ -53,11 +65,30 @@ module Splash
                           :active => :rabbitmq,
                           :rabbitmq => { :port => 5672, :host => "localhost", :vhost => '/'} }
 
-    LOGGERS_STRUCT = { :list => [:cli,:daemon, :dual],
+    # loggers default settings
+    LOGGERS_STRUCT = { :list => [:cli,:daemon, :dual, :web],
                        :default => :cli,
                        :level => :info,
                        :daemon => {:file => '/var/log/splash.log'},
+                       :web => {:file => '/var/log/splash_web.log'},
                        :cli => {:color => true, :emoji => true }  }
 
+    WEBADMIN_IP = "127.0.0.1"
+    WEBADMIN_PORT = "9234"
+    WEBADMIN_PROXY = false
+    # the display name of daemon in proc info (ps/top)
+    WEBADMIN_PROCESS_NAME="Splash : WebAdmin."
+    # the default pid file path
+    WEBADMIN_PID_PATH="/var/run"
+    # the default pid file name
+    WEBADMIN_PID_FILE="splash.pid"
+    # the default sdtout trace file
+    WEBADMIN_STDOUT_TRACE="stdout.txt"
+    # the default sdterr trace file
+    WEBADMIN_STDERR_TRACE="stderr.txt"
+
+    # default transfer retention for trace
+    TRANSFER_DEFAULT_RETENTION=1
+
   end
 end

data/lib/splash/daemon.rb

@@ -1,2 +1,6 @@
 # coding: utf-8
-Dir[File.dirname(__FILE__) + '/daemon/*.rb'].each {|file| require file  }
+require File.dirname(__FILE__) + '/daemon/orchestrator.rb'
+require File.dirname(__FILE__) + '/daemon/metrics.rb'
+require File.dirname(__FILE__) + '/daemon/controller.rb'
+
+# Dir[File.dirname(__FILE__) + '/daemon/*.rb'].each {|file| require file  }

data/lib/splash/daemon/controller.rb

@@ -1,6 +1,13 @@
 # coding: utf-8
+require 'splash/daemon/orchestrator'
+
+# base Splash module
 module Splash
+
+  # global daemon module
   module Daemon
+
+    # Daemon Controller Module
     module Controller
       include Splash::Constants
       include Splash::Helpers
@@ -9,11 +16,17 @@ module Splash
       include Splash::Loggers
       include Splash::Daemon::Orchestrator
 
+      # Start the Splash Daemon
+      # @param [Hash] options
+      # @option options [Symbol] :quiet activate quiet mode for log (limit to :fatal)
+      # @option options [Symbol] :foreground run daemon in foreground
+      # @option options [Symbol] :purge clean input queue for daemon on configured transport
+      # @return [Hash] Exiter Case (:quiet_exit, :already_exist, :unknown_error or other)
       def startdaemon(options = {})
         config = get_config
         log = get_logger
         log.level = :fatal if options[:quiet]
-        unless verify_service host: config.prometheus_pushgateway_host ,port: config.prometheus_pushgateway_port then
+        unless verify_service url: config.prometheus_pushgateway_url then
           return {:case => :service_dependence_missing, :more => 'Prometheus Gateway'}
         end
         realpid = get_processes pattern: get_config.daemon_process_name
@@ -22,7 +35,7 @@ module Splash
           return {:case => :already_exist, :more => "Splash Process already launched on foreground "}
         end
 
-        unless File::exist? config.full_pid_path then
+        unless File::exist? config.daemon_full_pid_path then
           unless realpid.empty? then
             return {:case => :already_exist, :more => "Splash Process already launched "}
           end
@@ -37,19 +50,19 @@ module Splash
             end
           end
           daemon_config = {:description => config.daemon_process_name,
-              :pid_file => config.full_pid_path,
-              :stdout_trace => config.full_stdout_trace_path,
-              :stderr_trace => config.full_stderr_trace_path,
+              :pid_file => config.daemon_full_pid_path,
+              :stdout_trace => config.daemon_full_stdout_trace_path,
+              :stderr_trace => config.daemon_full_stderr_trace_path,
               :foreground => options[:foreground]
             }
 
-          ["int","term","hup"].each do |type| daemon_config["sig#{type}_handler".to_sym] = Proc::new {  ObjectSpace.each_object(Splash::Daemon::Orchestrator::Scheduler).first.shutdown } end
+          ["int","term","hup"].each do |type| daemon_config["sig#{type}_handler".to_sym] = Proc::new {  ObjectSpace.each_object(Splash::Daemon::Orchestrator::Scheduler).first.terminate } end
           res = daemonize daemon_config do
               Scheduler::new options
           end
           sleep 1
           if res == 0 then
-            pid = `cat #{config.full_pid_path}`.to_i
+            pid = `cat #{config.daemon_full_pid_path}`.to_i
             log.ok "Splash Daemon Started, with PID : #{pid}"
             return {:case => :quiet_exit, :more => "Splash Daemon successfully loaded."}
           else
@@ -61,30 +74,37 @@ module Splash
         end
       end
 
+      # Stop the Splash Daemon
+      # @param [Hash] options
+      # @option options [Symbol] :quiet activate quiet mode for log (limit to :fatal)
+      # @return [Hash] Exiter Case (:quiet_exit, :not_found, other)
       def stopdaemon(options = {})
           config = get_config
           log = get_logger
           log.level = :fatal if options[:quiet]
-          if File.exist?(config.full_pid_path) then
+          if File.exist?(config.daemon_full_pid_path) then
             begin
-              pid = `cat #{config.full_pid_path}`.to_i
+              pid = `cat #{config.daemon_full_pid_path}`.to_i
               Process.kill("TERM", pid)
               acase = {:case => :quiet_exit, :more => 'Splash stopped succesfully'}
             rescue Errno::ESRCH
               acase =  {:case => :not_found, :more => "Process of PID : #{pid} not found"}
             end
-            FileUtils::rm config.full_pid_path if File::exist? config.full_pid_path
+            FileUtils::rm config.daemon_full_pid_path if File::exist? config.daemon_full_pid_path
           else
             acase =  {:case => :not_found, :more => "Splash is not running"}
           end
           return acase
       end
 
+      # Status of the Splash Daemon, display status
+      # @param [Hash] options ignored
+      # @return [Hash] Exiter Case (:status_ko, :status_ok)
       def statusdaemon(options = {})
         log = get_logger
         config = get_config
         pid = realpid = ''
-        pid = `cat #{config.full_pid_path}`.to_s if File.exist?(config.full_pid_path)
+        pid = `cat #{config.daemon_full_pid_path}`.to_s if File.exist?(config.daemon_full_pid_path)
         listpid = get_processes({ :pattern => get_config.daemon_process_name})
         pid.chomp!
         if listpid.empty? then

data/lib/splash/daemon/metrics.rb

@@ -1,5 +1,12 @@
+# coding: utf-8
+
+# base Splash module
 module Splash
+
+  # global daemon module
   module Daemon
+
+    # Metrics management modulefor Splash daemon
     module Metrics
       include Splash::Constants
       include Splash::Helpers
@@ -7,64 +14,82 @@ module Splash
       include Splash::Loggers
 
       @@manager=nil
-      # factory of Configuration Class instance
-      # @param [String] config_file the path of the YAML Config file
-      # @return [SPlash::Config::Configuration]
-      def get_metrics_manager
-        return @@manager ||= Manager::new
-      end
 
+      # metrics manager factory
+      # @return [Splash::Daemon::Metrics::Manager]
+      def get_metrics_manager(session)
+        return @@manager ||= Manager::new(:session => session)
+      end
 
+      # Metrics Manager (collect and sending to Prometheus)
       class Manager
 
+        # metric : commands executions count during Splash daemon uptime
         attr_reader :execution_count
-        attr_reader :monitoring_count
-
-        def initialize
+        # metric : logs monitoring count during Splash daemon uptime
+        attr_reader :monitoring_logs_count
+        # metric : processes monitoring count during Splash daemon uptime
+        attr_reader :monitoring_processes_count
+
+        # Constructor prepare prometheus-client, defined metrics and init attributes
+        def initialize(options ={})
+          @session = options[:session]
           @config = get_config
           @starttime = Time.now
           @execution_count = 0
-          @monitoring_count = 0
+          @monitoring_logs_count = 0
+          @monitoring_processes_count = 0
+
 
           @registry = Prometheus::Client::Registry::new
           @metric_uptime = Prometheus::Client::Gauge.new(:splash_uptime, docstring: 'SPLASH self metric uptime')
           @metric_execution = Prometheus::Client::Gauge.new(:splash_execution, docstring: 'SPLASH self metric total commands execution count')
-          @metric_monitoring = Prometheus::Client::Gauge.new(:splash_monitoring, docstring: 'SPLASH self metric total logs monitoring count')
+          @metric_logs_monitoring = Prometheus::Client::Gauge.new(:splash_logs_monitoring, docstring: 'SPLASH self metric total logs monitoring count')
+          @metric_processes_monitoring = Prometheus::Client::Gauge.new(:splash_processes_monitoring, docstring: 'SPLASH self metric total processes monitoring count')
           @registry.register(@metric_uptime)
           @registry.register(@metric_execution)
-          @registry.register(@metric_monitoring)
+          @registry.register(@metric_logs_monitoring)
+          @registry.register(@metric_processes_monitoring)
         end
 
-
+        # virtual accessor uptime
         def uptime
           return Time.now - @starttime
         end
 
+        # increment metric : execution_count
         def inc_execution
           @execution_count += 1
         end
 
-
-        def inc_monitoring
-          @monitoring_count += 1
+        # increment metric : monitoring_logs_count
+        def inc_logs_monitoring
+          @monitoring_logs_count += 1
         end
 
+        # increment metric : monitoring_processes_count
+        def inc_processes_monitoring
+          @monitoring_processes_count += 1
+        end
 
+        # Send metrics to Prometheus PushGateway
+        # @return [Hash] Exiter case ( :service_dependence_missing , :quiet_exit)
         def notify
           log = get_logger
-          session  = get_session
-          unless verify_service host: @config.prometheus_pushgateway_host ,port: @config.prometheus_pushgateway_port then
+          unless verify_service url: @config.prometheus_pushgateway_url then
             return  { :case => :service_dependence_missing, :more => "Prometheus Notification not send." }
           end
 
-          log.debug "Sending Splash self metrics to PushGateway." , session
+          log.ok "Sending Splash self metrics to PushGateway." , @session
           @metric_uptime.set uptime
           @metric_execution.set execution_count
-          @metric_monitoring.set monitoring_count
+          @metric_logs_monitoring.set monitoring_logs_count
+          @metric_processes_monitoring.set monitoring_processes_count
+
           hostname = Socket.gethostname
-          url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
+          url = @config.prometheus_pushgateway_url
           Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
-          log.debug "Sending to Prometheus PushGateway done.", session
+          log.debug "Sending to Prometheus PushGateway done.", @session
           return {:case => :quiet_exit }
         end
 

data/lib/splash/daemon/orchestrator.rb

@@ -1,10 +1,16 @@
 # coding: utf-8
 Dir[File.dirname(__FILE__) + '/orchestrator/*.rb'].each {|file| require file  }
 
+# base Splash module
 module Splash
+
+  # global daemon module
   module Daemon
+
+    # orchestrator specific module
     module Orchestrator
 
+      # Splash Scheduler object
       class Scheduler
         include Splash::Constants
         include Splash::Helpers
@@ -13,49 +19,59 @@ module Splash
         include Splash::Daemon::Orchestrator::Grammar
         include Splash::Loggers
         include Splash::Logs
+        include Splash::Processes
         include Splash::Commands
+        include Splash::Sequences
 
-
+        # Constructor prepare the Scheduler
+        # commands Schedules
+        # logs monitorings
+        # process monitorings
+        # @param [Hash] options
+        # @option options [Symbol] :scheduling activate commands scheduling
         def initialize(options = {})
           @log = get_logger
           self.extend Splash::Daemon::Metrics
-          @metric_manager = get_metrics_manager
+          @session = get_session
+          @metric_manager = get_metrics_manager(@session)
           $stdout.sync = true
           $stderr.sync = true
           @server  = Rufus::Scheduler::new
           @server.extend SchedulerHooks
           @config = get_config
-          @result = LogScanner::new
+          @scheduling = options[:scheduling]
+
           @log.info "Splash Orchestrator starting :"
-          if options[:scheduling] then
-            @log.item "Initializing commands Scheduling."
+          if @scheduling then
+            @log.item "Initializing Sequences & commands Scheduling."
             init_commands_scheduling
-          end
-          sched,value = @config.daemon_logmon_scheduling.flatten
-          @log.item "Initializing logs monitorings & notifications."
-          @server.send sched,value do
-            begin
-              session = get_session
-              @metric_manager.inc_monitoring
-              @log.trigger "Logs monitoring for Scheduling : #{sched.to_s} #{value.to_s}", session
-              @result.analyse
-              @result.notify :session => session
-            rescue Errno::ECONNREFUSED
-              @log.error "PushGateway seems to be done, please start it.", session
-            end
+            init_sequences_scheduling
           end
 
-          sched,value = @config.daemon_metrics_scheduling.flatten
+          init_logs_monitoring_scheduling
+          init_process_monitoring_scheduling
+          init_metrics_scheduling
+          init_daemon_subscriber
 
-          @log.item "Initializing Splash metrics notifications."
-          @server.send sched,value do
-            begin
-              @metric_manager.notify
-            rescue Errno::ECONNREFUSED
-              @log.error "PushGateway seems to be done, please start it."
-            end
-          end
+        end
 
+
+
+
+
+        # Stop the Splash daemon gracefully
+        # @return [hash] Exiter Case :quiet_exit
+        def terminate
+          @log.info "Splash daemon shutdown"
+          @server.shutdown
+          change_logger logger: :cli
+          splash_exit case: :quiet_exit
+        end
+
+        private
+
+        #prepare main daemon subscriber
+        def init_daemon_subscriber
           hostname = Socket.gethostname
           transport = get_default_subscriber queue: "splash.#{hostname}.input"
           if transport.class == Hash and transport.include? :case then
@@ -77,14 +93,67 @@ module Splash
           end
         end
 
-        def terminate
-          @log.info "Splash daemon shutdown"
-          @server.shutdown
-          change_logger logger: :cli
-          splash_exit case: :quiet_exit
+        #prepare logs monitoring  sheduling
+        def init_logs_monitoring_scheduling
+          if @config.logs.empty? then
+            @log.item "No logs to monitor"
+          else
+            sched,value = @config.daemon_procmon_scheduling.flatten
+            @log.item "Initializing logs monitorings & notifications."
+            @log_result = LogScanner::new
+            @server.send sched,value do
+              begin
+                session = get_session
+                @metric_manager.inc_logs_monitoring
+                @log.trigger "Logs monitoring for Scheduling : #{sched.to_s} #{value.to_s}", session
+                @log_result.analyse
+                @log_result.notify :session => session
+              rescue Errno::ECONNREFUSED
+                @log.error "PushGateway seems to be done, please start it.", session
+              end
+            end
+          end
         end
 
-        private
+        #prepare process monitoring  sheduling
+        def init_process_monitoring_scheduling
+          if @config.processes.empty? then
+            @log.item "No processes to monitor"
+          else
+            sched,value = @config.daemon_logmon_scheduling.flatten
+            @log.item "Initializing processes monitorings & notifications."
+            @process_result = ProcessScanner::new
+            @server.send sched,value do
+              begin
+                session = get_session
+                @metric_manager.inc_processes_monitoring
+                @log.trigger "Processes monitoring for Scheduling : #{sched.to_s} #{value.to_s}", session
+                @process_result.analyse
+                @process_result.notify :session => session
+              rescue Errno::ECONNREFUSED
+                @log.error "PushGateway seems to be done, please start it.", session
+              end
+            end
+          end
+        end
+
+
+        #prepare metrics sheduling
+        def init_metrics_scheduling
+          sched,value = @config.daemon_metrics_scheduling.flatten
+          @log.item "Initializing Splash metrics notifications."
+          @server.send sched,value do
+            begin
+              @log.trigger "Splash Metrics monitoring for Scheduling : #{sched.to_s} #{value.to_s}", @session
+              @metric_manager.notify
+            rescue Errno::ECONNREFUSED
+              @log.error "PushGateway seems to be done, please start it."
+            end
+          end
+        end
+
+
+        # prepare commands Scheduling
         def init_commands_scheduling
           config = get_config.commands
           commands = config.select{|key,value| value.include? :schedule}.keys
@@ -97,21 +166,57 @@ module Splash
               execute command: command.to_s, session: session
             end
           end
+        end
 
+
+        # prepare sequences Scheduling
+        def init_sequences_scheduling
+          config = get_config.sequences
+          sequences = config.select{|key,value| value.include? :schedule}.keys
+          sequences.each do |sequence|
+            sched,value = config[sequence][:schedule].flatten
+            @log.arrow "Scheduling sequence #{sequence.to_s}"
+            @server.send sched,value do
+              session  = get_session
+              @log.trigger "Executing Scheduled sequence #{sequence.to_s} for Scheduling : #{sched.to_s} #{value.to_s}", session
+              run_seq name: sequence.to_s, session: session
+            end
+          end
         end
 
+        # reset the orchestrator
+        # @return [Hash] Exiter case
+        def reset_orchestrator
+          @server.shutdown
+          @server = Rufus::Scheduler::new
+          @server.extend SchedulerHooks
+          @config = rehash_config
+          @log.info "Splash Orchestrator re-hashing :"
+          if @scheduling then
+            @log.item "Re-Initializing Sequences & commands Scheduling."
+            init_commands_scheduling
+            init_sequences_scheduling
+          end
+          init_logs_monitoring_scheduling
+          init_process_monitoring_scheduling
+          init_metrics_scheduling
+        end
+
+
+        # execute_command verb : execute command specified in payload
+        # @param [Hash] options
+        # @option options [Symbol] :command the name of the command
+        # @option options [Symbol] :ack ack flag to inhibit execution and send ack to Prometheus (0)
+        # @return [Hash] Exiter case
         def execute(options)
           command =  CommandWrapper::new(options[:command])
           if options[:ack] then
-            command.ack
           else
             @metric_manager.inc_execution
             return command.call_and_notify trace: true, notify: true, callback: true, session: options[:session]
           end
         end
-
       end
-
     end
   end
 end