code: def __safe_handlers_callback(self, method_name, *args, **kwargs):
          # type: (str, *Any, **Any) -> bool
          
          if self.state == StoredInstance.KILLED:
              # Nothing to do
              return False
  
          # Behavior flags
          exception_as_error = kwargs.pop("exception_as_error", False)
          break_on_false = kwargs.pop("break_on_false", False)
  
          result = True
          for handler in self.get_handlers():
              # Get the method for each handler
              try:
                  method = getattr(handler, method_name)
              except AttributeError:
                  # Ignore missing methods
                  pass
              else:
                  try:
                      # Call it
                      res = method(*args, **kwargs)
                      if res is not None and not res:
                          # Ignore 'None' results
                          result = False
                  except Exception as ex:
                      # Log errors
                      self._logger.exception(
                          "Error calling handler '%s': %s", handler, ex
                      )
  
                      # We can consider exceptions as errors or ignore them
                      result = result and not exception_as_error
  
                  if not handler and break_on_false:
                      # The loop can stop here
                      break
  
          return result
docs: Calls the given method with the given arguments in all handlers.
          Logs exceptions, but doesn't propagate them.
          Methods called in handlers must return None, True or False.
  
          Special parameters can be given in kwargs:
  
          * 'exception_as_error': if it is set to True and an exception is raised
            by a handler, then this method will return False. By default, this
            flag is set to False and exceptions are ignored.
          * 'break_on_false': if it set to True, the loop calling the handler
            will stop after an handler returned False. By default, this flag
            is set to False, and all handlers are called.
  
          :param method_name: Name of the method to call
          :param args: List of arguments for the method to call
          :param kwargs: Dictionary of arguments for the method to call and the
                         behavior of the call
          :return: True if all handlers returned True (or None), else False