prometheus-splash 0.8.0 → 0.8.5

data/lib/splash/cli/process.rb

@@ -12,65 +12,77 @@ module CLISplash
     # Thor method : unning Splash configured processes monitors analyse
     desc "analyse", "analyze processes defined in Splash config"
     def analyse
-      log  = get_logger
-      results = ProcessScanner::new
-      res = results.analyse
-      log.info "Splash Configured process records :"
-      full_status = true
-      results.output.each do |result|
-        if result[:status] == :running then
-          log.ok "Process : #{result[:process]} : running"
-          log.item "Detected patterns : "
-          result[:patterns].each do |pattern|
-            log.arrow "/#{pattern}/"
+      if is_root? then
+        log  = get_logger
+        results = ProcessScanner::new
+        res = results.analyse
+        log.info "Splash Configured process records :"
+        full_status = true
+        results.output.each do |result|
+          if result[:status] == :running then
+            log.ok "Process : #{result[:process]} : running"
+            log.item "Detected patterns : "
+            result[:patterns].each do |pattern|
+              log.arrow "/#{pattern}/"
+            end
+            log.item "CPU usage in % : #{result[:cpu]} "
+            log.item "Memory usage in % : #{result[:mem]} "
+          else
+            log.ko "Process : #{result[:process]} : inexistant"
+            log.item "Detected patterns : "
+            result[:patterns].each do |pattern|
+              log.arrow "/#{pattern}/"
+            end
           end
-          log.item "CPU usage in % : #{result[:cpu]} "
-          log.item "Memory usage in % : #{result[:mem]} "
-        else
-          log.ko "Process : #{result[:process]} : inexistant"
-          log.item "Detected patterns : "
-          result[:patterns].each do |pattern|
-            log.arrow "/#{pattern}/"
-          end
-        end
 
-        full_status = false unless result[:status] == :running
-      end
+          full_status = false unless result[:status] == :running
+        end
 
-      if full_status then
-        log.ok "Global status : no error found"
+        if full_status then
+          log.ok "Global status : no error found"
+        else
+          log.error "Global status : some error found"
+        end
+        splash_exit case: :quiet_exit
       else
-        log.error "Global status : some error found"
+        splash_exit case: :not_root, :more => "Process analysis"
       end
-      splash_exit case: :quiet_exit
     end
 
 
     # Thor method : running Splash configured processes monitors analyse and sending to Prometheus Pushgateway
     desc "monitor", "monitor processes defined in Splash config"
     def monitor
-      log = get_logger
-      log.level = :fatal if options[:quiet]
-      result = ProcessScanner::new
-      result.analyse
-      splash_exit result.notify
+      if is_root? then
+        log = get_logger
+        log.level = :fatal if options[:quiet]
+        result = ProcessScanner::new
+        result.analyse
+        splash_exit result.notify
+      else
+        splash_exit case: :not_root, :more => "Process analysis"
+      end
     end
 
     # Thor method : display a specific Splash configured process monitor
     desc "show PROCESS", "show Splash configured process record for PROCESS"
     def show(record)
-      log = get_logger
-      process_recordset = get_config.processes.select{|item| item[:process] == record }
-      unless process_recordset.empty? then
-        record = process_recordset.first
-        log.item "Process monitor : #{record[:process]}"
-        log.arrow "patterns :"
-        record[:patterns].each do |pattern|
-          log.flat "   - /#{pattern}/"
+      if is_root? then
+        log = get_logger
+        process_recordset = get_config.processes.select{|item| item[:process] == record }
+        unless process_recordset.empty? then
+          record = process_recordset.first
+          log.item "Process monitor : #{record[:process]}"
+          log.arrow "patterns :"
+          record[:patterns].each do |pattern|
+            log.flat "   - /#{pattern}/"
+          end
+          splash_exit case: :quiet_exit
+        else
+          splash_exit case: :not_found, :more => "Process not configured"
         end
-        splash_exit case: :quiet_exit
       else
-        splash_exit case: :not_found, :more => "Process not configured"
+        splash_exit case: :not_root, :more => "Process analysis"
       end
     end
 
@@ -82,20 +94,101 @@ module CLISplash
     LONGDESC
     option :detail, :type => :boolean,  :aliases => "-D"
     def list
-      log = get_logger
-      log.info "Splash configured process records :"
-      process_recordset = get_config.processes
-      log.ko 'No configured process found' if process_recordset.empty?
-      process_recordset.each do |record|
-        log.item "Process monitor : #{record[:process]}"
-        if options[:detail] then
-          log.arrow "patterns :"
-          record[:patterns].each do |pattern|
-            log.flat "   - /#{pattern}/"
+      if is_root? then
+        log = get_logger
+        log.info "Splash configured process records :"
+        process_recordset = get_config.processes
+        log.ko 'No configured process found' if process_recordset.empty?
+        process_recordset.each do |record|
+          log.item "Process monitor : #{record[:process]}"
+          if options[:detail] then
+            log.arrow "patterns :"
+            record[:patterns].each do |pattern|
+              log.flat "   - /#{pattern}/"
+            end
           end
         end
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_root, :more => "Process analysis"
+      end
+    end
+
+    # Thor method : display the full list of Splash configured process monitors
+    desc "get_result PROCESS", "Get last or specific process monitoring report"
+    long_desc <<-LONGDESC
+    Get last or specific process monitoring report\n
+    with --date <DATE>, a date format string (same as in history ouput)
+    LONGDESC
+    option :date, :type => :string,  :aliases => "-D"
+    def get_result(process)
+      if is_root? then
+        log = get_logger
+        log.info "Process : #{process}"
+        config = get_config
+        records = ProcessRecords::new(process).get_all_records
+        if options[:date] then
+          wanted = records.select{|key,value| key.keys.first == options[:date]}.first
+        else
+          wanted = records.last
+        end
+        if wanted.nil? then
+          splash_exit case: :not_found, more: "Process never monitored"
+        else
+          record =wanted.keys.first
+          value=wanted[record]
+          log.item record
+          log.arrow "Status : #{value[:status].to_s}"
+          log.arrow "CPU Percent : #{value[:cpu_percent]}"
+          log.arrow "MEM Percent : #{value[:mem_percent]}"
+        end
+      else
+        splash_exit case: :not_root, :more => "Process get result"
+      end
+    end
+
+
+    # Thor method : show logs monitoring history
+    long_desc <<-LONGDESC
+    show Process monitoring history for LABEL\n
+    LONGDESC
+    option :table, :type => :boolean,  :aliases => "-t"
+    desc "history PROCESS", "show process monitoring history"
+    def history(process)
+      if is_root? then
+        log = get_logger
+        log.info "Process : #{process}"
+        config = get_config
+        if options[:table] then
+          table = TTY::Table.new do |t|
+            t << ["Start Date", "Status", "CPU Percent", "MEM Percent"]
+            t << ['','','','']
+            ProcessRecords::new(process).get_all_records.each do |item|
+              record =item.keys.first
+              value=item[record]
+              t << [record, value[:status].to_s, value[:cpu_percent], value[:mem_percent]]
+            end
+          end
+          if check_unicode_term  then
+            puts table.render(:unicode)
+          else
+            puts table.render(:ascii)
+          end
+
+        else
+          ProcessRecords::new(process).get_all_records.each do |item|
+            record =item.keys.first
+            value=item[record]
+            log.item record
+            log.arrow "Status : #{value[:status].to_s}"
+            log.arrow "CPU Percent : #{value[:cpu_percent]}"
+            log.arrow "MEM Percent : #{value[:mem_percent]}"
+          end
+        end
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_root, :more => "Process analysis"
       end
-      splash_exit case: :quiet_exit
     end
 
   end

data/lib/splash/cli/transfers.rb

@@ -44,7 +44,10 @@ module CLISplash
       log = get_logger
       log.item "Transfer : #{name}"
       config = get_config
-      data = TxRecords::new(name).get_all_records.select {|record,value| record == options[:date]}.first
+      data = TxRecords::new(name).get_all_records.select {|item|
+        record =item.keys.first
+        value=item[record]
+        record == options[:date]}.first
       if data.nil? then
         log.ko "Result for #{name} on date #{options[:date]} not found"
         splash_exit case: :not_found, :more => "Result inexistant"
@@ -93,7 +96,9 @@ module CLISplash
         table = TTY::Table.new do |t|
           t << ["Start Date", "End date", "time", "Files count","File count error","Status"]
           t << ['','','','','','']
-          TxRecords::new(name).get_all_records.each do |record,value|
+          TxRecords::new(name).get_all_records.each do |item|
+            record =item.keys.first
+            value=item[record]
             start_date = record
             end_date = (value[:end_date].nil?)? '': value[:end_date]
             time  = (value[:time].nil?)? '': value[:time]
@@ -111,7 +116,9 @@ module CLISplash
         end
 
       else
-        TxRecords::new(name).get_all_records.each do |record,value|
+        TxRecords::new(name).get_all_records.each do |item|
+          record =item.keys.first
+          value=item[record]
           failed = (value[:count].nil? or value[:done].nil?)? 'undef': value[:count].to_i - value[:done].count
           if value[:end_date].nil? then
             log.item "Event : #{record} STATUS : #{value[:status]}"

data/lib/splash/commands.rb

@@ -6,6 +6,83 @@ module Splash
   # Splash Commands module/namespace
   module Commands
 
+
+    class CmdNotifier
+
+      @@registry = Prometheus::Client::Registry::new
+      @@metric_exitcode = Prometheus::Client::Gauge.new(:exitcode, docstring: 'SPLASH metric batch exitcode')
+      @@metric_time = Prometheus::Client::Gauge.new(:exectime, docstring: 'SPLASH metric batch execution time')
+      @@registry.register(@@metric_exitcode)
+      @@registry.register(@@metric_time)
+
+
+
+      def initialize(options={})
+        @config = get_config
+        @url = @config.prometheus_pushgateway_url
+        @name = "cmd_#{options[:name].to_s}"
+        @exitcode = options[:exitcode]
+        @time = options[:time]
+      end
+
+      # send metrics to Prometheus PushGateway
+      # @return [Bool]
+      def notify
+        unless verify_service url: @url then
+          return { :case => :service_dependence_missing, :more => "Prometheus Notification not send."}
+        end
+        @@metric_exitcode.set(@exitcode)
+        @@metric_time.set(@time)
+        hostname = Socket.gethostname
+        return Prometheus::Client::Push.new(@name, hostname, @url).add(@@registry)
+      end
+
+    end
+
+
+    class CmdRecords
+      include Splash::Backends
+      include Splash::Constants
+      def initialize(name)
+        @name = name
+        @backend = get_backend :execution_trace
+      end
+
+
+      def clear
+        @backend.del({:key => @name}) if  @backend.exist?({key: @name})
+      end
+
+      def purge(retention)
+        retention = {} if retention.nil?
+        if retention.include? :hours then
+          adjusted_datetime = DateTime.now - retention[:hours].to_f / 24
+        elsif retention.include? :hours then
+          adjusted_datetime = DateTime.now - retention[:days].to_i
+        else
+          adjusted_datetime = DateTime.now - DEFAULT_RETENTION
+        end
+
+        data = get_all_records
+
+        data.delete_if { |item|
+          DateTime.parse(item.keys.first) <= (adjusted_datetime)}
+        @backend.put key: @name, value: data.to_yaml
+      end
+
+      def add_record(record)
+        data = get_all_records
+        data.push({ DateTime.now.to_s => record })
+        @backend.put key: @name, value: data.to_yaml
+      end
+
+      def get_all_records(options={})
+        return (@backend.exist?({key: @name}))? YAML::load(@backend.get({key: @name})) : []
+      end
+
+    end
+
+
     # command execution wrapper
     class CommandWrapper
       include Splash::Templates
@@ -16,11 +93,7 @@ module Splash
       include Splash::Transports
 
 
-      @@registry = Prometheus::Client::Registry::new
-      @@metric_exitcode = Prometheus::Client::Gauge.new(:errorcode, docstring: 'SPLASH metric batch errorcode')
-      @@metric_time = Prometheus::Client::Gauge.new(:exectime, docstring: 'SPLASH metric batch execution time')
-      @@registry.register(@@metric_exitcode)
-      @@registry.register(@@metric_time)
+
 
       # Constructor
       # @param [String] name the name of the command
@@ -28,7 +101,7 @@ module Splash
         @config  = get_config
         @url = @config.prometheus_pushgateway_url
         @name = name
-        unless @config.commands.keys.include? @name.to_sym then
+        unless @config.commands.select{|cmd| cmd[:name] == @name.to_sym }.count > 0 then
           splash_exit case: :not_found, more: "command #{@name} is not defined in configuration"
         end
       end
@@ -43,14 +116,17 @@ module Splash
       # @param [String] value numeric.to_s
       # @param [String] time execution time numeric.to_s
       # @return [Hash] Exiter case :quiet_exit
-      def notify(value,time)
+      def notify(value,time, session)
+        log = get_logger
         unless verify_service url: @config.prometheus_pushgateway_url then
           return { :case => :service_dependence_missing, :more => "Prometheus Notification not send."}
         end
-        @@metric_exitcode.set(value)
-        @@metric_time.set(time)
-        hostname = Socket.gethostname
-        Prometheus::Client::Push.new(@name, hostname, @url).add(@@registry)
+        cmdmonitor = CmdNotifier::new({name: @name, exitcode: value, time: time})
+        if cmdmonitor.notify then
+          log.ok "Sending metrics to Prometheus Pushgateway",session
+        else
+          log.ko "Failed to send metrics to Prometheus Pushgateway",session
+        end
         return { :case => :quiet_exit}
       end
 
@@ -68,18 +144,20 @@ module Splash
         session = (options[:session])? options[:session] : get_session
         acase = { :case => :quiet_exit }
         exit_code = 0
-        if @config.commands[@name.to_sym][:delegate_to] then
+        command = @config.commands.select{|command| command[:name] == @name.to_sym}.first
+        if command[:delegate_to] then
           return { :case => :options_incompatibility, :more => '--hostname forbidden with delagate commands'} if options[:hostname]
-          log.send "Remote command : #{@name} execution delegate to : #{@config.commands[@name.to_sym][:delegate_to][:host]} as : #{@config.commands[@name.to_sym][:delegate_to][:remote_command]}", session
+          log.send "Remote command : #{@name} execution delegate to : #{command[:delegate_to][:host]} as : #{command[:delegate_to][:remote_command]}", session
+          log.warn "Local command : #{command[:command]} defined but ignored, because delegate have the priority"
           begin
             transport = get_default_client
             if transport.class == Hash  and transport.include? :case then
               return transport
             else
               res = transport.execute({ :verb => :execute_command,
-                payload: {:name => @config.commands[@name.to_sym][:delegate_to][:remote_command].to_s},
+                payload: {:name => command[:delegate_to][:remote_command].to_s},
                 :return_to => "splash.#{Socket.gethostname}.return",
-                :queue => "splash.#{@config.commands[@name.to_sym][:delegate_to][:host]}.input" })
+                :queue => "splash.#{command[:delegate_to][:host]}.input" })
               exit_code = res[:exit_code]
               log.receive "return with exitcode #{exit_code}", session
 
@@ -93,70 +171,67 @@ module Splash
           start_date = DateTime.now.to_s
           unless options[:trace] then
             log.item "Traceless execution", session
-            if @config.commands[@name.to_sym][:user] then
-              log.item "Execute with user : #{@config.commands[@name.to_sym][:user]}.", session
-              system("sudo -u #{@config.commands[@name.to_sym][:user]} #{@config.commands[@name.to_sym][:command]} > /dev/null 2>&1")
+            if command[:user] then
+              log.item "Execute with user : #{command[:user]}.", session
+              system("sudo -u #{command[:user]} #{command[:command]} > /dev/null 2>&1")
             else
-              system("#{@config.commands[@name.to_sym][:command]} > /dev/null 2>&1")
+              system("#{command[:command]} > /dev/null 2>&1")
             end
             time = Time.now - start
             exit_code = $?.exitstatus
           else
             log.item "Tracefull execution", session
-            if @config.commands[@name.to_sym][:user] then
-              log.item "Execute with user : #{@config.commands[@name.to_sym][:user]}.", session
-              stdout, stderr, status = Open3.capture3("sudo -u #{@config.commands[@name.to_sym][:user]} #{@config.commands[@name.to_sym][:command]}")
+            if command[:user] then
+              log.item "Execute with user : #{command[:user]}.", session
+              stdout, stderr, status = Open3.capture3("sudo -u #{command[:user]} #{command[:command]}")
             else
-              stdout, stderr, status = Open3.capture3(@config.commands[@name.to_sym][:command])
+              stdout, stderr, status = Open3.capture3(command[:command])
             end
             time = Time.now - start
-            tp = Template::new(
-              list_token: @config.execution_template_tokens,
-              template_file: @config.execution_template_path)
             data = Hash::new
             data[:start_date] = start_date
             data[:end_date] = DateTime.now.to_s
             data[:cmd_name] = @name
-            data[:cmd_line] = @config.commands[@name.to_sym][:command]
-            data[:desc] = @config.commands[@name.to_sym][:desc]
+            data[:cmd_line] = command[:command]
+            data[:desc] = command[:desc]
             data[:status] = status.to_s
             data[:stdout] = stdout
             data[:stderr] = stderr
             data[:exec_time] = time.to_s
-            backend = get_backend :execution_trace
-            key = @name
-
-            backend.put key: key, value: data.to_yaml
+            cmdrec = CmdRecords::new @name
+            cmdrec.purge(command[:retention])
+            cmdrec.add_record data
             exit_code = status.exitstatus
           end
           log.ok "Command executed", session
           log.arrow "exitcode #{exit_code}", session
           if options[:notify] then
-            acase = notify(exit_code,time.to_i)
-            get_logger.ok "Prometheus Gateway notified.",session
+            acase = notify(exit_code,time.to_i,session)
           else
             log.item "Without Prometheus notification", session
           end
         end
         if options[:callback] then
-          on_failure = (@config.commands[@name.to_sym][:on_failure])? @config.commands[@name.to_sym][:on_failure] : false
-          on_success = (@config.commands[@name.to_sym][:on_success])? @config.commands[@name.to_sym][:on_success] : false
+          on_failure = (command[:on_failure])? command[:on_failure] : false
+          on_success = (command[:on_success])? command[:on_success] : false
           if on_failure and exit_code > 0 then
             log.item "On failure callback : #{on_failure}", session
-            if @config.commands.keys.include?  on_failure then
+            if @config.commands.select {|item| item[:name] == on_failure}.count > 0 then
               @name = on_failure.to_s
               call_and_notify options
             else
-              acase = { :case => :configuration_error , :more => "on_failure call error : #{on_failure} command inexistant."}
+              log.error "on_failure call error : #{on_failure.to_s} command inexistant.", session
+              acase = { :case => :configuration_error , :more => "Command #{command[:name]} callback coniguration error"}
             end
           end
           if on_success and exit_code == 0 then
             log.item "On success callback : #{on_success}", session
-            if @config.commands.keys.include?  on_success then
+            if @config.commands.select {|item| item[:name] == on_success}.count > 0 then
               @name = on_success.to_s
               call_and_notify options
             else
-              acase = { :case => :configuration_error , :more => "on_success call error : #{on_failure} command inexistant."}
+              log.error "on_success call error : #{on_success.to_s} command inexistant."
+              acase = { :case => :configuration_error , :more => "Command #{command[:name]} callback coniguration error"}
             end
           end
         else