prometheus-splash 0.8.3 → 0.8.4

data/config/splash.yml

@@ -142,7 +142,7 @@
       :patterns:
         - cron
       :retention:
-          :hours: 5
+        :hours: 5
 
 
 ###

data/lib/splash/backends.rb

@@ -11,7 +11,7 @@ module Splash
 
     # factory for backend
     # @param [Symbol] store the name of the store actually in [:execution_trace]
-    # @return [Splash::Backends::<Type>|Hash] with type in [:redis,:file] or Exiter case :configuration_error 
+    # @return [Splash::Backends::<Type>|Hash] with type in [:redis,:file] or Exiter case :configuration_error
     def get_backend(store)
       splash_exit case: :configuration_error, more: "backend definition failure" if get_config[:backends][:stores][store].nil?
       backend = get_config[:backends][:stores][store][:type].to_s
@@ -23,5 +23,11 @@ module Splash
       end
     end
 
+    # return list of configured backand
+    # @return [Hash] the backends hash list/structure
+    def list_backends
+      return get_config[:backends][:stores]
+    end
+
   end
 end

data/lib/splash/backends/file.rb

@@ -54,7 +54,7 @@ module Splash
       # @option options [Symbol] :key the name of the record
       # @return [Boolean] status of the operation
       def del(options)
-        ::File.unlink("#{@path}/#{suffix_trace(options[:key])}") if File.exist?("#{@path}/#{suffix_trace(options[:key])}")
+        ::File.unlink("#{@path}/#{suffix_trace(options[:key])}") if ::File.exist?("#{@path}/#{suffix_trace(options[:key])}")
       end
 
       # verifiy a specific record existance

data/lib/splash/cli/commands.rb

@@ -15,7 +15,7 @@ module CLISplash
 
 
     # Thor method : execution of command
-    desc "execute NAME", "run for command/sequence or ack result"
+    desc "execute COMMAND", "run for command/sequence or ack result"
     long_desc <<-LONGDESC
     execute command or sequence or ack result\n
     with --no-trace prevent storing execution trace in configured backend (see config file)\n
@@ -79,7 +79,7 @@ module CLISplash
 
 
     # Thor method : scheduling commands
-    desc "schedule NAME", "Schedule excution of command on Splash daemon"
+    desc "schedule COMMAND", "Schedule excution of command on Splash daemon"
     long_desc <<-LONGDESC
     Schedule excution of command on Splash daemon\n
     with --hostname, Schedule on an other Splash daemon via transport\n
@@ -125,7 +125,7 @@ module CLISplash
     end
 
     # Thor method : getting a treeview of sequence of commands
-    desc "treeview", "Show commands sequence tree"
+    desc "treeview COMMAND", "Show commands sequence tree"
     long_desc <<-LONGDESC
     Show commands sequence tree\n
     with --hostname, ask other Splash daemon via transport\n
@@ -284,11 +284,11 @@ module CLISplash
     show commands executions history for LABEL\n
     LONGDESC
     option :table, :type => :boolean,  :aliases => "-t"
-    desc "history LABEL", "show commands executions history"
+    desc "history COMMAND", "show commands executions history"
     def history(command)
       if is_root? then
         log = get_logger
-        log.info "Log : #{command}#"
+        log.info "Command : #{command}"
         config = get_config
         if options[:table] then
           table = TTY::Table.new do |t|
@@ -328,52 +328,8 @@ module CLISplash
       end
     end
 
-    # Thor method : getting information on the last execution of a command
-    desc "lastrun COMMAND", "Show last running result for specific configured command COMMAND"
-    long_desc <<-LONGDESC
-    Show last running result for specific configured command COMMAND\n
-    with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
-    LONGDESC
-    option :hostname, :type => :string,  :aliases => "-H"
-    def lastrun(command)
-      unless is_root? then
-        splash_exit case: :not_root, :more => "Command last execution report"
-      end
-      log = get_logger
-      backend = get_backend :execution_trace
-      redis = (backend.class == Splash::Backends::Redis)? true : false
-      if not redis and options[:hostname] then
-        splash_exit case: :specific_config_required, :more => "Redis backend is requiered for Remote execution report request"
-      end
-      splash_exit case: :not_root if not is_root? and not redis
-      list = get_config.commands.keys
-      if options[:hostname] then
-        options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
-        list = backend.list("*", options[:hostname]).map(&:to_sym)
-      end
-      if list.include? command.to_sym then
-        log.info "Splash command #{command} previous execution report:\n"
-        req  = { :key => command}
-        req[:hostname] = options[:hostname] if options[:hostname]
-        if backend.exist? req then
-          res = backend.get req
-          tp = Template::new(
-              list_token: get_config.execution_template_tokens,
-              template_file: get_config.execution_template_path)
-          tp.map YAML::load(res).last.values.first
-          log.flat tp.output
-        else
-          log.ko "Command not already runned."
-        end
-        splash_exit case: :quiet_exit
-      else
-        splash_exit case: :not_found, :more => "Command report never runned remotly" if options[:hostname]
-      end
-    end
-
-
     # Thor method : getting information on one specific execution of a command
-    desc "onerun COMMAND", "Show running result for specific configured command COMMAND"
+    desc "get_result COMMAND", "Show running result for specific configured command COMMAND"
     long_desc <<-LONGDESC
     Show specific running result for specific configured command COMMAND\n
     with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
@@ -381,8 +337,8 @@ module CLISplash
 
     LONGDESC
     option :hostname, :type => :string,  :aliases => "-H"
-    option :date, :type => :string,  :aliases => "-D", :required => true
-    def onerun(command)
+    option :date, :type => :string,  :aliases => "-D"
+    def get_result(command)
       unless is_root? then
         splash_exit case: :not_root, :more => "Command specific execution report"
       end
@@ -407,11 +363,15 @@ module CLISplash
           tp = Template::new(
               list_token: get_config.execution_template_tokens,
               template_file: get_config.execution_template_path)
-          prov =  YAML::load(res).select{|key,value| key.keys.first == options[:date]}
-          if prov.empty? then
+          if options[:date] then
+            prov =  YAML::load(res).select{|key,value| key.keys.first == options[:date]}.first
+          else
+            prov = YAML::load(res).last
+          end
+          if prov.nil? then
             log.ko "Command not runned one this date or date misformatted."
           else
-            tp.map prov.first.values.first
+            tp.map prov.values.first
             log.flat tp.output
           end
         else
@@ -419,12 +379,16 @@ module CLISplash
         end
         splash_exit case: :quiet_exit
       else
-        splash_exit case: :not_found, :more => "Command report never runned remotly" if options[:hostname]
+        if options[:hostname]
+            splash_exit case: :not_found, :more => "Command never runned remotly"
+          else
+            splash_exit case: :not_found, :more => "Command never runned"
+          end
       end
     end
 
     # Thor method : getting the list of avaibles executions reports
-    desc "getreportlist", "list all executions report results "
+    desc "reportlist", "list all executions report results "
     long_desc <<-LONGDESC
     list all executions report results\n
     with --pattern <SEARCH>, search type string, wilcard * (group) ? (char)\n
@@ -437,7 +401,7 @@ module CLISplash
     option :hostname, :type => :string,  :aliases => "-H"
     option :all, :type => :boolean, :negate => false,  :aliases => "-A"
     option :detail, :type => :boolean,  :aliases => "-D"
-    def getreportlist
+    def reportlist
       unless is_root? then
         splash_exit case: :not_root, :more => "Command execution report list"
       end

data/lib/splash/cli/config.rb

@@ -9,6 +9,7 @@ module CLISplash
     include Splash::Helpers
     include Splash::Exiter
     include Splash::Loggers
+    include Splash::Backends
 
     # Thor method : running of Splash setup
     desc "setup", "Setup installation fo Splash"
@@ -49,8 +50,18 @@ module CLISplash
 
     # Thor method : flushing configured backend
     desc "flushbackend", "Flush configured backend"
+    option :name, :type => :string,  :aliases => "-N"
     def flushbackend
-      acase = run_as_root :flush_backend
+      if options[:name] then
+        acase = run_as_root :flush_backend, options
+      else
+        return_cases = {}
+        list_backends.each do |key,value|
+          return_cases[key] = run_as_root :flush_backend, { :name => key }
+        end
+        errors = return_cases.select {|key,value| value[:case] != :quiet_exit}.keys
+        acase = (errors.empty?)? {:case => :quiet_exit, :more => "All backends flushed successfully"}: {:case => :configuration_error, :more => "Backends #{errors.join(',')} flushing failed"}
+      end
       splash_exit acase
     end
 

data/lib/splash/cli/logs.rb

@@ -63,10 +63,10 @@ module CLISplash
     end
 
 
-    
+
 
     # Thor method : display a specific Splash configured log monitor
-    desc "show LOG", "show Splash configured log monitoring for LOG"
+    desc "show LABEL", "show Splash configured log monitoring for LOG"
     def show(logrecord)
       if is_root? then
         log = get_logger
@@ -110,6 +110,38 @@ module CLISplash
       end
     end
 
+    # Thor method : display the full list of Splash configured log monitors
+    desc "get_result LABEL", "Get last or specific log monitoring report"
+    long_desc <<-LONGDESC
+    Get last or specific log 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(label)
+      if is_root? then
+        log = get_logger
+        log.info "Log : #{label}"
+        config = get_config
+        records = LogsRecords::new(label).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: "Log never monitored"
+        else
+          record =wanted.keys.first
+          value=wanted[record]
+          log.item record
+          log.arrow "Status : #{value[:status].to_s}"
+          log.arrow "nb files : #{value[:errors]}"
+          log.arrow "nb lines : #{value[:lines]}"
+        end
+      else
+        splash_exit case: :not_root, :more => "Log get result"
+      end
+    end
 
     # Thor method : show logs monitoring history
     long_desc <<-LONGDESC

data/lib/splash/cli/process.rb

@@ -114,6 +114,39 @@ module CLISplash
       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

data/lib/splash/config.rb

@@ -13,8 +13,10 @@ module Splash
 
     class ConfigLinter
       def initialize
-        @lints_present = {:logs => [:label, :log, :pattern ]}
-        @lints_types = {:logs => {:label => Symbol, :log => String, :pattern => String, :retention => Hash}}
+        @lints_present = {:logs => [:label, :log, :pattern ],
+                          :processes => [:process, :patterns ]}
+        @lints_types = {:logs => {:label => Symbol, :log => String, :pattern => String, :retention => Hash},
+                        :processes  => {:process => Symbol, :patterns => Array, :retention => Hash}}
       end
 
       def verify(options ={})
@@ -97,15 +99,16 @@ module Splash
       end
 
 
-      def add_log(options = {})
+      def add_record(options = {})
         @config_from_file = readconf @config_file
+        key = options[:key]
         res = ConfigLinter::new.verify(options)
         if res[:status] == :success then
-          if @config_from_file[:logs].select{|item| item[:label] == options[:record][:label]}.count > 0 then
+          if @config_from_file[options[:type]].select{|item| item[options[:key]] == options[:record][options[:key]]}.count > 0 then
             return {:status => :already_exist}
           else
             res[:useless].each {|item| options[:record].delete item} if options[:clean]
-            @config_from_file[:logs].push options[:record]
+            @config_from_file[options[:type]].push options[:record]
             writeconf
             hash_config_to_default
             return {:status => :success}
@@ -116,12 +119,12 @@ module Splash
       end
 
 
-      def delete_log(options = {})
+      def delete_record(options = {})
         @config_from_file = readconf @config_file
-        unless @config_from_file[:logs].select{|item| item[:label] == options[:label]}.count > 0 then
+        unless @config_from_file[options[:type]].select{|item| item[options[:key]] == options[options[:key]]}.count > 0 then
           return {:status => :not_found}
         else
-          @config_from_file[:logs].delete_if {|value| options[:label] == value[:label] }
+          @config_from_file[options[:type]].delete_if {|value| options[options[:key]] == value[options[:key]] }
           writeconf
           hash_config_to_default
           return {:status => :success}

data/lib/splash/config/flush.rb

@@ -16,8 +16,8 @@ module Splash
       self.extend Splash::Backends
       self.extend Splash::Loggers
       log = get_logger
-      log.info "Splash backend flushing"
-      name  = (options[:name])? options[:name] : :execution_trace
+      name  = (options[:name])? options[:name].to_sym : :execution_trace
+      log.info "Splash backend #{name.to_s} flushing"
       backend = get_backend name
       if backend.flush then
         return { :case => :quiet_exit, :more => "Splash backend #{name.to_s} flushed" }

data/lib/splash/constants.rb

@@ -7,7 +7,7 @@ module Splash
   module Constants
 
     # Current splash version
-    VERSION = "0.8.3"
+    VERSION = "0.8.4"
     # the path to th config file, not overridable by config
     CONFIG_FILE = "/etc/splash.yml"
     # the default execution trace_path if backend file

data/lib/splash/logs.rb

@@ -48,6 +48,10 @@ module Splash
         @backend = get_backend :logs_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
@@ -132,7 +136,7 @@ module Splash
           logsrec = LogsRecords::new item[:label]
           errors = (item[:count])? item[:count] : 0
           lines = (item[:lines])? item[:lines] : 0
-          missing = (item[:status] = :missing)? 1 : 0
+          missing = (item[:status] == :missing)? 1 : 0
           file = item[:log]
           logsrec.purge(item[:retention])
           logsrec.add_record :status => item[:status],

data/lib/splash/processes.rb

@@ -52,6 +52,10 @@ module Splash
         @backend = get_backend :process_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

data/lib/splash/webadmin/api/routes/config.rb

@@ -27,35 +27,77 @@ WebAdminApp.post '/api/config/addlog.?:format?' do
   addlog = {}
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
   log.call "API : config, verb : POST, route : addlog, format : #{format}"
-  res = get_config.add_log :record => YAML::load(request.body.read), :type => :logs, :clean => true
+  res = get_config.add_record :record => YAML::load(request.body.read), :key => :label, :type => :logs, :clean => true
   case res[:status]
   when :success
-    addlog = splash_return case: :quiet_exit, :more => "add logs"
+    addlog = splash_return case: :quiet_exit, :more => "add log done"
   when :already_exist
-    addlog = splash_return case: :already_exist, :more => "add logs"
+    addlog = splash_return case: :already_exist, :more => "add log twice nto allowed"
   when :failure
-    addlog = splash_return case: :configuration_error, :more => "add logs"
+    addlog = splash_return case: :configuration_error, :more => "add log failed"
     addlog[:data] = res
   end
   content_type format
   format_response(addlog, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
 
+WebAdminApp.post '/api/config/addprocess.?:format?' do
+  log = get_logger
+  addprocess = {}
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : config, verb : POST, route : addprocess, format : #{format}"
+  res = get_config.add_record :record => YAML::load(request.body.read), :type => :processes, :key => :process, :clean => true
+  case res[:status]
+  when :success
+    addprocess = splash_return case: :quiet_exit, :more => "add process done"
+  when :already_exist
+    addprocess = splash_return case: :already_exist, :more => "add process twice not allowed"
+  when :failure
+    addprocess = splash_return case: :configuration_error, :more => "add process failed"
+    addprocess[:data] = res
+  end
+  content_type format
+  format_response(addprocess, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end
+
+
 
 WebAdminApp.delete '/api/config/deletelog/:label.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
   log.call "API : config, verb : DELETE, route : deletelog, format : #{format}"
-  res = get_config.delete_log label: params[:label].to_sym
   deletelog = {}
+  logsrec = Splash::Logs::LogsRecords::new params[:label].to_sym
+  logsrec.clear
+  res = get_config.delete_record :type => :logs, key: :label, label: params[:label].to_sym
   case res[:status]
   when :success
-    deletelog = splash_return case: :quiet_exit, :more => "delete logs"
+    deletelog = splash_return case: :quiet_exit, :more => "delete log done"
   when :not_found
-    deletelog = splash_return case: :not_found, :more => "delete logs"
+    deletelog = splash_return case: :not_found, :more => "nothing done for logs"
   else
-    deletelog = splash_return case: :configuration_error, :more => "delete logs"
+    deletelog = splash_return case: :configuration_error, :more => "delete log failed"
   end
   content_type format
   format_response(deletelog, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
+
+WebAdminApp.delete '/api/config/deleteprocess/:process.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : config, verb : DELETE, route : deleteprocess, format : #{format}"
+  deleteprocess = {}
+  procrec = Splash::Processes::ProcessRecords::new params[:process].to_sym
+  procrec.clear
+  res = get_config.delete_record :type => :processes, :key => :process, process: params[:process].to_sym
+  case res[:status]
+  when :success
+    deleteprocess = splash_return case: :quiet_exit, :more => "delete process done"
+  when :not_found
+    deleteprocess = splash_return case: :not_found, :more => "nothing done for processes"
+  else
+    deleteprocess = splash_return case: :configuration_error, :more => "delete process failed"
+  end
+  content_type format
+  format_response(deleteprocess, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end