prometheus-splash 0.8.3 → 0.8.6

data/config/splash.yml

@@ -73,49 +73,51 @@
 
 ### Sample configuration of commands and scheduling
   :commands:
-    :id_root:
+    - :name: :id_root
       :desc: run id command on root
       :command: id root
-    :true_test:
+    - :name: :true_test
       :desc: "test command returning true : 0"
       :command: "true"
       :schedule:
         :every: "1h"
       :on_failure: :ls_slash_tmp
       :on_success: :pwd
-    :false_test:
+    - :name: :false_test
       :desc: "test command returning false > 0"
       :command: "false"
       :schedule:
         :every: "1h"
       :on_failure: :ls_slash_tmp
       :on_success: :pwd
-    :ls_slash_tmp:
+    - :name: :ls_slash_tmp
       :desc: list file in /tmp
       :command: ls -al /tmp
       :user: daemon
       :on_success: :echo1
-    :pwd:
+    - :name: :pwd
       :desc: run pwd
       :command: pwd
       :on_success: :echo1
       :on_failure: :echo2
-    :echo1:
+    - :name: :echo1
       :desc: echo 'foo'
       :command: echo foo
       :on_failure: :echo3
-    :echo2:
+    - :name: :echo2
       :desc: echo 'bar'
       :command: echo bar
-    :echo3:
+    - :name: :echo3
       :desc: echo 'been'
       :command: echo been
-    :rand_sleep_5:
+    - :name: :rand_sleep_5
       :desc: sleep on a rand 5
       :command: ruby -e 'sleep rand(5)'
       :schedule:
-        :every: "10s"
-    :test_remote_call:
+        :every: "30s"
+      :retention:
+        :hours: 1
+    - :name: :test_remote_call
       :desc: remote call test
       :delegate_to:
         :host: omicron
@@ -138,11 +140,11 @@
 
 ### configuration of monitored processes
   :processes:
-    - :process: cron
+    - :process: :cron
       :patterns:
         - cron
       :retention:
-          :hours: 5
+        :hours: 5
 
 
 ###

data/lib/splash/backends/file.rb

@@ -54,7 +54,7 @@ module Splash
       # @option options [Symbol] :key the name of the record
       # @return [Boolean] status of the operation
       def del(options)
-        ::File.unlink("#{@path}/#{suffix_trace(options[:key])}") if File.exist?("#{@path}/#{suffix_trace(options[:key])}")
+        ::File.unlink("#{@path}/#{suffix_trace(options[:key])}") if ::File.exist?("#{@path}/#{suffix_trace(options[:key])}")
       end
 
       # verifiy a specific record existance

data/lib/splash/backends.rb

@@ -11,7 +11,7 @@ module Splash
 
     # factory for backend
     # @param [Symbol] store the name of the store actually in [:execution_trace]
-    # @return [Splash::Backends::<Type>|Hash] with type in [:redis,:file] or Exiter case :configuration_error 
+    # @return [Splash::Backends::<Type>|Hash] with type in [:redis,:file] or Exiter case :configuration_error
     def get_backend(store)
       splash_exit case: :configuration_error, more: "backend definition failure" if get_config[:backends][:stores][store].nil?
       backend = get_config[:backends][:stores][store][:type].to_s
@@ -23,5 +23,11 @@ module Splash
       end
     end
 
+    # return list of configured backand
+    # @return [Hash] the backends hash list/structure
+    def list_backends
+      return get_config[:backends][:stores]
+    end
+
   end
 end

data/lib/splash/cli/commands.rb

@@ -15,7 +15,7 @@ module CLISplash
 
 
     # Thor method : execution of command
-    desc "execute NAME", "run for command/sequence or ack result"
+    desc "execute COMMAND", "run for command/sequence or ack result"
     long_desc <<-LONGDESC
     execute command or sequence or ack result\n
     with --no-trace prevent storing execution trace in configured backend (see config file)\n
@@ -79,7 +79,7 @@ module CLISplash
 
 
     # Thor method : scheduling commands
-    desc "schedule NAME", "Schedule excution of command on Splash daemon"
+    desc "schedule COMMAND", "Schedule excution of command on Splash daemon"
     long_desc <<-LONGDESC
     Schedule excution of command on Splash daemon\n
     with --hostname, Schedule on an other Splash daemon via transport\n
@@ -125,7 +125,7 @@ module CLISplash
     end
 
     # Thor method : getting a treeview of sequence of commands
-    desc "treeview", "Show commands sequence tree"
+    desc "treeview COMMAND", "Show commands sequence tree"
     long_desc <<-LONGDESC
     Show commands sequence tree\n
     with --hostname, ask other Splash daemon via transport\n
@@ -159,7 +159,7 @@ module CLISplash
       end
       log.info "Command : #{command.to_s}" if depht == 0
       aproc = Proc::new do |command,depht|
-        cmd  = commands[command.to_sym]
+        cmd  = commands.select{|item| item[:name] ==  command.to_sym}.first
         if cmd[:on_failure] then
           spacer=  " " * depht + " "
           log.flat "#{spacer}* on failure => #{cmd[:on_failure]}"
@@ -211,16 +211,16 @@ module CLISplash
         list = get_config.commands
       end
       log.info "Splash configured commands :"
-      log.ko 'No configured commands found' if list.keys.empty?
-      list.keys.each do |command|
-        log.item "#{command.to_s}"
+      log.ko 'No configured commands found' if list.empty?
+      list.each do |command|
+        log.item "#{command[:name].to_s}"
         if options[:detail] then
-          log.arrow "command line : '#{list[command][:command]}'"
-          log.arrow "command description : '#{list[command][:desc]}'"
-          log.arrow "command failure callback : '#{list[command.to_sym][:on_failure]}'" if list[command.to_sym][:on_failure]
-          log.arrow "command success callback : '#{list[command.to_sym][:on_success]}'" if list[command.to_sym][:on_success]
-          if list[command.to_sym][:schedule]
-            sched,val = list[command.to_sym][:schedule].flatten
+          log.arrow "command line : '#{command[:command]}'"
+          log.arrow "command description : '#{command[:desc]}'"
+          log.arrow "command failure callback : '#{command[:on_failure]}'" if command[:on_failure]
+          log.arrow "command success callback : '#{command[:on_success]}'" if command[:on_success]
+          if command[:schedule] then
+            sched,val = command[:schedule].flatten
             log.arrow "command scheduled : #{sched} #{val}."
           end
         end
@@ -235,7 +235,7 @@ module CLISplash
     with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
     LONGDESC
     option :hostname, :type => :string,  :aliases => "-H"
-    def show(command)
+    def show(name)
       unless is_root? then
         splash_exit case: :not_root, :more => "Command show specifications"
       end
@@ -261,14 +261,15 @@ module CLISplash
       else
         list = get_config.commands
       end
-      if list.keys.include? command.to_sym then
-        log.info "Splash command : #{command}"
-        log.item "command line : '#{list[command.to_sym][:command]}'"
-        log.item "command description : '#{list[command.to_sym][:desc]}'"
-        log.item "command failure callback : '#{list[command.to_sym][:on_failure]}'" if list[command.to_sym][:on_failure]
-        log.item "command success callback : '#{list[command.to_sym][:on_success]}'" if list[command.to_sym][:on_success]
-        if list[command.to_sym][:schedule]
-          sched,val = list[command.to_sym][:schedule].flatten
+      command = list.select{|item| item[:name] == name.to_sym}.first
+      unless command.nil?  then
+        log.info "Splash command : #{command[:name]}"
+        log.item "command line : '#{command[:command]}'"
+        log.item "command description : '#{command[:desc]}'"
+        log.item "command failure callback : '#{command[:on_failure]}'" if command[:on_failure]
+        log.item "command success callback : '#{command[:on_success]}'" if command[:on_success]
+        if command[:schedule]
+          sched,val = command[:schedule].flatten
           log.item "command scheduled : #{sched} #{val}."
         end
         splash_exit case: :quiet_exit
@@ -284,11 +285,11 @@ module CLISplash
     show commands executions history for LABEL\n
     LONGDESC
     option :table, :type => :boolean,  :aliases => "-t"
-    desc "history LABEL", "show commands executions history"
+    desc "history COMMAND", "show commands executions history"
     def history(command)
       if is_root? then
         log = get_logger
-        log.info "Log : #{command}#"
+        log.info "Command : #{command}"
         config = get_config
         if options[:table] then
           table = TTY::Table.new do |t|
@@ -301,7 +302,7 @@ module CLISplash
                             value[:end_date],
                             value[:exec_time],
                             value[:stdout].empty?,
-                            value[:stdout].empty?]
+                            value[:stderr].empty?]
             end
           end
           if check_unicode_term  then
@@ -328,52 +329,8 @@ module CLISplash
       end
     end
 
-    # Thor method : getting information on the last execution of a command
-    desc "lastrun COMMAND", "Show last running result for specific configured command COMMAND"
-    long_desc <<-LONGDESC
-    Show last running result for specific configured command COMMAND\n
-    with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
-    LONGDESC
-    option :hostname, :type => :string,  :aliases => "-H"
-    def lastrun(command)
-      unless is_root? then
-        splash_exit case: :not_root, :more => "Command last execution report"
-      end
-      log = get_logger
-      backend = get_backend :execution_trace
-      redis = (backend.class == Splash::Backends::Redis)? true : false
-      if not redis and options[:hostname] then
-        splash_exit case: :specific_config_required, :more => "Redis backend is requiered for Remote execution report request"
-      end
-      splash_exit case: :not_root if not is_root? and not redis
-      list = get_config.commands.keys
-      if options[:hostname] then
-        options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
-        list = backend.list("*", options[:hostname]).map(&:to_sym)
-      end
-      if list.include? command.to_sym then
-        log.info "Splash command #{command} previous execution report:\n"
-        req  = { :key => command}
-        req[:hostname] = options[:hostname] if options[:hostname]
-        if backend.exist? req then
-          res = backend.get req
-          tp = Template::new(
-              list_token: get_config.execution_template_tokens,
-              template_file: get_config.execution_template_path)
-          tp.map YAML::load(res).last.values.first
-          log.flat tp.output
-        else
-          log.ko "Command not already runned."
-        end
-        splash_exit case: :quiet_exit
-      else
-        splash_exit case: :not_found, :more => "Command report never runned remotly" if options[:hostname]
-      end
-    end
-
-
     # Thor method : getting information on one specific execution of a command
-    desc "onerun COMMAND", "Show running result for specific configured command COMMAND"
+    desc "get_result COMMAND", "Show running result for specific configured command COMMAND"
     long_desc <<-LONGDESC
     Show specific running result for specific configured command COMMAND\n
     with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
@@ -381,8 +338,8 @@ module CLISplash
 
     LONGDESC
     option :hostname, :type => :string,  :aliases => "-H"
-    option :date, :type => :string,  :aliases => "-D", :required => true
-    def onerun(command)
+    option :date, :type => :string,  :aliases => "-D"
+    def get_result(command)
       unless is_root? then
         splash_exit case: :not_root, :more => "Command specific execution report"
       end
@@ -393,12 +350,12 @@ module CLISplash
         splash_exit case: :specific_config_required, :more => "Redis backend is requiered for Remote execution report request"
       end
       splash_exit case: :not_root if not is_root? and not redis
-      list = get_config.commands.keys
+      list = get_config.commands
       if options[:hostname] then
         options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
         list = backend.list("*", options[:hostname]).map(&:to_sym)
       end
-      if list.include? command.to_sym then
+      if list.select{|cmd| cmd[:name] == command.to_sym}.count > 0  then
         log.info "Splash command #{command} previous execution report:\n"
         req  = { :key => command}
         req[:hostname] = options[:hostname] if options[:hostname]
@@ -407,11 +364,15 @@ module CLISplash
           tp = Template::new(
               list_token: get_config.execution_template_tokens,
               template_file: get_config.execution_template_path)
-          prov =  YAML::load(res).select{|key,value| key.keys.first == options[:date]}
-          if prov.empty? then
+          if options[:date] then
+            prov =  YAML::load(res).select{|key,value| key.keys.first == options[:date]}.first
+          else
+            prov = YAML::load(res).last
+          end
+          if prov.nil? then
             log.ko "Command not runned one this date or date misformatted."
           else
-            tp.map prov.first.values.first
+            tp.map prov.values.first
             log.flat tp.output
           end
         else
@@ -419,12 +380,16 @@ module CLISplash
         end
         splash_exit case: :quiet_exit
       else
-        splash_exit case: :not_found, :more => "Command report never runned remotly" if options[:hostname]
+        if options[:hostname]
+            splash_exit case: :not_found, :more => "Command never runned remotly"
+          else
+            splash_exit case: :not_found, :more => "Command never runned"
+          end
       end
     end
 
     # Thor method : getting the list of avaibles executions reports
-    desc "getreportlist", "list all executions report results "
+    desc "reportlist", "list all executions report results "
     long_desc <<-LONGDESC
     list all executions report results\n
     with --pattern <SEARCH>, search type string, wilcard * (group) ? (char)\n
@@ -437,7 +402,7 @@ module CLISplash
     option :hostname, :type => :string,  :aliases => "-H"
     option :all, :type => :boolean, :negate => false,  :aliases => "-A"
     option :detail, :type => :boolean,  :aliases => "-D"
-    def getreportlist
+    def reportlist
       unless is_root? then
         splash_exit case: :not_root, :more => "Command execution report list"
       end

data/lib/splash/cli/config.rb

@@ -9,6 +9,7 @@ module CLISplash
     include Splash::Helpers
     include Splash::Exiter
     include Splash::Loggers
+    include Splash::Backends
 
     # Thor method : running of Splash setup
     desc "setup", "Setup installation fo Splash"
@@ -49,8 +50,18 @@ module CLISplash
 
     # Thor method : flushing configured backend
     desc "flushbackend", "Flush configured backend"
+    option :name, :type => :string,  :aliases => "-N"
     def flushbackend
-      acase = run_as_root :flush_backend
+      if options[:name] then
+        acase = run_as_root :flush_backend, options
+      else
+        return_cases = {}
+        list_backends.each do |key,value|
+          return_cases[key] = run_as_root :flush_backend, { :name => key }
+        end
+        errors = return_cases.select {|key,value| value[:case] != :quiet_exit}.keys
+        acase = (errors.empty?)? {:case => :quiet_exit, :more => "All backends flushed successfully"}: {:case => :configuration_error, :more => "Backends #{errors.join(',')} flushing failed"}
+      end
       splash_exit acase
     end
 

data/lib/splash/cli/daemon.rb

@@ -99,7 +99,7 @@ module CLISplash
     end
 
     # Thor method : sending reset verb over transport in the input queue of Splashd
-    desc "getjobs", "send a reset verb to HOSTNAME daemon over transport (need an active tranport), Typicallly RabbitMQ"
+    desc "reset", "send a reset verb to HOSTNAME daemon over transport (need an active tranport), Typicallly RabbitMQ"
     def reset(hostname=Socket.gethostname)
       log = get_logger
       log.info "ctrl+c for interrupt"

data/lib/splash/cli/logs.rb

@@ -63,10 +63,10 @@ module CLISplash
     end
 
 
-    
+
 
     # Thor method : display a specific Splash configured log monitor
-    desc "show LOG", "show Splash configured log monitoring for LOG"
+    desc "show LABEL", "show Splash configured log monitoring for LOG"
     def show(logrecord)
       if is_root? then
         log = get_logger
@@ -110,6 +110,38 @@ module CLISplash
       end
     end
 
+    # Thor method : display the full list of Splash configured log monitors
+    desc "get_result LABEL", "Get last or specific log monitoring report"
+    long_desc <<-LONGDESC
+    Get last or specific log monitoring report\n
+    with --date <DATE>, a date format string (same as in history ouput)
+    LONGDESC
+    option :date, :type => :string,  :aliases => "-D"
+    def get_result(label)
+      if is_root? then
+        log = get_logger
+        log.info "Log : #{label}"
+        config = get_config
+        records = LogsRecords::new(label).get_all_records
+        if options[:date] then
+          wanted = records.select{|key,value| key.keys.first == options[:date]}.first
+        else
+          wanted = records.last
+        end
+        if wanted.nil? then
+          splash_exit case: :not_found, more: "Log never monitored"
+        else
+          record =wanted.keys.first
+          value=wanted[record]
+          log.item record
+          log.arrow "Status : #{value[:status].to_s}"
+          log.arrow "nb files : #{value[:errors]}"
+          log.arrow "nb lines : #{value[:lines]}"
+        end
+      else
+        splash_exit case: :not_root, :more => "Log get result"
+      end
+    end
 
     # Thor method : show logs monitoring history
     long_desc <<-LONGDESC

data/lib/splash/cli/process.rb

@@ -114,6 +114,39 @@ module CLISplash
       end
     end
 
+    # Thor method : display the full list of Splash configured process monitors
+    desc "get_result PROCESS", "Get last or specific process monitoring report"
+    long_desc <<-LONGDESC
+    Get last or specific process monitoring report\n
+    with --date <DATE>, a date format string (same as in history ouput)
+    LONGDESC
+    option :date, :type => :string,  :aliases => "-D"
+    def get_result(process)
+      if is_root? then
+        log = get_logger
+        log.info "Process : #{process}"
+        config = get_config
+        records = ProcessRecords::new(process).get_all_records
+        if options[:date] then
+          wanted = records.select{|key,value| key.keys.first == options[:date]}.first
+        else
+          wanted = records.last
+        end
+        if wanted.nil? then
+          splash_exit case: :not_found, more: "Process never monitored"
+        else
+          record =wanted.keys.first
+          value=wanted[record]
+          log.item record
+          log.arrow "Status : #{value[:status].to_s}"
+          log.arrow "CPU Percent : #{value[:cpu_percent]}"
+          log.arrow "MEM Percent : #{value[:mem_percent]}"
+        end
+      else
+        splash_exit case: :not_root, :more => "Process get result"
+      end
+    end
+
 
     # Thor method : show logs monitoring history
     long_desc <<-LONGDESC

data/lib/splash/cli/webadmin.rb

@@ -35,9 +35,10 @@ module CLISplash
     long_desc <<-LONGDESC
     Starting Splash Daemon\n
     LONGDESC
+    option :foreground, :type => :boolean,  :aliases => "-F"
     desc "start", "Splash WebAdmin Daemon status"
     def start
-      acase = run_as_root :startweb
+      acase = run_as_root :startweb, options
       splash_exit acase
     end
 

data/lib/splash/commands.rb

@@ -48,6 +48,11 @@ module Splash
         @backend = get_backend :execution_trace
       end
 
+
+      def clear
+        @backend.del({:key => @name}) if  @backend.exist?({key: @name})
+      end
+
       def purge(retention)
         retention = {} if retention.nil?
         if retention.include? :hours then
@@ -96,7 +101,7 @@ module Splash
         @config  = get_config
         @url = @config.prometheus_pushgateway_url
         @name = name
-        unless @config.commands.keys.include? @name.to_sym then
+        unless @config.commands.select{|cmd| cmd[:name] == @name.to_sym }.count > 0 then
           splash_exit case: :not_found, more: "command #{@name} is not defined in configuration"
         end
       end
@@ -139,18 +144,20 @@ module Splash
         session = (options[:session])? options[:session] : get_session
         acase = { :case => :quiet_exit }
         exit_code = 0
-        if @config.commands[@name.to_sym][:delegate_to] then
+        command = @config.commands.select{|command| command[:name] == @name.to_sym}.first
+        if command[:delegate_to] then
           return { :case => :options_incompatibility, :more => '--hostname forbidden with delagate commands'} if options[:hostname]
-          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]}", session
+          log.send "Remote command : #{@name} execution delegate to : #{command[:delegate_to][:host]} as : #{command[:delegate_to][:remote_command]}", session
+          log.warn "Local command : #{command[:command]} defined but ignored, because delegate have the priority"
           begin
             transport = get_default_client
             if transport.class == Hash  and transport.include? :case then
               return transport
             else
               res = transport.execute({ :verb => :execute_command,
-                payload: {:name => @config.commands[@name.to_sym][:delegate_to][:remote_command].to_s},
+                payload: {:name => command[:delegate_to][:remote_command].to_s},
                 :return_to => "splash.#{Socket.gethostname}.return",
-                :queue => "splash.#{@config.commands[@name.to_sym][:delegate_to][:host]}.input" })
+                :queue => "splash.#{command[:delegate_to][:host]}.input" })
               exit_code = res[:exit_code]
               log.receive "return with exitcode #{exit_code}", session
 
@@ -164,35 +171,35 @@ module Splash
           start_date = DateTime.now.to_s
           unless options[:trace] then
             log.item "Traceless execution", session
-            if @config.commands[@name.to_sym][:user] then
-              log.item "Execute with user : #{@config.commands[@name.to_sym][:user]}.", session
-              system("sudo -u #{@config.commands[@name.to_sym][:user]} #{@config.commands[@name.to_sym][:command]} > /dev/null 2>&1")
+            if command[:user] then
+              log.item "Execute with user : #{command[:user]}.", session
+              system("sudo -u #{command[:user]} #{command[:command]} > /dev/null 2>&1")
             else
-              system("#{@config.commands[@name.to_sym][:command]} > /dev/null 2>&1")
+              system("#{command[:command]} > /dev/null 2>&1")
             end
             time = Time.now - start
             exit_code = $?.exitstatus
           else
             log.item "Tracefull execution", session
-            if @config.commands[@name.to_sym][:user] then
-              log.item "Execute with user : #{@config.commands[@name.to_sym][:user]}.", session
-              stdout, stderr, status = Open3.capture3("sudo -u #{@config.commands[@name.to_sym][:user]} #{@config.commands[@name.to_sym][:command]}")
+            if command[:user] then
+              log.item "Execute with user : #{command[:user]}.", session
+              stdout, stderr, status = Open3.capture3("sudo -u #{command[:user]} #{command[:command]}")
             else
-              stdout, stderr, status = Open3.capture3(@config.commands[@name.to_sym][:command])
+              stdout, stderr, status = Open3.capture3(command[:command])
             end
             time = Time.now - start
             data = Hash::new
             data[:start_date] = start_date
             data[:end_date] = DateTime.now.to_s
             data[:cmd_name] = @name
-            data[:cmd_line] = @config.commands[@name.to_sym][:command]
-            data[:desc] = @config.commands[@name.to_sym][:desc]
+            data[:cmd_line] = command[:command]
+            data[:desc] = command[:desc]
             data[:status] = status.to_s
             data[:stdout] = stdout
             data[:stderr] = stderr
             data[:exec_time] = time.to_s
             cmdrec = CmdRecords::new @name
-            cmdrec.purge(@config.commands[@name.to_sym][:retention])
+            cmdrec.purge(command[:retention])
             cmdrec.add_record data
             exit_code = status.exitstatus
           end
@@ -205,24 +212,26 @@ module Splash
           end
         end
         if options[:callback] then
-          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
+          on_failure = (command[:on_failure])? command[:on_failure] : false
+          on_success = (command[:on_success])? command[:on_success] : false
           if on_failure and exit_code > 0 then
             log.item "On failure callback : #{on_failure}", session
-            if @config.commands.keys.include?  on_failure then
+            if @config.commands.select {|item| item[:name] == on_failure}.count > 0 then
               @name = on_failure.to_s
               call_and_notify options
             else
-              acase = { :case => :configuration_error , :more => "on_failure call error : #{on_failure} command inexistant."}
+              log.error "on_failure call error : #{on_failure.to_s} command inexistant.", session
+              acase = { :case => :configuration_error , :more => "Command #{command[:name]} callback coniguration error"}
             end
           end
           if on_success and exit_code == 0 then
             log.item "On success callback : #{on_success}", session
-            if @config.commands.keys.include?  on_success then
+            if @config.commands.select {|item| item[:name] == on_success}.count > 0 then
               @name = on_success.to_s
               call_and_notify options
             else
-              acase = { :case => :configuration_error , :more => "on_success call error : #{on_failure} command inexistant."}
+              log.error "on_success call error : #{on_success.to_s} command inexistant."
+              acase = { :case => :configuration_error , :more => "Command #{command[:name]} callback coniguration error"}
             end
           end
         else

data/lib/splash/config/flush.rb

@@ -16,8 +16,8 @@ module Splash
       self.extend Splash::Backends
       self.extend Splash::Loggers
       log = get_logger
-      log.info "Splash backend flushing"
-      name  = (options[:name])? options[:name] : :execution_trace
+      name  = (options[:name])? options[:name].to_sym : :execution_trace
+      log.info "Splash backend #{name.to_s} flushing"
       backend = get_backend name
       if backend.flush then
         return { :case => :quiet_exit, :more => "Splash backend #{name.to_s} flushed" }