prometheus-splash 0.5.0 → 0.7.0

data/lib/splash/loggers/cli.rb

@@ -1,11 +1,17 @@
 # coding: utf-8
+
+# base Splash module
 module Splash
+
+  # Splash Loggers module
   module Loggers
 
+    # Cli specific logger
     class Cli < Splash::Loggers::LoggerTemplate
 
       include Splash::Config
 
+      # mapping of UTf-8 emoji for log levels or alias
       EMOJI =  { :unknown => "\u{1F4A5}",
                  :fatal => "\u{26D4}",
                  :error => "\u{1F6AB}",
@@ -22,6 +28,7 @@ module Splash
                  :success => "\u{1F4AA}",
                  :debug => "\u{1F41B}"}
 
+      # mapping of colors for log levels or alias
       COLORS = { :unknown => :red,
                  :fatal => :red,
                  :error => :red,
@@ -39,7 +46,11 @@ module Splash
                  :debug => :magenta}
 
 
-
+      # log wrapper
+      # @param [Hash] options
+      # @option options [Symbol] :level defined in Splash::Loggers::LEVEL or Splash::Loggers::ALIAS
+      # @option options [String] :message
+      # display formatted string to STDOUT
       def log(options)
         level = (ALIAS.keys.include? options[:level])?  ALIAS[options[:level]] : options[:level]
         if @active_levels.include? level then
@@ -59,14 +70,20 @@ module Splash
         end
       end
 
+      # setter in configuration for emoji display
+      # @param [Boolean] status
       def emoji=(status)
         get_config.loggers[:cli][:emoji] = status
       end
 
+      # setter in configuration for color display
+      # @param [Boolean] status
       def color=(status)
         get_config.loggers[:cli][:color] = status
       end
 
+      # check if unicode must be used with term ENV
+      # @return [Boolean]
       def check_unicode_term
         return false unless ENV.include? "TERM"
         if ENV.values_at("LC_ALL","LC_CTYPE","LANG").compact.first.include?("UTF-8") and ENV.values_at('TERM').first.include? "xterm" then
@@ -78,7 +95,5 @@ module Splash
 
     end
 
-    class BadLevel < Exception; end
-
   end
 end

data/lib/splash/loggers/daemon.rb

@@ -1,12 +1,17 @@
 # coding: utf-8
+
+# base Splash module
 module Splash
-  module Loggers
 
+  # Splash Loggers module
+  module Loggers
 
+    # Daemon specific logger
     class Daemon < Splash::Loggers::LoggerTemplate
 
 
-
+      # contructor, open log file
+      # @return [Splash::Loggers::Daemon]
       def initialize
         self.level = get_config.loggers[:level]
         @log_file = get_config.loggers[:daemon][:file]
@@ -14,7 +19,12 @@ module Splash
         @stream.sync = true
       end
 
-
+      # log wrapper
+      # @param [Hash] options
+      # @option options [Symbol] :level defined in Splash::Loggers::LEVEL or Splash::Loggers::ALIAS
+      # @option options [String] :message
+      # @option options [String] :session a session number
+      # write formatted string to log file
       def log(options)
         pid = Process.pid.to_s
         date = DateTime.now.to_s
@@ -28,6 +38,7 @@ module Splash
         end
       end
 
+      # close log file descriptor
       def close
         @stream.close
       end

data/lib/splash/loggers/dual.rb

@@ -1,11 +1,31 @@
+# coding: utf-8
+
+# base Splash module
 module Splash
+
+  # Splash Loggers module
   module Loggers
 
-    class Dual < Splash::Loggers::LoggerTemplate
-      include Splash::Config
+    # Dual multiplexer specific logger
+    # log against CLi and Daemon
+    class Dual #< Splash::Loggers::LoggerTemplate
 
 
+      include Splash::Config
+
+      # build levels and alias forwarders
+      LEVELS.each do |method|
+        define_method(method) do |message,session = ''|
+            self.log({ :level => method, :message => message, :session => session})
+        end
+      end
+      ALIAS.keys.each do |method|
+        define_method(method) do |message,session = ''|
+            self.log({ :level => method, :message => message, :session => session})
+        end
+      end
 
+      # Constructor build two attributes for each loggers : Cli, Daemon
       def initialize
         super
         @log1 = Splash::Loggers::Cli::new
@@ -17,6 +37,19 @@ module Splash
         @log2.log options
       end
 
+      # getter for root level
+      # @return [Symbol] a level
+      def level
+        @level
+      end
+
+      # setter for global level, both Cli and Daemon
+      # @param [Symbol] level a level in Splash::Loggers::LEVELS or Splash::Loggers::ALIAS
+      def level=(level)
+        @level = level
+        @log1.level=level
+        @log2.level=level
+      end
     end
   end
 end

data/lib/splash/loggers/web.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+# base Splash module
+module Splash
+
+  # Splash Loggers module
+  module Loggers
+
+    # Web specific logger
+    class Web < Splash::Loggers::LoggerTemplate
+
+
+      # contructor, open log file
+      # @return [Splash::Loggers::Web]
+      def initialize
+        self.level = get_config.loggers[:level]
+        @log_file = get_config.loggers[:web][:file]
+        @stream = File::open(@log_file, 'a')
+        @stream.sync = true
+      end
+
+      # log wrapper
+      # @param [Hash] options
+      # @option options [Symbol] :level defined in Splash::Loggers::LEVEL or Splash::Loggers::ALIAS
+      # @option options [String] :message
+      # @option options [String] :session a session number
+      # write formatted string to log file
+      def log(options)
+        pid = Process.pid.to_s
+        date = DateTime.now.to_s
+        level = (ALIAS.keys.include? options[:level])?  ALIAS[options[:level]] : options[:level]
+        if @active_levels.include? level then
+          unless options[:session].empty? then
+            @stream.puts "[#{date}] (#{pid}) (#{options[:session]}) #{alt(options[:level])} : #{options[:message]}"
+          else
+            @stream.puts "[#{date}] (#{pid}) #{alt(options[:level])} : #{options[:message]}"
+          end
+        end
+      end
+
+      # close log file descriptor
+      def close
+        @stream.close
+      end
+
+
+
+    end
+
+  end
+end

data/lib/splash/logs.rb

@@ -1,68 +1,81 @@
 # coding: utf-8
+
+# base Splash module
 module Splash
-  class LogScanner
-    include Splash::Constants
-    include Splash::Config
 
+  # Logs namespace
+  module Logs
 
-    # LogScanner Constructor
-    # return [LogScanner]
-    def initialize
-      @logs_target = get_config.logs
-      @config = get_config
-      @registry = Prometheus::Client.registry
-      @metric_count = Prometheus::Client::Gauge.new(:logerrors, docstring: 'SPLASH metric log error', labels: [:log ])
-      @metric_missing = Prometheus::Client::Gauge.new(:logmissing, docstring: 'SPLASH metric log missing', labels: [:log ])
-      @metric_lines = Prometheus::Client::Gauge.new(:loglines, docstring: 'SPLASH metric log lines numbers', labels: [:log ])
-      @registry.register(@metric_count)
-      @registry.register(@metric_missing)
-      @registry.register(@metric_lines)
-    end
+    # Log scanner and notifier
+    class LogScanner
+      include Splash::Constants
+      include Splash::Config
 
 
-    # start log analyse for log target in config
-    def analyse
-      @logs_target.each do |record|
-        record[:count]=0 if record[:count].nil?
-        record[:status] = :clean if record[:status].nil?
-        if File.exist?(record[:log]) then
-          record[:count] = File.readlines(record[:log]).grep(/#{record[:pattern]}/).size
-          record[:status] = :matched if record[:count] > 0
-          record[:lines] = `wc -l "#{record[:log]}"`.strip.split(/\s+/)[0].to_i unless record[:status] == :missing
-        else
-          record[:status] = :missing
-        end
+      # LogScanner Constructor : initialize prometheus metrics
+      # return [Splash::Logs::LogScanner]
+      def initialize
+        @logs_target = Marshal.load(Marshal.dump(get_config.logs))
+        @config = get_config
+        @registry = Prometheus::Client::Registry::new
+        @metric_count = Prometheus::Client::Gauge.new(:logerrors, docstring: 'SPLASH metric log error', labels: [:log ])
+        @metric_missing = Prometheus::Client::Gauge.new(:logmissing, docstring: 'SPLASH metric log missing', labels: [:log ])
+        @metric_lines = Prometheus::Client::Gauge.new(:loglines, docstring: 'SPLASH metric log lines numbers', labels: [:log ])
+        @registry.register(@metric_count)
+        @registry.register(@metric_missing)
+        @registry.register(@metric_lines)
       end
-      return {:case => :quiet_exit }
-    end
 
-    # pseudo-accessor on @logs_target
-    def output
-      return @logs_target
-    end
 
-    # start notification on prometheus for metric logerrors, logmissing; loglines
-    def notify(options = {})
-      log = get_logger
-      unless verify_service host: @config.prometheus_pushgateway_host ,port: @config.prometheus_pushgateway_port then
-        return  { :case => :service_dependence_missing, :more => "Prometheus Notification not send." }
+      # start log analyse for log target in config
+      # @return [Hash] Exiter case :quiet_exit
+      def analyse
+        @logs_target.each do |record|
+          record[:count]=0 if record[:count].nil?
+          record[:status] = :clean if record[:status].nil?
+          if File.exist?(record[:log]) then
+            record[:count] = File.readlines(record[:log]).grep(/#{record[:pattern]}/).size
+            record[:status] = :matched if record[:count] > 0
+            record[:lines] = `wc -l "#{record[:log]}"`.strip.split(/\s+/)[0].to_i unless record[:status] == :missing
+          else
+            record[:status] = :missing
+          end
+        end
+        return {:case => :quiet_exit }
       end
-      session = (options[:session]) ? options[:session] : log.get_session
-      log.info "Sending metrics to Prometheus Pushgateway", session
-      @logs_target.each do |item|
-        missing = (item[:status] == :missing)? 1 : 0
-        log.item "Sending metrics for #{item[:log]}", session
-        @metric_count.set(item[:count], labels: { log: item[:log] })
-        @metric_missing.set(missing, labels: { log: item[:log] })
-        lines = (item[:lines])? item[:lines] : 0
-        @metric_lines.set(lines, labels: { log: item[:log] })
+
+      # pseudo-accessor on @logs_target
+      # @return [Hash] the logs structure
+      def output
+        return @logs_target
+      end
+
+      # start notification on prometheus for metric logerrors, logmissing; loglines
+      # @param [Hash] options
+      # @option options [String] :session a session number for log daemon
+      # @return [Hash] Exiter case :quiet_exit
+      def notify(options = {})
+        log = get_logger
+        unless verify_service url: @config.prometheus_pushgateway_url then
+          return  { :case => :service_dependence_missing, :more => "Prometheus Notification not send." }
+        end
+        session = (options[:session]) ? options[:session] : log.get_session
+        log.info "Sending metrics to Prometheus Pushgateway", session
+        @logs_target.each do |item|
+          missing = (item[:status] == :missing)? 1 : 0
+          log.item "Sending metrics for #{item[:log]}", session
+          @metric_count.set(item[:count], labels: { log: item[:log] })
+          @metric_missing.set(missing, labels: { log: item[:log] })
+          lines = (item[:lines])? item[:lines] : 0
+          @metric_lines.set(lines, labels: { log: item[:log] })
+        end
+        hostname = Socket.gethostname
+        url = @config.prometheus_pushgateway_url
+        Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
+        log.ok "Sending to Prometheus PushGateway done.", session
+        return {:case => :quiet_exit }
       end
-      hostname = Socket.gethostname
-      url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
-      Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
-      log.ok "Sending to Prometheus PushGateway done.", session
-      return {:case => :quiet_exit }
-    end
 
+    end
   end
 end

data/lib/splash/processes.rb

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+# base Splash Module
+module Splash
+
+  # Processes namespace
+  module Processes
+
+    # Processes scanner and notifier
+    class ProcessScanner
+      include Splash::Constants
+      include Splash::Config
+
+
+      # ProcessScanner Constructor : initialize prometheus metrics
+      # @return [Splash::Processes::ProcessScanner]
+      def initialize
+        @processes_target = Marshal.load(Marshal.dump(get_config.processes))
+        @config = get_config
+        @registry = Prometheus::Client::Registry::new
+        @metric_status = Prometheus::Client::Gauge.new(:process_status, docstring: 'SPLASH metric process status', labels: [:process ])
+        @metric_cpu_percent = Prometheus::Client::Gauge.new(:process_cpu_percent, docstring: 'SPLASH metric process CPU usage in percent', labels: [:process ])
+        @metric_mem_percent = Prometheus::Client::Gauge.new(:process_mem_percent, docstring: 'SPLASH metric process MEM usage in percent', labels: [:process ])
+        @registry.register(@metric_status)
+        @registry.register(@metric_cpu_percent)
+        @registry.register(@metric_mem_percent)
+
+      end
+
+
+      # start process analyse for process target in config
+      # @return [Hash] Exiter case :quiet_exit
+      def analyse
+        @processes_target.each do |record|
+          list =  get_processes patterns: record[:patterns], full: true
+          if list.empty?
+            record[:status] = :inexistant
+            record[:cpu] = 0
+            record[:mem] = 0
+          else
+            record[:status] = :running
+            record[:cpu] = list[0]['%CPU']
+            record[:mem] = list[0]['%MEM']
+          end
+        end
+        return {:case => :quiet_exit }
+      end
+
+      # pseudo-accessor on @processes_target
+      # @return [Hash] the processes structure
+      def output
+        return @processes_target
+      end
+
+      # start notification on prometheus for metrics
+      # @param [Hash] options
+      # @option options [String] :session a session number for log daemon
+      # @return [Hash] Exiter case :quiet_exit
+      def notify(options = {})
+        log = get_logger
+        unless verify_service url: @config.prometheus_pushgateway_url then
+          return  { :case => :service_dependence_missing, :more => "Prometheus Notification not send." }
+        end
+        session = (options[:session]) ? options[:session] : log.get_session
+        log.info "Sending metrics to Prometheus Pushgateway", session
+        @processes_target.each do |item|
+          missing = (item[:status] == :missing)? 1 : 0
+          log.item "Sending metrics for #{item[:process]}", session
+          val = (item[:status] == :running )? 1 : 0
+          @metric_status.set(val, labels: { process: item[:process] })
+          @metric_cpu_percent.set(item[:cpu], labels: { process: item[:process] })
+          @metric_mem_percent.set(item[:mem], labels: { process: item[:process] })
+        end
+        hostname = Socket.gethostname
+        url = @config.prometheus_pushgateway_url
+        Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
+        log.ok "Sending to Prometheus PushGateway done.", session
+        return {:case => :quiet_exit }
+      end
+
+    end
+  end
+end

data/lib/splash/sequences.rb

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+# base Splash module
+module Splash
+
+  # Splash Commands module/namespace
+  module Sequences
+
+    include Splash::Commands
+    include Splash::Config
+    include Splash::Loggers
+    include Splash::Exiter
+    include Splash::Transports
+
+    def run_seq(params = {})
+      list = get_config.sequences
+      name = params[:name].to_sym
+      acase = {}
+      seq_res = []
+      log = get_logger
+      log.info "beginnning Sequence execution : #{name}"
+      session = (params[:session])? params[:session] : get_session
+      if list.include? name then
+        seq_options = (list[name][:options].nil?)? {} : list[name][:options]
+        list[name][:definition].each do |step|
+          log.info "STEP : #{step[:step]}",session
+          if step[:on_host].nil? then
+            command =  CommandWrapper::new(step[:command].to_s)
+              step[:callback] = true if step[:callback].nil?
+              step[:trace] = true if step[:trace].nil?
+              step[:notify] = true if step[:notify].nil?
+              step[:session] = session
+              acase = command.call_and_notify step
+          else
+            log.info "Remote execution of #{step[:command]} on #{step[:on_host]}", session
+            begin
+              transport = get_default_client
+              if transport.class == Hash  and transport.include? :case then
+                return transport
+              else
+                acase = transport.execute({ :verb => :execute_command,
+                                          payload: {:name => step[:command].to_s},
+                                         :return_to => "splash.#{Socket.gethostname}.return",
+                                         :queue => "splash.#{step[:on_host]}.input" })
+                log.receive "return with exitcode #{acase[:exit_code]}", session
+              end
+            rescue Interrupt
+              acase = { case: :interrupt, more: "Remote command exection", exit_code: 33}
+            end
+
+           end
+           seq_res.push acase[:exit_code]
+           continue = (seq_options[:continue].nil?)? true : seq_options[:continue]
+           if acase[:exit_code] > 0 and continue == false then
+             acase[:more] = "Break execution on error, continue = false"
+             break
+           end
+        end
+      else
+        return  { :case => :not_found, :more => "Sequence #{name} not configured" }
+      end
+
+      if seq_res.select {|res| res > 0}.count == seq_res.count then
+        acase =  { case: :status_ko, more: "all execution failed" }
+      elsif seq_res.select {|res| res > 0}.count > 0 then
+        acase =  { case: :status_ko, more: "some execution failed" }
+      else
+        acase =  { case: :status_ok, more: "all execution successed" }
+      end
+      acase[:more] << " with remote call interrupt" if seq_res.include?(33)
+      return acase
+    end
+
+
+    def list_seq(options = {})
+      list = get_config.sequences
+      unless list.empty?
+        acase = { :case =>  :quiet_exit , :more => "List configured sequences"}
+        acase[:data] = list
+        return acase
+      else
+        return { :case => :not_found, :more => 'No sequences configured' }
+      end
+    end
+
+    def show_seq(options = {})
+      list = get_config.sequences
+      name = options[:name].to_sym
+      if list.include? name then
+        acase = { :case => :quiet_exit, :more => "Show specific sequence : #{name}"}
+        acase[:data] = list[name]
+      else
+        return { :case => :not_found, :more => "Sequence #{name} not configured" }
+      end
+      return acase
+    end
+
+    def schedule_seq(options = {})
+      acase = { :case => :quiet_exit,  :more => "schedule" }
+      return acase
+
+    end
+
+  end
+end