code: async def prod(self, limit: int = None) -> int:
          
          c = 0
  
          if self.last_prod_started:
              self.metrics.add_event(MetricsName.LOOPER_RUN_TIME_SPENT, time.perf_counter() - self.last_prod_started)
          self.last_prod_started = time.perf_counter()
  
          self.quota_control.update_state({
              'request_queue_size': len(self.monitor.requestTracker.unordered())}
          )
  
          if self.status is not Status.stopped:
              c += await self.serviceReplicas(limit)
              c += await self.serviceNodeMsgs(limit)
              c += await self.serviceClientMsgs(limit)
              with self.metrics.measure_time(MetricsName.SERVICE_NODE_ACTIONS_TIME):
                  c += self._serviceActions()
              with self.metrics.measure_time(MetricsName.SERVICE_TIMERS_TIME):
                  self.timer.service()
              with self.metrics.measure_time(MetricsName.SERVICE_MONITOR_ACTIONS_TIME):
                  c += self.monitor._serviceActions()
              c += await self.serviceViewChanger(limit)
              c += await self.service_observable(limit)
              c += await self.service_observer(limit)
              with self.metrics.measure_time(MetricsName.FLUSH_OUTBOXES_TIME):
                  self.nodestack.flushOutBoxes()
  
          if self.isGoing():
              with self.metrics.measure_time(MetricsName.SERVICE_NODE_LIFECYCLE_TIME):
                  self.nodestack.serviceLifecycle()
              with self.metrics.measure_time(MetricsName.SERVICE_CLIENT_STACK_TIME):
                  self.clientstack.serviceClientStack()
  
          return c
docs: .opened
          This function is executed by the node each time it gets its share of
          CPU time from the event loop.
  
          :param limit: the number of items to be serviced in this attempt
          :return: total number of messages serviced by this node