Python syslog.openlog() Examples

def main():
    if len(sys.argv) > 2:
        Fatal('usage: %s [containers.yaml]' % sys.argv[0])

    if len(sys.argv) == 2:
        with open(sys.argv[1], 'r') as fp:
            config = yaml.load(fp)
    else:
        config = yaml.load(sys.stdin)

    syslog.openlog(PROGNAME)
    LogInfo('processing container manifest')

    CheckVersion(config)

    all_volumes = LoadVolumes(config.get('volumes', []))
    user_containers = LoadUserContainers(config.get('containers', []),
                                         all_volumes)
    CheckGroupWideConflicts(user_containers)

    if user_containers:
        infra_containers = LoadInfraContainers(user_containers)
        RunContainers(infra_containers + user_containers) 

def init_logging():
    globals()['logFacility'] = getattr(syslog, config.logfacility)
    globals()['logIdentity'] = config.logidentity
    globals()['moduleLogLevel'] = getattr(syslog, config.moduleloglevel)
    globals()['scanLogLevel'] = getattr(syslog, config.scanloglevel)
    globals()['logResultFromSource'] = config.logresultfromsource
    syslog.openlog(logIdentity, 0, logFacility)

# Keeping this here for legacy purposes. It's now deprecated. 

def safe_open(self):
        try:
            syslog.openlog(self.app, syslog.LOG_PID)
        except Exception as e:
            print(e) 

def __init__(self, name, facility):
        syslog.openlog(name, 0, facility) 

def __init__(self, facility, options=syslog.LOG_PID):
    syslog.openlog(logoption=options, facility=facility)
    super().__init__() 

def changeProfile(profile_id):
    name = os.getenv('LOGNAME', 'unknown')
    syslog.openlog("%s (%s/%s)" %(APP_NAME, name, profile_id)) 

def openlog():
    name = os.getenv('LOGNAME', 'unknown')
    syslog.openlog("%s (%s/1)" %(APP_NAME, name))
    atexit.register(closelog) 

def __init__(self, program_name, facility=None):
        # Default values always get evaluated, for which reason we avoid
        # using 'syslog' directly, which may not be available.
        facility = facility if facility is not None else syslog.LOG_USER
        if not syslog:
            raise RuntimeError("Syslog not available on this platform")
        super(SyslogHandler, self).__init__()
        syslog.openlog(program_name, 0, facility) 

def writeLog(msg):

	"""Output a message to the console/Syslog depending on the host"""

	if os.name == "posix":
        	syslog.openlog(logoption=syslog.LOG_PID,facility=syslog.LOG_MAIL)
        	syslog.syslog(msg)
	else:
		print msg
        return 

def __init__(self):
        """Initialize trigger engine"""
        self.rlist = []
        self.rules = []
        self.newrules = []
        self.threads = {}
        syslog.openlog(facility=syslog.LOG_DAEMON) 

def __init__(self, rule):
        """Initialize trigger object"""
        self.rule = rule
        self.tzone = TIME_ZONE
        self.lasteventid = None
        self.justfired = False
        self.timeint = timedelta(minutes=self.rule.time_int)
        syslog.openlog(facility=syslog.LOG_DAEMON) 

def __init__(self):
        """Initialize trigger engine"""
        self.rlist = []
        self.rules = []
        self.newrules = []
        self.threads = {}
        syslog.openlog(facility=syslog.LOG_DAEMON) 

def __init__(self):
        """Initialize sentry core"""
        self.rule_types = {}
        self.threads = {}
        syslog.openlog(facility=syslog.LOG_DAEMON) 

def __init__(self):
        """Initialize daemon core object"""
        # Open our log facility:
        syslog.openlog(facility=syslog.LOG_DAEMON) 

def __init__(self, config='/opt/LogESP/config/parser.conf'):
        """Initialize live parser"""
        self.conf = config
        self.threads = []
        syslog.openlog(facility=syslog.LOG_DAEMON) 

def __init__(self):
        """Initialize live parser"""
        self.parser = None
        self.parser_name = None
        self.event_type = None
        self.log_source = None
        syslog.openlog(facility=syslog.LOG_DAEMON) 

def syslog_writer_before_all(self, features):
        import syslog

        syslog.openlog("radish")
        syslog.syslog("begin run {}".format(self.marker)) 

def test_syslog_binary_name(self):
        # There is no way to test the actual output written to the
        # syslog (e.g. /var/log/syslog) to confirm binary_name value
        # is actually present
        syslog.openlog = mock.Mock()
        handlers.OSSysLogHandler()
        syslog.openlog.assert_called_with(handlers._get_binary_name(),
                                          0, syslog.LOG_USER) 

def __init__(self, facility=None):
        # Default values always get evaluated, for which reason we avoid
        # using 'syslog' directly, which may not be available.
        facility = facility if facility is not None else syslog.LOG_USER
        # Do not use super() unless type(logging.Handler) is 'type'
        # (i.e. >= Python 2.7).
        if not syslog:
            raise RuntimeError("Syslog not available on this platform")
        logging.Handler.__init__(self)
        binary_name = _get_binary_name()
        syslog.openlog(binary_name, 0, facility) 

def __init__(self, threshold, sid=None, encoding='UTF-8'):
        import syslog
        AbstractLogger.__init__(self, threshold)
        if sid is None:
            sid = 'syslog'
        self.encoding = encoding
        syslog.openlog(sid, syslog.LOG_PID) 

def safe_open(self):
        try:
            syslog.openlog(self.app, syslog.LOG_PID)
        except Exception as e:
            print(e) 

def main():
    config = get_config_port_ip()
    list_live_ip(config)
    for i in config.keys():
        if arp(i) == config[i]:
            continue
        if arp(i) == 'none':
            syslog.openlog( 'WARNING', 0, syslog.LOG_LOCAL7 )
            syslog.syslog(syslog.LOG_ALERT, '%s %s IS NOT ACTIVE ' % (socket.gethostname(), i))
        else:
            syslog.openlog( 'WARNING', 0, syslog.LOG_LOCAL4 )
            syslog.syslog(syslog.LOG_ALERT, '%s %s IS IN WRONG PORT %s AND SHOULD BE IN %s ' % (socket.gethostname(), i, arp(i),config[i] )) 

def log(program, function, msg, level="I", display=True):
    global LAST_SHOWN
    # open syslog
    syslog.openlog("system: %s %s:%s:" % (level, program, function))
    # set priority
    priority = syslog.LOG_INFO
    if level == "E":
        priority = syslog.LOG_ERR
    elif level == "W":
        priority = syslog.LOG_WARNING
    priority |= syslog.LOG_LOCAL4
    # write to syslog
    syslog.syslog(priority, msg)
    #
    # NOTE: showlog / showlog -f to check the logs
    #

    if display:
        program_display = " %s: " % program
        displayed = " "
        # If loglevel is anything else than I, add it to our tag
        if level != "I":
            displayed += "[%s] " % level
        displayed += utf8_str(msg)
        # print using FBInk (via cFFI)
        fbink.fbink_print(fbink.FBFD_AUTO, "%s\n%s" % (program_display, displayed), FBINK_CFG) 

def SendNotice(Message):

    try:

        syslog.openlog("genmon")
        syslog.syslog("%s" % Message)
        syslog.closelog()

    except Exception as e1:
        log.error("Error: " + str(e1))
        console.error("Error: " + str(e1))

#------------------- Command-line interface for gengpio ------------------------ 

def __init__(self, facility=None, log_pid=True, log_perror=False,
                 **kwargs):
        """
        Initialize Syslog Object
        """
        super(NotifySyslog, self).__init__(**kwargs)

        if facility:
            try:
                self.facility = SYSLOG_FACILITY_MAP[facility]

            except KeyError:
                msg = 'An invalid syslog facility ' \
                      '({}) was specified.'.format(facility)
                self.logger.warning(msg)
                raise TypeError(msg)
        else:
            self.facility = \
                SYSLOG_FACILITY_MAP[
                    self.template_tokens['facility']['default']]

        # Logging Options
        self.logoptions = 0

        # Include PID with each message.
        # This may not appear evident if using journalctl since the pid
        # will always display itself; however it will appear visible
        # for log_perror combinations
        self.log_pid = log_pid

        # Print to stderr as well.
        self.log_perror = log_perror

        if log_pid:
            self.logoptions |= syslog.LOG_PID

        if log_perror:
            self.logoptions |= syslog.LOG_PERROR

        # Initialize our loggig
        syslog.openlog(
            self.app_id, logoption=self.logoptions, facility=self.facility)
        return 

def __init__(self, facility=None, log_pid=True, log_perror=False,
                 **kwargs):
        """
        Initialize Syslog Object
        """
        super(NotifySyslog, self).__init__(**kwargs)

        if facility:
            try:
                self.facility = SYSLOG_FACILITY_MAP[facility]

            except KeyError:
                msg = 'An invalid syslog facility ' \
                      '({}) was specified.'.format(facility)
                self.logger.warning(msg)
                raise TypeError(msg)
        else:
            self.facility = \
                SYSLOG_FACILITY_MAP[
                    self.template_tokens['facility']['default']]

        # Logging Options
        self.logoptions = 0

        # Include PID with each message.
        # This may not appear evident if using journalctl since the pid
        # will always display itself; however it will appear visible
        # for log_perror combinations
        self.log_pid = log_pid

        # Print to stderr as well.
        self.log_perror = log_perror

        if log_pid:
            self.logoptions |= syslog.LOG_PID

        if log_perror:
            self.logoptions |= syslog.LOG_PERROR

        # Initialize our loggig
        syslog.openlog(
            self.app_id, logoption=self.logoptions, facility=self.facility)
        return