prometheus-splash 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6674f3e9608370fdb5cd83f68ad51c91f749230f1698009ddd811d795000af1b
+  data.tar.gz: 314e8c80cdcc580bf1ccc45fc887adb3907d5d2d9af1b3930d0fee04ff740e27
+SHA512:
+  metadata.gz: c8cbdb6c3b296602a997d95727abb23da02ef27227afe7654a9a6213795f156d70d117569a71192aa5768837d650e4f3e9b760196e5e471c743ae0999be06989
+  data.tar.gz: bfc21d04dafd15d23c5e6ddf9de3851d103f64e800be0875ffd6ca8d6d68bedeef29fe9d4c205caf8b3bdb130ee57062630bd1f2f572e4337edc7d16dbb2093a

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in codetree.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Splash Copyright (c) 2020 Ultragreen Software, Romain GEORGES
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,32 @@
+# Splash
+
+SPLASH is *Supervision with Prometheus of Logs and Asynchronous tasks for Services or Hosts*
+
+
+Prometheus Logs and Batchs supervision over PushGateway
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'splash'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install splash
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,61 @@
+require "bundler/gem_tasks"
+require 'rubygems'
+require 'rspec'
+require 'rake'
+require "rake/clean"
+require "rubygems/package_task"
+require "rdoc/task"
+require 'code_statistics'
+require 'rspec/core/rake_task'
+require 'yard'
+require 'yard/rake/yardoc_task.rb'
+require "rake/tasklib"
+require "roodi"
+require "roodi_task"
+
+
+RoodiTask.new() do | t |
+t.patterns = %w(lib/**/*.rb)
+t.config = "ultragreen_roodi_coding_convention.yml"
+end
+
+
+CLEAN.include('*.tmp','*.old')
+CLOBBER.include('*.tmp', 'build/*','#*#')
+
+
+content = File::readlines(File.join(File.dirname(__FILE__), 'splash.gemspec')).join
+spec = eval(content)
+
+RSpec::Core::RakeTask.new('spec')
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = [ 'lib/**/*.rb', '-', 'doc/**/*','spec/**/*_spec.rb']
+  t.options += ['--title', "Gem Documentation"]
+  t.options += ['-o', "yardoc"]
+  t.options += ['-r', "doc/manual.rdoc"]
+end
+YARD::Config.load_plugin('yard-rspec')
+
+namespace :yardoc do
+  task :clobber do
+    rm_r "yardoc" rescue nil
+    rm_r ".yardoc" rescue nil
+  end
+end
+task :clobber => "yardoc:clobber"
+
+
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+Rake::RDocTask.new('rdoc') do |d|
+  d.rdoc_files.include('doc/**/*','bin/*')
+  d.main = 'doc/manual.rdoc'
+  d.title = 'Dorsal : Yard'
+  d.options << '--line-numbers' << '--diagram' << '-SHN'
+end
+
+task :default => [:gem]

data/bin/splash

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby -W:no-deprecated
+
+require 'prometheus/client'
+require 'prometheus/client/push'
+
+begin
+  require 'thor'
+rescue Gem::GemNotFoundException
+  $stderr.puts "Loadind error, it's like you try to run Splash, with a lake of dependencies."
+  $stderr.puts "If you run on RVM, please run with rvmsudo and not with sudo."
+  $stderr.puts "If problem is percistant, please, proceed to new install and Setup."
+end
+
+require 'yaml'
+
+require 'splash/constants'
+require 'splash/helpers'
+require 'splash/config'
+
+require 'splash/command'
+require 'splash/logs'
+require 'splash/controller'
+
+#inhibit warning : due to prometheus-client call to URI.encode warning
+$-w = nil
+
+include Splash::Helpers
+
+module CLISplash
+
+
+  class Commands < Thor
+
+    option :ack, :type => :boolean
+    desc "wrap NAME", "wrapping for command or ack result"
+    def wrap(name)
+      command =  Splash::CommandWrapper::new(name)
+      command.ack if options[:ack]
+      command.call_and_notify
+    end
+  end
+
+
+  class CLIController < Thor
+    include Splash::LogsMonitor::DaemonController
+
+    option :foreground, :type => :boolean
+    desc "start", "Starting Logs Monitor Daemon"
+    def start
+      run_as_root :startdaemon
+    end
+
+    desc "stop", "Stopping Logs Monitor Daemon"
+    def stop
+      run_as_root :stopdaemon
+    end
+
+
+  end
+
+  class Config < Thor
+    include Splash::Config
+    include Splash::Helpers
+
+    desc "setup", "Setup installation fo Splash"
+    def setup
+      run_as_root :setupsplash
+
+    end
+
+    desc "sanitycheck", "Verify installation fo Splash"
+    def sanitycheck
+      run_as_root :checkconfig
+    end
+
+    desc "version", "display current Splash version"
+    def version
+        config = get_config
+        puts "Splash version : #{config.version}, Author : #{config.author}"
+        puts config.copyright
+    end
+
+
+  end
+
+
+  class Logs < Thor
+
+    desc "analyse", "analyze logs in config"
+    def analyse
+      result = Splash::LogScanner::new
+      result.analyse
+      p result.output
+    end
+
+    desc "monitor", "monitor logs in config"
+    def monitor
+      result = Splash::LogScanner::new
+      result.analyse
+      result.notify
+    end
+
+
+  end
+end
+
+class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+  include CLISplash
+  desc "commands SUBCOMMAND ...ARGS", "Managing commands/batchs supervision"
+  subcommand "commands", Commands
+  desc "logs SUBCOMMAND ...ARGS", "Managing Files/Logs supervision"
+  subcommand "logs", Logs
+  desc "daemon SUBCOMMAND ...ARGS", "Logs monitor daemon contoller"
+  subcommand "daemon", CLIController
+  desc "config SUBCOMMAND ...ARGS", "config tools for Splash"
+  subcommand "config", Config
+end
+
+
+
+
+
+
+CLI.start(ARGV)

data/config/splash.yml

@@ -0,0 +1,17 @@
+:splash:
+  :logs:
+    - :log: /tmp/test
+      :pattern: ERROR
+    - :log: /var/log/message
+      :pattern: error
+  :daemon:
+    :user: daemon
+    :group: daemon
+    :process_name: "Splash : Prometheus logs monitoring."
+    :paths:
+      :pid_path: /tmp
+      :trace_path: /tmp/splash
+    :files:
+      :stdout_trace: stdout.txt
+      :stderr_trace: stderr.txt
+      :pid_file: splash.pid

data/lib/splash/command.rb

@@ -0,0 +1,29 @@
+module Splash
+  class CommandWrapper
+    def initialize(name)
+      @name = name
+    end
+
+    def ack
+      puts "Sending ack for command : '#{@name}'"
+      notify(0)
+      exit 0
+    end
+
+    def notify(value)
+      registry = Prometheus::Client.registry
+      metric = Prometheus::Client::Gauge.new(:errorcode, docstring: 'SPLASH metric batch errorcode')
+      registry.register(metric)
+      metric.set(value)
+      Prometheus::Client::Push.new(@name).add(registry)
+    end
+
+
+    def call_and_notify
+      puts "Executing command : '#{@name}' and notify Prometheus PushGateway"
+      system("#{@name} > /dev/null")
+      exit_code = $?.exitstatus
+      notify(exit_code)
+    end
+  end
+end

data/lib/splash/config.rb

@@ -0,0 +1,151 @@
+module Splash
+  module Config
+    include Splash::Helpers
+    include Splash::Constants
+
+
+
+    class Configuration < Hash
+      include Splash::Constants
+      def initialize(config_file=CONFIG_FILE)
+        config_from_file = readconf config_file
+        self[:version] = VERSION
+        self[:author] = "#{AUTHOR} <#{EMAIL}>"
+        self[:copyright] = "#{COPYRIGHT} #{LICENSE}"
+        self[:daemon_process_name] = (config_from_file[:daemon][:process_name])? config_from_file[:daemon][:process_name] : DAEMON_PROCESS_NAME
+        self[:daemon_user] = (config_from_file[:daemon][:user])? config_from_file[:daemon][:user] : DAEMON_USER
+        self[:daemon_group] = (config_from_file[:daemon][:group])? config_from_file[:daemon][:group] : DAEMON_GROUP
+        self[:pid_path] = (config_from_file[:daemon][:paths][:pid_path])? config_from_file[:daemon][:paths][:pid_path] : PID_PATH
+        self[:trace_path] = (config_from_file[:daemon][:paths][:trace_path])? config_from_file[:daemon][:paths][:trace_path] : TRACE_PATH
+        self[:pid_file] = (config_from_file[:daemon][:files][:pid_file])? config_from_file[:daemon][:files][:pid_file] : PID_FILE
+        self[:stdout_trace] = (config_from_file[:daemon][:files][:stdout_trace])? config_from_file[:daemon][:files][:stdout_trace] : STDOUT_TRACE
+        self[:stderr_trace] = (config_from_file[:daemon][:files][:stderr_trace])? config_from_file[:daemon][:files][:stderr_trace] : STDERR_TRACE
+        self[:logs] = (config_from_file[:logs])? config_from_file[:logs] : {}
+      end
+
+      def logs
+        return self[:logs]
+      end
+
+      def author
+        return self[:author]
+      end
+
+      def copyright
+        return self[:copyright]
+      end
+
+      def version
+        return self[:version]
+      end
+
+      def daemon_process_name
+        return self[:daemon_process_name]
+      end
+
+      def daemon_user
+        return self[:daemon_user]
+      end
+
+      def daemon_group
+        return self[:daemon_group]
+      end
+
+      def full_pid_path
+        return "#{self[:pid_path]}/#{self[:pid_file]}"
+      end
+
+      def full_stdout_trace_path
+        return "#{self[:trace_path]}/#{self[:stdout_trace]}"
+      end
+
+      def full_stderr_trace_path
+        return "#{self[:trace_path]}/#{self[:stderr_trace]}"
+      end
+
+      private
+      def readconf(file = CONFIG_FILE)
+        return YAML.load_file(file)[:splash]
+      end
+
+
+    end
+
+
+    def get_config(config_file=CONFIG_FILE)
+      return Configuration::new config_file
+    end
+
+
+    def setupsplash
+      conf_in_path = search_file_in_gem "splash", "config/splash.yml"
+
+      print "* Installing Configuration file : #{CONFIG_FILE} : "
+      if install_file source: conf_in_path, target: CONFIG_FILE, mode: "644", owner: "root", group: "wheel" then
+        puts "[OK]"
+      else
+        puts "[KO]"
+      end
+      config = get_config
+
+      print "* Checking pid file path : #{config[:pid_path]}"
+      if make_folder path: config[:pid_path], mode: "644", owner: "root", group: "wheel" then
+        puts "[OK]"
+      else
+        puts "[KO]"
+      end
+
+      print "* Checking trace file path : #{config[:trace_path]}"
+      if make_folder path: config[:trace_path], mode: "777", owner: config.daemon_user, group: config.daemon_group then
+        puts "[OK]"
+      else
+        puts "[KO]"
+      end
+
+      puts "Splash config done. "
+
+    end
+
+    def checkconfig
+      config = get_config
+      print "Config file : #{CONFIG_FILE}"
+      res = verify_file(name: CONFIG_FILE, mode: "644", owner: "root", group: "wheel")
+      if res.empty? then
+        print "[OK]\n"
+      else
+        print "[KO]\n"
+        print res
+      end
+
+
+    end
+
+    private
+
+    def search_file_in_gem(_gem,_file)
+      if Gem::Specification.respond_to?(:find_by_name)
+        begin
+          spec = Gem::Specification.find_by_name(_gem)
+        rescue LoadError
+          spec = nil
+        end
+      else
+        spec = Gem.searcher.find(_gem)
+      end
+      if spec then
+        if Gem::Specification.respond_to?(:find_by_name)
+          res = spec.lib_dirs_glob.split('/')
+        else
+          res = Gem.searcher.lib_dirs_for(spec).split('/')
+        end
+        res.pop
+        services_path = res.join('/').concat("/#{_file}")
+        return services_path if File::exist?(services_path)
+        return false
+      else
+        return false
+      end
+    end
+
+  end
+end

data/lib/splash/constants.rb

@@ -0,0 +1,18 @@
+module Splash
+  module Constants
+    VERSION = "0.0.1"
+    CONFIG_FILE = "/etc/splash.yml"
+    DAEMON_USER = "root"
+    DAEMON_GROUP = "wheel"
+    PID_PATH="/var/run"
+    TRACE_PATH="/var/run/splash"
+    PID_FILE="splash.pid"
+    STDOUT_TRACE="stdout.txt"
+    STDERR_TRACE="stderr.txt"
+    DAEMON_PROCESS_NAME="Splash : Prometheus logs monitoring."
+    AUTHOR="Romain GEORGES"
+    EMAIL = "gems@ultragreen.net"
+    COPYRIGHT="Ultragreen (c) 2020"
+    LICENSE="BSD-2-Clause"
+  end
+end

data/lib/splash/controller.rb

@@ -0,0 +1,48 @@
+
+module Splash
+  module LogsMonitor
+    module DaemonController
+      include Splash::Constants
+      include Splash::Helpers
+      include Splash::Config
+
+      def startdaemon(options = {})
+        config = get_config
+        unless File::exist? config.full_pid_path then
+          return daemonize :description => config.daemon_process_name,
+                           :pid_file => config.full_pid_path,
+                           :daemon_user => config.daemon_user,
+                           :daemon_group => config.daemon_group,
+                           :stdout_trace => config.full_stdout_trace_path,
+                           :stderr_trace => config.full_stderr_trace_path do
+            result = LogScanner::new
+            while true
+              sleep 5
+              puts "Notify"
+              result.analyse
+              result.notify
+            end
+          end
+        end
+      end
+
+      def stopdaemon(options = {})
+          config = get_config
+          if File.exist?(config.full_pid_path) then
+
+            begin
+              pid = `cat #{config.full_pid_path}`.to_i
+              Process.kill("TERM", pid)
+            rescue Errno::ESRCH
+              $stderr.puts "Process of PID : #{pid} not found"
+            end
+              FileUtils::rm config.full_pid_path if File::exist? config.full_pid_path
+            return true
+          else
+            return false
+          end
+      end
+
+    end
+  end
+end

data/lib/splash/helpers.rb

@@ -0,0 +1,205 @@
+# coding: utf-8
+require 'fileutils'
+require 'etc'
+
+# coding: utf-8
+module Splash
+  module Helpers
+
+    def is_root?
+      case (Process.uid)
+      when 0
+        return true
+      else
+        return false
+      end
+    end
+
+    def run_as_root(method)
+      unless is_root?
+        $stderr.puts "You need to be root to execute this subcommands : #{method.to_s}"
+        $stderr.puts "Please execute with sudo, or rvmsudo."
+        exit 10
+      else
+        self.send method
+      end
+    end
+
+    # method for daemonize blocks
+    # @param [Hash] _options the list of options, keys are symbols
+    # @option  _options [String] :description the description of the process, use for $0
+    # @option  _options [String] :pid_file the pid filenam
+    # @yield a process definion or block given
+    # @example usage inline
+    #    class Test
+    #      include Splash::Helpers::Application
+    #      private :daemonize
+    #      def initialize
+    #        @loop = Proc::new do
+    #          loop do
+    #            sleep 1
+    #          end
+    #        end
+    #      end
+    #
+    #      def run
+    #        daemonize({:description => "A loop daemon", :pid_file => '/tmp/pid.file'}, &@loop)
+    #      end
+    #     end
+    #
+    # @example usage block
+    #    class Test
+    #      include Splash::Helpers::Application
+    #      include Dorsal::Privates
+    #      private :daemonize
+    #      def initialize
+    #      end
+    #
+    #      def run
+    #        daemonize :description => "A loop daemon", :pid_file => '/tmp/pid.file' do
+    #          loop do
+    #            sleep 1
+    #          end
+    #        end
+    #      end
+    #     end
+    # @return [Fixnum] pid the pid of the forked processus
+    def daemonize(options)
+      #Process.euid = 0
+      #Process.egid = 0
+      return yield if options[:debug]
+      trap("SIGINT"){ exit! 0 }
+      trap("SIGTERM"){ exit! 0 }
+      trap("SIGHUP"){ exit! 0 }
+
+      fork do
+        #Process.daemon
+        File.open(options[:pid_file],"w"){|f| f.puts Process.pid } if options[:pid_file]
+        uid = Etc.getpwnam(options[:daemon_user]).uid
+        gid = Etc.getgrnam(options[:daemon_group]).gid
+        Process::UID.change_privilege(uid)
+      #  Process::GID.change_privilege(gid)
+        $stdout.reopen(options[:stdout_trace], "w")
+        $stderr.reopen(options[:stderr_trace], "w")
+
+        #$0 = options[:description]
+        Process.setproctitle options[:description]
+
+        yield
+
+      end
+      return true
+    end
+
+    # @!group facilités sur le système de fichier
+
+    # facilité d'installation de fichier
+    # @param [Hash] options
+    # @option options [String] :source le chemin source du fichier
+    # @option options [String] :target le chemin cible du fichier
+    def install_file(options = {})
+      #begin
+        FileUtils::copy options[:source], options[:target] #unless File::exist? options[:target]
+        FileUtils.chmod options[:mode].to_i(8), options[:target] if options[:mode]
+        FileUtils.chown options[:owner], options[:group], options[:target] if options[:owner] and options[:group]
+        return true
+      #rescue StandardError
+        # return false
+      #end
+    end
+
+    # facilité de création de répertoire
+    # @param [Hash] options
+    # @option options [String] :path le répertoire à créer (relatif ou absolut)
+    def make_folder(options = {})
+      begin
+        FileUtils::mkdir_p options[:path] unless File::exist? options[:path]
+        FileUtils.chmod options[:mode].to_i(8), options[:path] if options[:mode]
+        FileUtils.chown options[:owner], options[:group], options[:path] if options[:owner] and options[:group]
+        return true
+      rescue StandardError
+        return false
+      end
+    end
+
+    # facilité de liaison symbolique  de fichier
+    # @param [Hash] options
+    # @option options [String] :source le chemin source du fichier
+    # @option options [String] :link le chemin du lien symbolique
+    def make_link(options = {})
+      begin
+        FileUtils::rm options[:link] if (File::symlink? options[:link] and not File::exist? options[:link])
+        FileUtils::ln_s options[:source], options[:link] unless File::exist? options[:link]
+        return true
+      rescue StandardError
+        return false
+      end
+    end
+    # @!endgroup
+
+
+    #@!group  Vérifiers de l'application
+
+    # verifier d'existence d'un repertoire
+    # @return [Bool] vrai ou faux
+    # @param [Hash] options
+    # @option options [String] :path le répertoire à créer (relatif ou absolut)
+    def verify_folder(options ={})
+      return File.directory?(options[:path])
+    end
+
+    # verifier d'existence d'un lien
+    # @return [Bool] vrai ou faux
+    # @param [Hash] options
+    # @option options [String] :name path du lien
+    def verify_link(options ={})
+      return File.file?(options[:name])
+    end
+
+    # verifier d'existence d'un fichier
+    # @return [Bool] vrai ou faux
+    # @param [Hash] options
+    # @option options [String] :name path du fichier
+    def verify_file(options ={})
+      res = Array::new
+      return  [:inexistant] unless File.file?(options[:name])
+      stat = File.stat(options[:name])
+      if options[:mode] then
+        mode = "%o" % stat.mode
+        res << :mode if mode[-3..-1] != options[:mode]
+      end
+      if options[:owner] then
+        res << :owner if Etc.getpwuid(stat.uid).name != options[:owner]
+      end
+      if options[:group] then
+        res << :group if Etc.getgrgid(stat.gid).name != options[:group]
+      end
+      return res
+    end
+
+    # verifier de l'ecoute d'un service sur un host et port donné en TCP
+    # @return [Bool] vrai ou faux
+    # @param [Hash] options
+    # @option options [String] :host le nom d'hote
+    # @option options [String] :port le port TCP
+    def verify_service(options ={})
+      begin
+        Timeout::timeout(1) do
+          begin
+            s = TCPSocket.new(options[:host], options[:port])
+            s.close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return false
+          end
+        end
+      rescue Timeout::Error
+        return false
+      end
+    end
+    #!@endgroup
+
+
+
+  end
+end

data/lib/splash/logs.rb

@@ -0,0 +1,39 @@
+module Splash
+  class LogScanner
+    include Splash::Constants
+    include Splash::Config
+
+    def initialize
+      @logs_target = get_config.logs
+
+      @registry = Prometheus::Client.registry
+      @metric = Prometheus::Client::Gauge.new(:logerror, docstring: 'SPLASH metric log error', labels: [:log ])
+      @registry.register(@metric)
+    end
+
+    def analyse
+      @logs_target.each do |record|
+        record[:count]=0 if record[:count].nil?
+        record[:status] = :clean if record[:status].nil?
+        if File.exist?(record[:log]) then
+          record[:count] = File.readlines(record[:log]).grep(/#{record[:pattern]}/).size
+          record[:status] = :matched if record[:count] > 0
+        else
+          record[:status] = :mssing
+        end
+      end
+    end
+
+    def output
+      return @logs_target
+    end
+
+    def notify
+      @logs_target.each do |item|
+        @metric.set(item[:count], labels: { log: item[:log] })
+      end
+      Prometheus::Client::Push.new('Splash').add(@registry)
+    end
+
+  end
+end

data/splash.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'splash/constants'
+
+Gem::Specification.new do |spec|
+  spec.name          = "prometheus-splash"
+  spec.version       = Splash::Constants::VERSION
+  spec.authors       = [Splash::Constants::AUTHOR]
+  spec.email         = [Splash::Constants::EMAIL]
+  spec.description   = %q{Prometheus Logs and Batchs supervision over PushGateway}
+  spec.summary       = %q{Supervision with Prometheus of Logs and Asynchronous tasks for Services or Hosts }
+  spec.homepage      = "http://www.ultragreen.net"
+  spec.license       = Splash::Constants::LICENSE
+  spec.require_paths << 'bin'
+  spec.bindir = 'bin'
+  spec.executables = Dir["bin/*"].map!{|item| item.gsub("bin/","")}
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency 'thor','~> 1.0.1'
+  spec.add_runtime_dependency 'prometheus-client','~> 2.0.0'
+  spec.add_development_dependency 'rake', '~> 13.0.1'
+  spec.add_development_dependency 'rspec', '~> 3.9.0'
+  spec.add_development_dependency 'yard', '~> 0.9.24'
+  spec.add_development_dependency 'rdoc', '~> 6.2.1'
+  spec.add_development_dependency 'roodi', '~> 5.0.0'
+  spec.add_development_dependency 'code_statistics', '~> 0.2.13'
+  spec.add_development_dependency 'yard-rspec', '~> 0.1'
+
+
+end

data/templates/splashd.service

@@ -0,0 +1,20 @@
+[Unit]
+Description=Splash Daemon
+After=network-online.target
+
+[Service]
+Type=simple
+
+User=splash
+Group=splash
+UMask=007
+
+ExecStart=/splash daemon start
+
+Restart=on-failure
+
+# Configures the time to wait before service is stopped forcefully.
+TimeoutStopSec=300
+
+[Install]
+WantedBy=multi-user.target

data/ultragreen_roodi_coding_convention.yml

@@ -0,0 +1,25 @@
+AssignmentInConditionalCheck:
+CaseMissingElseCheck:
+ClassLineCountCheck:             
+  line_count: 300
+ClassNameCheck:                  
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+#ClassVariableCheck:
+CyclomaticComplexityBlockCheck:  
+  complexity: 5
+CyclomaticComplexityMethodCheck: 
+  complexity: 10
+EmptyRescueBodyCheck:
+ForLoopCheck:
+MethodLineCountCheck:            
+  line_count: 30 
+MethodNameCheck:                 
+  pattern: !ruby/regexp /^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ 
+# MissingForeignKeyIndexCheck:
+ModuleLineCountCheck:            
+  line_count: 500
+ModuleNameCheck:          
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ParameterNumberCheck:            
+  parameter_count: 5
+ 

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: prometheus-splash
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Romain GEORGES
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: prometheus-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.24
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.24
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.2.1
+- !ruby/object:Gem::Dependency
+  name: roodi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: code_statistics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.13
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.13
+- !ruby/object:Gem::Dependency
+  name: yard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: Prometheus Logs and Batchs supervision over PushGateway
+email:
+- gems@ultragreen.net
+executables:
+- splash
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/splash
+- config/splash.yml
+- lib/splash/command.rb
+- lib/splash/config.rb
+- lib/splash/constants.rb
+- lib/splash/controller.rb
+- lib/splash/helpers.rb
+- lib/splash/logs.rb
+- splash.gemspec
+- templates/splashd.service
+- ultragreen_roodi_coding_convention.yml
+homepage: http://www.ultragreen.net
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Supervision with Prometheus of Logs and Asynchronous tasks for Services or
+  Hosts
+test_files: []