golden hour

/opt/saltstack/salt/lib/python3.10/site-packages/salt/returners

File/Folder	Size	Actions
__init__.py	5.98 KB
__pycache__	-
appoptics_return.py	6.11 KB
carbon_return.py	8.24 KB
cassandra_cql_return.py	15.14 KB
cassandra_return.py	2.41 KB
couchbase_return.py	8.88 KB
couchdb_return.py	10.35 KB
django_return.py	2.57 KB
elasticsearch_return.py	12.18 KB
etcd_return.py	7.9 KB
highstate_return.py	15.59 KB
influxdb_return.py	8.03 KB
kafka_return.py	2.12 KB
librato_return.py	4.29 KB
local.py	541 B
local_cache.py	17.39 KB
mattermost_returner.py	4.08 KB
memcache_return.py	5.72 KB
mongo_future_return.py	10.01 KB
mongo_return.py	6.06 KB
multi_returner.py	2.82 KB
mysql.py	18.81 KB
nagios_nrdp_return.py	4.92 KB
odbc.py	7.77 KB
pgjsonb.py	17.36 KB
postgres.py	10.33 KB
postgres_local_cache.py	10.82 KB
pushover_returner.py	6.55 KB
rawfile_json.py	2.23 KB
redis_return.py	8.55 KB
sentry_return.py	5.24 KB
slack_returner.py	6.02 KB
slack_webhook_return.py	11.22 KB
sms_return.py	2.64 KB
smtp_return.py	8.2 KB
splunk.py	5.84 KB
sqlite3_return.py	7.73 KB
syslog_return.py	5.26 KB
telegram_return.py	1.92 KB
xmpp_return.py	4.81 KB
zabbix_return.py	2.45 KB

Edit: syslog_return.py

"""
Return data to the host operating system's syslog facility

To use the syslog returner, append '--return syslog' to the
salt command.

.. code-block:: bash

salt '*' test.ping --return syslog

The following fields can be set in the minion conf file::

syslog.level (optional, Default: LOG_INFO)
    syslog.facility (optional, Default: LOG_USER)
    syslog.tag (optional, Default: salt-minion)
    syslog.options (list, optional, Default: [])

Available levels, facilities, and options can be found in the
``syslog`` docs for your python version.

.. note::

The default tag comes from ``sys.argv[0]`` which is
    usually "salt-minion" but could be different based on
    the specific environment.

Configuration example:

.. code-block:: yaml

syslog.level: 'LOG_ERR'
    syslog.facility: 'LOG_DAEMON'
    syslog.tag: 'mysalt'
    syslog.options:
      - LOG_PID

Of course you can also nest the options:

.. code-block:: yaml

syslog:
      level: 'LOG_ERR'
      facility: 'LOG_DAEMON'
      tag: 'mysalt'
      options:
        - LOG_PID

Alternative configuration values can be used by
prefacing the configuration. Any values not found
in the alternative configuration will be pulled from
the default location:

.. code-block:: yaml

alternative.syslog.level: 'LOG_WARN'
    alternative.syslog.facility: 'LOG_NEWS'

To use the alternative configuration, append
``--return_config alternative`` to the salt command.

.. versionadded:: 2015.5.0

.. code-block:: bash

salt '*' test.ping --return syslog --return_config alternative

To override individual configuration items, append
--return_kwargs '{"key:": "value"}' to the salt command.

.. versionadded:: 2016.3.0

.. code-block:: bash

salt '*' test.ping --return syslog --return_kwargs '{"level": "LOG_DEBUG"}'

.. note::

Syslog server implementations may have limits on the maximum
    record size received by the client. This may lead to job
    return data being truncated in the syslog server's logs. For
    example, for rsyslog on RHEL-based systems, the default
    maximum record size is approximately 2KB (which return data
    can easily exceed). This is configurable in rsyslog.conf via
    the $MaxMessageSize config parameter. Please consult your syslog
    implmentation's documentation to determine how to adjust this limit.

"""

import logging

import salt.returners
import salt.utils.jid
import salt.utils.json

try:
    import syslog

HAS_SYSLOG = True
except ImportError:
    HAS_SYSLOG = False

log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = "syslog"

def _get_options(ret=None):
    """
    Get the returner options from salt.
    """

defaults = {"level": "LOG_INFO", "facility": "LOG_USER", "options": []}

attrs = {
        "level": "level",
        "facility": "facility",
        "tag": "tag",
        "options": "options",
    }

_options = salt.returners.get_returner_options(
        __virtualname__,
        ret,
        attrs,
        __salt__=__salt__,
        __opts__=__opts__,
        defaults=defaults,
    )
    return _options

def _verify_options(options):
    """
    Verify options and log warnings

Returns True if all options can be verified,
    otherwise False
    """

# sanity check all vals used for bitwise operations later
    bitwise_args = [("level", options["level"]), ("facility", options["facility"])]
    bitwise_args.extend([("option", x) for x in options["options"]])

for opt_name, opt in bitwise_args:
        if not hasattr(syslog, opt):
            log.error("syslog has no attribute %s", opt)
            return False
        if not isinstance(getattr(syslog, opt), int):
            log.error("%s is not a valid syslog %s", opt, opt_name)
            return False

# Sanity check tag
    if "tag" in options:
        if not isinstance(options["tag"], str):
            log.error("tag must be a string")
            return False
        if len(options["tag"]) > 32:
            log.error("tag size is limited to 32 characters")
            return False

return True

def __virtual__():
    if not HAS_SYSLOG:
        return False, "Could not import syslog returner; syslog is not installed."
    return __virtualname__

def returner(ret):
    """
    Return data to the local syslog
    """

_options = _get_options(ret)

if not _verify_options(_options):
        return

# Get values from syslog module
    level = getattr(syslog, _options["level"])
    facility = getattr(syslog, _options["facility"])

# parse for syslog options
    logoption = 0
    for opt in _options["options"]:
        logoption = logoption | getattr(syslog, opt)

# Open syslog correctly based on options and tag
    if "tag" in _options:
        syslog.openlog(
            ident=salt.utils.stringutils.to_str(_options["tag"]), logoption=logoption
        )
    else:
        syslog.openlog(logoption=logoption)

# Send log of given level and facility
    syslog.syslog(facility | level, salt.utils.json.dumps(ret))

# Close up to reset syslog to defaults
    syslog.closelog()

def prep_jid(nocache=False, passed_jid=None):  # pylint: disable=unused-argument
    """
    Do any work necessary to prepare a JID, including sending a custom id
    """
    return passed_jid if passed_jid is not None else salt.utils.jid.gen_jid(__opts__)