initial commit

Author: jon-da-thon

.gitignore

@@ -0,0 +1,36 @@
+# idea/intellij IDE project and module files
+.idea/
+*.iml
+
+# vim swap files
+*.sw[mnop]
+*~
+
+# python bytecode
+*.pyc
+
+# unit testing generated files
+.coverage
+.noseids
+
+# python packaging artifacts
+*.egg
+*.egg-info/
+build/
+dist/
+
+# rpm packaging artifacts
+rpmbuild/
+
+# log files
+*.log
+*.log.bz
+*.log.gz
+*.log.[0-9]
+*.log.[0-9][0-9]
+*.log.[0-9][0-9][0-9]
+*.\d\+\.log
+
+# config files containing repo secrets
+pip.conf
+setup.cfg

.travis.yml

@@ -0,0 +1,10 @@
+language: python
+python:
+  - "2.7"
+# command to install dependencies
+install:
+  - "pip install -r requirements.txt"
+  - "pip install -r test_requirements.txt"
+  - "pip install -r setup_requirements.txt"
+# command to run tests
+script: nosetests --exe

VERSION

@@ -0,0 +1 @@
+0.1.0

examples/configyamlwithenv.py

@@ -0,0 +1,61 @@
+#!/bin/env python2
+
+"""
+A sample of YAML-based logging configuration.
+
+The python standard logging library gets configured from YAML text.  In this sample configuration three loggers are
+configured and each has a different level configured in a different way.
+- The root logger is configured.
+- The logger 'envlog' is configured using the environment variable LOGLEVEL.  This is to illustrate how you can use
+the _ENV directive to customize configurations.
+- The logger 'envdefaultlog' would be configured using a variable, but since it doesnt exist the default in the _ENV
+directive is used.  This is to illustrate the alternate syntax of the _ENV directive for default values.
+"""
+
+import os
+import logging
+from StringIO import StringIO
+
+from logging_yamlconfig import logging_yaml_init_fh
+
+# make a logging configuration
+configtxt = """
+version: 1
+handlers:
+  console:
+    class: logging.StreamHandler
+    stream: 'ext://sys.stdout'
+loggers:
+  envlog:
+    level: _ENV:LOGLEVEL
+  envdefaultlog:
+    level: _ENV:NONEXISTENTENVVAR:CRITICAL
+root:
+  level: WARN
+  handlers:
+  - console
+"""
+
+yamlfile = StringIO(configtxt)
+
+# demonstrate env var support in yaml- DEBUG loglevel
+os.environ['LOGLEVEL'] = 'DEBUG'
+
+# load the configuration with yaml dictconfig helper
+logging_yaml_init_fh(yamlfile)
+
+# create a logger
+rootlog = logging.getLogger()           # the effective log level will be WARN, as specified in the config
+envlog = logging.getLogger('envlog')    # the level will be DEBUG since we put that in the environment
+envdefaultlog = logging.getLogger('envdefaultlog') # the environment variable (likely) doesn't exist so the default is used
+
+# sample log messages- the different loggers will have different effective levels as determined by the yaml and the env
+for log in rootlog, envlog, envdefaultlog:
+    print '### logger:', log.name
+    log.debug('debug message')
+    log.info('info message')
+    log.warn('warn message')
+    log.error('error message')
+    log.critical('critical message')
+
+# vim: set ts=4 sw=4 expandtab:

logging_yamlconfig/__init__.py

@@ -0,0 +1,7 @@
+from .configloader import EnvLoggingYAMLConfigLoader, LoggingYAMLConfigLoader, logging_yaml_init, \
+                          logging_yaml_init_fh, logging_yaml_init_dict
+
+__all__ = [ 'LoggingYAMLConfigLoader', 'EnvLoggingYAMLConfigLoader', 'logging_yaml_init', 'logging_yaml_init_fh',
+            'logging_yaml_init_dict']
+
+# vim: set ts=4 sw=4 expandtab:

logging_yamlconfig/configloader.py

@@ -0,0 +1,190 @@
+import os
+import re
+import sys
+import yaml
+import logging.config
+
+
+class YamlEnvLoader(yaml.Loader):
+    """
+    an extended YAML loader which can get values from environment variables where _ENV is specified, e.g.
+
+    path: _ENV:PATH
+
+    will be replaced with the PATH environment variable, such that the resulting dictionary will be equivalent to:
+
+    { "path": os.environ['PATH'] }
+
+    if the environment variable specified does not exist, the value will be None. you can otherwise specify a default
+    value with the form:
+
+    _ENV:VARNAME:DEFAULT
+
+    NOTE: these _ENV statements will be replaced with either None, a string, an int, or a float depending solely on the
+    content.  this interpretation was added because,even though environment variables are always strings, you might want
+    to pass arguments to a handler for configuration which expects a number (maxBytes on RotatingFileHandler, or port on
+    SocketHandler for example).
+    """
+    YAML_ENV_PATTERN = re.compile(r'^_ENV:(?P<envname>[^:]+)(:(?P<default>[^:]+))?$')
+
+    def __init__(self, stream):
+        yaml.add_implicit_resolver('!pathex', self.YAML_ENV_PATTERN, Loader=self)
+        yaml.add_constructor('!pathex', self._pathex_constructor, Loader=self)
+        super(YamlEnvLoader, self).__init__(stream)
+
+    def _pathex_constructor(self, loader, node):
+        value = self.construct_scalar(node)
+        m = self.YAML_ENV_PATTERN.match(value)
+        if m is None:
+            return value
+        else:
+            envval = os.environ.get(m.group('envname'), m.group('default'))
+            try:
+                if int(envval) == float(envval):
+                    envval = int(envval)
+                else:
+                    envval = float(envval)
+            except (TypeError, ValueError):
+                pass
+            return envval
+
+
+class ConfigLocator(object):
+    """
+    initialized with a search path and will return the first existent file on that path from the locate method.  this is
+    the interface expected by the locator member of the configloader objects below.
+    """
+    DEFAULT_SEARCH_PATH = ['./pylogging.yaml',
+                           '/etc/pylogging.yaml']
+
+    def __init__(self, search_path=None, yaml_loader_class=yaml.BaseLoader):
+        if search_path is None:
+            search_path = self.DEFAULT_SEARCH_PATH
+
+        self.search_path = search_path
+
+    def locate(self):
+        log_configs = filter(
+            os.path.exists, map(os.path.abspath, self.search_path)
+        )
+
+        if len(log_configs) > 0:
+            return log_configs[0]
+        else:
+            print >>sys.stderr, 'ERROR: could not find log configuration file in search path [%s]' % \
+                                ', '.join(log_configs)
+            sys.exit(1)
+
+
+class LoggingYAMLConfigLoader(object):
+    """
+    yaml configuration helper for the standard python logger.  see the convenience methods named logging_yaml_init* for
+    usage
+    """
+    def __init__(self, locator=None, yaml_loader_class=yaml.BaseLoader):
+        if locator is None:
+            locator = ConfigLocator()
+
+        self.locator = locator
+        self.yaml_loader_class = yaml_loader_class
+
+    def configure(self):
+        configpath = self.locator.locate()
+
+        try:
+            with open(configpath, 'r') as logfh:
+                self.configure_fh(logfh)
+        except Exception, e:
+            print >>sys.stderr, "ERROR: could not open log file at \'%s\': %s" % (configpath, str(e),)
+            sys.exit(1)
+
+    def configure_fh(self, fh):
+        try:
+            logconfig = yaml.load(fh, Loader=self.yaml_loader_class)
+        except Exception, e:
+            print >>sys.stderr, "ERROR: could not deserialize logging yaml: %s" % str(e)
+            sys.exit(1)
+
+        self.configure_dict(logconfig)
+
+    def configure_dict(self, dct):
+        try:
+            logging.config.dictConfig(dct)
+        except Exception, e:
+            print >>sys.stderr, "ERROR: could not configure logger with logging yaml- %s" % str(e)
+
+
+class EnvLoggingYAMLConfigLoader(LoggingYAMLConfigLoader):
+    def __init__(self, locator=None):
+        super(EnvLoggingYAMLConfigLoader, self).__init__(locator, YamlEnvLoader)
+
+
+def logging_yaml_init(search_path=None, env_in_yaml=True):
+    """
+    configures the logger using YAML from a search path, see
+    https://docs.python.org/2/howto/logging.html#logging-advanced-tutorial for dictConfig format
+
+    if the first file found along the path does not contain a valid logging configuration in YAML the process will exit
+    (fail closed).
+
+    :param search_path: optional, specifies a list of file paths to check for a yaml configuration file
+    :param env_in_yaml: whether or not to extend the yaml loader with support for values of the form
+    _ENV:<NAME>:<DEFAULT>
+    :return: None
+    """
+    # make config locator
+    if search_path is not None:
+        locator = ConfigLocator(search_path)
+    else:
+        locator = ConfigLocator()
+
+    # make loader
+    if env_in_yaml:
+        loader_class = EnvLoggingYAMLConfigLoader
+    else:
+        loader_class = LoggingYAMLConfigLoader
+
+    loader = loader_class(locator)
+
+    loader.configure()
+
+
+def logging_yaml_init_fh(fh, env_in_yaml=True):
+    """
+    configures the logger using YAML from a filehandle, see
+    https://docs.python.org/2/howto/logging.html#logging-advanced-tutorial for dictConfig format
+
+    if the file handle does not contain a valid logging configuration in YAML the process will call sys.exit (fail
+    closed).
+
+    :param fh: an open filehandle containing yaml
+    :param env_in_yaml: whether or not to extend the yaml loader with support for values of the form
+    _ENV:<NAME>:<DEFAULT>
+    :return: None
+    """
+    if env_in_yaml:
+        loader_class = EnvLoggingYAMLConfigLoader
+    else:
+        loader_class = LoggingYAMLConfigLoader
+
+    loader = loader_class()
+
+    loader.configure_fh(fh)
+
+
+def logging_yaml_init_dict(dct):
+    """
+    configures the python standard logger using a dictionary, see
+    https://docs.python.org/2/howto/logging.html#logging-advanced-tutorial for dictConfig format
+
+    if dictionary does not contain a valid logging configuration the process will call sys.exit (fail closed).
+
+    :param dct: dictionary containing logger configuration
+    :return:
+    """
+    loader = LoggingYAMLConfigLoader()
+
+    loader.configure_dict(dct)
+
+
+# vim: set ts=4 sw=4 expandtab:

requirements.txt

@@ -0,0 +1 @@
+PyYAML>=3.11,<3.12

setup.py

@@ -0,0 +1,46 @@
+import os
+
+from setuptools import setup, find_packages, findall
+
+def get_version():
+	with open(os.path.join(thisdir, 'VERSION'), 'r') as fh:
+		return fh.readline().strip()
+
+def get_requires(filename='requirements.txt'):
+	requires = []
+	with open(os.path.join(thisdir, filename), 'r') as fh:
+		for line in fh.readlines():
+			requires += [ line.strip() ]
+	return requires
+
+thisdir = os.path.dirname(os.path.realpath(__file__))
+
+# parse version number from text file
+VERSION = get_version()
+
+# find packages and binaries
+ALL_PACKAGES = find_packages()
+SCRIPTS = findall('bin')
+
+# parse requirements from text files
+ALL_INSTALL_REQUIRES = get_requires()
+ALL_TEST_REQUIRES = get_requires('test_requirements.txt')
+ALL_SETUP_REQUIRES = get_requires('setup_requirements.txt')
+
+setup(
+	name='logging_yamlconfig',
+	version=VERSION,
+	description='Python dictconfig helpers for yaml config files',
+	author='IBM',
+	author_email='jdye@us.ibm.com',
+	packages=ALL_PACKAGES,
+	provides=ALL_PACKAGES,
+	scripts=SCRIPTS,
+	include_package_data=True,
+	setup_requires=ALL_SETUP_REQUIRES,
+    install_requires=ALL_INSTALL_REQUIRES,
+    tests_require=ALL_TEST_REQUIRES,
+    test_suite='nose.collector'
+)
+
+# vim: set ts=4 sw=4 expandtab:

setup_requirements.txt

@@ -0,0 +1,2 @@
+setuptools>=11.0,<13.0
+setuptools-git>=1.1,<1.2