watchmonkey_cli 1.9.0 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 623f20ce059d5f6b5b7a9681f22cf5ce6f165e13481b6707289be5d1a8fa2859
-  data.tar.gz: b4b3ab70d5aa2fb649cdbbaa0e2c99d2da446bfae49ef332bf2d65b3d551b391
+  metadata.gz: 5d2615fa891c7ccb38541934fa918c33fa37a93cc3d3c52ece8db41a100e1d0b
+  data.tar.gz: 98f2a66da3fdc810c9b7fc1396ba12a605f3cd12d939585e9c9ed03d9f252fbf
 SHA512:
-  metadata.gz: 3b82d300ad1617ded3156dc8fa1e82f27a435f9965134236d2b21fef7d8a2df2019e7e7786650ae3bc4c925d9cc9e27e9054b015ed3f514b0d88185c5f47d93b
-  data.tar.gz: 65a2ec5bad871ca993cebdee262461f11f175117377ecdad0261bda5fb780f6c5a6962d7447fb0c108541880377d8b8c4880d444b540886ad567051dcc703781
+  metadata.gz: 23307a955c34627a32e0023df5dc40874eda5d72e80f152e2a57bcf12be767b34db53fc565ffbc8329060cbfe8e72871956123bf553f0ff409ed4468528bca0f
+  data.tar.gz: c671b5bac01cf8c423eef81ada024cd35a1c82f426c9fa80cee4cb90047aa242c579a39248ef349d2cc69d7be281037caac74afa410d59af633029f5b5860b52

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in dle.gemspec
 gemspec
+
+# optional dependencies
+gem 'telegram-bot-ruby'

data/README.md

@@ -4,10 +4,11 @@ Watchmonkey is a very simple tool to monitor resources with Ruby without the nee
 
 Before looking any further you might want to know:
 
-  * There is no escalation or notification system but you may add it yourself
-  * I created this for being used with [Platypus](http://sveinbjorn.org/platypus) hence the [Platypus Hook](https://github.com/2called-chaos/watchmonkey_cli/blob/master/lib/watchmonkey_cli/hooks/platypus.rb)
+  * There is no escalation or notification system (except experimental telegram bot) but you may add it yourself
+  * I originally created this for being used with [Platypus](http://sveinbjorn.org/platypus) hence the [Platypus Hook](https://github.com/2called-chaos/watchmonkey_cli/blob/master/lib/watchmonkey_cli/hooks/platypus.rb)
   * This is how the text output looks like: [Screenshot](http://imgur.com/8yLYnKb)
   * This is how the Platypus support looks like: [ProgressBar](http://imgur.com/Vd8ZD7A) [HTML/WebView](http://imgur.com/5FwmWFZ)
+  * This is how Telegram Bot looks for now: [Telegram Screenshot](http://imgur.com/HBONi51)
 
 ---
 
@@ -43,6 +44,8 @@ To get a list of available options invoke Watchmonkey with the `--help` or `-h`
             --generate-config [myconfig] Generates a example config in ~/.watchmonkey
         -l, --log [file]                 Log to file, defaults to ~/.watchmonkey/logs/watchmonkey.log
         -t, --threads [NUM]              Amount of threads to be used for checking (default: 10)
+        -e, --except tag1,tag2           Don't run tasks tagged with given tags
+        -o, --only tag1,tag2             Only run tasks tagged with given tags
         -s, --silent                     Only print errors and infos
         -q, --quiet                      Only print errors
 
@@ -81,6 +84,15 @@ If you want to monitor something that is not covered by the buildin handlers you
 By default Watchmonkey will run all tests once and then exit. This addon will enable Watchmonkey to run in a loop and run tests on a periodic interval.
 Since this seems like a core feature it might get included directly into Watchmonkey but for now take a look at the [application configuration file](https://github.com/2called-chaos/watchmonkey_cli/blob/master/doc/config_example.rb) and [ReQueue source code](https://github.com/2called-chaos/watchmonkey_cli/blob/master/lib/watchmonkey_cli/hooks/requeue.rb) for integration examples.
 
+### Telegram Bot
+Notify via Telegram. Experimental. Refer to [application configuration file](https://github.com/2called-chaos/watchmonkey_cli/blob/master/doc/config_example.rb) and [TelegramBot source code](https://github.com/2called-chaos/watchmonkey_cli/blob/master/lib/watchmonkey_cli/hooks/telegram_bot.rb) for further information.
+
+* works with ReQueue (wouldn't make much sense otherwise huh?)
+* optional per-user message throttling via checker uniqid (checker name + host + arguments)
+* optional per-user only/except filters based on tags
+* planned: robust telegram connection failure handling
+* planned: per-user regex exclusion filters
+
 ### Platypus support
 [Platypus](http://sveinbjorn.org/platypus) is a MacOS software to create dead simple GUI wrappers for scripts. There is buildin support for the interface types ProgressBar and WebView. For integration examples take a look at the [application configuration file](https://github.com/2called-chaos/watchmonkey_cli/blob/master/doc/config_example.rb) and [Platypus hook source code](https://github.com/2called-chaos/watchmonkey_cli/blob/master/lib/watchmonkey_cli/hooks/platypus.rb).
 

data/VERSION

@@ -1 +1 @@
-1.9.0
+1.12.0

data/doc/checker_example.rb

@@ -12,9 +12,18 @@ module MyWatchmonkeyCheckers
     #     e.g. my_checker "http://google.com", some_option: true
     self.checker_name = "my_checker"
 
+    # Maximum amount of time this task may run before it gets killed.
+    # Set to 0/false to have no time limit whatsoever.
+    # Set to proc to evaluate at runtime
+    # Defaults to app.opts[:maxrt] if nil/unset
+    #self.maxrt = false
+    #self.maxrt = 5.minutes
+    #self.maxrt = ->(app, checker, args){ app.opts[:maxrt] && app.opts[:maxrt] * 2 }
+
     # Called by configuration defining a check with all the arguments.
     #   e.g. my_checker "http://google.com", some_option: true
     # Should invoke `app.enqueue` which will by default call `#check!` method with given arguments.
+    # Must have options as last argument!
     def enqueue host, opts = {}
       opts = { some_option: false }.merge(opts)
 
@@ -28,6 +37,7 @@ module MyWatchmonkeyCheckers
     end
 
     # First argument is the result object, all other arguments came from `app.enqueue` call.
+    # Must have options as last argument!
     def check! result, host, opts = {}
       # Do your checks and modify the result object.
       # Debug messages will not show if -s/--silent or -q/--quiet argument is passed.

data/doc/config_example.rb

@@ -43,3 +43,59 @@ if @argv.delete("--platypus")
 
   @opts[:colorize] = false # doesn't render in platypus
 end
+
+
+
+# Integrate Telegram notifications
+# For options refer to the source code:
+#     https://github.com/2called-chaos/watchmonkey_cli/blob/master/lib/watchmonkey_cli/hooks/telegram_bot.rb
+if @argv.delete("--telegram")
+  require "watchmonkey_cli/hooks/telegram_bot"
+  WatchmonkeyCli::TelegramBot.hook!(self, {
+    # to create a bot refer to https://core.telegram.org/bots#6-botfather
+    api_key: "123456789:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+
+    # poll timeout, the longer this is (in seconds) the longer it will take to gracefully shut down
+    timeout: 5,
+
+    # optionally log incoming messages
+    #logger: Logger.new(STDOUT),
+
+    # purge old throttle data, default: 30.days
+    #throttle_retention: 30.days,
+
+    # retry sending messages that failed, default: false
+    # Not recommended since on connection failure a HUGE amount of messages will accumulate
+    # and spam you (and reach rate limits) upon connection restore.
+    #retry_on_egress_failure: false,
+
+    # configure your notification targets, if not listed you can't interact with the bot
+    notify: [
+      [
+        # your telegram ID, if you try talking to the bot it will tell you your ID
+        987654321,
+
+        # flags
+        #   - :all        -- same as :debug, :info, :error (not recommended)
+        #   - :debug      -- send all debug messages (not recommended)
+        #   - :info       -- send all info messages (not recommended)
+        #   - :error      -- send all error messages (RECOMMENDED)
+        #   - :admin_flag -- allows access to some commands (/wm_shutdown /stats)
+        [:error, :admin_flag],
+
+        # options (all optional, you can comment them out but leave the {})
+        {
+          # throttle: seconds(int) -- throttle messages by checker uniqid for this long (0/false = no throttle, default)
+          throttle: 15*60,
+
+          # only: Array(string, symbol) -- only notify when tagged with given tags
+          only: %w[production critical],
+
+          # except: Array(string, symbol) -- don't notify when tagged with given tags (runs after only-check)
+          except: %w[database],
+        }
+      ],
+      [123456789, [:error], { throttle: 30.minutes }]
+    ],
+  })
+end

data/lib/watchmonkey_cli/application/configuration.rb

@@ -59,9 +59,11 @@ module WatchmonkeyCli
         end
       end
 
-      def initialize app, file
+      def initialize app, file = nil, tags = []
         @app = app
         @file = file
+        @tags = tags
+        return unless file
         begin
           eval File.read(file, encoding: "utf-8"), binding, file
         rescue
@@ -74,9 +76,42 @@ module WatchmonkeyCli
         @app.fetch_connection(:ssh, name, opts, &b)
       end
 
+      def tag_all! *tags
+        @tags = tags.map(&:to_sym)
+      end
+
       def method_missing meth, *args, &block
         if c = @app.checkers[meth.to_s]
-          c.enqueue(*args)
+          opts = args.extract_options!
+          only = @app.opts[:tag_only]
+          except = @app.opts[:tag_except]
+
+          # build tags
+          tags = (@tags + (opts[:tags] || []).map(&:to_sym))
+          if @app.opts[:autotag]
+            tags << :"WMC-#{c.class.checker_name}" # checker name
+            if args[0].is_a?(Symbol)
+              tags << :"WMS-#{args[0]}" # ssh/local connection
+            elsif args[0].is_a?(String) && args[0].match(/\Ahttp(s)?:\/\//i)
+              uri = URI.parse(args[0]) rescue false
+              tags << :"WMH-#{uri.hostname.gsub(".", "_")}" if uri # hostname from URL
+            end
+          end
+          tags = tags.uniq
+          @app.tag_list.merge(tags)
+
+          if only.any?
+            if tags.any?{|t| only.include?(t) }
+              if tags.any?{|t| except.include?(t) }
+                return @app.debug "Skipping #{meth} with #{args} and #{opts} due to tag_except filter..."
+              end
+            else
+              return @app.debug "Skipping #{meth} with #{args} and #{opts} due to tag_only filter..."
+            end
+          elsif tags.any?{|t| except.include?(t) }
+            return @app.debug "Skipping #{meth} with #{args} and #{opts} due to tag_except filter..."
+          end
+          c.enqueue(*args, opts.merge(tags: tags))
         else
           super
         end

data/lib/watchmonkey_cli/application/configuration.tpl

@@ -1,5 +1,26 @@
 # This is a Ruby file!
 
+# =========================================
+# = Step 0: Tag all checkers in this file =
+# =========================================
+
+# All checkers you define after this will get these
+# base tags (you can pass additional ones).
+# Do note that you can call this method multiple
+# times and it will replace your base tags for
+# all checkers to follow, base tags will be cleared
+# upon reaching the end of the file.
+
+tag_all! :production, :critical
+
+# You can use additional tags on any checker by passing
+# a `tags` option consisting of an Array of strings or symbols.
+#   e.g.:
+#     some_checker :some_target, tags: %w[critical foo bar]
+
+
+
+
 # =================================
 # = Step 1: Setup SSH connections =
 # =================================
@@ -36,7 +57,7 @@ ssh_connection :my_server, host: "wheel@example.com", port: 23 # additional opti
 #
 #    timeout    Maximum time to wait for request (default: 20 seconds)
 #     verify    If enabled the peer will be verified (default: true)
-#  threshold    Minimum certificate lifetime before showing warnings (default: 1.month)
+#  threshold    Minimum certificate lifetime before showing warnings (default: 28.days)
 #
 ssl_expiration "https://example.com", threshold: 3.months
 

data/lib/watchmonkey_cli/application/core.rb

@@ -1,6 +1,12 @@
 module WatchmonkeyCli
   class Application
     module Core
+      def filtered_threads
+        Thread.list.reject do |thr|
+          thr.backtrace[0]["gems/concurrent-ruby"] rescue false
+        end
+      end
+
       # ===================
       # = Signal trapping =
       # ===================
@@ -37,10 +43,31 @@ module WatchmonkeyCli
         end
       end
 
-      def fire which, *args
+      def fire which, *args, &block
         return if @disable_event_firing
-        sync { debug "[Event] Firing #{which} (#{@hooks[which].try(:length) || 0} handlers) #{args.map(&:class)}", 99 }
-        @hooks[which] && @hooks[which].each{|h| h.call(*args) }
+        sync { debug "[Event] Firing #{which} (#{@hooks[which].try(:length) || 0} handlers) #{args.map(&:class)}#{" HAS_BLOCK" if block}", 99 }
+        if block && (!@hooks[which] || @hooks[which].empty?)
+          block.call
+        else
+          if @hooks[which] && @hooks[which].any?
+            if block
+              catch :abort do
+                _fire_around(@hooks[which], args, 0, &block)
+              end
+            else
+              @hooks[which].all?{|h| h.call(*args) }
+            end
+          end
+        end
+      end
+
+      def _fire_around hooks, args, index = 0, &block
+        return block.call unless hook = hooks[index]
+        skip = catch(:skip) {
+          hook.call(*args) { _fire_around(hooks, args, index + 1, &block) }
+          nil
+        }
+        _fire_around(hooks, args, index + 1, &block) if skip
       end
 
 
@@ -81,7 +108,12 @@ module WatchmonkeyCli
 
       def close_connections!
         @connections.each do |type, clist|
-          clist.each{|id, con| con.close! }
+          clist.each do |id, con|
+            if con.established?
+              debug "[SHUTDOWN] closing #{type} connection #{id} #{con}"
+              con.close!
+            end
+          end
         end
       end
 
@@ -97,8 +129,26 @@ module WatchmonkeyCli
           @queue << [checker, a, ->(*a) {
             begin
               result = Checker::Result.new(checker, *a)
+
+              # assign tags
+              taskopts = a.extract_options!
+              result.tags = taskopts[:tags] || []
+              a << taskopts
+
               checker.debug(result.str_running)
-              checker.safe(result.str_safe) { cb.call(result, *a) }
+              checker.rsafe(result) {
+                timeout = checker.class.maxrt.nil? ? @opts[:maxrt] : checker.class.maxrt
+                timeout = timeout.call(self, checker, a) if timeout.respond_to?(:call)
+                begin
+                  if timeout && timeout > 0
+                    Timeout::timeout(timeout) { cb.call(result, *a) }
+                  else
+                    cb.call(result, *a)
+                  end
+                rescue Timeout::Error => ex
+                  result.error! "TIMEOUT: did not finish within #{timeout} seconds, task killed!"
+                end
+              }
               fire(:result_dump, result, a, checker)
               result.dump!
             ensure

data/lib/watchmonkey_cli/application/dispatch.rb

@@ -3,7 +3,11 @@ module WatchmonkeyCli
     module Dispatch
       def dispatch action = (@opts[:dispatch] || :help)
         if respond_to?("dispatch_#{action}")
-          send("dispatch_#{action}")
+          fire(:dispatch_before, action)
+          fire(:dispatch_around, action) do
+            send("dispatch_#{action}")
+          end
+          fire(:dispatch_after, action)
         else
           abort("unknown action #{action}", 1)
         end
@@ -41,7 +45,7 @@ module WatchmonkeyCli
       ensure
         @running = false
         stop_checkers!
-        close_connections!
+        Timeout::timeout(@opts[:conclosewait]) { close_connections! } rescue false
         release_signals
       end
 

data/lib/watchmonkey_cli/application/output_helper.rb

@@ -13,6 +13,10 @@ module WatchmonkeyCli
         sync { @opts[:stdout].send(:warn, *a) }
       end
 
+      def info msg
+        puts c("[INFO]  #{msg}", :blue)
+      end
+
       def debug msg, lvl = 1
         puts c("[DEBUG] #{msg}", :black) if @opts[:debug] && @opts[:debug] >= lvl
       end

data/lib/watchmonkey_cli/application.rb

@@ -1,6 +1,6 @@
 module WatchmonkeyCli
   class Application
-    attr_reader :opts, :checkers, :connections, :threads, :queue, :hooks, :processed
+    attr_reader :opts, :checkers, :connections, :threads, :queue, :hooks, :processed, :tag_list
     include Helper
     include OutputHelper
     include Colorize
@@ -21,9 +21,22 @@ module WatchmonkeyCli
           app.haltpoint
         rescue Interrupt
           app.abort("Interrupted", 1)
+        rescue SystemExit
+          # silence
         ensure
+          $wm_runtime_exiting = true
           app.fire(:wm_shutdown)
-          app.debug "#{Thread.list.length} threads remain..."
+          if app.filtered_threads.length > 1
+            app.error "[WARN] #{app.filtered_threads.length} threads remain (should be 1)..."
+            app.filtered_threads.each do |thr|
+              app.debug "[THR] #{Thread.main == thr ? "MAIN" : "THREAD"}\t#{thr.alive? ? "ALIVE" : "DEAD"}\t#{thr.inspect}", 10
+              thr.backtrace.each do |l|
+                app.debug "[THR]\t#{l}", 20
+              end
+            end
+          else
+            app.debug "1 thread remains..."
+          end
         end
       end
     end
@@ -36,6 +49,7 @@ module WatchmonkeyCli
       @monitor = Monitor.new
       @threads = []
       @queue = Queue.new
+      @tag_list = Set.new
       @processed = 0
       @running = false
       @opts = {
@@ -45,11 +59,16 @@ module WatchmonkeyCli
         colorize: true,          # -m flag
         debug: false,            # -d flag
         threads: 10,             # -t flag
+        maxrt: 120.seconds,      # max runtime of a single task after which it will be terminated (may break SSH connection), 0/false to not limit runtime
+        conclosewait: 10,        # max seconds to wait for connections to be closed (may never if they got killed by maxrt)
         loop_forever: false,     # (internal) loop forever (app mode)
         loop_wait_empty: 1,      # (internal) time to wait in thread if queue is empty
+        autotag: true,           # (internal) if true checkers will get auto tags for checker name and hostname/connection
         silent: false,           # -s flag
         quiet: false,            # -q flag
         stdout: STDOUT,          # (internal) STDOUT redirect
+        tag_only: [],            # -o flag
+        tag_except: [],          # -e flag
       }
       init_params
       yield(self)
@@ -63,6 +82,8 @@ module WatchmonkeyCli
         opts.on("--generate-config [myconfig]", "Generates a example config in ~/.watchmonkey") {|s| @opts[:dispatch] = :generate_config; @opts[:config_name] = s }
         opts.on("-l", "--log [file]", "Log to file, defaults to ~/.watchmonkey/logs/watchmonkey.log") {|s| @opts[:logfile] = s || logger_filename }
         opts.on("-t", "--threads [NUM]", Integer, "Amount of threads to be used for checking (default: 10)") {|s| @opts[:threads] = s }
+        opts.on("-e", "--except tag1,tag2", Array, "Don't run tasks tagged with given tags") {|s| @opts[:tag_except] = s.map(&:to_sym) }
+        opts.on("-o", "--only tag1,tag2", Array, "Only run tasks tagged with given tags") {|s| @opts[:tag_only] = s.map(&:to_sym) }
         opts.on("-s", "--silent", "Only print errors and infos") { @opts[:silent] = true }
         opts.on("-q", "--quiet", "Only print errors") { @opts[:quiet] = true }
 
@@ -74,10 +95,15 @@ module WatchmonkeyCli
         opts.on("-z", "Do not check for updates on GitHub (with -v/--version)") { @opts[:check_for_updates] = false }
         opts.on("--dump-core", "for developers") { @opts[:dump] = true }
       end
+      fire(:optparse_init, @optparse)
     end
 
     def parse_params
-      @optparse.parse!(@argv)
+      fire(:optparse_parse_before, @optparse)
+      fire(:optparse_parse_around, @optparse) do
+        @optparse.parse!(@argv)
+      end
+      fire(:optparse_parse_after, @optparse)
     rescue OptionParser::ParseError => e
       abort(e.message)
       dispatch(:help)

data/lib/watchmonkey_cli/checker.rb

@@ -17,6 +17,14 @@ module WatchmonkeyCli
       @checker_name = name
     end
 
+    def self.maxrt
+      @maxrt
+    end
+
+    def self.maxrt= seconds
+      @maxrt = seconds
+    end
+
     module AppHelper
       def init_checkers!
         @checkers = {}
@@ -44,16 +52,24 @@ module WatchmonkeyCli
 
     class Result
       attr_reader :checker, :type, :args
-      attr_accessor :result, :command, :data
+      attr_accessor :result, :command, :data, :tags
 
       def initialize checker, *args
         @checker = checker
         @args = args
         @mutex = Monitor.new
         @type = :info
+        @tags = []
         @spool = { error: [], info: [], debug: []}
       end
 
+      def uniqid additional = []
+        ([
+          self.class.name,
+          @args.map(&:to_s).to_s,
+        ] + additional).join("/")
+      end
+
       def sync &block
         @mutex.synchronize(&block)
       end
@@ -147,6 +163,10 @@ module WatchmonkeyCli
       end
     end
 
+    def blank_config tags = []
+      Application::Configuration.new(app, nil, tags)
+    end
+
     # def to_s
     #   string = "#<#{self.class.name}:#{self.object_id} "
     #   fields = self.class.inspector_fields.map{|field| "#{field}: #{self.send(field)}"}
@@ -168,8 +188,10 @@ module WatchmonkeyCli
             error "#{descriptor}retry #{tries} reason is `#{e.class}: #{e.message}'"
             e.backtrace.each{|l| debug "\t\t#{l}" }
           end
-          sleep 1
-          retry
+          unless $wm_runtime_exiting
+            sleep 1
+            retry
+          end
         end
         error "#{descriptor}retries exceeded"
       end
@@ -187,10 +209,12 @@ module WatchmonkeyCli
             e.backtrace.each{|l| resultobj.debug "\t\t#{l}" }
             resultobj.dump!
           end
-          sleep 1
-          retry
+          unless $wm_runtime_exiting
+            sleep 1
+            retry
+          end
         end
-        resultobj.error! "#{descriptor}retries exceeded"
+        resultobj.error! "retries exceeded"
         resultobj.dump!
       end
     end

data/lib/watchmonkey_cli/checkers/dev_pry.rb

@@ -0,0 +1,29 @@
+module WatchmonkeyCli
+  module Checkers
+    class DevPry < Checker
+      self.checker_name = "dev_pry"
+      self.maxrt = false
+
+      def enqueue host, opts = {}
+        host = app.fetch_connection(:loopback, :local) if !host || host == :local
+        host = app.fetch_connection(:ssh, host) if host.is_a?(Symbol)
+        app.enqueue(self, host, opts)
+      end
+
+      def check! result, host, opts = {}
+        if app.opts[:threads] > 1
+          result.error! "pry only works properly within the main thread, run watchmonkey with `-t0`"
+          return
+        end
+
+        begin
+          require "pry"
+          binding.pry
+          1+1 # pry may bug out otherwise if it's last statement
+        rescue LoadError => ex
+          result.error! "pry is required (gem install pry)! #{ex.class}: #{ex.message}"
+        end
+      end
+    end
+  end
+end

data/lib/watchmonkey_cli/checkers/ftp_availability.rb

@@ -4,7 +4,7 @@ module WatchmonkeyCli
       self.checker_name = "ftp_availability"
 
       def enqueue host, opts = {}
-        opts = { threshold: 1.months }.merge(opts)
+        opts = {}.merge(opts)
         app.enqueue(self, host, opts)
       end
 

data/lib/watchmonkey_cli/checkers/ssl_expiration.rb

@@ -4,7 +4,7 @@ module WatchmonkeyCli
       self.checker_name = "ssl_expiration"
 
       def enqueue page, opts = {}
-        opts = { threshold: 1.months, verify: true, timeout: 20 }.merge(opts)
+        opts = { threshold: 28.days, verify: true, timeout: 20 }.merge(opts)
         app.enqueue(self, page, opts)
       end
 

data/lib/watchmonkey_cli/checkers/unix_defaults.rb

@@ -35,7 +35,9 @@ module WatchmonkeyCli
           #   sec.check!(result, host, opts[which])
           # end
           # app.enqueue_sub(self, which, host, opts[which]) if opts[which]
-          spawn_sub(which, host, opts[which].is_a?(Hash) ? opts[which] : {}) unless opts[which] == false
+          #spawn_sub(which, host, (opts[which].is_a?(Hash) ? opts[which] : {}).merge(tags: result.tags)) unless opts[which] == false
+          stags = (opts[:tags] || []).reject{|t| t.to_s.start_with?("WMC-") }
+          blank_config(stags).send(which, host, (opts[which].is_a?(Hash) ? opts[which] : {})) unless opts[which] == false
         end
       end
     end

data/lib/watchmonkey_cli/checkers/www_availability.rb

@@ -9,7 +9,8 @@ module WatchmonkeyCli
         # if available enable ssl_expiration support
         if page.start_with?("https://") && opts[:ssl_expiration] != false && !app.running?
           sopts = { timeout: opts[:timeout] }.merge(opts[:ssl_expiration].is_a?(Hash) ? opts[:ssl_expiration] : {})
-          spawn_sub("ssl_expiration", page, sopts)
+          stags = (opts[:tags] || []).reject{|t| t.to_s.start_with?("WMC-") }
+          blank_config(stags).ssl_expiration(page, sopts)
         end
       end
 

data/lib/watchmonkey_cli/hooks/platypus.rb

@@ -71,7 +71,7 @@ module WatchmonkeyCli
                     <dt>Items in Queue</dt><dd class="qlength">#{@queue.length}</dd>
                     <dt>Items in ReQ</dt><dd class="rqlength">#{@requeue.length}</dd>
                     <dt>Workers</dt><dd class="workers">#{@threads.select{|t| t[:working] }.length}/#{@threads.length} working (#{@threads.select(&:alive?).length} alive)</dd>
-                    <dt>Threads</dt><dd class="tlength">#{Thread.list.length}</dd>
+                    <dt>Threads</dt><dd class="tlength">#{filtered_threads.length}</dd>
                     <dt>Processed entries</dt><dd class="processed">#{@processed}</dd>
                     <dt>Watching since</dt><dd>#{@boot}</dd>
                     <dt>Last draw</dt><dd class="lastdraw">#{Time.current}</dd>
@@ -93,7 +93,7 @@ module WatchmonkeyCli
                 $("dd.qlength").html("#{@queue.length}");
                 $("dd.rqlength").html("#{@requeue.length}");
                 $("dd.workers").html("#{@threads.select{|t| t[:working] }.length}/#{@threads.length} working#{ti}");
-                $("dd.tlength").html("#{Thread.list.length}");
+                $("dd.tlength").html("#{filtered_threads.length}");
                 $("dd.processed").html("#{@processed}");
                 $("dd.lastdraw").html("#{Time.current}");
                 $("pre.lasterrors").html("#{escape_javascript @platypus_status_cache[:errors].map{|t,e| "#{t}: #{e}" }.join("\n")}");

data/lib/watchmonkey_cli/hooks/requeue.rb

@@ -37,11 +37,12 @@ module WatchmonkeyCli
               puts "     Queue: #{@queue.length}"
               puts "   Requeue: #{@requeue.length}"
               puts "   Workers: #{@threads.select{|t| t[:working] }.length}/#{@threads.length} working (#{@threads.select(&:alive?).length} alive)"
-              puts "   Threads: #{Thread.list.length}"
+              puts "   Threads: #{filtered_threads.length}"
               # puts "            #{@threads.select(&:alive?).length} alive"
               # puts "            #{@threads.select{|t| t.status == "run" }.length} running"
               # puts "            #{@threads.select{|t| t.status == "sleep" }.length} sleeping"
               puts " Processed: #{@processed}"
+              puts "  Promises: #{@telegram_bot_egress_promises.length}" if @telegram_bot_egress_promises
               puts "========== //STATUS =========="
             end
           end
@@ -101,6 +102,16 @@ module WatchmonkeyCli
             }]
           end
         end
+
+        def requeue_runall
+          return if $wm_runtime_exiting
+          sync do
+            debug "Running all queued tasks immediately!"
+            @requeue.each_with_index do |(run_at, callback), index|
+              @requeue[index][0] = Time.now
+            end
+          end
+        end
       end
     end
   end