Beispiel #1
0
def initialize_logging(syslog_tag, syslog_facility, loggers,
        log_level=logging.INFO, use_syslog=False):
    if os.path.exists('/dev/log'):
        syslog_device = '/dev/log'
    elif os.path.exists('/var/run/syslog'):
        syslog_device = '/var/run/syslog'

    base_fmt = ('%(name)s:%(levelname)s %(message)s:%(pathname)s:%(lineno)s')

    cfg = {
        'version': 1,
        'filters': {},
        'formatters': {
            'debug': {
                '()': UTF8SafeFormatter,
                'datefmt': '%H:%M:%s',
                'format': '%(asctime)s ' + base_fmt,
            },
            'prod': {
                '()': UTF8SafeFormatter,
                'datefmt': '%H:%M:%s',
                'format': '%s: [%%(REMOTE_ADDR)s] %s' % (syslog_tag, base_fmt),
            },
            'tornado': {
                '()': TornadoLogFormatter,
                'color': True
            },
        },
        'handlers': {
            'console': {
                '()': logging.StreamHandler,
                'formatter': 'tornado'
            },
            'null': {
                '()': NullHandler,
            },
            'syslog': {
                '()': logging.handlers.SysLogHandler,
                'facility': syslog_facility,
                'address': syslog_device,
                'formatter': 'prod',
            },
        },
        'loggers': {
        }
    }

    for key, value in loggers.items():
        cfg[key].update(value)

    # Set the level and handlers for all loggers.
    for logger in cfg['loggers'].values():
        if 'handlers' not in logger:
            logger['handlers'] = ['syslog' if use_syslog else 'console']
        if 'level' not in logger:
            logger['level'] = log_level
        if 'propagate' not in logger:
            logger['propagate'] = False

    dictconfig.dictConfig(cfg)
def log_configure():
    """You have to explicitly call this to configure logging."""
    for key, value in settings.LOGGING.items():
        cfg[key].update(value)

    USE_SYSLOG = settings.HAS_SYSLOG and not settings.DEBUG

    if USE_SYSLOG:
        cfg['loggers']['z.timer'] = {'handlers': ['syslog2']}

    # Set the level and handlers for all loggers.
    for logger in cfg['loggers'].values() + [cfg['root']]:
        if 'handlers' not in logger:
            logger['handlers'] = ['syslog' if USE_SYSLOG else 'console']
        if 'level' not in logger:
            logger['level'] = settings.LOG_LEVEL
        if logger is not cfg['root'] and 'propagate' not in logger:
            logger['propagate'] = False

    dictconfig.dictConfig(cfg)

    # logging.getLogger() accesses a singleton, this just binds
    # in the SentryHandler to error level messages
    tastypie = logging.getLogger('django.request.tastypie')
    if settings.USE_METLOG_FOR_RAVEN:
        tastypie.addHandler(MetlogTastypieHandler(settings.METLOG))
    else:
        tastypie.addHandler(SentryHandler())
Beispiel #3
0
def initialize_logging(syslog_tag, syslog_facility, loggers,
        log_level=logging.INFO, use_syslog=False):
    if os.path.exists('/dev/log'):
        syslog_device = '/dev/log'
    elif os.path.exists('/var/run/syslog'):
        syslog_device = '/var/run/syslog'

    base_fmt = ('%(name)s:%(levelname)s %(message)s:%(pathname)s:%(lineno)s')

    cfg = {
        'version': 1,
        'filters': {},
        'formatters': {
            'debug': {
                '()': UTF8SafeFormatter,
                'datefmt': '%H:%M:%s',
                'format': '%(asctime)s ' + base_fmt,
            },
            'prod': {
                '()': UTF8SafeFormatter,
                'datefmt': '%H:%M:%s',
                'format': '%s: [%%(REMOTE_ADDR)s] %s' % (syslog_tag, base_fmt),
            },
            'tornado': {
                '()': TornadoLogFormatter,
                'color': True
            },
        },
        'handlers': {
            'console': {
                '()': logging.StreamHandler,
                'formatter': 'tornado'
            },
            'null': {
                '()': NullHandler,
            },
            'syslog': {
                '()': logging.handlers.SysLogHandler,
                'facility': syslog_facility,
                'address': syslog_device,
                'formatter': 'prod',
            },
        },
        'loggers': {
        }
    }

    for key, value in loggers.items():
        cfg[key].update(value)

    # Set the level and handlers for all loggers.
    for logger in cfg['loggers'].values():
        if 'handlers' not in logger:
            logger['handlers'] = ['syslog' if use_syslog else 'console']
        if 'level' not in logger:
            logger['level'] = log_level
        if 'propagate' not in logger:
            logger['propagate'] = False

    dictconfig.dictConfig(cfg)
Beispiel #4
0
def configure_logging(config_dict=DEFAULT_LOGGING):
    """Configures logging with the specified configuration dictionary.

    :param config_dict: (optional) Standard Python logging configuration dictionary
    """

    dictconfig.dictConfig(config_dict)
Beispiel #5
0
def log_configure():
    """You have to explicitly call this to configure logging."""
    for key, value in settings.LOGGING.items():
        cfg[key].update(value)

    USE_SYSLOG = settings.HAS_SYSLOG and not settings.DEBUG


    if USE_SYSLOG:
        cfg['loggers']['z.timer'] = {'handlers': ['syslog2']}

    # Set the level and handlers for all loggers.
    for logger in cfg['loggers'].values() + [cfg['root']]:
        if 'handlers' not in logger:
            logger['handlers'] = ['syslog' if USE_SYSLOG else 'console']
        if 'level' not in logger:
            logger['level'] = settings.LOG_LEVEL
        if logger is not cfg['root'] and 'propagate' not in logger:
            logger['propagate'] = False

    dictconfig.dictConfig(cfg)

    if not settings.DEBUG:
        task_log = logging.getLogger('z.celery')
        task_proxy = celery.log.LoggingProxy(task_log)
        celery.conf.CELERYD_LOG_FILE = task_proxy
        celery.conf.CELERYD_LOG_COLOR = False
Beispiel #6
0
def setLog( config , logfilenm='/tmp/python.log', facil = 'LOG_USER'):
    if config == 'file':
        cfg = { 
                'version': 1,
                'root': {
                    'level': 'NOTSET',
                    'handlers': ['console', 'file']
                },
                'formatters': {
                    'std': {
                        'format': '%(name)s[%(process)d]: %(funcName)s: %(levelname)s: %(message)s'
                    }
                },
                'handlers': {
                    'console': {
                        'class': 'logging.StreamHandler',
                        'formatter': 'std',
                        'level': 'INFO',
                        'stream': 'ext://sys.stdout' },
                    'file': {
                        'class': 'logging.FileHandler',
                        'formatter': 'std',
                        'level': 'DEBUG',
                        'filename': logfilenm }
                }
            }
    elif config == 'system':
        cfg = {
                'version': 1,
                'root': {
                    'level': 'NOTSET',
                    'handlers': ['console', 'syslog']
                },
                'formatters': {
                    'std': {
                        'format': '%(name)s[%(process)d]: %(funcName)s: %(levelname)s: %(message)s'
                    }
                },
                'handlers': {
                    'console': {
                        'class' : 'logging.StreamHandler',
                        'formatter': 'std',
                        'level': 'INFO',
                        'stream': 'ext://sys.stdout' },
                    'syslog': {
                        'class': 'logging.handlers.SysLogHandler',
                        'formatter': 'std',
                        'level': 'DEBUG',
                        'facility': eval('logging.handlers.SysLogHandler.%s' % facil) }
                }
            }

    dictconfig.dictConfig( cfg )
    return logging
Beispiel #7
0
def log_configure():
    """You have to call this to explicity configure logging."""
    cfg = {
        "version": 1,
        "filters": {},
        "formatters": dict(prod=formatters["prod"]),
        "handlers": dict(syslog=handlers["syslog"]),
        "loggers": {"z": {"handlers": ["syslog"]}},
        "root": {},
    }
    dictconfig.dictConfig(cfg)
Beispiel #8
0
def log_configure():
    """You have to call this to explicity configure logging."""
    cfg = {
        'version': 1,
        'filters': {},
        'formatters': dict(prod2=formatters['prod2']),
        'handlers': dict(syslog2=handlers['syslog2']),
        'loggers': {},
        'root': {},
    }
    dictconfig.dictConfig(cfg)
Beispiel #9
0
def log_configure():
    """You have to call this to explicity configure logging."""
    cfg = {
        'version': 1,
        'filters': {},
        'formatters': dict(prod=formatters['prod']),
        'handlers': dict(syslog=handlers['syslog']),
        'loggers': {
            'z': {'handlers': ['syslog'], 'level': logging.INFO},
        },
        'root': {},
    }
    dictconfig.dictConfig(cfg)
Beispiel #10
0
def log_configure():
    """You have to call this to explicity configure logging."""
    cfg = {
        'version': 1,
        'filters': {},
        'formatters': dict(prod=formatters['prod']),
        'handlers': dict(syslog=handlers['syslog']),
        'loggers': {
            'z': {
                'handlers': ['syslog'],
                'level': logging.INFO
            },
        },
        'root': {},
    }
    dictconfig.dictConfig(cfg)
Beispiel #11
0
def initialize_logging(syslog_tag, syslog_facility, loggers, log_level=logging.INFO, use_syslog=False):
    if os.path.exists("/dev/log"):
        syslog_device = "/dev/log"
    elif os.path.exists("/var/run/syslog"):
        syslog_device = "/var/run/syslog"

    base_fmt = "%(name)s:%(levelname)s %(message)s:%(pathname)s:%(lineno)s"

    cfg = {
        "version": 1,
        "filters": {},
        "formatters": {
            "debug": {"()": UTF8SafeFormatter, "datefmt": "%H:%M:%s", "format": "%(asctime)s " + base_fmt},
            "prod": {
                "()": UTF8SafeFormatter,
                "datefmt": "%H:%M:%s",
                "format": "%s: [%%(REMOTE_ADDR)s] %s" % (syslog_tag, base_fmt),
            },
            "tornado": {"()": TornadoLogFormatter, "color": True},
        },
        "handlers": {
            "console": {"()": logging.StreamHandler, "formatter": "tornado"},
            "null": {"()": NullHandler},
            "syslog": {
                "()": logging.handlers.SysLogHandler,
                "facility": syslog_facility,
                "address": syslog_device,
                "formatter": "prod",
            },
        },
        "loggers": {},
    }

    for key, value in loggers.items():
        cfg[key].update(value)

    # Set the level and handlers for all loggers.
    for logger in cfg["loggers"].values():
        if "handlers" not in logger:
            logger["handlers"] = ["syslog" if use_syslog else "console"]
        if "level" not in logger:
            logger["level"] = log_level
        if "propagate" not in logger:
            logger["propagate"] = False

    dictconfig.dictConfig(cfg)
Beispiel #12
0
def log_configure():
    """You have to call this to explicity configure logging."""
    cfg = {
        'version': 1,
        'filters': {},
        'formatters': dict(prod=formatters['prod']),
        'handlers': dict(syslog=handlers['syslog']),
        'loggers': {
            'z': {'handlers': ['syslog'], 'level': logging.INFO},
        },
        'root': {},
        # Since this configuration is applied at import time
        # in verify.py we don't want it to clobber other logs
        # when imported into the marketplace Django app.
        'disable_existing_loggers': False,
    }
    dictconfig.dictConfig(cfg)
Beispiel #13
0
def log_configure():
    """You have to call this to explicity configure logging."""
    cfg = {
        'version': 1,
        'filters': {},
        'formatters': dict(prod=formatters['prod']),
        'handlers': dict(syslog=handlers['syslog']),
        'loggers': {
            'z': {'handlers': ['syslog'], 'level': logging.INFO},
        },
        'root': {},
        # Since this configuration is applied at import time
        # in verify.py we don't want it to clobber other logs
        # when imported into the marketplace Django app.
        'disable_existing_loggers': False,
    }
    dictconfig.dictConfig(cfg)
Beispiel #14
0
def setup_logging(
    default_path='logging.json', 
    default_level=logging.DEBUG,
    env_key='LOG_CFG'
):
    """Setup logging configuration

    """
    path = default_path
    value = os.getenv(env_key, None)
    if value:
        path = value
    if os.path.exists(path):
        with open(path, 'rt') as f:
            config = json.load(f)
        #logging.config.dictConfig(config)
        dictconfig.dictConfig(config)
    else:
        logging.basicConfig(level=default_level)
def log_configure():
    """You have to explicitly call this to configure logging."""
    for key, value in settings.LOGGING.items():
        cfg[key].update(value)

    USE_SYSLOG = settings.HAS_SYSLOG and not settings.DEBUG

    if USE_SYSLOG:
        cfg['loggers']['z.timer'] = {'handlers': ['syslog2']}

    # Set the level and handlers for all loggers.
    for logger in cfg['loggers'].values() + [cfg['root']]:
        if 'handlers' not in logger:
            logger['handlers'] = ['syslog' if USE_SYSLOG else 'console']
        if 'level' not in logger:
            logger['level'] = settings.LOG_LEVEL
        if logger is not cfg['root'] and 'propagate' not in logger:
            logger['propagate'] = False

    dictconfig.dictConfig(cfg)
Beispiel #16
0
def log_configure():
    """You have to explicitly call this to configure logging."""
    for key, value in settings.LOGGING.items():
        cfg[key].update(value)

    USE_SYSLOG = settings.HAS_SYSLOG and not settings.DEBUG

    if USE_SYSLOG:
        cfg['loggers']['z.timer'] = {'handlers': ['syslog2']}

    # Set the level and handlers for all loggers.
    for logger in cfg['loggers'].values() + [cfg['root']]:
        if 'handlers' not in logger:
            logger['handlers'] = ['syslog' if USE_SYSLOG else 'console']
        if 'level' not in logger:
            logger['level'] = settings.LOG_LEVEL
        if logger is not cfg['root'] and 'propagate' not in logger:
            logger['propagate'] = False

    dictconfig.dictConfig(cfg)
Beispiel #17
0
def init(base_level=DEFAULT_BASE_LOGGING_LEVEL,
         verbose_level=DEFAULT_VERBOSE_LOGGING_LEVEL,
         logging_config=None):
    """initializes a base logger

    you can use this to init a logger in any of your files.
    this will use config.py's LOGGER param and logging.dictConfig to configure
    the logger for you.

    :param int|logging.LEVEL base_level: desired base logging level
    :param int|logging.LEVEL verbose_level: desired verbose logging level
    :param dict logging_dict: dictConfig based configuration.
     used to override the default configuration from config.py
    :rtype: `python logger`
    """
    if logging_config is None:
        logging_config = {}
    logging_config = logging_config or LOGGER
    # TODO: (IMPRV) only perform file related actions if file handler is
    # TODO: (IMPRV) defined.

    log_file = LOGGER['handlers']['file']['filename']
    log_dir = os.path.dirname(os.path.expanduser(log_file))
    if os.path.isfile(log_dir):
        sys.exit('file {0} exists - log directory cannot be created '
                 'there. please remove the file and try again.'
                 .format(log_dir))
    try:
        if not os.path.exists(log_dir) and not len(log_dir) == 0:
            os.makedirs(log_dir)
        dictconfig.dictConfig(logging_config)
        lgr = logging.getLogger('user')
        lgr.setLevel(base_level)
        return lgr
    except ValueError as e:
        sys.exit('could not initialize logger.'
                 ' verify your logger config'
                 ' and permissions to write to {0} ({1})'
                 .format(log_file, e))
Beispiel #18
0
def configure():
    """Configures the logger using the default configuration.
    """
    try:
        log_file = LOGGER['handlers']['file']['filename']
    except KeyError as ex:
        sys.exit('Failed retrieving log file path ({0}).'.format(str(ex)))
    log_dir = os.path.dirname(os.path.expanduser(log_file))
    if os.path.isfile(log_dir):
        sys.exit(
            'File {0} exists - log directory cannot be created '
            'there. please remove the file and try again.'.format(log_dir))
    try:
        if not os.path.exists(log_dir) and not len(log_dir) == 0:
            os.makedirs(log_dir)
        dictconfig.dictConfig(LOGGER)

    except ValueError as ex:
        sys.exit('Could not configure logger.'
                 ' verify your logger config'
                 ' and permissions to write to {0} ({1})'.format(
                     log_file, str(ex)))
Beispiel #19
0
def configure():
    """Configures the logger using the default configuration.
    """
    try:
        log_file = LOGGER['handlers']['file']['filename']
    except KeyError as ex:
        sys.exit('Failed retrieving log file path ({0}).'.format(str(ex)))
    log_dir = os.path.dirname(os.path.expanduser(log_file))
    if os.path.isfile(log_dir):
        sys.exit('File {0} exists - log directory cannot be created '
                 'there. please remove the file and try again.'.format(
                     log_dir))
    try:
        if not os.path.exists(log_dir) and not len(log_dir) == 0:
            os.makedirs(log_dir)
        dictconfig.dictConfig(LOGGER)

    except ValueError as ex:
        sys.exit('Could not configure logger.'
                 ' verify your logger config'
                 ' and permissions to write to {0} ({1})'.format(
                     log_file, str(ex)))
def init(base_level=DEFAULT_BASE_LOGGING_LEVEL,
         verbose_level=DEFAULT_VERBOSE_LOGGING_LEVEL,
         logging_config=None):
    """initializes a base logger

    you can use this to init a logger in any of your files.
    this will use config.py's LOGGER param and logging.dictConfig to configure
    the logger for you.

    :param int|logging.LEVEL base_level: desired base logging level
    :param int|logging.LEVEL verbose_level: desired verbose logging level
    :param dict logging_dict: dictConfig based configuration.
     used to override the default configuration from config.py
    :rtype: `python logger`
    """
    if logging_config is None:
        logging_config = {}
    logging_config = logging_config or LOGGER
    # TODO: (IMPRV) only perform file related actions if file handler is
    # TODO: (IMPRV) defined.

    log_file = LOGGER['handlers']['file']['filename']
    log_dir = os.path.dirname(os.path.expanduser(log_file))
    if os.path.isfile(log_dir):
        sys.exit(
            'file {0} exists - log directory cannot be created '
            'there. please remove the file and try again.'.format(log_dir))
    try:
        if not os.path.exists(log_dir) and not len(log_dir) == 0:
            os.makedirs(log_dir)
        dictconfig.dictConfig(logging_config)
        lgr = logging.getLogger('user')
        lgr.setLevel(base_level)
        return lgr
    except ValueError as e:
        sys.exit('could not initialize logger.'
                 ' verify your logger config'
                 ' and permissions to write to {0} ({1})'.format(log_file, e))
Beispiel #21
0
def log_configure():
    """You have to explicitly call this to configure logging."""
    for key, value in settings.LOGGING.items():
        cfg[key].update(value)

    USE_SYSLOG = settings.HAS_SYSLOG and not settings.DEBUG

    if USE_SYSLOG:
        cfg["loggers"]["z.timer"] = {"handlers": ["syslog2"]}

    # Set the level and handlers for all loggers.
    for logger in cfg["loggers"].values() + [cfg["root"]]:
        if "handlers" not in logger:
            logger["handlers"] = ["syslog" if USE_SYSLOG else "console"]
        if "level" not in logger:
            logger["level"] = settings.LOG_LEVEL
        if logger is not cfg["root"] and "propagate" not in logger:
            logger["propagate"] = False

    dictconfig.dictConfig(cfg)

    tastypie = logging.getLogger("django.request.tastypie")
    tastypie.addHandler(SentryHandler())
Beispiel #22
0
def log_configure():
    """You have to explicitly call this to configure logging."""
    for key, value in settings.LOGGING.items():
        if isinstance(cfg[key], dict):
            cfg[key].update(value)
        else:
            cfg[key] = value

    USE_SYSLOG = settings.HAS_SYSLOG and not settings.DEBUG

    if USE_SYSLOG:
        cfg["loggers"]["z.timer"] = {"handlers": ["syslog2"]}

    # Set the level and handlers for all loggers.
    for logger in cfg["loggers"].values() + [cfg["root"]]:
        if "handlers" not in logger:
            logger["handlers"] = ["syslog" if USE_SYSLOG else "console"]
        if "level" not in logger:
            logger["level"] = settings.LOG_LEVEL
        if logger is not cfg["root"] and "propagate" not in logger:
            logger["propagate"] = False

    dictconfig.dictConfig(cfg)
Beispiel #23
0
        'syslog': {
            '()': logging.handlers.SysLogHandler,
            'facility': logging.handlers.SysLogHandler.LOG_LOCAL7,
            'formatter': 'prod',
        },
        'null': {
            '()': NullHandler,
        },
    },
    'loggers': {
        'mdn': {},
    },
    'root': {},
}

for key, value in settings.LOGGING.items():
    cfg[key].update(value)

# Set the level and handlers for all loggers.
for logger in cfg['loggers'].values() + [cfg['root']]:
    syslog = settings.HAS_SYSLOG and not settings.DEBUG
    if 'handlers' not in logger:
        logger['handlers'] = ['syslog' if syslog else 'console']
    if 'level' not in logger:
        logger['level'] = settings.LOG_LEVEL
    if logger is not cfg['root'] and 'propagate' not in logger:
        logger['propagate'] = False


dictconfig.dictConfig(cfg)
Beispiel #24
0
            'console':{
                'level':'DEBUG',
                'class':'logging.StreamHandler',
                'formatter': 'simple'
                },
            'file': {
                'class': 'logging.handlers.RotatingFileHandler',
                'level': 'ERROR',
                'formatter': 'detailed',
                'filename': BASE_DIR + '/logs/standalone.log',
                'mode': 'a',
                'maxBytes': 10485760,
                'backupCount': 5,
                },
            },
        'loggers': {
            'standalone': {
                'handlers':['console','file'],
                'propagate': True,
                'level':'DEBUG',
                },
            }
        }


# assign it to logging dictconfig
dictconfig.dictConfig(LOGGING)

# get root logger
LOGGER = logging.getLogger('standalone')
Beispiel #25
0
        }
    },
    'loggers': {
        'cocreate': {
            'handlers': ['default', 'file'],
            'level': 'DEBUG',
            'propagate': True
        },
        'django.request': {
            'handlers': ['default'],
            'level': 'WARN',
            'propagate': False
        },
    }
}
dictconfig.dictConfig(conf)
logger = logging.getLogger('cocreate')

# Initialize Rabbitmq connection
connection = pika.BlockingConnection(pika.ConnectionParameters('screenbird.com'))
cocreate_queue = connection.channel()
cocreate_queue.queue_declare(queue=settings.COCREATE_QUEUE_NAME, durable=True)

# Initialize Amazon S3 connection
s3 = boto.connect_s3(settings.AWS_ACCESS_KEY_ID, settings.AWS_SECRET_ACCESS_KEY)
bucket = s3.get_bucket(settings.AWS_VIDEO_BUCKET_NAME)

def download_from_s3(slug):
    """
    Downloads a given slug to a file from s3.
    """
Beispiel #26
0
 def apply_config(self, conf):
     dictConfig(conf)
Beispiel #27
0
def initialize_logging(log_config):
    use_syslog = log_config.pop('use_syslog', False)
    log_level = log_config.pop('log_level', logging.INFO)
    syslog_tag = log_config.pop('syslog_tag')
    syslog_facility = log_config.pop('syslog_facility',
            logging.handlers.SysLogHandler.LOG_LOCAL0)

    if os.path.exists('/dev/log'):
        syslog_device = '/dev/log'
    elif os.path.exists('/var/run/syslog'):
        syslog_device = '/var/run/syslog'

    base_fmt = ('%(name)s:%(levelname)s %(message)s')

    cfg = {
        'version': 1,
        'filters': {},
        'formatters': {
            'debug': {
                '()': UTF8SafeFormatter,
                'datefmt': '%H:%M:%s',
                'format': '%(asctime)s ' + base_fmt,
            },
            'prod': {
                '()': UTF8SafeFormatter,
                'datefmt': '%H:%M:%s',
                'format': '%s: [%%(REMOTE_ADDR)s] %s' % (syslog_tag, base_fmt),
            },
            'tornado': {
                '()': TornadoLogFormatter,
                'color': True
            },
        },
        'handlers': {
            'console': {
                '()': logging.StreamHandler,
                'formatter': 'tornado'
            },
            'null': {
                '()': NullHandler,
            },
            'syslog': {
                '()': logging.handlers.SysLogHandler,
                'facility': syslog_facility,
                'address': syslog_device,
                'formatter': 'prod',
            },
        },
        'loggers': {
            # root logger
            '': {}
        }
    }

    for key, value in log_config.items():
        cfg[key].update(value)

    # Set the level and handlers for all loggers.
    for logger in cfg['loggers'].values():
        if 'handlers' not in logger:
            logger['handlers'] = ['syslog' if use_syslog else 'console']
        if 'level' not in logger:
            logger['level'] = log_level
        if 'propagate' not in logger:
            logger['propagate'] = False

    # Set up color if we are in a tty and curses is installed
    cfg['formatters']['tornado']['color'] = False
    if curses and sys.stderr.isatty():
        try:
            curses.setupterm()
            if curses.tigetnum("colors") > 0:
                cfg['formatters']['tornado']['color'] = True
        except:
            pass

    dictconfig.dictConfig(cfg)
Beispiel #28
0
import logging
#import cloghandler
import logging.config

#formatter = logging.Formatter('%(asctime)s - %(name)s - %(process)d - %(levelname)s - %(message)s')

#logger = logging.getLogger("compress_log");
#logger.setLevel(logging.DEBUG)
#ch = logging.FileHandler("/var/log/z-agent.log")
#ch.setFormatter(formatter)
#logger.addHandler(ch)

#ch1=logging.StreamHandler()
#ch1.setFormatter(formatter)
#console = logging.getLogger(__name__)
#console.setLevel(logging.DEBUG)
#console.addHandler()

import os
import yaml
import sys

basepath = os.path.dirname(__file__).rstrip(__name__)
yaml_cfg = os.path.join(basepath, "conf", "log.yaml")
if sys.version_info[0] == 2 and sys.version_info[1] < 7:
    import dictconfig
    dictconfig.dictConfig(yaml.load(open(yaml_cfg, "r")))
else:
    logging.config.dictConfig(yaml.load(open(yaml_cfg, "r")))
Beispiel #29
0
    },
    'loggers': {
        'django.request': {
            'handlers': ['mail_admins'],
            'level': 'ERROR',
            'propagate': False,
        },
        'cef': {
            'handlers': ['cef_syslog' if use_syslog else 'cef_console'],
        }
    },
    'root': {},
}

for key, value in settings.LOGGING.items():
    if hasattr(cfg[key], 'update'):
        cfg[key].update(value)
    else:
        cfg[key] = value

# Set the level and handlers for all loggers.
for logger in cfg['loggers'].values() + [cfg['root']]:
    if 'handlers' not in logger:
        logger['handlers'] = ['syslog' if use_syslog else 'console']
    if 'level' not in logger:
        logger['level'] = settings.LOG_LEVEL
    if logger is not cfg['root'] and 'propagate' not in logger:
        logger['propagate'] = False

dictconfig.dictConfig(cfg)
Beispiel #30
0
def initialize_logging(log_config):
    use_syslog = log_config.pop('use_syslog', False)
    log_level = log_config.pop('log_level', logging.INFO)
    syslog_tag = log_config.pop('syslog_tag')
    syslog_facility = log_config.pop('syslog_facility',
                                     logging.handlers.SysLogHandler.LOG_LOCAL0)

    if os.path.exists('/dev/log'):
        syslog_device = '/dev/log'
    elif os.path.exists('/var/run/syslog'):
        syslog_device = '/var/run/syslog'

    base_fmt = ('%(name)s:%(levelname)s %(message)s')

    cfg = {
        'version': 1,
        'filters': {},
        'formatters': {
            'debug': {
                '()': UTF8SafeFormatter,
                'datefmt': '%H:%M:%s',
                'format': '%(asctime)s ' + base_fmt,
            },
            'prod': {
                '()': UTF8SafeFormatter,
                'datefmt': '%H:%M:%s',
                'format': '%s: [%%(REMOTE_ADDR)s] %s' % (syslog_tag, base_fmt),
            },
            #'tornado': {
            #    '()': TornadoLogFormatter,
            #    'color': True
            #},
        },
        'handlers': {
            'console': {
                '()': logging.StreamHandler,
                'formatter': 'debug'
            },
            'null': {
                '()': NullHandler,
            },
            'syslog': {
                '()': logging.handlers.SysLogHandler,
                'facility': syslog_facility,
                'address': syslog_device,
                'formatter': 'prod',
            },
        },
        'loggers': {
            # root logger
            '': {}
        }
    }

    for key, value in log_config.items():
        cfg[key].update(value)

    # Set the level and handlers for all loggers.
    for logger in cfg['loggers'].values():
        if 'handlers' not in logger:
            logger['handlers'] = ['syslog' if use_syslog else 'console']
        if 'level' not in logger:
            logger['level'] = log_level
        if 'propagate' not in logger:
            logger['propagate'] = False

    # Set up color if we are in a tty and curses is installed
    #cfg['formatters']['tornado']['color'] = False
    #if curses and sys.stderr.isatty():
    #    try:
    #        curses.setupterm()
    #        if curses.tigetnum("colors") > 0:
    #            cfg['formatters']['tornado']['color'] = True
    #    except:
    #        pass

    dictconfig.dictConfig(cfg)
Beispiel #31
0
 def setUp(self):
     dictconfig.dictConfig(cfg)
     self.log = logging.getLogger('test.lib.misc.logging')
     self.request = RequestFactory().get('http://foo.com/blargh')
Beispiel #32
0
 def setUp(self):
     dictconfig.dictConfig(cfg)
     self.log = logging.getLogger('test.lib.misc.logging')
Beispiel #33
0
        }
    },
    'loggers': {
        'cocreate': {
            'handlers': ['default', 'file'],
            'level': 'DEBUG',
            'propagate': True
        },
        'django.request': {
            'handlers': ['default'],
            'level': 'WARN',
            'propagate': False
        },
    }
}
dictconfig.dictConfig(conf)
logger = logging.getLogger('cocreate')

# Initialize Rabbitmq connection
connection = pika.BlockingConnection(
    pika.ConnectionParameters('screenbird.com'))
cocreate_queue = connection.channel()
cocreate_queue.queue_declare(queue=settings.COCREATE_QUEUE_NAME, durable=True)

# Initialize Amazon S3 connection
s3 = boto.connect_s3(settings.AWS_ACCESS_KEY_ID,
                     settings.AWS_SECRET_ACCESS_KEY)
bucket = s3.get_bucket(settings.AWS_VIDEO_BUCKET_NAME)


def download_from_s3(slug):
Beispiel #34
0
 def setUp(self):
     dictconfig.dictConfig(cfg)
     self.log = logging.getLogger('test.lib.misc.logging')
     self.request = RequestFactory().get('http://foo.com/blargh')
Beispiel #35
0
 def setUp(self):
     dictconfig.dictConfig(cfg)
     self.log = logging.getLogger('test.lib.misc.logging')