prometheus-splash 0.3.0 → 0.4.0

data/lib/splash/cli/config.rb

@@ -2,19 +2,20 @@
 module CLISplash
 
   class Config < Thor
-    include Splash::Config
+    include Splash::ConfigUtilities
     include Splash::Helpers
     include Splash::Exiter
+    include Splash::Loggers
 
 
     desc "setup", "Setup installation fo Splash"
     long_desc <<-LONGDESC
-    Setup installation fo Splash
+    Setup installation fo Splash\n
     with --preserve, preserve from reinstallation of the config
     LONGDESC
     option :preserve, :type => :boolean
     def setup
-      acase = run_as_root :setupsplash
+      acase = run_as_root :setupsplash, options
       splash_exit acase
     end
 
@@ -26,9 +27,10 @@ module CLISplash
 
     desc "version", "display current Splash version"
     def version
+      log = get_logger
       config = get_config
-      puts "Splash version : #{config.version}, Author : #{config.author}"
-      puts config.copyright
+      log.info "Splash version : #{config.version}, Author : #{config.author}"
+      log_info config.copyright
       splash_exit case: :quiet_exit
     end
 

data/lib/splash/cli/daemon.rb

@@ -5,6 +5,7 @@ module CLISplash
     include Splash::LogsMonitor::DaemonController
     include Splash::Transports
     include Splash::Exiter
+    include Splash::Loggers
 
 
     option :foreground, :type => :boolean
@@ -18,6 +19,7 @@ module CLISplash
     LONGDESC
     desc "start", "Starting Splash Daemon"
     def start
+      log = get_logger
       if options[:purge] then
         transport = get_default_client
         if transport.class == Hash  and transport.include? :case then
@@ -25,7 +27,7 @@ module CLISplash
         else
           queue = "splash.#{Socket.gethostname}.input"
           transport.purge queue: queue
-          puts " * Queue : #{queue} purged"
+          log.info "Queue : #{queue} purged"
         end
       end
       acase = run_as_root :startdaemon, options
@@ -35,13 +37,14 @@ module CLISplash
 
     desc "purge", "Purge Transport Input queue of Daemon"
     def purge
+      log = get_logger
       transport = get_default_client
       if transport.class == Hash  and transport.include? :case then
         splash_exit transport
       else
         queue = "splash.#{Socket.gethostname}.input"
         transport.purge queue: queue
-        puts " * Queue : #{queue} purged"
+        log.ok "Queue : #{queue} purged"
         splash_exit case: :quiet_exit
       end
     end
@@ -60,13 +63,14 @@ module CLISplash
 
     desc "ping HOSTNAME", "send a ping to HOSTNAME daemon over transport (need an active tranport), Typicallly RabbitMQ"
     def ping(hostname=Socket.gethostname)
-      puts "ctrl+c for interrupt"
+      log = get_logger
+      log.info "ctrl+c for interrupt"
       begin
         transport = get_default_client
         if transport.class == Hash  and transport.include? :case then
           splash_exit transport
         else
-          puts transport.execute({ :verb => :ping,
+          log.receive transport.execute({ :verb => :ping,
                                   :payload => {:hostname => Socket.gethostname},
                                   :return_to => "splash.#{Socket.gethostname}.returncli",
                                   :queue => "splash.#{hostname}.input" })

data/lib/splash/cli/logs.rb

@@ -8,21 +8,33 @@ module CLISplash
 
     desc "analyse", "analyze logs in config"
     def analyse
+      log  = get_logger
       results = Splash::LogScanner::new
       res = results.analyse
-      puts "SPlash Configured logs status :"
+      log.info "SPlash Configured logs status :"
       full_status = true
       results.output.each do |result|
-        status = (result[:status] == :clean)? "OK": "KO"
-        puts " * Log : #{result[:log]} : [#{status}]"
-        puts "   - Detected pattern : #{result[:pattern]}"
-        puts "   - detailled Status : #{result[:status].to_s}"
-        puts "     count = #{result[:count]}" if result[:status] == :matched
-        puts "     nb lines = #{result[:lines]}" if result[:status] != :missing
+        if result[:status] == :clean then
+          log.ok "Log : #{result[:log]} : no errors"
+          log.item "Detected pattern : #{result[:pattern]}"
+          log.item "Nb lines = #{result[:lines]}"
+        elsif result[:status] == :missing then
+          log.ko "Log : #{result[:log]} : missing !"
+          log.item "Detected pattern : #{result[:pattern]}"
+        else
+          log.ko "Log : #{result[:log]} : #{result[:count]} errors"
+          log.item "Detected pattern : #{result[:pattern]}"
+          log.item "Nb lines = #{result[:lines]}"
+        end
+
         full_status = false unless result[:status] == :clean
       end
       display_status = (full_status)? "OK": "KO"
-      puts "Global Status : [#{display_status}]"
+      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
     end
 
@@ -36,32 +48,34 @@ module CLISplash
     end
 
     desc "show LOG", "show configured log monitoring for LOG"
-    def show(log)
-      log_record_set = get_config.logs.select{|item| item[:log] == log }
+    def show(logrecord)
+      log = get_logger
+      log_record_set = get_config.logs.select{|item| item[:log] == logrecord }
       unless log_record_set.empty? then
         record = log_record_set.first
-        puts "Splash log monitor : #{record[:log]}"
-        puts "  ->   pattern : /#{record[:pattern]}/"
+        log.info "Splash log monitor : #{record[:log]}"
+        log.item "pattern : /#{record[:pattern]}/"
         splash_exit case: :quiet_exit
-    else
+      else
         splash_exit case: :not_found, :more => "log not configured"
       end
     end
 
     desc "list", "Show configured logs monitoring"
     long_desc <<-LONGDESC
-    Show configured logs monitoring
+    Show configured logs monitoring\n
     with --detail, show logs monitor details
     LONGDESC
     option :detail, :type => :boolean
     def list
-      puts "Splash configured log monitoring :"
+      log = get_logger
+      log.info "Splash configured log monitoring :"
       log_record_set = get_config.logs
-      puts 'No configured commands found' if log_record_set.empty?
+      log.ko 'No configured commands found' if log_record_set.empty?
       log_record_set.each do |record|
-        puts " *  log monitor : #{record[:log]}"
+        log.item "log monitor : #{record[:log]}"
         if options[:detail] then
-          puts "  ->   pattern : /#{record[:pattern]}/"
+          log.flat "  ->   pattern : /#{record[:pattern]}/"
         end
       end
       splash_exit case: :quiet_exit

data/lib/splash/commands.rb

@@ -25,7 +25,7 @@ module Splash
     end
 
     def ack
-      puts "Sending ack for command : '#{@name}'"
+      get_logger.info "Sending ack for command : '#{@name}'"
       notify(0,0)
     end
 
@@ -37,17 +37,18 @@ module Splash
       @@metric_time.set(time)
       hostname = Socket.gethostname
       Prometheus::Client::Push.new(@name, hostname, @url).add(@@registry)
-      puts " * Prometheus Gateway notified."
+      get_logger.ok "Prometheus Gateway notified."
       return { :case => :quiet_exit}
     end
 
 
     def call_and_notify(options)
+      log = get_logger
       acase = { :case => :quiet_exit }
       exit_code = 0
       if @config.commands[@name.to_sym][:delegate_to] then
         return { :case => :options_incompatibility, :more => '--hostname forbidden with delagate commands'} if options[:hostname]
-        puts "Remote command : #{@name} execution delegate to : #{@config.commands[@name.to_sym][:delegate_to][:host]} as : #{@config.commands[@name.to_sym][:delegate_to][:remote_command]}"
+        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]}"
         begin
           transport = get_default_client
           if transport.class == Hash  and transport.include? :case then
@@ -58,18 +59,18 @@ module Splash
               :return_to => "splash.#{Socket.gethostname}.return",
               :queue => "splash.#{@config.commands[@name.to_sym][:delegate_to][:host]}.input" })
             exit_code = res[:exit_code]
-            puts "  => exitcode #{exit_code}"
+            log.receive "return with exitcode #{exit_code}"
 
           end
         end
       else
-        puts "Executing command : '#{@name}' "
+        log.info "Executing command : '#{@name}' "
         start = Time.now
         start_date = DateTime.now.to_s
         unless options[:trace] then
-          puts " * Traceless execution"
+          log.item "Traceless execution"
           if @config.commands[@name.to_sym][:user] then
-            puts " * Execute with user : #{@config.commands[@name.to_sym][:user]}."
+            log.item "Execute with user : #{@config.commands[@name.to_sym][:user]}."
             system("sudo -u #{@config.commands[@name.to_sym][:user]} #{@config.commands[@name.to_sym][:command]} > /dev/null 2>&1")
           else
             system("#{@config.commands[@name.to_sym][:command]} > /dev/null 2>&1")
@@ -77,9 +78,9 @@ module Splash
           time = Time.now - start
           exit_code = $?.exitstatus
         else
-          puts " * Tracefull execution"
+          log.item "Tracefull execution"
           if @config.commands[@name.to_sym][:user] then
-            puts " * Execute with user : #{@config.commands[@name.to_sym][:user]}."
+            log.item "Execute with user : #{@config.commands[@name.to_sym][:user]}."
             stdout, stderr, status = Open3.capture3("sudo -u #{@config.commands[@name.to_sym][:user]} #{@config.commands[@name.to_sym][:command]}")
           else
             stdout, stderr, status = Open3.capture3(@config.commands[@name.to_sym][:command])
@@ -103,12 +104,12 @@ module Splash
           backend.put key: key, value: data.to_yaml
           exit_code = status.exitstatus
         end
-
-        puts "  => exitcode #{exit_code}"
+        log.ok "Command executed"
+        log.arrow "exitcode #{exit_code}"
         if options[:notify] then
           acase = notify(exit_code,time.to_i)
         else
-          puts " * Without Prometheus notification"
+          log.item "Without Prometheus notification"
         end
       end
 
@@ -116,7 +117,7 @@ module Splash
         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
         if on_failure and exit_code > 0 then
-          puts " * On failure callback : #{on_failure}"
+          log.item "On failure callback : #{on_failure}"
           if @config.commands.keys.include?  on_failure then
             @name = on_failure.to_s
             call_and_notify options
@@ -125,16 +126,16 @@ module Splash
           end
         end
         if on_success and exit_code == 0 then
-          puts " * On success callback : #{on_success}"
+          log.item "On success callback : #{on_success}"
           if @config.commands.keys.include?  on_success then
             @name = on_success.to_s
             call_and_notify options
           else
-            $stderr.puts "on_success call error : configuration mistake : #{on_success} command inexistant."
+            acase = { :case => :configuration_error , :more => "on_success call error : #{on_failure} command inexistant."}
           end
         end
       else
-        puts " * Without callbacks sequences"
+        log.item "Without callbacks sequences"
       end
       acase[:exit_code] = exit_code
       return acase

data/lib/splash/config.rb

@@ -31,6 +31,7 @@ module Splash
 
         self[:transports] = {} ; self[:transports].merge! TRANSPORTS_STRUCT ; self[:transports].merge! config_from_file[:transports] if config_from_file[:transports]
         self[:backends] = {} ; self[:backends].merge! BACKENDS_STRUCT ; self[:backends].merge! config_from_file[:backends] if config_from_file[:backends]
+        self[:loggers] = {} ; self[:loggers].merge! LOGGERS_STRUCT ; self[:loggers].merge! config_from_file[:loggers] if config_from_file[:loggers]
 
         self[:logs] = (config_from_file[:logs])? config_from_file[:logs] : {}
         self[:commands] = (config_from_file[:commands])? config_from_file[:commands] : {}
@@ -39,6 +40,9 @@ module Splash
 
       # @!group accessors on configurations Items
 
+      def loggers
+        return self[:loggers]
+      end
 
       def backends
         return self[:backends]

data/lib/splash/config/sanitycheck.rb

@@ -3,53 +3,57 @@ module Splash
   module ConfigUtilities
     include Splash::Constants
 
+
+
     # Sanitycheck action method for testing installation of Splash
     # @return [Integer] an errorcode value
-    def checkconfig
-      puts "Splash -> sanitycheck : "
+    def checkconfig(options ={})
+      self.extend Splash::Loggers
+      log = get_logger
+      log.info "Splash -> sanitycheck : "
       config = get_config
       full_res = 0
-      print "* Config file : #{CONFIG_FILE} : "
       res = verify_file(name: CONFIG_FILE, mode: "644", owner: config.user_root, group: config.group_root)
+      target = "Config file : #{CONFIG_FILE}"
       if res.empty? then
-        print "[OK]\n"
+        log.ok target
       else
-        print "[KO]\n"
+        log.ko target
         full_res =+ 1
-        puts "    pbm => #{res.map {|p| p.to_s}.join(',')}"
+        log.flat "    pbm => #{res.map {|p| p.to_s}.join(',')}"
       end
 
-      print "* PID Path : #{config[:pid_path]} : "
+      target = "PID Path : #{config[:pid_path]}"
       res = verify_folder(name: config[:pid_path], mode: "644", owner: config.user_root, group: config.group_root)
       if res.empty? then
-        print "[OK]\n"
+        log.ok target
       else
-        print "[KO]\n"
+        log.ko target
         full_res =+ 1
-        puts "    pbm => #{res.map {|p| p.to_s}.join(',')}"
+        log.flat "    pbm => #{res.map {|p| p.to_s}.join(',')}"
 
       end
 
-      print "* trace Path : #{config[:trace_path]} : "
-      res = verify_folder(name: config[:trace_path], mode: "777", owner: config.user_root, group: config.group_root)
+      target =  "Trace Path : #{config[:trace_path]}"
+      res = verify_folder(name: config[:trace_path], mode: "644", owner: config.user_root, group: config.group_root)
       if res.empty? then
-        print "[OK]\n"
+        log.ok target
       else
-        print "[KO]\n"
+        log.ko target
         full_res =+ 1
-        puts "    pbm => #{res.map {|p| p.to_s}.join(',')}"
+        log.flat "    pbm => #{res.map {|p| p.to_s}.join(',')}"
       end
 
-      print "* Prometheus PushGateway Service running : "
+      target = "Prometheus PushGateway Service running"
       if verify_service host: config.prometheus_pushgateway_host ,port: config.prometheus_pushgateway_port then
-        print "[OK]\n"
+        log.ok target
       else
-        print "[KO]\n"
+        log.ko target
         full_res =+ 1
       end
 
       if full_res > 0 then
-        $stderr.puts " => #{full_res} errors occured"
+        log.error "#{full_res} errors occured"
         return { :case => :splash_sanitycheck_error }
       else
         return { :case => :splash_sanitycheck_success}

data/lib/splash/config/setup.rb

@@ -22,36 +22,40 @@ module Splash
           puts "[KO]"
         end
       else
-        puts "Config file preservation."
+        puts "Config file preservation, verify your homemade templates."
       end
       config = get_config
+      self.extend Splash::Loggers
+      log = get_logger
+      log.ok "Splash Initialisation"
       report_in_path = search_file_in_gem "prometheus-splash", "templates/report.txt"
-      print "* Installing template file : #{config.execution_template_path} : "
+      target =  "Installing template file : #{config.execution_template_path}"
       if install_file source: report_in_path, target: config.execution_template_path, mode: "644", owner: config.user_root, group: config.group_root then
-        puts "[OK]"
+        log.ok target
       else
         full_res =+ 1
-        puts "[KO]"
+        log.ko target
       end
 
-      print "* Creating/Checking pid file path : #{config[:pid_path]} : "
+      target = "Creating/Checking pid file path : #{config[:pid_path]}"
       if make_folder path: config[:pid_path], mode: "644", owner: config.user_root, group: config.group_root then
-        puts "[OK]"
+        log.ok target
       else
         full_res =+ 1
-        puts "[KO]"
+        log.ko target
       end
 
-      print "* Creating/Checking trace file path : #{config[:trace_path]} : "
+      target = "Creating/Checking trace file path : #{config[:trace_path]} : "
       if make_folder path: config[:trace_path], mode: "644", owner: config.user_root, group: config.group_root then
-        puts "[OK]"
+        log.ok target
       else
         full_res =+ 1
-        puts "[KO]"
+        log.ko target
       end
 
+
       if full_res > 0 then
-        $stderr.puts " => #{full_res} errors occured"
+        log.error "#{full_res} errors occured"
         return { :case => :splash_setup_error}
       else
         return { :case => :splash_setup_success }

data/lib/splash/constants.rb

@@ -1,7 +1,7 @@
 # coding: utf-8
 module Splash
   module Constants
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
 
     # the path to th config file, not overridable by config
     CONFIG_FILE = "/etc/splash.yml"
@@ -47,10 +47,14 @@ module Splash
                         :stores => { :execution_trace => { :type => :file, :path => "/var/run/splash" }}}
     # transports default settings
     TRANSPORTS_STRUCT = { :list => [:rabbitmq],
-                        :active => :rabbitmq,
-                        :rabbitmq => { :port => 5672, :host => "localhost"} }
-
-
+                          :active => :rabbitmq,
+                          :rabbitmq => { :port => 5672, :host => "localhost", :vhost => '/'} }
+
+    LOGGERS_STRUCT = { :list => [:cli,:daemon, :dual],
+                       :default => :cli,
+                       :level => :info,
+                       :daemon => {:file => '/var/log/splash.log'},
+                       :cli => {:color => true, :emoji => true }  }
 
   end
 end