docs: def start(self):
          '''
          Take the messages from the queue,
          inspect and identify the operating system,
          then queue the message correspondingly.
          '''
          # metric counters
          napalm_logs_server_messages_received = Counter(
              "napalm_logs_server_messages_received",
              "Count of messages received from listener processes"
          )
          napalm_logs_server_skipped_buffered_messages = Counter(
              'napalm_logs_server_skipped_buffered_messages',
              'Count of messages skipped as they were already buffered',
              ['device_os']
          )
          napalm_logs_server_messages_with_identified_os = Counter(
              "napalm_logs_server_messages_with_identified_os",
              "Count of messages with positive os identification",
              ['device_os']
          )
          napalm_logs_server_messages_without_identified_os = Counter(
              "napalm_logs_server_messages_without_identified_os",
              "Count of messages with negative os identification"
          )
          napalm_logs_server_messages_failed_device_queuing = Counter(
              "napalm_logs_server_messages_failed_device_queuing",
              "Count of messages per device os that fail to be queued to a device process",
              ['device_os']
          )
          napalm_logs_server_messages_device_queued = Counter(
              "napalm_logs_server_messages_device_queued",
              "Count of messages queued to device processes",
              ['device_os']
          )
          napalm_logs_server_messages_unknown_queued = Counter(
              "napalm_logs_server_messages_unknown_queued",
              "Count of messages queued as unknown"
          )
          self._setup_ipc()
          # Start suicide polling thread
          cleanup = threading.Thread(target=self._cleanup_buffer)
          cleanup.start()
          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:
              # Take messages from the main queue
              try:
                  bin_obj = self.sub.recv()
                  msg, address = umsgpack.unpackb(bin_obj, use_list=False)
              except zmq.ZMQError as error:
                  if self.__up is False:
                      log.info('Exiting on process shutdown')
                      return
                  else:
                      log.error(error, exc_info=True)
                      raise NapalmLogsExit(error)
              if six.PY3:
                  msg = str(msg, 'utf-8')
              else:
                  msg = msg.encode('utf-8')
              log.debug('[%s] Dequeued message from %s: %s', address, msg, time.time())
              napalm_logs_server_messages_received.inc()
              os_list = self._identify_os(msg)
  
              for dev_os, msg_dict in os_list:
                  if dev_os and dev_os in self.started_os_proc:
                      # Identified the OS and the corresponding process is started.
                      # Then send the message in the right queue
                      log.debug('Identified OS: %s', dev_os)
                      log.debug('Queueing message to %s', dev_os)
                      if six.PY3:
                          dev_os = bytes(dev_os, 'utf-8')
                      if self._buffer:
                          message = '{dev_os}/{host}/{msg}'.format(dev_os=dev_os,
                                                                   host=msg_dict['host'],
                                                                   msg=msg_dict['message'])
                          message_key = base64.b64encode(message)
                          if self._buffer[message_key]:
                              log.info('"%s" seems to be already buffered, skipping', msg_dict['message'])
                              napalm_logs_server_skipped_buffered_messages.labels(device_os=dev_os).inc()
                              continue
                          log.debug('"%s" is not buffered yet, added', msg_dict['message'])
                          self._buffer[message_key] = 1
                      self.pub.send_multipart([dev_os,
                                               umsgpack.packb((msg_dict, address))])
                      # self.os_pipes[dev_os].send((msg_dict, address))
                      napalm_logs_server_messages_with_identified_os.labels(device_os=dev_os).inc()
                      napalm_logs_server_messages_device_queued.labels(device_os=dev_os).inc()
  
                  elif dev_os and dev_os not in self.started_os_proc:
                      # Identified the OS, but the corresponding process does not seem to be started.
                      log.info('Unable to queue the message to %s. Is the sub-process started?', dev_os)
                      napalm_logs_server_messages_with_identified_os.labels(device_os=dev_os).inc()
                      napalm_logs_server_messages_failed_device_queuing.labels(device_os=dev_os).inc()
  
                  elif not dev_os and self.opts['_server_send_unknown']:
                      # OS not identified, but the user requested to publish the message as-is
                      log.debug('Unable to identify the OS, sending directly to the publishers')
                      to_publish = {
                          'ip': address,
                          'host': 'unknown',
                          'timestamp': int(time.time()),
                          'message_details': msg_dict,
                          'os': UNKNOWN_DEVICE_NAME,
                          'error': 'UNKNOWN',
                          'model_name': 'unknown'
                      }
                      self.publisher_pub.send(umsgpack.packb(to_publish))
                      napalm_logs_server_messages_unknown_queued.inc()
                      napalm_logs_server_messages_without_identified_os.inc()