prometheus-splash 0.3.0 → 0.4.0

data/lib/splash/controller.rb

@@ -6,25 +6,34 @@ module Splash
       include Splash::Helpers
       include Splash::Config
       include Splash::Orchestrator
+      include Splash::Exiter
+      include Splash::Loggers
 
       def startdaemon(options = {})
         config = get_config
+        log = get_logger
         unless verify_service host: config.prometheus_pushgateway_host ,port: config.prometheus_pushgateway_port then
           return {:case => :service_dependence_missing, :more => 'Prometheus Gateway'}
         end
         unless File::exist? config.full_pid_path then
-          res = daemonize :description => config.daemon_process_name,
+          daemon_config = {:description => config.daemon_process_name,
               :pid_file => config.full_pid_path,
               :stdout_trace => config.full_stdout_trace_path,
-              :stderr_trace => config.full_stderr_trace_path, :foreground => options[:foreground] do
+              :stderr_trace => config.full_stderr_trace_path,
+              :foreground => options[:foreground]
+            }
+
+          ["int","term","hup"].each do |type| daemon_config["sig#{type}_handler".to_sym] = Proc::new {  ObjectSpace.each_object(Splash::Orchestrator::Scheduler).first.shutdown } end
+          res = daemonize daemon_config do
               Scheduler::new options
           end
+          sleep 1
           if res == 0 then
             pid = `cat #{config.full_pid_path}`.to_i
-            puts "Splash Daemon Started, with PID : #{pid}"
-            return {:case => :quiet_exit}
+            log.ok "Splash Daemon Started, with PID : #{pid}"
+            return {:case => :quiet_exit, :more => "Splash Daemon successfully loaded."}
           else
-            return {:case => :unknown_error, :more => "Splash Daemon loading error, see logs for more details"}
+            return {:case => :unknown_error, :more => "Splash Daemon loading error, see logs for more details."}
           end
 
         else
@@ -49,7 +58,8 @@ module Splash
           return acase
       end
 
-      def statusdaemon
+      def statusdaemon(options = {})
+        log = get_logger
         config = get_config
         pid = realpid = ''
         pid = `cat #{config.full_pid_path}`.to_s if File.exist?(config.full_pid_path)
@@ -57,14 +67,14 @@ module Splash
         pid.chomp!
         realpid.chomp!
         unless realpid.empty? then
-          print "Splash Process is running with PID #{realpid} "
+          log.item "Splash Process is running with PID #{realpid} "
         else
-          print 'Splash Process not found '
+          log.item 'Splash Process not found '
         end
         unless pid.empty? then
-          puts "and PID file exist with PID #{pid}"
+          log.item "and PID file exist with PID #{pid}"
         else
-          puts "and PID file don't exist"
+          log.item "and PID file don't exist"
         end
         if pid == realpid then
           return {:case => :status_ok }

data/lib/splash/dependencies.rb

@@ -24,6 +24,7 @@ module Splash
       require 'rufus-scheduler'
       require 'tty-markdown'
       require 'tty-pager'
+      require 'colorize'
       require "redis"
 
     rescue Gem::GemNotFoundException
@@ -37,11 +38,13 @@ module Splash
     require 'splash/constants'
     require 'splash/helpers'
     require 'splash/config'
+    require 'splash/loggers'
     require 'splash/exiter'
     require 'splash/templates'
     require 'splash/backends'
     require 'splash/transports'
 
+
     require 'splash/commands'
     require 'splash/logs'
     require 'splash/orchestrator'

data/lib/splash/exiter.rb

@@ -1,6 +1,7 @@
 # coding: utf-8
 module Splash
   module Exiter
+    include Splash::Loggers
     EXIT_MAP= {
 
        # context execution
@@ -34,15 +35,16 @@ module Splash
     }
 
     def splash_exit(options = {})
+      log = get_logger
       mess = ""
       mess = EXIT_MAP[options[:case]][:message] if EXIT_MAP[options[:case]].include? :message
       mess << " : " unless mess.empty? or not options[:more]
       mess << "#{options[:more]}" if options[:more]
       if  EXIT_MAP[options[:case]][:code] == 0 then
-        puts mess unless mess.empty?
+        log.success mess unless mess.empty?
         exit 0
       else
-        $stderr.puts mess unless mess.empty?
+        log.fatal mess unless mess.empty?
         exit EXIT_MAP[options[:case]][:code]
       end
     end

data/lib/splash/helpers.rb

@@ -1,3 +1,4 @@
+# @option  options [String] :stdout_trace the path of the file where to redirect STDOUT
 # coding: utf-8
 module Splash
   module Helpers
@@ -89,6 +90,9 @@ module Splash
     # @option  options [String] :daemon_group the group to change privileges
     # @option  options [String] :stderr_trace the path of the file where to redirect STDERR
     # @option  options [String] :stdout_trace the path of the file where to redirect STDOUT
+    # @option  options [Proc] :sigint_handler handler Proc for SIGINT signal
+    # @option  options [Proc] :sigterm_handler handler Proc for SIGTERM signal
+    # @option  options [Proc] :sighup_handler handler Proc for SIGHuP signal
     # @option  options [Bool] :foreground option to run foreground
     # @yield a process definion or block given
     # @example usage inline
@@ -129,11 +133,33 @@ module Splash
       #Process.euid = 0
       #Process.egid = 0
 
-      trap("SIGINT"){ exit! 0 }
-      trap("SIGTERM"){ exit! 0 }
-      trap("SIGHUP"){ exit! 0 }
-      return yield if options[:foreground]
+      trap("SIGINT"){
+        if options[:sigint_handler] then
+          options[:sigint_handler].call
+        else
+          exit! 0
+        end
+      }
+      trap("SIGTERM"){
+        if options[:sigterm_handler] then
+          options[:sigterm_handler].call
+        else
+          exit! 0
+        end
+       }
+      trap("SIGHUP"){
+        if options[:sighup_handler] then
+          options[:sighup_handler].call
+        else
+          exit! 0
+        end
+       }
+      if options[:foreground]
+        change_logger logger: :dual
+        return yield
+      end
       fork do
+        change_logger logger: :daemon
         #Process.daemon
         File.open(options[:pid_file],"w"){|f| f.puts Process.pid } if options[:pid_file]
         if options[:daemon_user] and options[:daemon_group] then

data/lib/splash/loggers.rb

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+
+module Splash
+  module Loggers
+    include Splash::Config
+
+    @@logger=nil
+
+    def get_logger(options = {})
+      logger = (get_config.loggers[:list].include? options[:logger])? options[:logger].to_s : get_config.loggers[:default].to_s
+      aclass = "Splash::Loggers::#{logger.capitalize}"
+#      begin
+        return @@logger = Kernel.const_get(aclass)::new if options[:force]
+        return @@logger ||= Kernel.const_get(aclass)::new
+#      rescue
+#        splash_exit case: :configuration_error, more: "Logger specified inexistant : #{logger}"
+#      end
+    end
+
+
+    def change_logger(options = {})
+      options[:force] = true
+      get_logger(options)
+    end
+
+
+
+    class LoggerTemplate
+      include Splash::Config
+
+      LEVELS = [:debug, :warn, :info, :result, :fatal, :unknown]
+      ALIAS = {:flat => :info, :item => :info, :ok => :info, :ko => :info, :trigger => :info,
+        :schedule => :info, :arrow => :info, :send => :info,
+        :receive => :info, :error => :result, :success => :result }
+      LEVELS.each do |method|
+        define_method(method) do |message|
+            self.log({ :level => method, :message => message})
+        end
+      end
+      ALIAS.keys.each do |method|
+        define_method(method) do |message|
+            self.log({ :level => method, :message => message})
+        end
+      end
+      def initialize
+        self.level = get_config.loggers[:level]
+
+
+      end
+
+
+      def log(options)
+        level = (ALIAS.keys.include? options[:level])?  ALIAS[options[:level]] : options[:level]
+        if @active_levels.include? level then
+          puts options[:message]
+        end
+      end
+
+
+      def level
+        return @active_levels.first
+      end
+
+      def level=(level)
+        if LEVELS.include? level then
+          @active_levels = LEVELS.dup
+          @active_levels.shift(LEVELS.index(level))
+        else
+          raise BadLevel
+        end
+      end
+
+
+      private
+      def alt(symbol)
+        return "=>" if symbol == :arrow
+        return '' if symbol == :flat
+        return symbol.to_s.upcase
+      end
+
+    end
+
+    class BadLevel < Exception; end
+
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/loggers/*.rb'].each {|file| require file  }

data/lib/splash/loggers/cli.rb

@@ -0,0 +1,83 @@
+# coding: utf-8
+module Splash
+  module Loggers
+
+    class Cli < Splash::Loggers::LoggerTemplate
+
+      include Splash::Config
+
+      EMOJI =  { :unknown => "\u{1F4A5}",
+                 :fatal => "\u{26D4}",
+                 :error => "\u{1F6AB}",
+                 :ko => "\u{1F44E}",
+                 :warn => "\u{26A0}",
+                 :info => "\u{2139}",
+                 :item => " \u{1F539}",
+                 :arrow => "  \u{27A1}",
+                 :schedule => "\u{23F1}",
+                 :trigger => "\u{23F0}",
+                 :send => "\u{1F4E4}",
+                 :receive => "\u{1F4E5}",
+                 :ok => "\u{1F44D}",
+                 :success => "\u{1F4AA}",
+                 :debug => "\u{1F41B}"}
+
+      COLORS = { :unknown => :red,
+                 :fatal => :red,
+                 :error => :red,
+                 :ko => :yellow,
+                 :warn => :yellow,
+                 :item => :white,
+                 :arrow => :white,
+                 :send => :white,
+                 :schedule => :white,
+                 :trigger => :white,
+                 :receive => :white,
+                 :info => :cyan,
+                 :ok => :green,
+                 :success => :green,
+                 :debug => :magenta}
+
+
+
+      def log(options)
+        level = (ALIAS.keys.include? options[:level])?  ALIAS[options[:level]] : options[:level]
+        if @active_levels.include? level then
+          if options[:level] == :flat then
+            puts options[:message]
+          else
+            String.disable_colorization = !get_config.loggers[:cli][:color]
+            emoji = get_config.loggers[:cli][:emoji]
+            emoji = check_unicode_term if emoji
+            if emoji then
+              display = "#{EMOJI[options[:level]]} #{options[:message]}"
+            else
+              display = "#{alt(options[:level])} #{options[:message]}"
+            end
+            puts display.colorize(COLORS[options[:level]])
+          end
+        end
+      end
+
+      def emoji=(status)
+        get_config.loggers[:cli][:emoji] = status
+      end
+
+      def color=(status)
+        get_config.loggers[:cli][:color] = status
+      end
+
+      def check_unicode_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
+
+    class BadLevel < Exception; end
+
+  end
+end

data/lib/splash/loggers/daemon.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+module Splash
+  module Loggers
+
+
+    class Daemon < Splash::Loggers::LoggerTemplate
+
+
+
+      def initialize
+        self.level = get_config.loggers[:level]
+        @log_file = get_config.loggers[:daemon][:file]
+        @stream = File::open(@log_file, 'a')
+        @stream.sync = true
+      end
+
+
+      def log(options)
+        level = (ALIAS.keys.include? options[:level])?  ALIAS[options[:level]] : options[:level]
+        if @active_levels.include? level then
+          @stream.puts "#{alt(options[:level])} #{options[:message]}"
+        end
+      end
+
+      def close
+        @stream.close
+      end
+
+    end
+
+  end
+end

data/lib/splash/loggers/dual.rb

@@ -0,0 +1,22 @@
+module Splash
+  module Loggers
+
+    class Dual < Splash::Loggers::LoggerTemplate
+      include Splash::Config
+
+
+
+      def initialize
+        super
+        @log1 = Splash::Loggers::Cli::new
+        @log2 = Splash::Loggers::Daemon::new
+      end
+
+      def log(options)
+        @log1.log options
+        @log2.log options
+      end
+
+    end
+  end
+end

data/lib/splash/logs.rb

@@ -43,13 +43,14 @@ module Splash
 
     # start notification on prometheus for metric logerrors, logmissing; loglines
     def notify
+      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." }
       end
-      puts "Sending metrics to Prometheus Pushgateway"
+      log.info "Sending metrics to Prometheus Pushgateway"
       @logs_target.each do |item|
         missing = (item[:status] == :missing)? 1 : 0
-        puts " * Sending metrics for #{item[:log]}"
+        log.item "Sending metrics for #{item[:log]}"
         @metric_count.set(item[:count], labels: { log: item[:log] })
         @metric_missing.set(missing, labels: { log: item[:log] })
         lines = (item[:lines])? item[:lines] : 0
@@ -58,7 +59,7 @@ module Splash
       hostname = Socket.gethostname
       url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
       Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
-      puts "Sending done."
+      log.ok "Sending to Prometheus PushGateway done."
       return {:case => :quiet_exit }
     end
 

data/lib/splash/orchestrator.rb

@@ -12,27 +12,30 @@ module Splash
         include Splash::Config
         include Splash::Transports
         include Splash::Orchestrator::Grammar
+        include Splash::Loggers
+
         def initialize(options = {})
+          @log = get_logger
           $stdout.sync = true
           $stderr.sync = true
           @server  = Rufus::Scheduler::new
           @server.extend SchedulerHooks
           @config = get_config
           @result = LogScanner::new
-          puts "Splash Orchestrator starting :"
+          @log.info "Splash Orchestrator starting :"
           if options[:scheduling] then
-            puts " * Initializing commands Scheduling."
+            @log.item "Initializing commands Scheduling."
             self.init_commands_scheduling
           end
           sched,value = @config.daemon_logmon_scheduling.flatten
-          puts " * Initializing logs monitorings & notifications."
+          @log.item "Initializing logs monitorings & notifications."
           @server.send sched,value do
             begin
+              @log.trigger "Logs monitoring for Scheduling : #{sched.to_s} #{value.to_s}"
               @result.analyse
               @result.notify
-              $stdout.flush
             rescue Errno::ECONNREFUSED
-              $stderr.puts "PushGateway seems to be done, please start it."
+              @log.error "PushGateway seems to be done, please start it."
             end
           end
           hostname = Socket.gethostname
@@ -43,21 +46,26 @@ module Splash
           transport.subscribe(:block => true) do |delivery_info, properties, body|
             content = YAML::load(body)
             if VERBS.include? content[:verb]
-              puts "Receive valid remote order, verb : #{content[:verb].to_s}"
+              @log.receive "Valid remote order, verb : #{content[:verb].to_s}"
               if content[:payload] then
                 res = self.send content[:verb], content[:payload]
               else
                 res = self.send content[:verb]
               end
               get_default_client.publish queue: content[:return_to], message: res.to_yaml
+              @log.send "Result to #{content[:return_to]}."
             else
-              puts "Receive INVALID remote order, verb : #{content[:verb].to_s}"
+              @log.receive "INVALID remote order, verb : #{content[:verb].to_s}"
               get_default_client.publish queue: content[:return_to], message: "Unkown verb #{content[:verb]}".to_yaml
             end
           end
         end
 
         def terminate
+          @log.info "Splash daemon shutdown"
+          @server.shutdown
+          change_logger logger: :cli
+          splash_exit case: :quiet_exit 
         end
 
         private
@@ -66,8 +74,9 @@ module Splash
             commands = config.select{|key,value| value.include? :schedule}.keys
             commands.each do |command|
               sched,value = config[command][:schedule].flatten
-              puts "   => Scheduling command #{command.to_s}"
+              @log.arrow "Scheduling command #{command.to_s}"
               @server.send sched,value do
+                @log.trigger "Executing Scheduled command #{command.to_s} for Scheduling : #{sched.to_s} #{value.to_s}"
                 self.execute command: command.to_s
               end
             end