code: def _consume(self, message):
          
  
          try:
              self.validate(message)
          except RuntimeWarning as e:
              self.log.warn("Received invalid message {0}".format(e))
              return
  
          # Pass along headers if present.  May be useful to filters or
          # fedmsg.meta routines.
          if isinstance(message, dict) and 'headers' in message and 'body' in message:
              message['body']['headers'] = message['headers']
  
          if hasattr(self, "replay_name"):
              for m in check_for_replay(
                      self.replay_name, self.name_to_seq_id,
                      message, self.hub.config):
  
                  try:
                      self.validate(m)
                      return super(FedmsgConsumer, self)._consume(m)
                  except RuntimeWarning as e:
                      self.log.warn("Received invalid message {}".format(e))
          else:
              return super(FedmsgConsumer, self)._consume(message)
docs: Called when a message is consumed.
  
          This private method handles some administrative setup and teardown
          before calling the public interface `consume` typically implemented
          by a subclass.
  
          When `moksha.blocking_mode` is set to `False` in the config, this
          method always returns `None`.  The argued message is stored in an
          internal queue where the consumer's worker threads should eventually
          pick it up.
  
          When `moksha.blocking_mode` is set to `True` in the config, this
          method should return True or False, indicating whether the message
          was handled or not.  Specifically, in the event that the inner
          `consume` method raises an exception of any kind, this method
          should return `False` indicating that the message was not
          successfully handled.
  
          Args:
              message (dict): The message as a dictionary.
  
          Returns:
              bool: Should be interpreted as whether or not the message was
              handled by the consumer, or `None` if `moksha.blocking_mode` is
              set to False.