def start(transport='zmq',
          address='0.0.0.0',
          port=49017,
          auth_address='0.0.0.0',
          auth_port=49018,
          disable_security=False,
          certificate=None,
          os_whitelist=None,
          os_blacklist=None,
          error_whitelist=None,
          error_blacklist=None,
          host_whitelist=None,
          host_blacklist=None):
    '''
    Listen to napalm-logs and publish events into the Salt event bus.

    transport: ``zmq``
        Choose the desired transport.

        .. note::
            Currently ``zmq`` is the only valid option.

    address: ``0.0.0.0``
        The address of the publisher, as configured on napalm-logs.

    port: ``49017``
        The port of the publisher, as configured on napalm-logs.

    auth_address: ``0.0.0.0``
        The address used for authentication
        when security is not disabled.

    auth_port: ``49018``
        Port used for authentication.

    disable_security: ``False``
        Trust unencrypted messages.
        Strongly discouraged in production.

    certificate: ``None``
        Absolute path to the SSL certificate.

    os_whitelist: ``None``
        List of operating systems allowed. By default everything is allowed.

    os_blacklist: ``None``
        List of operating system to be ignored. Nothing ignored by default.

    error_whitelist: ``None``
        List of errors allowed.

    error_blacklist: ``None``
        List of errors ignored.

    host_whitelist: ``None``
        List of hosts or IPs to be allowed.

    host_blacklist: ``None``
        List of hosts of IPs to be ignored.
    '''
    if not disable_security:
        if not certificate:
            log.critical('Please use a certificate, or disable the security.')
            return
        auth = napalm_logs.utils.ClientAuth(certificate,
                                            address=auth_address,
                                            port=auth_port)

    transport_recv_fun = _get_transport_recv(name=transport,
                                             address=address,
                                             port=port)
    if not transport_recv_fun:
        log.critical('Unable to start the engine', exc_info=True)
        return
    master = False
    if __opts__['__role'] == 'master':
        master = True
    while True:
        log.debug('Waiting for napalm-logs to send anything...')
        raw_object = transport_recv_fun()
        log.debug('Received from napalm-logs:')
        log.debug(raw_object)
        if not disable_security:
            dict_object = auth.decrypt(raw_object)
        else:
            dict_object = napalm_logs.utils.unserialize(raw_object)
        try:
            event_os = dict_object['os']
            if os_blacklist or os_whitelist:
                valid_os = salt.utils.stringutils.check_whitelist_blacklist(
                    event_os,
                    whitelist=os_whitelist,
                    blacklist=os_blacklist)
                if not valid_os:
                    log.info('Ignoring NOS %s as per whitelist/blacklist', event_os)
                    continue
            event_error = dict_object['error']
            if error_blacklist or error_whitelist:
                valid_error = salt.utils.stringutils.check_whitelist_blacklist(
                    event_error,
                    whitelist=error_whitelist,
                    blacklist=error_blacklist)
                if not valid_error:
                    log.info('Ignoring error %s as per whitelist/blacklist', event_error)
                    continue
            event_host = dict_object.get('host') or dict_object.get('ip')
            if host_blacklist or host_whitelist:
                valid_host = salt.utils.stringutils.check_whitelist_blacklist(
                    event_host,
                    whitelist=host_whitelist,
                    blacklist=host_blacklist)
                if not valid_host:
                    log.info('Ignoring messages from %s as per whitelist/blacklist', event_host)
                    continue
            tag = 'napalm/syslog/{os}/{error}/{host}'.format(
                os=event_os,
                error=event_error,
                host=event_host
            )
        except KeyError as kerr:
            log.warning('Missing keys from the napalm-logs object:', exc_info=True)
            log.warning(dict_object)
            continue  # jump to the next object in the queue
        log.debug('Sending event %s', tag)
        log.debug(raw_object)
        if master:
            event.get_master_event(__opts__,
                                   __opts__['sock_dir']
                                   ).fire_event(dict_object, tag)
        else:
            __salt__['event.send'](tag, dict_object)