docs: def on_processed(self, message, result, start_time):
          """Invoked after a message is processed by the consumer and
          implements the logic for how to deal with a message based upon
          the result.
  
          :param rejected.data.Message message: The message that was processed
          :param int result: The result of the processing of the message
          :param float start_time: When the message was received
  
          """
          duration = max(start_time, time.time()) - start_time
          self.counters[self.TIME_SPENT] += duration
          self.measurement.add_duration(self.TIME_SPENT, duration)
  
          if result == data.MESSAGE_DROP:
              LOGGER.debug('Rejecting message due to drop return from consumer')
              self.reject(message, False)
              self.counters[self.DROPPED] += 1
  
          elif result == data.MESSAGE_EXCEPTION:
              LOGGER.debug('Rejecting message due to MessageException')
              self.reject(message, False)
              self.counters[self.MESSAGE_EXCEPTION] += 1
  
          elif result == data.PROCESSING_EXCEPTION:
              LOGGER.debug('Rejecting message due to ProcessingException')
              self.reject(message, False)
              self.counters[self.PROCESSING_EXCEPTION] += 1
  
          elif result == data.CONFIGURATION_EXCEPTION:
              LOGGER.debug('Rejecting message due to ConfigurationException '
                           'and shutting down')
              self.reject(message, False)
              self.counters[self.CONFIGURATION_EXCEPTION] += 1
              self.stop_consumer()
              self.shutdown_connections()
  
          elif result == data.CONSUMER_EXCEPTION:
              LOGGER.debug('Re-queueing message due to ConsumerException')
              self.reject(message, True)
              self.on_processing_error()
              self.counters[self.CONSUMER_EXCEPTION] += 1
  
          elif result == data.RABBITMQ_EXCEPTION:
              LOGGER.debug('Processing interrupted due to RabbitMQException')
              self.on_processing_error()
              self.counters[self.RABBITMQ_EXCEPTION] += 1
  
          elif result == data.UNHANDLED_EXCEPTION:
              LOGGER.debug('Re-queueing message due to UnhandledException')
              self.reject(message, True)
              self.on_processing_error()
              self.counters[self.UNHANDLED_EXCEPTION] += 1
  
          elif result == data.MESSAGE_REQUEUE:
              LOGGER.debug('Re-queueing message due Consumer request')
              self.reject(message, True)
              self.counters[self.REQUEUED] += 1
  
          elif result == data.MESSAGE_ACK and not self.no_ack:
              self.ack_message(message)
  
          self.counters[self.PROCESSED] += 1
          self.measurement.set_tag(self.PROCESSED, True)
          self.maybe_submit_measurement()
          self.reset_state()