docs: def start_monitoring(self):
          """
          Pass IP lists to monitor sub-plugins and get results from them.
  
          Override the common definition of this function, since in the multi
          plugin it's a little different: Instead of monitoring ourselves, we
          just use a number of other plugins to gather results. The multi plugin
          just serves as a proxy and (de)multiplexer for those other plugins.
  
          Note that we don't have to push any updates about failed IPs if nothing
          new was detected. Therefore, our own updates can be entirely driven by
          updates from the sub-plugin, which keeps our architecture simple.
  
          """
          logging.info("Multi-plugin health monitor: Started in thread.")
          try:
              while True:
                  # Get new IP addresses and pass them on to the sub-plugins
                  new_ips = self.get_new_working_set()
                  if new_ips:
                      logging.debug("Sending list of %d IPs to %d plugins." %
                                    (len(new_ips), len(self.plugins)))
                      for q in self.monitor_ip_queues.values():
                          q.put(new_ips)
  
                  # Get any notifications about failed or questionable IPs from
                  # the plugins.
                  all_failed_ips = self._accumulate_ips_from_plugins(
                                              "failed",
                                              self.failed_queue_lookup,
                                              self.report_failed_acc)
                  if all_failed_ips:
                      self.q_failed_ips.put(all_failed_ips)
  
                  all_questionable_ips = self._accumulate_ips_from_plugins(
                                              "questionable",
                                              self.questionable_queue_lookup,
                                              self.report_questionable_acc)
                  if all_questionable_ips:
                      self.q_questionable_ips.put(all_questionable_ips)
  
                  time.sleep(self.get_monitor_interval())
  
          except common.StopReceived:
              # Received the stop signal, just exiting the thread function
              return