prometheus-splash 0.6.0 → 0.8.2

data/lib/splash/helpers.rb

@@ -252,7 +252,7 @@ module Splash
     # check folder
     # @return [Array] of Symbol with error type : [:inexistant,:mode,:owner,:group]
     # @param [Hash] options
-    # @option options [String] :path folder path (relative or absolute)
+    # @option options [String] :name folder path (relative or absolute)
     # @option options [String] :mode String for OCTAL rights like "644", optionnal
     # @option options [String] :owner file owner for folder, optionnal
     # @option options [String] :group  file group for folder, optionnal
@@ -310,11 +310,20 @@ module Splash
     # @param [Hash] options
     # @option options [String] :host hostname
     # @option options [String] :port TCP port
+    # @option options [String] :url full URL, priority on :host and :port
     def verify_service(options ={})
       begin
+        if options[:url] then
+          uri = URI.parse(options[:url])
+          host = uri.host
+          port = uri.port
+        else
+          host = options[:host]
+          port = options[:port]
+        end
         Timeout::timeout(1) do
           begin
-            s = TCPSocket.new(options[:host], options[:port])
+            s = TCPSocket.new(host, port)
             s.close
             return true
           rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
@@ -327,12 +336,11 @@ module Splash
     end
     #!@endgroup
 
-
     def format_response(data, format)
       response = case format
                  when 'application/json' then JSON.pretty_generate(data)
                  when 'text/x-yaml' then data.to_yaml
-                 else JSON.pretty_generate(data)
+                 else data.to_yaml
                  end
       return response
     end
@@ -346,6 +354,16 @@ module Splash
        return result[extension]
     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
+        return true
+      else
+        return false
+      end
+    end
 
   end
 end

data/lib/splash/loggers/cli.rb

@@ -10,6 +10,7 @@ module Splash
     class Cli < Splash::Loggers::LoggerTemplate
 
       include Splash::Config
+      include Splash::Helpers
 
       # mapping of UTf-8 emoji for log levels or alias
       EMOJI =  { :unknown => "\u{1F4A5}",
@@ -82,16 +83,7 @@ module Splash
         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
-          return true
-        else
-          return false
-        end
-      end
+
 
     end
 

data/lib/splash/logs.rb

@@ -6,6 +6,79 @@ module Splash
   # Logs namespace
   module Logs
 
+    class LogsNotifier
+
+      @@registry = Prometheus::Client::Registry::new
+      @@metric_missing = Prometheus::Client::Gauge.new(:logmissing, docstring: 'SPLASH metric log missing', labels: [:log ])
+      @@metric_count = Prometheus::Client::Gauge.new(:logerrors, docstring: 'SPLASH metric log error', 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)
+
+      def initialize(options={})
+        @config = get_config
+        @url = @config.prometheus_pushgateway_url
+        @name = options[:name]
+        @missing = options[:missing]
+        @lines = options[:lines]
+        @errors = options[:errors]
+      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_missing.set(@missing, labels: { log: @name })
+        @@metric_count.set(@errors, labels: { log: @name })
+        @@metric_lines.set(@lines, labels: { log: @name })
+        hostname = Socket.gethostname
+        return Prometheus::Client::Push.new("Splash", hostname, @url).add(@@registry)
+      end
+
+    end
+
+    class LogsRecords
+      include Splash::Backends
+      include Splash::Constants
+      def initialize(name)
+        @name = name
+        @backend = get_backend :logs_trace
+      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
+
+
+
     # Log scanner and notifier
     class LogScanner
       include Splash::Constants
@@ -17,13 +90,7 @@ module Splash
       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
 
 
@@ -56,23 +123,30 @@ module Splash
       # @return [Hash] Exiter case :quiet_exit
       def notify(options = {})
         log = get_logger
-        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
         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] })
+          logsrec = LogsRecords::new item[:label]
+          errors = (item[:count])? item[:count] : 0
           lines = (item[:lines])? item[:lines] : 0
-          @metric_lines.set(lines, labels: { log: item[:log] })
+          missing = (item[:status] = :missing)? 1 : 0
+          file = item[:log]
+          logsrec.purge(item[:retention])
+          logsrec.add_record :status => item[:status],
+                           :errors => errors,
+                           :lines => lines,
+                           :file => file
+
+          logsmonitor = LogsNotifier::new({name: item[:label], missing: missing, file: file, errors: errors, lines: lines})
+          if logsmonitor.notify then
+            log.ok "Sending metrics for log #{file} to Prometheus Pushgateway", session
+          else
+            log.ko "Failed to send metrics for log #{file} to Prometheus Pushgateway", session
+          end
         end
-        hostname = Socket.gethostname
-        url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}/#{@config.prometheus_pushgateway_path}"
-        Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
-        log.ok "Sending to Prometheus PushGateway done.", session
         return {:case => :quiet_exit }
       end
 

data/lib/splash/processes.rb

@@ -6,6 +6,81 @@ module Splash
   # Processes namespace
   module Processes
 
+
+    class ProcessNotifier
+
+      @@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)
+
+
+      def initialize(options={})
+        @config = get_config
+        @url = @config.prometheus_pushgateway_url
+        @name = options[:name]
+        @status = options[:status]
+        @cpu_percent = options[:cpu_percent]
+        @mem_percent = options[:mem_percent]
+      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_mem_percent.set(@mem_percent, labels: { process: @name })
+        @@metric_cpu_percent.set(@cpu_percent, labels: { process: @name })
+        @@metric_status.set(@status, labels: { process: @name })
+        hostname = Socket.gethostname
+        return Prometheus::Client::Push.new("Splash", hostname, @url).add(@@registry)
+      end
+
+    end
+
+
+    class ProcessRecords
+      include Splash::Backends
+      include Splash::Constants
+
+      def initialize(name)
+        @name = name
+        @backend = get_backend :process_trace
+      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
+
     # Processes scanner and notifier
     class ProcessScanner
       include Splash::Constants
@@ -17,14 +92,6 @@ module Splash
       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
 
 
@@ -58,23 +125,27 @@ module Splash
       # @return [Hash] Exiter case :quiet_exit
       def notify(options = {})
         log = get_logger
-        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
         session = (options[:session]) ? options[:session] : log.get_session
         log.info "Sending metrics to Prometheus Pushgateway", session
         @processes_target.each do |item|
+          processrec = ProcessRecords::new item[:process]
           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] })
+          processrec.purge(item[:retention])
+          processrec.add_record :status => item[:status],
+                           :cpu_percent => item[:cpu],
+                           :mem_percent => item[:mem] ,
+                           :process => item[:process]
+          processmonitor = ProcessNotifier::new({name: item[:process], status: val , cpu_percent: item[:cpu], mem_percent: item[:mem]})
+          if processmonitor.notify then
+            log.ok "Sending metrics for process #{item[:process]} to Prometheus Pushgateway", session
+          else
+            log.ko "Failed to send metrics for process #{item[:process]} to Prometheus Pushgateway", session
+          end
         end
-        hostname = Socket.gethostname
-        url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}/#{@config.prometheus_pushgateway_path}"
-        Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
-        log.ok "Sending to Prometheus PushGateway done.", session
         return {:case => :quiet_exit }
       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