prometheus-splash 0.5.3 → 0.8.1

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,12 +1,19 @@
+# coding: utf-8
+
+# base Splash module
 module Splash
+
+  # Splash Loggers module
   module Loggers
 
+    # 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})
@@ -18,6 +25,7 @@ module Splash
         end
       end
 
+      # Constructor build two attributes for each loggers : Cli, Daemon
       def initialize
         super
         @log1 = Splash::Loggers::Cli::new
@@ -28,10 +36,15 @@ module Splash
         @log1.log options
         @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

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,27 +1,101 @@
 # coding: utf-8
+
+# base Splash module
 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
       include Splash::Config
 
 
-      # LogScanner Constructor
-      # return [LogScanner]
+      # LogScanner Constructor : initialize prometheus metrics
+      # return [Splash::Logs::LogScanner]
       def initialize
-        @logs_target = get_config.logs
+        @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
 
 
       # 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?
@@ -38,30 +112,41 @@ module Splash
       end
 
       # 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 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}"
-        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

@@ -1,27 +1,102 @@
+# coding: utf-8
+
+# base Splash Module
 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
       include Splash::Config
 
 
-      # LogScanner Constructor
-      # return [LogScanner]
+      # ProcessScanner Constructor : initialize prometheus metrics
+      # @return [Splash::Processes::ProcessScanner]
       def initialize
-        @processes_target = get_config.processes
+        @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 log analyse for log target in config
+      # 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
@@ -39,30 +114,38 @@ module Splash
       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 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}"
-        Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
-        log.ok "Sending to Prometheus PushGateway done.", session
         return {:case => :quiet_exit }
       end