prometheus-splash 0.5.3 → 0.6.0

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,15 +1,21 @@
 # coding: utf-8
+
+# base Splash module
 module Splash
+
+  # Logs namespace
   module Logs
+
+    # 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 ])
@@ -22,6 +28,7 @@ module Splash
 
 
       # 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,11 +45,15 @@ 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
@@ -59,7 +70,7 @@ module Splash
           @metric_lines.set(lines, labels: { log: item[:log] })
         end
         hostname = Socket.gethostname
-        url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
+        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 }

data/lib/splash/processes.rb

@@ -1,14 +1,21 @@
+# coding: utf-8
+
+# base Splash Module
 module Splash
+
+  # Processes namespace
   module Processes
+
+    # 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 ])
@@ -21,7 +28,8 @@ module Splash
       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,11 +47,15 @@ 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
@@ -60,7 +72,7 @@ module Splash
           @metric_mem_percent.set(item[:mem], labels: { process: item[:process] })
         end
         hostname = Socket.gethostname
-        url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
+        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 }

data/lib/splash/templates.rb

@@ -1,12 +1,19 @@
 # coding: utf-8
+
+# base Splash Module
 module Splash
+
+  # Templates namespace
   module Templates
 
     # KISS template Engine
     class Template
 
+      # getter of the list of token
       attr_reader :list_token
+      # getter of the template file
       attr_reader :template_file
+      # getter of the flat content of the template
       attr_reader :content
 
       # constructor : generate the pseudo accessor for template Class from token list
@@ -72,8 +79,11 @@ module Splash
 
     end
 
+    # Exception for an invalid Token list
     class InvalidTokenList < Exception; end
+    # Exception for an malformed token
     class NotAToken < Exception; end
+    # Exception for an invalid template file
     class NoTemplateFile < Exception; end
 
   end

data/lib/splash/transports.rb

@@ -1,9 +1,16 @@
 # coding: utf-8
 
+# base Splash module
 module Splash
+
+  # Splash Transports namespace
   module Transports
     include Splash::Config
 
+
+    # factory for Splash::Transports::Rabbitmq::Subscriber
+    # @param [Hash] options
+    # @return [Splash::Transports::Rabbitmq::Subscriber|Hash] Subscriber or Exiter case :configuration_error
     def get_default_subscriber(options)
       config = get_config.transports
       transport = config[:active]
@@ -20,6 +27,8 @@ module Splash
       end
     end
 
+    # factory for Splash::Transports::Rabbitmq::Client
+    # @return [Splash::Transports::Rabbitmq::Client|Hash] Client or Exiter case :configuration_error
     def get_default_client
       config = get_config.transports
       transport = config[:active]

data/lib/splash/transports/rabbitmq.rb

@@ -1,14 +1,24 @@
 # coding: utf-8
+
+# base Splash module
 module Splash
+
+  # Splash Transports namespace
   module Transports
+
+    # RabbitMQ Transport
     module Rabbitmq
 
+      # Subscriber Mode RabbitMQ Client
       class Subscriber
         include Splash::Config
         extend Forwardable
 
         def_delegators :@queue, :subscribe
 
+        # Constructor Forward subscribe method and initialize a Bunny Client atribute @queue
+        # @param [Hash] options
+        # @option options [String] :queue the name of the subscribed queue
         def initialize(options = {})
           @config = get_config.transports
 
@@ -32,12 +42,13 @@ module Splash
 
       end
 
-
+      # publish / get Mode RabbitMQ Client
       class Client
         include Splash::Config
         include Splash::Transports
         include Splash::Loggers
 
+        # Constructor initialize a Bunny Client
         def initialize
           @config = get_config.transports
           host = @config[:rabbitmq][:host]
@@ -48,7 +59,7 @@ module Splash
           conf  = { :host => host, :vhost => vhost, :user => user, :password => passwd, :port => port.to_i}
 
           begin
-            @connection = Bunny.new conf 
+            @connection = Bunny.new conf
             @connection.start
             @channel = @connection.create_channel
           rescue Bunny::Exception
@@ -56,19 +67,32 @@ module Splash
           end
         end
 
-
+        # purge a queue
+        # @param [Hash] options
+        # @option options [String] :queue the name of the queue to purge
         def purge(options)
           @channel.queue(options[:queue]).purge
         end
 
+        # publish to a queue
+        # @param [Hash] options
+        # @option options [String] :queue the name of the queue to purge
+        # @option options [String] :message the message to send
         def publish(options ={})
           return @channel.default_exchange.publish(options[:message], :routing_key => options[:queue])
         end
 
+        # ack a specific message for manual ack with a delivery tag to a queue
+        # @param [String] ack
+        # @return [Boolean]
         def ack(ack)
           return @channel.acknowledge(ack, false)
         end
 
+
+        # send an execution order message (verb+payload) via RabbitMQ to an slash input queue
+        # @param [Hash] order
+        # @return [Void] unserialized Void object from YAML
         def execute(order)
           queue = order[:return_to]
           lock = Mutex.new
@@ -85,6 +109,11 @@ module Splash
           return res
         end
 
+        # Get a message from a RabbitMQ queue
+        # @param [Hash] options
+        # @option options [String] :queue the name of the queue to query
+        # @option options [String] :manual_ack flag to inhibit ack
+        # @return [Hash] Payload + ack tag if :manual_ack
         def get(options ={})
           queue = @channel.queue(options[:queue])
           opt = {}; opt[:manual_ack] = (options[:manual_ack])? true : false
@@ -94,6 +123,7 @@ module Splash
           return res
         end
 
+        # close the RabbitMQ connection
         def close
           @connection.close
         end

data/lib/splash/webadmin.rb

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+
+
+# base Splash module
+module Splash
+
+  # global daemon module
+  module WebAdmin
+
+    # Daemon Controller Module
+    module Controller
+      include Splash::Constants
+      include Splash::Helpers
+      include Splash::Config
+      include Splash::Exiter
+      include Splash::Loggers
+
+
+      # Start the Splash Daemon
+      # @param [Hash] options
+      # @option options [Symbol] :quiet activate quiet mode for log (limit to :fatal)
+      # @return [Hash] Exiter Case (:quiet_exit, :already_exist, :unknown_error or other)
+      def startdaemon(options = {})
+        require 'splash/webadmin/main'
+        config = get_config
+        log = get_logger
+        log.level = :fatal if options[:quiet]
+        realpid = get_processes pattern: get_config.webadmin_process_name
+
+
+        unless File::exist? config.full_pid_path then
+          unless realpid.empty? then
+            return {:case => :already_exist, :more => "Splash WebAdmin Process already launched "}
+          end
+
+          daemon_config = {:description => config.webadmin_process_name,
+              :pid_file => config.webadmin_full_pid_path,
+              :stdout_trace => config.webadmin_full_stdout_trace_path,
+              :stderr_trace => config.webadmin_full_stderr_trace_path
+            }
+
+          ["int","term","hup"].each do |type| daemon_config["sig#{type}_handler".to_sym] = Proc::new {  WebAdminApp.quit! } end
+          res = daemonize daemon_config do
+            log = get_logger logger: :web, force: true
+            log.info "Starting Splash WebAdmin"
+            WebAdminApp.run!
+          end
+          sleep 1
+          if res == 0 then
+            pid = `cat #{config.webadmin_full_pid_path}`.to_i
+            log.ok "Splash WebAdmin Started, with PID : #{pid}"
+            return {:case => :quiet_exit, :more => "Splash WebAdmin successfully loaded."}
+          else
+            return {:case => :unknown_error, :more => "Splash WebAdmin loading error, see logs for more details."}
+          end
+
+        else
+          return {:case => :already_exist, :more => "Pid File, please verify if Splash WebAdmin is running."}
+        end
+      end
+
+      # Stop the Splash WebAdmin
+      # @param [Hash] options
+      # @option options [Symbol] :quiet activate quiet mode for log (limit to :fatal)
+      # @return [Hash] Exiter Case (:quiet_exit, :not_found, other)
+      def stopdaemon(options = {})
+          config = get_config
+          log = get_logger
+          log.level = :fatal if options[:quiet]
+          if File.exist?(config.webadmin_full_pid_path) then
+            begin
+              pid = `cat #{config.webadmin_full_pid_path}`.to_i
+              Process.kill("TERM", pid)
+              acase = {:case => :quiet_exit, :more => 'Splash WebAdmin stopped succesfully'}
+            rescue Errno::ESRCH
+              acase =  {:case => :not_found, :more => "Process of PID : #{pid} not found"}
+            end
+            FileUtils::rm config.webadmin_full_pid_path if File::exist? config.webadmin_full_pid_path
+          else
+            acase =  {:case => :not_found, :more => "Splash WebAdmin is not running"}
+          end
+          return acase
+      end
+
+      # Status of the Splash WebAdmin, display status
+      # @param [Hash] options ignored
+      # @return [Hash] Exiter Case (:status_ko, :status_ok)
+      def statusdaemon(options = {})
+        log = get_logger
+        config = get_config
+        pid = realpid = ''
+        pid = `cat #{config.webadmin_full_pid_path}`.to_s if File.exist?(config.webadmin_full_pid_path)
+        listpid = get_processes({ :pattern => get_config.webadmin_process_name})
+        pid.chomp!
+        if listpid.empty? then
+          realpid = ''
+        else
+          realpid = listpid.first
+        end
+        unless realpid.empty? then
+          log.item "Splash  WebAdmin Process is running with PID #{realpid} "
+        else
+          log.item 'Splash  WebAdminProcess not found '
+        end
+        unless pid.empty? then
+          log.item "and PID file exist with PID #{pid}"
+        else
+          log.item "and PID file don't exist"
+        end
+        if pid == realpid then
+          return {:case => :status_ok }
+        elsif pid.empty? then
+          return {:case => :status_ko, :more => "PID File error, you have to kill process manualy, with : '(sudo )kill -TERM #{realpid}'"}
+        elsif realpid.empty? then
+          return {:case => :status_ko, :more => "Process Splash WebAdmin missing, run 'splash webadmin stop' before reload properly"}
+        end
+      end
+
+    end
+  end
+end