prometheus-splash 0.7.0 → 0.8.4

data/lib/splash/webadmin/api/routes/logs.rb

@@ -4,56 +4,71 @@
 
 WebAdminApp.get '/api/logs/list.?:format?' do
   log = get_logger
+  list = {}
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : logs, verb : GET, route : list, format : #{format}"
+  log.call "API : logs, verb : GET, route : list, format : #{format}"
   logs_recordset = get_config.logs
-  obj =  splash_return case: :quiet_exit, :more => "logses list"
-  obj[:data] = logs_recordset
+  list =  splash_return case: :quiet_exit, :more => "logs list"
+  list[:data] = logs_recordset
   content_type format
-  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  format_response(list, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
   end
 
 WebAdminApp.get '/api/logs/show/:name.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : logs, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
+  log.call "API : logs, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
   logs_recordset = get_config.logs.select{|item| item[:label] == params[:name].to_sym }
+  show = {}
   unless logs_recordset.empty? then
     record = logs_recordset.first
-    obj = splash_return case: :quiet_exit
-    obj[:data] = record
+    show = splash_return case: :quiet_exit
+    show[:data] = record
+    status 201
   else
-    obj = splash_return case: :not_found, :more => "logs not configured"
+    show = splash_return case: :not_found, :more => "logs not configured"
   end
-  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  format_response(show, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
 
 WebAdminApp.post '/api/logs/analyse.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : logs, verb : POST, route : analyse, format : #{format}"
+  log.call "API : logs, verb : POST, route : analyse, format : #{format}"
   results = Splash::Logs::LogScanner::new
   results.analyse
   res = results.output
-  obj =  splash_return case: :quiet_exit, :more => "logs analyse report"
-  obj[:data] = res
+  analyse =  splash_return case: :quiet_exit, :more => "logs analyse report"
+  analyse[:data] = res
   status 201
   content_type format
-  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  format_response(analyse, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
 
 WebAdminApp.post '/api/logs/monitor.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : logs, verb : POST, route : monitor, format : #{format}"
+  log.call "API : logs, verb : POST, route : monitor, format : #{format}"
   results = Splash::Logs::LogScanner::new
   results.analyse
-  res = splash_return results.notify
-  if res[:status] == :failure then
+  monitor = splash_return results.notify
+  if monitor[:status] == :failure then
     status 503
   else
     status 201
   end
   content_type format
-  format_response(res, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  format_response(monitor, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end
+
+WebAdminApp.get '/api/logs/history/:label.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : logs, verb : GET, route : history, format : #{format}"
+  record = Splash::Logs::LogsRecords::new(params[:label]).get_all_records
+  history =  splash_return case: :quiet_exit, :more => "log monitoring history"
+  history[:data] = record
+  content_type format
+  status 201
+  format_response(history, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end

data/lib/splash/webadmin/api/routes/process.rb

@@ -2,10 +2,10 @@
 
 
 
-WebAdminApp.get '/api/process/list.?:format?' do
+WebAdminApp.get '/api/processes/list.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : process, verb : GET, route : list, format : #{format}"
+  log.call "API : processes, verb : GET, route : list, format : #{format}"
   process_recordset = get_config.processes
   obj =  splash_return case: :quiet_exit, :more => "Processes list"
   obj[:data] = process_recordset
@@ -13,11 +13,11 @@ WebAdminApp.get '/api/process/list.?:format?' do
   format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
   end
 
-WebAdminApp.get '/api/process/show/:name.?:format?' do
+WebAdminApp.get '/api/processes/show/:name.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : process, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
-  process_recordset = get_config.processes.select{|item| item[:process] == params[:name] }
+  log.call "API : processes, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
+  process_recordset = get_config.processes.select{|item| item[:process] == params[:name].to_sym }
   unless process_recordset.empty? then
     record = process_recordset.first
     obj = splash_return case: :quiet_exit
@@ -29,10 +29,10 @@ WebAdminApp.get '/api/process/show/:name.?:format?' do
   format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
 
-WebAdminApp.post '/api/process/analyse.?:format?' do
+WebAdminApp.post '/api/processes/analyse.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : process, verb : POST, route : analyse, format : #{format}"
+  log.call "API : processes, verb : POST, route : analyse, format : #{format}"
   results = Splash::Processes::ProcessScanner::new
   results.analyse
   res = results.output
@@ -43,10 +43,10 @@ WebAdminApp.post '/api/process/analyse.?:format?' do
   format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
 
-WebAdminApp.post '/api/process/monitor.?:format?' do
+WebAdminApp.post '/api/processes/monitor.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : process, verb : POST, route : monitor, format : #{format}"
+  log.call "API : processes, verb : POST, route : monitor, format : #{format}"
   results = Splash::Processes::ProcessScanner::new
   results.analyse
   res = splash_return results.notify
@@ -58,3 +58,15 @@ WebAdminApp.post '/api/process/monitor.?:format?' do
   content_type format
   format_response(res, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
+
+WebAdminApp.get '/api/processes/history/:process.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : processes, verb : GET, route : history, format : #{format}"
+  record = Splash::Processes::ProcessRecords::new(params[:process]).get_all_records
+  history =  splash_return case: :quiet_exit, :more => "Proces monitoring history"
+  history[:data] = record
+  content_type format
+  status 201
+  format_response(history, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end

data/lib/splash/webadmin/api/routes/sequences.rb

@@ -5,7 +5,7 @@
 WebAdminApp.get '/api/sequences/list.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : sequences, verb : GET, route : list, format : #{format}"
+  log.call "API : sequences, verb : GET, route : list, format : #{format}"
   obj =  splash_return case: :quiet_exit, :more => "Sequences list"
   obj[:data] = get_config.sequences
   content_type format
@@ -15,7 +15,7 @@ WebAdminApp.get '/api/sequences/list.?:format?' do
 WebAdminApp.get '/api/sequences/show/:name.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : sequences, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
+  log.call "API : sequences, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
   sequences_recordset = get_config.sequences[params[:name].to_sym]
   unless sequences_recordset.nil? then
     obj = splash_return case: :quiet_exit

data/lib/splash/webadmin/main.rb

@@ -6,6 +6,9 @@ class WebAdminApp < Sinatra::Base
   include Splash::Helpers
   include Splash::Exiter
   include Splash::Loggers
+  include Splash::Daemon::Controller
+  include Splash::Logs
+  include Splash::Processes
 
   set :server, 'thin'
   set :port, get_config.webadmin_port

data/lib/splash/webadmin/portal/controllers/commands.rb

@@ -1,5 +1,7 @@
 WebAdminApp.get '/commands' do
   get_menu 2
+  log = get_logger
+  log.call "WEB : commands, verb : GET, controller : /commands"
   url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/commands/list.yml"
   raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
   @data = YAML::load(raw)[:data]

data/lib/splash/webadmin/portal/controllers/documentation.rb

@@ -1,5 +1,7 @@
 WebAdminApp.get '/documentation' do
   get_menu 6
+  log = get_logger
+  log.call "WEB : documentation, verb : GET, controller : /documentation"
     filename = search_file_in_gem("prometheus-splash","README.md")
     @data = Kramdown::Document.new(File::readlines(filename).join).to_html
     slim :documentation, :format => :html

data/lib/splash/webadmin/portal/controllers/home.rb

@@ -1,12 +1,36 @@
 WebAdminApp.get '/' do
+  log = get_logger
+  log.call "WEB : BASE, verb : GET, controller : /"
   get_menu -1
   url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/full.yml"
   @raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
   @data = YAML::load(@raw)[:data]
+  @status = get_processes({ :pattern => get_config.daemon_process_name}).empty?
   slim :home, :format => :html
 end
 
 WebAdminApp.get '/home' do
   get_menu 0
+  log = get_logger
+  log.call "WEB : home, verb : GET, controller : /home"
   slim :home, :format => :html
 end
+
+WebAdminApp.get '/daemon/:action' do
+  content_type :text
+  log = get_logger
+  log.call "WEB : daemon, verb : GET, controller : /daemon/:action"
+  case params[:action]
+  when 'start'
+    startdaemon scheduling: true, purge: false
+    return 'start'
+  when 'stop'
+    stopdaemon
+    return 'stop'
+  when 'restart'
+    stopdaemon
+    startdaemon scheduling: true, purge: false
+    return 'start'
+  else
+  end
+end

data/lib/splash/webadmin/portal/controllers/logs.rb

@@ -1,5 +1,7 @@
-WebAdminApp.get '/logs' do
+WebAdminApp.get '/logs/?:status?/?:label?' do
   get_menu 0
+  log = get_logger
+  log.call "WEB : logs, verb : GET, controller : /logs/?:status?/?:label?"
   url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/logs/list.yml"
   raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
   @data = YAML::load(raw)[:data]
@@ -7,8 +9,62 @@ WebAdminApp.get '/logs' do
   raw = RestClient::Request.execute(method: 'POST', url: url,timeout: 10)
   prov = YAML::load(raw)[:data]
   @result = {}
+  @log_failed = params[:label] if params[:status] == 'failure'
+  @log_saved = params[:label] if params[:status] == 'success'
   prov.each {|item|
     @result[item[:label]] = item
   }
   slim :logs, :format => :html
 end
+
+
+WebAdminApp.get '/add_modify_log/?:label?' do
+  get_menu 0
+  log = get_logger
+  log.call "WEB : logs, verb : GET, controller : /add_modify_log/?:label?"
+  @data = {}
+  if params[:label] then
+    url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/logs/show/#{params[:label].to_s}.yml"
+    raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
+    res = YAML::load(raw)
+    @data = res[:data] if res[:status] == :success
+    @data[:old_label] = params[:label].to_s
+  end
+  slim :log_form, :format => :html
+end
+
+
+WebAdminApp.get '/get_log_history/:label' do
+  get_menu 0
+  log = get_logger
+  log.call "WEB : logs, verb : GET, controller : /get_log_history/:label"
+  @data = {}
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/logs/history/#{params[:label].to_s}.yml"
+  raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
+  res = YAML::load(raw)
+  @data = res[:data] if res[:status] == :success
+  @label = params[:label].to_s
+  slim :log_history, :format => :html
+end
+
+WebAdminApp.post '/save_log' do
+  get_menu 0
+  log = get_logger
+  log.call "WEB : logs, verb : POST, controller : /save_log/?:label?"
+  data = {}
+  data[:log] = params[:log]
+  data[:pattern] = params[:pattern]
+  data[:label] = params[:label].to_sym
+  if params[:update] then
+    url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/deletelog/#{params[:old_label]}"
+    raw = RestClient::Request.execute(method: 'DELETE', url: url,timeout: 10)
+  end
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/addlog.yml"
+  raw = RestClient::Request.execute(method: 'POST', url: url,timeout: 10, payload: data.to_yaml)
+  res = YAML::load(raw)
+  if res[:status] == :success then
+    redirect "/logs/success/#{params[:label].to_s}"
+  else
+    redirect "/logs/failure/#{params[:label].to_s}"
+  end
+end

data/lib/splash/webadmin/portal/controllers/processes.rb

@@ -1,14 +1,72 @@
-WebAdminApp.get '/processes' do
+WebAdminApp.get '/processes/?:status?/?:process?' do
   get_menu 1
-  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/process/list.yml"
+  log = get_logger
+  log.call "WEB : processes, verb : GET, controller : /processes/?:status?/?:process?"
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/processes/list.yml"
   raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
   @data = YAML::load(raw)[:data]
-  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/process/analyse.yml"
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/processes/analyse.yml"
   raw = RestClient::Request.execute(method: 'POST', url: url,timeout: 10)
   prov = YAML::load(raw)[:data]
   @result = {}
+  @process_failed = params[:process] if params[:status] == 'failure'
+  @process_saved = params[:process] if params[:status] == 'success'
   prov.each {|item|
     @result[item[:process]] = item
   }
   slim :processes, :format => :html
 end
+
+WebAdminApp.get '/add_modify_process/?:process?' do
+  get_menu 1
+  log = get_logger
+  log.call "WEB : processes, verb : GET, controller : /add_modify_process/?:process?"
+  @data = {}
+  if params[:process] then
+    url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/processes/show/#{params[:process].to_s}.yml"
+    raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
+    res = YAML::load(raw)
+    @data = res[:data] if res[:status] == :success
+    if @data[:patterns].class == Array then
+      prov = @data[:patterns].join('|')
+      @data[:patterns] = prov
+    end
+    @data[:old_process] = params[:process].to_s
+  end
+  slim :process_form, :format => :html
+end
+
+
+WebAdminApp.get '/get_process_history/:process' do
+  get_menu 1
+  log = get_logger
+  log.call "WEB : processes, verb : GET, controller : /get_process_history/:process"
+  @data = {}
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/processes/history/#{params[:process].to_s}.yml"
+  raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
+  res = YAML::load(raw)
+  @data = res[:data] if res[:status] == :success
+  @process = params[:process].to_s
+  slim :process_history, :format => :html
+end
+
+WebAdminApp.post '/save_process' do
+  get_menu 1
+  log = get_logger
+  log.call "WEB : processes, verb : POST, controller : /save_process/?:process?"
+  data = {}
+  data[:patterns] = params[:patterns].split('|')
+  data[:process] = params[:process].to_sym
+  if params[:update] then
+    url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/deleteprocess/#{params[:old_process]}"
+    raw = RestClient::Request.execute(method: 'DELETE', url: url,timeout: 10)
+  end
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/addprocess.yml"
+  raw = RestClient::Request.execute(method: 'POST', url: url,timeout: 10, payload: data.to_yaml)
+  res = YAML::load(raw)
+  if res[:status] == :success then
+    redirect "/processes/success/#{params[:process].to_s}"
+  else
+    redirect "/processes/failure/#{params[:process].to_s}"
+  end
+end

data/lib/splash/webadmin/portal/controllers/proxy.rb

@@ -1,27 +1,36 @@
 
 
 WebAdminApp.use Rack::ReverseProxy do
-  reverse_proxy /^\/pushgateway\/?(.*)$/, get_config.prometheus_pushgateway_url
+  reverse_proxy /^\/pushgateway\/?(.*)$/, get_config.prometheus_pushgateway_url + '/'
   reverse_proxy_options preserve_host: true
 end
 
 
 WebAdminApp.use Rack::ReverseProxy do
-  reverse_proxy /^\/prometheus\/?(.*)$/, get_config.prometheus_url
+  reverse_proxy /^\/prometheus\/?(.*)$/, get_config.prometheus_url + '/'
+  reverse_proxy_options preserve_host: true
+end
+
+
+WebAdminApp.use Rack::ReverseProxy do
+  reverse_proxy /^\/alertmanager\/?(.*)$/, get_config.prometheus_alertmanager_url + '/'
   reverse_proxy_options preserve_host: true
 end
 
 WebAdminApp.get '/proxy/links' do
   get_menu 5
-
+  log = get_logger
+  log.call "WEB : proxy, verb : GET, controller : /proxy/links"
   config = get_config
   if config.webadmin_proxy == true then
     @proxy = true
     @pushgateway_url = "http://#{config.webadmin_ip}:#{config.webadmin_port}/pushgateway"
     @prometheus_url = "http://#{config.webadmin_ip}:#{config.webadmin_port}/prometheus"
+    @alertmanager_url = "http://#{config.webadmin_ip}:#{config.webadmin_port}/prometheus"
   else
     @proxy = false
     @pushgateway_url = "#{config.prometheus_pushgateway_url}"
+    @alertmanager_url = "#{config.prometheus_alertmanager_url}"
     @prometheus_url = "#{config.prometheus_url}"
   end
   slim :proxy, :format => :html

data/lib/splash/webadmin/portal/controllers/restclient.rb

@@ -1,14 +1,19 @@
 WebAdminApp.get '/restclient' do
+  log = get_logger
+  log.call "WEB : restclient, verb : GET, controller : /restclient"
   get_menu 4
   slim :restclient,  :format => :html
 end
 
 WebAdminApp.post '/restclient/query' do
+  log = get_logger
+  log.call "WEB : processes, verb : GET, controller : /restclient/query"
   @method = params[:method]
   @url = params[:url]
+  @body = params[:body]
   @notfound = false
   begin
-    @result = RestClient::Request.execute(method: @method.to_sym, url: @url,timeout: 10)
+    @result = RestClient::Request.execute(method: @method.to_sym, url: @url,timeout: 10, payload: @body)
   rescue SocketError
     @result = false
   rescue RestClient::NotFound => e