コード例 #1
0
def getLogger(
        logging_file_name="%s.log" % app_name,
        logging_stanza_name="python",
        log_format=DEFAULT_LOGGING_FORMAT):
    """
    source : http://dev.splunk.com/view/logging/SP-CAAAFCN
    """
    logger = logging.getLogger(app_name)
    SPLUNK_HOME = os.environ.get('SPLUNK_HOME', '~')
    LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log.cfg')
    LOGGING_LOCAL_CONFIG_FILE = os.path.join(
        SPLUNK_HOME, 'etc', 'log-local.cfg')
    LOGGING_STANZA_NAME = logging_stanza_name
    LOGGING_FILE_NAME = logging_file_name
    BASE_LOG_PATH = os.path.join(SPLUNK_HOME, 'var', 'log', 'splunk')
    COMPLETE_PATH = os.path.join(BASE_LOG_PATH, LOGGING_FILE_NAME)
    if not os.path.exists(BASE_LOG_PATH):
        os.makedirs(BASE_LOG_PATH)
    LOGGING_FORMAT = log_format
    file_handler = logging.FileHandler(COMPLETE_PATH)
    splunk_log_handler = logging.handlers.RotatingFileHandler(COMPLETE_PATH, mode='a',
                                                              maxBytes=MAX_FILE_SIZE,
                                                              backupCount=5)
    splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
    logger.addHandler(file_handler)
    logger.addHandler(splunk_log_handler)
    splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE,
                             LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
    logger.setLevel(logging.INFO)
    return logger
コード例 #2
0
ファイル: bs4.py プロジェクト: swipswaps/nlp-text-analytics
 def setup_logging(self):
     logger = logging.getLogger('splunk.foo')    
     SPLUNK_HOME = os.environ['SPLUNK_HOME']
     
     LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log.cfg')
     LOGGING_LOCAL_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log-local.cfg')
     LOGGING_STANZA_NAME = 'python'
     LOGGING_FILE_NAME = "nlp-text-analytics.log"
     BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
     LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"
     splunk_log_handler = logging.handlers.RotatingFileHandler(
         os.path.join(
             SPLUNK_HOME,
             BASE_LOG_PATH,
             LOGGING_FILE_NAME
         ), mode='a') 
     splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
     logger.addHandler(splunk_log_handler)
     setupSplunkLogger(
         logger,
         LOGGING_DEFAULT_CONFIG_FILE,
         LOGGING_LOCAL_CONFIG_FILE,
         LOGGING_STANZA_NAME
     )
     return logger
コード例 #3
0
    def setup_logging():
        """
        Setup logging

        Log is written to /opt/splunk/var/log/splunk/octopus.log
        """
        logger = logging.getLogger('splunk.octopus')
        logger.setLevel(logging.INFO)
        SPLUNK_HOME = os.environ['SPLUNK_HOME']

        LOGGING_DEFAULT_CONFIG_FILE = os.path.join(_SPLUNK_HOME, 'etc',
                                                   'log.cfg')
        LOGGING_LOCAL_CONFIG_FILE = os.path.join(_SPLUNK_HOME, 'etc',
                                                 'log-local.cfg')
        LOGGING_STANZA_NAME = 'python'
        LOGGING_FILE_NAME = "octopus.log"
        BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
        LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"

        splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(
            _SPLUNK_HOME, BASE_LOG_PATH, LOGGING_FILE_NAME),
                                                                  mode='a')
        splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
        logger.addHandler(splunk_log_handler)
        splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE,
                                 LOGGING_LOCAL_CONFIG_FILE,
                                 LOGGING_STANZA_NAME)

        return logger
コード例 #4
0
    def setup_logging(self):
        """
		Setup logging
		Log is written to /opt/splunk/var/log/splunk/traffic_inv_kvstore.log
		"""
        FILENAME = os.path.splitext(os.path.basename(__file__))[0]
        logger = logging.getLogger('splunk.' + FILENAME)
        logger.setLevel(logging.INFO)
        SPLUNK_HOME = os.environ['SPLUNK_HOME']

        LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc',
                                                   'log.cfg')
        LOGGING_LOCAL_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc',
                                                 'log-local.cfg')
        LOGGING_STANZA_NAME = 'python'
        LOGGING_FILE_NAME = FILENAME + ".log"
        BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
        LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"

        splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(
            SPLUNK_HOME, BASE_LOG_PATH, LOGGING_FILE_NAME),
                                                                  mode='a')
        splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
        logger.addHandler(splunk_log_handler)
        splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE,
                                 LOGGING_LOCAL_CONFIG_FILE,
                                 LOGGING_STANZA_NAME)

        # some logging in case of successful initialization.
        logger.info("Script started and logging initialized correctly.")

        return logger
コード例 #5
0
 def setup_logging(self):
     self.logger = logging.getLogger('splunk.SplunkAppforAWSBilling')
     LOGGING_DEFAULT_CONFIG_FILE = os.path.join(self.splunk_home, 'etc', 'log.cfg')
     LOGGING_LOCAL_CONFIG_FILE = os.path.join(self.splunk_home, 'etc', 'log-local.cfg')
     LOGGING_STANZA_NAME = 'python'
     LOGGING_FILE_NAME = "SplunkAppforAWSBilling.log"
     BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
     LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"
     splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(self.splunk_home, BASE_LOG_PATH, LOGGING_FILE_NAME), mode='a')
     splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
     self.logger.addHandler(splunk_log_handler)
     splunk.setupSplunkLogger(self.logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
コード例 #6
0
 def setup_logging(self):
     self.logger = logging.getLogger('splunk.SplunkAppforAWSBilling')
     LOGGING_DEFAULT_CONFIG_FILE = os.path.join(self.splunk_home, 'etc', 'log.cfg')
     LOGGING_LOCAL_CONFIG_FILE = os.path.join(self.splunk_home, 'etc', 'log-local.cfg')
     LOGGING_STANZA_NAME = 'python'
     LOGGING_FILE_NAME = "SplunkAppforAWSBilling.log"
     BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
     LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"
     splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(self.splunk_home, BASE_LOG_PATH, LOGGING_FILE_NAME), mode='a')
     splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
     self.logger.addHandler(splunk_log_handler)
     splunk.setupSplunkLogger(self.logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
コード例 #7
0
def setup_logging():
    logger = logging.getLogger('splunk.script')    
    SPLUNK_HOME = os.environ['SPLUNK_HOME']
    # define logging configuration. taken from python-site/splunk/appserver/mrsparkle/root.py
    LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log.cfg')
    LOGGING_LOCAL_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log-local.cfg')
    LOGGING_STANZA_NAME = 'python'
    BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
    LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"
    splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(SPLUNK_HOME, BASE_LOG_PATH, 'search_script.log'), mode='a') 
    splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
    logger.addHandler(splunk_log_handler)
    splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
    return logger
コード例 #8
0
def setup_logger():
	logger = logging.getLogger('splunk.octoblu')
	SPLUNK_HOME = os.environ['SPLUNK_HOME']
	LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log.cfg')
	LOGGING_LOCAL_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log-local.cfg')
	LOGGING_STANZA_NAME = 'python'
	LOGGING_FILE_NAME = "octoblu.log"
	BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
	LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"
	splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(SPLUNK_HOME, BASE_LOG_PATH, LOGGING_FILE_NAME), mode='a')
	splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
	logger.addHandler(splunk_log_handler)
	splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
	return logger
コード例 #9
0
ファイル: __init__.py プロジェクト: mealy/splunk
def setup_logging():
    logger = logging.getLogger("splunk.script")
    SPLUNK_HOME = os.environ["SPLUNK_HOME"]
    # define logging configuration. taken from python-site/splunk/appserver/mrsparkle/root.py
    LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, "etc", "log.cfg")
    LOGGING_LOCAL_CONFIG_FILE = os.path.join(SPLUNK_HOME, "etc", "log-local.cfg")
    LOGGING_STANZA_NAME = "python"
    BASE_LOG_PATH = os.path.join("var", "log", "splunk")
    LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"
    splunk_log_handler = logging.handlers.RotatingFileHandler(
        os.path.join(SPLUNK_HOME, BASE_LOG_PATH, "search_script.log"), mode="a"
    )
    splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
    logger.addHandler(splunk_log_handler)
    splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
    return logger
コード例 #10
0
def setup_logging():
    #Copied from http://dev.splunk.com/view/splunk-extensions/SP-CAAAEA9 
    logger = logging.getLogger('splunk.monitis-lookup')    
    SPLUNK_HOME = os.environ['SPLUNK_HOME']
    
    LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log.cfg')
    LOGGING_LOCAL_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log-local.cfg')
    LOGGING_STANZA_NAME = 'python'
    LOGGING_FILE_NAME = "monitis-lookup.log"
    BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
    LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"
    splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(SPLUNK_HOME, BASE_LOG_PATH, LOGGING_FILE_NAME), mode='a') 
    splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
    logger.addHandler(splunk_log_handler)
    splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
    return logger
コード例 #11
0
def setup_logging(n):
    logger = logging.getLogger(n)
    if myDebug == 'yes':
        logger.setLevel(logging.DEBUG)
    else:
        logger.setLevel(logging.ERROR)
    LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log.cfg')
    LOGGING_LOCAL_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log-local.cfg')
    LOGGING_STANZA_NAME = 'python'
    LOGGING_FILE_NAME = '%s.log' % myScript
    BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
    LOGGING_FORMAT = '%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s'
    splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(SPLUNK_HOME, BASE_LOG_PATH, LOGGING_FILE_NAME), mode='a')
    splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
    logger.addHandler(splunk_log_handler)
    splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
    return logger
コード例 #12
0
def _setup_logging_splunk_configs(logger):
    '''
    Read logging level information from config files to overwrite log level

    :param logger - the logger
    :return the logger with logging level overwritten
    '''
    logging_default_config_file = make_splunkhome_path(['etc', 'log.cfg'])
    logging_local_config_file = make_splunkhome_path(['etc', 'log-local.cfg'])
    logging_stanza_name = 'python'
    setupSplunkLogger(
        logger,
        logging_default_config_file,
        logging_local_config_file,
        logging_stanza_name,
        verbose=False)
    return logger
コード例 #13
0
def setup_logging():
    #Copied from http://dev.splunk.com/view/splunk-extensions/SP-CAAAEA9
    logger = logging.getLogger('splunk.monitis-lookup')
    SPLUNK_HOME = os.environ['SPLUNK_HOME']

    LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log.cfg')
    LOGGING_LOCAL_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc',
                                             'log-local.cfg')
    LOGGING_STANZA_NAME = 'python'
    LOGGING_FILE_NAME = "monitis-lookup.log"
    BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
    LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"
    splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(
        SPLUNK_HOME, BASE_LOG_PATH, LOGGING_FILE_NAME),
                                                              mode='a')
    splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
    logger.addHandler(splunk_log_handler)
    splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE,
                             LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
    return logger
コード例 #14
0
 def setup_logging(self):
     """
     Just set up some splunky logging goodness.
     :return:
     """
     self.logger = logging.getLogger("splunk.SplunkAppforAWSBilling")
     LOGGING_DEFAULT_CONFIG_FILE = os.path.join(self.splunk_home, "etc", "log.cfg")
     LOGGING_LOCAL_CONFIG_FILE = os.path.join(self.splunk_home, "etc", "log-local.cfg")
     LOGGING_STANZA_NAME = "python"
     LOGGING_FILE_NAME = "SplunkAppforAWSBilling.log"
     BASE_LOG_PATH = os.path.join("var", "log", "splunk")
     LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t%(module)s:%(lineno)d - %(message)s"
     splunk_log_handler = logging.handlers.RotatingFileHandler(
         os.path.join(self.splunk_home, BASE_LOG_PATH, LOGGING_FILE_NAME), mode="a"
     )
     splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
     self.logger.addHandler(splunk_log_handler)
     splunk.setupSplunkLogger(
         self.logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME
     )
コード例 #15
0
ファイル: r_index_logging.py プロジェクト: Ismael-VC/r
def setup_logging():
    global logger
    if not logger:
        logger = logging.getLogger("splunk.r")
        if "SPLUNK_HOME" in os.environ:
            splunk_home = os.environ["SPLUNK_HOME"]
            logging_default_config_file = os.path.join(splunk_home, "etc", "log.cfg")
            logging_local_config_file = os.path.join(splunk_home, "etc", "log-local.cfg")
            logging_stanza_name = "python"
            logging_file_name = "r.log"
            base_log_path = os.path.join("var", "log", "splunk")
            logging_format = "%(asctime)s %(levelname)s %(message)s"
            splunk_log_handler = logging.handlers.RotatingFileHandler(
                os.path.join(splunk_home, base_log_path, logging_file_name), mode="a"
            )
            splunk_log_handler.setFormatter(logging.Formatter(logging_format))
            logger.addHandler(splunk_log_handler)
            splunk.setupSplunkLogger(
                logger, logging_default_config_file, logging_local_config_file, logging_stanza_name
            )
    return logger
コード例 #16
0
def setup_logging():
    """
     setup_logging as found on http://dev.splunk.com/view/logging/SP-CAAAFCN
    """
    logger = logging.getLogger('splunk.shareprivateobjects')
    SPLUNK_HOME = os.environ['SPLUNK_HOME']

    LOGGING_DEFAULT_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc', 'log.cfg')
    LOGGING_LOCAL_CONFIG_FILE = os.path.join(SPLUNK_HOME, 'etc',
                                             'log-local.cfg')
    LOGGING_STANZA_NAME = 'python'
    LOGGING_FILE_NAME = "changedispatchttlall.log"
    BASE_LOG_PATH = os.path.join('var', 'log', 'splunk')
    LOGGING_FORMAT = "%(asctime)s %(levelname)-s\t %(message)s"
    splunk_log_handler = logging.handlers.RotatingFileHandler(os.path.join(
        SPLUNK_HOME, BASE_LOG_PATH, LOGGING_FILE_NAME),
                                                              mode='a')
    splunk_log_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
    logger.addHandler(splunk_log_handler)
    splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE,
                             LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)
    return logger
コード例 #17
0
 def get_logger(self,
                app_name=None,
                file_name="kenny_loggins",
                log_level=logging.INFO):
     log_location = make_splunkhome_path(['var', 'log', 'splunk', app_name])
     # logging.setLoggerClass(SplunkLogger)
     LOGGING_DEFAULT_CONFIG_FILE = make_splunkhome_path(
         ['etc', 'apps', app_name, 'default', 'log.cfg'])
     LOGGING_LOCAL_CONFIG_FILE = make_splunkhome_path(
         ['etc', 'apps', app_name, 'local', 'log.cfg'])
     LOGGING_STANZA_NAME = app_name
     _log = logging.getLogger("{}".format(file_name))
     if not os.path.isdir(log_location):
         os.mkdir(log_location)
     output_file_name = os.path.join(log_location,
                                     "{}.log".format(file_name))
     _log.propogate = False
     _log.setLevel(logging.INFO)
     f_handle = handlers.RotatingFileHandler(output_file_name,
                                             maxBytes=25000000,
                                             backupCount=5)
     formatter = logging.Formatter(
         '%(asctime)s log_level=%(levelname)s pid=%(process)d tid=%(threadName)s file="%(filename)s" function="%(funcName)s" line_number="%(lineno)d" version="{}" %(message)s'
         .format(gmail_version.__version__))
     f_handle.setFormatter(formatter)
     if not len(_log.handlers):
         _log.addHandler(f_handle)
     try:
         splunk.setupSplunkLogger(_log, LOGGING_DEFAULT_CONFIG_FILE,
                                  LOGGING_LOCAL_CONFIG_FILE,
                                  LOGGING_STANZA_NAME)
     except Exception as e:
         _log.setLevel(logging.DEBUG)
         _log.error(
             "Failed to setup Logger {3}:{4}: {1}:{0}, setting log_level to {2}"
             .format(e, type(e), log_level, app_name, file_name))
         _log.setLevel(log_level)
     return _log
コード例 #18
0
ファイル: r_index_logging.py プロジェクト: skywalka/r
def setup_logging():
    global logger
    if not logger:
        logger = logging.getLogger('splunk.r')
        if 'SPLUNK_HOME' in os.environ:
            splunk_home = os.environ['SPLUNK_HOME']
            logging_default_config_file = os.path.join(splunk_home, 'etc',
                                                       'log.cfg')
            logging_local_config_file = os.path.join(splunk_home, 'etc',
                                                     'log-local.cfg')
            logging_stanza_name = 'python'
            logging_file_name = "r.log"
            base_log_path = os.path.join('var', 'log', 'splunk')
            logging_format = "%(asctime)s %(levelname)s %(message)s"
            splunk_log_handler = logging.handlers.RotatingFileHandler(
                os.path.join(splunk_home, base_log_path, logging_file_name),
                mode='a')
            splunk_log_handler.setFormatter(logging.Formatter(logging_format))
            logger.addHandler(splunk_log_handler)
            splunk.setupSplunkLogger(logger, logging_default_config_file,
                                     logging_local_config_file,
                                     logging_stanza_name)
    return logger
コード例 #19
0
ファイル: mask.py プロジェクト: scrt/event_masker
def setup_logging(logging_level: int):
    logger = logging.getLogger('event_masker_command.log')
    logger.setLevel(logging_level)
    splunk_home = os.environ['SPLUNK_HOME']

    logging_file_name = "event_masker.log"
    base_log_path = os.path.join('var', 'log', 'splunk')
    logging_format = "%(asctime)s %(levelname)s %(message)s"
    splunk_log_handler = logging.handlers.RotatingFileHandler(
        os.path.join(splunk_home, base_log_path, logging_file_name),
        mode='a',
        maxBytes=25000000,
        backupCount=5)
    splunk_log_handler.setFormatter(logging.Formatter(logging_format))
    logger.addHandler(splunk_log_handler)

    logging_default_config_file = os.path.join(splunk_home, 'etc', 'log.cfg')
    logging_local_config_file = os.path.join(splunk_home, 'etc',
                                             'log-local.cfg')
    logging_stanza_name = 'python'
    splunk.setupSplunkLogger(logger, logging_default_config_file,
                             logging_local_config_file, logging_stanza_name)
    return logger
コード例 #20
0
ファイル: root.py プロジェクト: DRArpitha/splunk
class SafeXMLParser(lxml.etree.XMLParser):
    """An XML Parser that ignores requests for external entities"""
    def __init__(self, *a, **kw):
        super(SafeXMLParser, self).__init__(*a, **kw)
        self.resolvers.add(NullResolver())
        
parser = SafeXMLParser()
lxml.etree.set_default_parser(parser)
lxml.etree.UnsafeXMLParser = lxml.etree.XMLParser
lxml.etree.XMLParser = SafeXMLParser



try:
    splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)


    #
    # continue importing
    #

    import re, time, shutil, hashlib
    import splunk.clilib.cli_common
    import splunk.util, splunk.entity
    from controllers.top import *
    import cherrypy
    from lib.util import make_absolute, splunk_to_cherry_cfg, get_rss_parent_dir, make_splunkhome_path, is_encrypted_cert
    from lib import i18n, filechain, error, startup
    from lib.customlogmanager import SplunkedLogManager
    from splunk.appserver.mrsparkle.lib import module
コード例 #21
0
def setup_logging(logfile_name=None,
                  logger_name=None,
                  logger=None,
                  level=logging.INFO,
                  is_console_header=False,
                  log_format=LOG_DEFAULT_FMT,
                  is_propagate=False):
    '''
    Setup logging

    @param logfile_name: log file name
    @param logger_name: logger name (if logger specified then we ignore this argument)
    @param logger: logger object
    @param level: logging level
    @param is_console_header: set to true if console logging is required
    @param log_format: log message format
    @param is_propagate: set to true if you want to propagate log to higher level
    @return: logger
    '''
    if (logfile_name is None or logger_name is None) and logger is None:
        raise ValueError((
            "log_name or logger_name is not specified and logger object is not provided."
        ))

    if logger is None:
        # Logger is singleton so if logger is already defined it will return old handler
        logger = logging.getLogger(logger_name)

    logger = logger.logger if isinstance(logger,
                                         CloudgatewayLogger) else logger

    # Save the handlers before overwriting logger
    loghandlers = logger.handlers

    # If handlers is already defined then do not create new handler, this way we can avoid file opening again
    # which is issue on windows see ITOA-2439 for more information
    # Now we are checking if we need create new handler(s)
    hasFileHandler = False
    hasConsoleHandler = False
    handlerFormat = None
    for handler in loghandlers:
        if isinstance(handler, logging.handlers.RotatingFileHandler):
            handlerFormat = handlerFormat if handlerFormat else handler.formatter
            hasFileHandler = True
        elif isinstance(handler, logging.StreamHandler):
            handlerFormat = handlerFormat if handlerFormat else handler.formatter
            hasConsoleHandler = True

    # If logger_name is None: will create a child logger with different properties from parent.
    # If the given logger_name is not equal to the existing logger's name, also will create a child logger
    if logger_name is None or logger.name != logger_name:
        # dot(.) in the two log names make the new logger is the child of the existing logger,
        # so new handlers added to the new one will not impact the old one.
        logger = logging.getLogger(
            "%s.%s" % (logger.name, logger_name if logger_name else "sub"))

    logger.propagate = is_propagate  # Prevent the log messages from being duplicated in the python.log file
    logger.setLevel(level)

    if not hasFileHandler:
        try:
            lockdir = make_splunkhome_path(['var', CLOUDGATEWAY, 'lock'])
            if not os.path.exists(os.path.dirname(lockdir)):
                os.mkdir(make_splunkhome_path(['var', CLOUDGATEWAY]))
                os.mkdir(make_splunkhome_path(['var', CLOUDGATEWAY, 'lock']))
            elif not os.path.exists(lockdir):
                os.mkdir(lockdir)
        except OSError as ose:
            #Swallow all "File exists" errors - another thread/process beat us to the punch
            if ose.errno != 17:
                raise

        logfile = logfile_name
        if os.path.basename(logfile_name) == logfile_name:
            logfile = make_splunkhome_path(
                ['var', 'log', 'splunk', logfile_name])
        #Note that there are still some issues with windows here, going to make it so that we dont
        file_handler = logging.handlers.RotatingFileHandler(logfile,
                                                            maxBytes=2500000,
                                                            backupCount=5)
        file_handler.setFormatter(
            handlerFormat if handlerFormat else logging.Formatter(log_format))
        logger.addHandler(file_handler)

    if is_console_header and not hasConsoleHandler:
        console_handler = logging.StreamHandler()
        console_handler.setFormatter(
            handlerFormat if handlerFormat else logging.Formatter(log_format))
        logger.addHandler(console_handler)

    # Read logging level information from log.cfg so it will overwrite log
    # Note if logger level is specified on that file then it will overwrite log level
    LOGGING_DEFAULT_CONFIG_FILE = make_splunkhome_path(['etc', 'log.cfg'])
    LOGGING_LOCAL_CONFIG_FILE = make_splunkhome_path(['etc', 'log-local.cfg'])
    LOGGING_STANZA_NAME = 'python'
    setupSplunkLogger(logger,
                      LOGGING_DEFAULT_CONFIG_FILE,
                      LOGGING_LOCAL_CONFIG_FILE,
                      LOGGING_STANZA_NAME,
                      verbose=False)

    return logger
コード例 #22
0
            #Swallow all "File exists" errors - another thread/process beat us to the punch
            if ose.errno != 17:
                raise

        #Note that there are still some issues with windows here, going to make it so that we dont
        file_handler = logging.handlers.RotatingFileHandler(make_splunkhome_path(['var', 'log', 'splunk', log_name]),
                                                            maxBytes=2500000, backupCount=5)
        formatter = logging.Formatter(log_format)
        file_handler.setFormatter(formatter)
        logger.addHandler(file_handler)

        # Console stream handler
        if is_console_header:
            console_handler = logging.StreamHandler()
            console_handler.setFormatter(logging.Formatter(log_format))
            logger.addHandler(console_handler)

    # Read logging level information from log.cfg so it will overwrite log
    # Note if logger level is specified on that file then it will overwrite log level
    LOGGING_DEFAULT_CONFIG_FILE = make_splunkhome_path(['etc', 'log.cfg'])
    LOGGING_LOCAL_CONFIG_FILE = make_splunkhome_path(['etc', 'log-local.cfg'])
    LOGGING_STANZA_NAME = 'python'
    setupSplunkLogger(
        logger,
        LOGGING_DEFAULT_CONFIG_FILE,
        LOGGING_LOCAL_CONFIG_FILE,
        LOGGING_STANZA_NAME,
        verbose=False
    )

    return logger
コード例 #23
0
def get_logger(name=BASE_LOGGER_NAME, level=DEFAULT_LEVEL):
    """Returns a general-purpose logger instance.

    The logger is configured to write to both:
      * A (rotated) file in $SPLUNK_HOME/var/log/splunk/<name>.log
      * Standard error.

    Additionally, it consults $SPLUNK_HOME/etc/log.cfg and
    log-local.cfg for default log-levels. You can configure per-logger
    log-levels by adding a property to log-local.cfg that looks like:

        [python]
        myloggername = DEBUG

    For DEBUG messages to show up in search.log as well, you will need
    to modify $SPLUNK_HOME/etc/log-searchprocess-local.cfg to contain:

        category.ChunkedExternProcessor=DEBUG

    Idiomatic usage is:

        #!/usr/bin/env python
        import setup_logging
        logger = setup_logging.get_logger()

        def foo():
            logger.warn("Red Alert, report to battle stations")

    """
    logger = logging.getLogger(name)

    # Initial setup
    if len(logger.handlers) == 0:
        logger.setLevel(level)
        logger.propagate = False

        has_splunk_home = os.environ.get('SPLUNK_HOME')
        if has_splunk_home:
            path = make_splunkhome_path(
                ['var', 'log', 'splunk', name + '.log'])
            backup_count = 5
        else:
            # No backups if logging to current directory
            path = os.path.normpath(os.path.join(os.getcwd(), name + '.log'))
            backup_count = 0

        file_handler = logging.handlers.RotatingFileHandler(
            path, maxBytes=1000000, backupCount=backup_count)
        formatter = logging.Formatter(
            '%(created)f PID %(process)d %(asctime)s %(levelname)s [%(name)s] [%(funcName)s] %(message)s'
        )
        file_handler.setFormatter(formatter)
        logger.addHandler(file_handler)

        stream_handler = logging.StreamHandler()
        stream_handler.setFormatter(
            logging.Formatter('%(levelname)s %(message)s'))
        logger.addHandler(stream_handler)

        if has_splunk_home:
            try:
                import splunk
                # Read logging level information from log.cfg so it will overwrite log
                # Note if logger level is specified on that file then it will overwrite log level
                LOGGING_DEFAULT_CONFIG_FILE = make_splunkhome_path(
                    ['etc', 'log.cfg'])
                LOGGING_LOCAL_CONFIG_FILE = make_splunkhome_path(
                    ['etc', 'log-local.cfg'])
                LOGGING_STANZA_NAME = 'python'
                splunk.setupSplunkLogger(logger,
                                         LOGGING_DEFAULT_CONFIG_FILE,
                                         LOGGING_LOCAL_CONFIG_FILE,
                                         LOGGING_STANZA_NAME,
                                         verbose=False)
            except ImportError:
                warning_msg = (
                    'Unable to import splunk python module: cannot setup splunk logging. '
                    'If you are using the Splunk Machine Learning Toolkit\'s code directly, '
                    'without a custom search command, you may see this warning.'
                )
                logger.warn(warning_msg)
        else:
            logger.warn('No SPLUNK_HOME set. Logging to %s', path)

    return logger
コード例 #24
0
ファイル: setup_logging.py プロジェクト: TPLink32/spnk1
def get_logger(name=BASE_LOGGER_NAME, level=DEFAULT_LEVEL):
    """Returns a general-purpose logger instance.

    The logger is configured to write to both:
      * A (rotated) file in $SPLUNK_HOME/var/log/splunk/<name>.log
      * Standard error.

    Additionally, it consults $SPLUNK_HOME/etc/log.cfg and
    log-local.cfg for default log-levels. You can configure per-logger
    log-levels by adding a property to log-local.cfg that looks like:

        [python]
        myloggername = DEBUG

    For DEBUG messages to show up in search.log as well, you will need
    to modify $SPLUNK_HOME/etc/log-searchprocess-local.cfg to contain:

        category.ChunkedExternProcessor=DEBUG

    Idiomatic usage is:

        #!/usr/bin/env python
        import setup_logging
        logger = setup_logging.get_logger()

        def foo():
            logger.warn("Red Alert, report to battle stations")

    """
    logger = logging.getLogger(name)

    # Initial setup
    if len(logger.handlers) == 0:
        logger.setLevel(level)
        logger.propagate = False

        path = make_splunkhome_path(['var', 'log', 'splunk', name + '.log'])
        file_handler = logging.handlers.RotatingFileHandler(path,
                                                            maxBytes=1000000,
                                                            backupCount=5)
        formatter = logging.Formatter(
            '%(created)f %(asctime)s %(levelname)s [%(name)s] [%(funcName)s] %(message)s'
        )
        file_handler.setFormatter(formatter)
        logger.addHandler(file_handler)

        stream_handler = logging.StreamHandler()
        stream_handler.setFormatter(
            logging.Formatter('%(levelname)s %(message)s'))
        logger.addHandler(stream_handler)

        # Read logging level information from log.cfg so it will overwrite log
        # Note if logger level is specified on that file then it will overwrite log level
        LOGGING_DEFAULT_CONFIG_FILE = make_splunkhome_path(['etc', 'log.cfg'])
        LOGGING_LOCAL_CONFIG_FILE = make_splunkhome_path(
            ['etc', 'log-local.cfg'])
        LOGGING_STANZA_NAME = 'python'
        splunk.setupSplunkLogger(logger,
                                 LOGGING_DEFAULT_CONFIG_FILE,
                                 LOGGING_LOCAL_CONFIG_FILE,
                                 LOGGING_STANZA_NAME,
                                 verbose=False)

    return logger
コード例 #25
0
class SafeXMLParser(lxml.etree.XMLParser):
    """An XML Parser that ignores requests for external entities"""
    def __init__(self, *a, **kw):
        super(SafeXMLParser, self).__init__(*a, **kw)
        self.resolvers.add(NullResolver())
        
parser = SafeXMLParser()
lxml.etree.set_default_parser(parser)
lxml.etree.UnsafeXMLParser = lxml.etree.XMLParser
lxml.etree.XMLParser = SafeXMLParser



try:
    splunk.setupSplunkLogger(logger, LOGGING_DEFAULT_CONFIG_FILE, LOGGING_LOCAL_CONFIG_FILE, LOGGING_STANZA_NAME)


    #
    # continue importing
    #

    import re, time, shutil, hashlib
    import splunk.clilib.cli_common
    import splunk.clilib.bundle_paths
    import splunk.util, splunk.entity
    from controllers.top import *
    import cherrypy
    from lib.util import make_absolute, splunk_to_cherry_cfg, get_rss_parent_dir, make_splunkhome_path, is_encrypted_cert
    from lib import i18n, filechain, error, startup
    from lib.customlogmanager import SplunkedLogManager