docs: def start(self):
          '''
          Start the worker process.
          '''
          # metrics
          napalm_logs_device_messages_received = Counter(
              'napalm_logs_device_messages_received',
              "Count of messages received by the device process",
              ['device_os']
          )
          napalm_logs_device_raw_published_messages = Counter(
              'napalm_logs_device_raw_published_messages',
              "Count of raw type published messages",
              ['device_os']
          )
          napalm_logs_device_published_messages = Counter(
              'napalm_logs_device_published_messages',
              "Count of published messages",
              ['device_os']
          )
          napalm_logs_device_oc_object_failed = Counter(
              'napalm_logs_device_oc_object_failed',
              "Counter of failed OpenConfig object generations",
              ['device_os']
          )
  
          self._setup_ipc()
          # Start suicide polling thread
          thread = threading.Thread(target=self._suicide_when_without_parent, args=(os.getppid(),))
          thread.start()
          signal.signal(signal.SIGTERM, self._exit_gracefully)
          self.__up = True
          while self.__up:
              # bin_obj = self.sub.recv()
              # msg_dict, address = umsgpack.unpackb(bin_obj, use_list=False)
              try:
                  bin_obj = self.sub.recv()
                  msg_dict, address = umsgpack.unpackb(bin_obj, use_list=False)
              except zmq.ZMQError as error:
                  if self.__up is False:
                      log.info('Exiting on process shutdown [%s]', self._name)
                      return
                  else:
                      raise NapalmLogsExit(error)
              log.debug('%s: dequeued %s, received from %s', self._name, msg_dict, address)
              napalm_logs_device_messages_received.labels(device_os=self._name).inc()
              host = msg_dict.get('host')
              prefix_id = msg_dict.pop('__prefix_id__')
              if 'timestamp' in msg_dict:
                  timestamp = msg_dict.pop('timestamp')
              else:
                  timestamp = self._format_time(msg_dict.get('time', ''),
                                                msg_dict.get('date', ''),
                                                msg_dict.get('timeZone', 'UTC'),
                                                prefix_id)
              facility = msg_dict.get('facility')
              severity = msg_dict.get('severity')
  
              kwargs = self._parse(msg_dict)
              if not kwargs:
                  # Unable to identify what model to generate for the message in cause.
                  # But publish the message when the user requested to push raw messages.
                  to_publish = {
                      'ip': address,
                      'host': host,
                      'timestamp': timestamp,
                      'message_details': msg_dict,
                      'os': self._name,
                      'error': 'RAW',
                      'model_name': 'raw',
                      'facility': facility,
                      'severity': severity
                  }
                  log.debug('Queueing to be published:')
                  log.debug(to_publish)
                  # self.pub_pipe.send(to_publish)
                  self.pub.send(umsgpack.packb(to_publish))
                  napalm_logs_device_raw_published_messages.labels(device_os=self._name).inc()
                  continue
              try:
                  if '__python_fun__' in kwargs:
                      log.debug('Using the Python parser to determine the YANG-equivalent object')
                      yang_obj = kwargs['__python_fun__'](msg_dict)
                  else:
                      yang_obj = self._emit(**kwargs)
              except Exception:
                  log.exception('Unexpected error when generating the OC object.', exc_info=True)
                  napalm_logs_device_oc_object_failed.labels(device_os=self._name).inc()
                  continue
              log.debug('Generated OC object:')
              log.debug(yang_obj)
              error = kwargs.get('error')
              model_name = kwargs.get('model')
              to_publish = {
                  'error': error,
                  'host': host,
                  'ip': address,
                  'timestamp': timestamp,
                  'yang_message': yang_obj,
                  'message_details': msg_dict,
                  'yang_model': model_name,
                  'os': self._name,
                  'facility': facility,
                  'severity': severity
              }
              log.debug('Queueing to be published:')
              log.debug(to_publish)
              # self.pub_pipe.send(to_publish)
              self.pub.send(umsgpack.packb(to_publish))
              # self._publish(to_publish)
              napalm_logs_device_published_messages.labels(device_os=self._name).inc()