def _setup_custom_logger(self):
LOG_PATH = './log'
try:
os.mkdir(LOG_PATH)
except Exception as e:
pass
create_folder_if_not_exists(LOG_PATH)
LOG_FILE = "{0}/{1}".format(LOG_PATH, "migu")
formatter = logging.Formatter(
"[%(asctime)s] %(threadName)s - %(filename)s %(funcName)s():%(lineno)d %(levelname)s \t%(message)s") # same as default
# formatter = logging.Formatter('%(asctime)s [%(pathname)s: %(lineno)d] %(levelname)s %(message)s')
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
file_handler = ParallelTimedRotatingFileHandler(LOG_FILE, when='H')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# setup `RainbowLoggingHandler`
handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
# Add file handler
return logger
def setup_console_logging(log_level=None):
"""Setup console logging.
Aimed to give easy sane defaults for loggig in command line applications.
Don't use logging settings from INI, but use hardcoded defaults.
"""
formatter = logging.Formatter("[%(asctime)s] [%(name)s %(funcName)s] %(message)s") # same as default
# setup `RainbowLoggingHandler`
# and quiet some logs for the test output
handler = RainbowLoggingHandler(sys.stdout)
handler.setFormatter(formatter)
logger = logging.getLogger()
logger.handlers = [handler]
env_level = os.environ.get("LOG_LEVEL", "info")
log_level = log_level or getattr(logging, env_level.upper())
logger.setLevel(log_level)
logger = logging.getLogger("requests.packages.urllib3.connectionpool")
logger.setLevel(logging.ERROR)
# SQL Alchemy transactions
logger = logging.getLogger("txn")
logger.setLevel(logging.ERROR)
def setup():
formatter = logging.Formatter(
"[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s"
) # same as default
# setup `RainbowLoggingHandler`
# and quiet some logs for the test output
handler = RainbowLoggingHandler(sys.stderr)
handler.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(handler)
if "VERBOSE_TEST" in os.environ:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.ERROR)
logger = logging.getLogger("requests.packages.urllib3.connectionpool")
logger.setLevel(logging.ERROR)
logger = logging.getLogger("cryptoassets.core.backend.blockio")
logger.setLevel(logging.DEBUG)
logger = logging.getLogger("cryptoassets.core.backend.bitcoind")
logger.setLevel(logging.WARN)
# SQL Alchemy transactions
logger = logging.getLogger("txn")
logger.setLevel(logging.ERROR)
def setup():
formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # same as default
# setup `RainbowLoggingHandler`
# and quiet some logs for the test output
handler = RainbowLoggingHandler(sys.stderr)
handler.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(handler)
if "VERBOSE_TEST" in os.environ:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.ERROR)
logger = logging.getLogger("requests.packages.urllib3.connectionpool")
logger.setLevel(logging.ERROR)
logger = logging.getLogger("cryptoassets.core.backend.blockio")
logger.setLevel(logging.DEBUG)
logger = logging.getLogger("cryptoassets.core.backend.bitcoind")
logger.setLevel(logging.WARN)
# SQL Alchemy transactions
logger = logging.getLogger("txn")
logger.setLevel(logging.ERROR)
def setup_custom_logger():
LOG_FILE = 'log/cpa'
formatter = logging.Formatter("[%(asctime)s] %(threadName)s - %(pathname)s %(funcName)s():%(lineno)d %(levelname)s \t%(message)s") # same as default
# formatter = logging.Formatter('%(asctime)s [%(pathname)s: %(lineno)d] %(levelname)s %(message)s')
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
file_handler = ParallelTimedRotatingFileHandler(LOG_FILE, when='H')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# console_handler = logging.StreamHandler(sys.stdout)
# console_handler.formatter = formatter
# logger.addHandler(console_handler)
# setup `RainbowLoggingHandler`
handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
#Add file handler
handler = TimedRotatingFileHandler(LOG_FILE,
when="h",
interval=1,
backupCount=48)
# try:
# raise RuntimeError("Opa!")
# except Exception as e:
# logger.exception(e)
return logger
def setup_logging() -> None:
"""
Sets up the logging module to have a verbose option and formats the Console handler and File handler
"""
logging.addLevelName(VERBOSE, "VERBOSE")
logging.Logger.verbose = logger_verbose
logging.verbose = logging_verbose
logging.VERBOSE = VERBOSE
# define console handler
console_handler = ConsoleHandler(sys.stderr)
if hasattr(console_handler, "_column_color"):
# noinspection PyProtectedMember
# pylint: disable=protected-access
console_handler._column_color['%(message)s'][logging.VERBOSE] = ('cyan', None, False)
console_formatter = logging.Formatter("[%(asctime)s] %(levelname)s : %(message)s", "%H:%M:%S")
console_handler.setFormatter(console_formatter)
console_handler.setLevel(logging.VERBOSE)
# define file handler
if not os.path.exists(os.path.dirname(get_global_conf().getdir("install", "log_file"))):
os.makedirs(os.path.dirname(get_global_conf().getdir("install", "log_file")))
file_handler = logging.FileHandler(get_global_conf().getdir("install", "log_file"))
# add handlers
logging.getLogger().addHandler(console_handler)
logging.getLogger().addHandler(file_handler)
logging.getLogger().setLevel(get_global_conf().getint("install", "log_level"))
def test_format_all_column():
logger = logging.getLogger('test_logging_format_all_column')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('''
name = '%(name)s'
levelno = '%(levelno)s'
levelname = '%(levelname)s'
pathname = '%(pathname)s'
filename = '%(filename)s'
module = '%(module)s'
lineno = '%(lineno)d'
funcName = '%(funcName)s'
created = '%(created)f'
asctime = '%(asctime)s'
msecs = '%(msecs)d'
relativeCreated = '%(relativeCreated)d'
thread = '%(thread)d'
threadName = '%(threadName)s'
process = '%(process)d'
message = '%(message)s'
''')
handler = RainbowLoggingHandler(sys.stderr)
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.debug("debug msg")
def _setStreamLoggingHandler(self, formatter):
handler = RainbowLoggingHandler(
sys.stderr,
datefmt='%Y-%m-%d %H:%M:%S',
color_name=('white', None, False),
color_levelno=('white', None, False),
color_levelname=('white', None, False),
color_pathname=('blue', None, True),
color_filename=('blue', None, True),
color_module=('blue', None, True),
color_lineno=('cyan', None, True),
color_funcName=('blue', None, True),
color_created=('white', None, False),
color_asctime=('black', None, True),
color_msecs=('white', None, False),
color_relativeCreated=('white', None, False),
color_thread=('white', None, False),
color_threadName=('white', None, False),
color_process=('black', None, True),
color_message_debug=('cyan', None, False),
color_message_info=('white', None, False),
color_message_warning=('yellow', None, True),
color_message_error=('red', None, True),
color_message_critical=('white', 'red', True))
handler.setFormatter(formatter)
return handler
def setup_console_logging(log_level: t.Optional[str] = None):
"""Setup console logging.
Aimed to give easy sane defaults for logging in command line applications.
Don't use logging settings from INI, but use hardcoded defaults.
"""
formatter = logging.Formatter(
"[%(asctime)s] [%(name)s %(funcName)s] %(message)s") # same as default
# setup `RainbowLoggingHandler`
# and quiet some logs for the test output
handler = RainbowLoggingHandler(sys.stdout)
handler.setFormatter(formatter)
logger = logging.getLogger()
logger.handlers = [handler]
env_level = os.environ.get("LOG_LEVEL", "info")
log_level = log_level or getattr(logging, env_level.upper())
logger.setLevel(log_level)
logger = logging.getLogger("requests.packages.urllib3.connectionpool")
logger.setLevel(logging.ERROR)
# SQL Alchemy transactions
logger = logging.getLogger("txn")
logger.setLevel(logging.ERROR)
def test_format_all_column():
logger = logging.getLogger('test_logging_format_all_column')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('''
name = '%(name)s'
levelno = '%(levelno)s'
levelname = '%(levelname)s'
pathname = '%(pathname)s'
filename = '%(filename)s'
module = '%(module)s'
lineno = '%(lineno)d'
funcName = '%(funcName)s'
created = '%(created)f'
asctime = '%(asctime)s'
msecs = '%(msecs)d'
relativeCreated = '%(relativeCreated)d'
thread = '%(thread)d'
threadName = '%(threadName)s'
process = '%(process)d'
message = '%(message)s'
''')
handler = RainbowLoggingHandler(sys.stderr)
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.debug("debug msg")
def init_logging(level='DEBUG', frmt=None, color=True, **kw):
try:
level = int(level)
except:
pass
if not frmt:
frmt = "%(asctime)-15s:%(levelname)5.5s:%(name)s:%(message)s"
logging.basicConfig(level=level, format=frmt, **kw)
if color and sys.stderr.isatty():
from rainbow_logging_handler import RainbowLoggingHandler
color_handler = RainbowLoggingHandler(
sys.stderr,
color_message_debug=('grey', None, False),
color_message_info=('blue', None, False),
color_message_warning=('yellow', None, True),
color_message_error=('red', None, True),
color_message_critical=('white', 'red', True),
)
formatter = formatter = logging.Formatter(frmt)
color_handler.setFormatter(formatter)
## Be conservative and apply color only when
# log-config looks like the "basic".
#
rlog = logging.getLogger()
if rlog.handlers and isinstance(rlog.handlers[0],
logging.StreamHandler):
rlog.removeHandler(rlog.handlers[0])
rlog.addHandler(color_handler)
def factory(logger_name):
"""Logger factory
"""
logger = logging.getLogger(logger_name)
handler = RainbowLoggingHandler(sys.stderr, datefmt=None)
handler.setFormatter(logging.Formatter("[%(asctime)s] %(filename)s %(funcName)s():%(lineno)d\t%(message)s"))
logger.addHandler(handler)
return logger
def setup_logging():
log = logging.getLogger("")
handler = RainbowLoggingHandler(sys.stderr)
handler._column_color['%(asctime)s'] = ('cyan', None, False)
handler._column_color['%(levelname)-7s'] = ('green', None, False)
handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False)
handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)-15s %(message)s"))
log.addHandler(handler)
log.setLevel(logging.INFO)
def logger(config_file):
CONFIG = configparser.RawConfigParser()
CONFIG.read(config_file)
logger_config = CONFIG['logger']
logger = logging.getLogger(logger_config['name'])
logger.setLevel(LOGGING_LEVELS.get(logger_config['level'], logging.NOTSET))
formatter = logging.Formatter(
'[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s'
)
handler = RainbowLoggingHandler(
sys.stderr,
color_funcName=('black', 'yellow', True)
)
handler.setFormatter(formatter)
logger.addHandler(handler)
if CONFIG.has_section('file_logger'):
file_logger_config = CONFIG['file_logger']
fh = logging.handlers.RotatingFileHandler(
file_logger_config['file_path'],
maxBytes=int(file_logger_config['max_log_file_size']),
backupCount=int(file_logger_config['backup_count'])
)
fh.setLevel(LOGGING_LEVELS.get(file_logger_config['level'],
logging.NOTSET))
fh.setFormatter(formatter)
logger.addHandler(fh)
if CONFIG.has_section('email_logger'):
email_logger_config = CONFIG['email_logger']
eh = logging.handlers.SMTPHandler(
(email_logger_config['host'], email_logger_config['port']),
email_logger_config['from'],
email_logger_config['to'],
email_logger_config['subject'],
(email_logger_config['username'], email_logger_config['password']),
()
)
eh.setLevel(LOGGING_LEVELS.get(email_logger_config['level'],
logging.NOTSET))
eh.setFormatter(formatter)
logger.addHandler(eh)
return logger
def __init__(self, device=None, username=None, password=None, verify_cert=False, domain='Global', loglevel=20):
self.logger = logging.getLogger('FIREPOWER')
self.logger.setLevel(loglevel)
formatter = logging.Formatter('%(asctime)s [%(name)s] [%(levelname)s] %(message)s')
handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True))
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.api = FireREST(device=device, username=username, password=password, verify_cert=verify_cert,
loglevel=loglevel)
self.domain = domain
def setup_logging(verbose=False):
log = logging.getLogger("")
handler = RainbowLoggingHandler(sys.stderr)
handler._column_color['%(asctime)s'] = ('cyan', None, False)
handler._column_color['%(levelname)-7s'] = ('green', None, False)
handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False)
handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)-15s %(message)s"))
log.addHandler(handler)
log.setLevel([logging.INFO, logging.DEBUG][verbose])
logging.getLogger("boto").level = logging.CRITICAL
def __init__(self,
checker: AbstractChecker,
coverage_threshold,
time_interval_count,
battery_threshold,
log=None,
improvement_score_limit=1):
"""
Constructs a solution for the volatile resources problem based on the fractional optimal solution
for the inherent bin packing problem as defined by Cambazard, et. al. -- Bin Packing with Linear Usage
Costs - An Application to Energy Management in Data Centres, https://hal.archives-ouvertes.fr/hal-00858159
:param checker:
"""
super(ConstructiveMapperFromFractional, self).__init__(checker)
# NOTE: names starting with __ are sort of private methods in python
self.__checker = checker
self.bins = []
self.items = []
self.pruning_steps_collection = [PruneLocalityConstraints()]
self.objective_value_of_fractional_opt = None
self.objective_value_of_integer_solution = None
if log is None:
self.log = logging.Logger(self.__class__.__name__)
handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'yellow',
True))
formatter = logging.Formatter(
'%(asctime)s.%(name)s.%(levelname).3s: %(message)s')
handler.setFormatter(formatter)
self.log.addHandler(handler)
self.log.setLevel(logging.INFO)
else:
self.log = log.getChild(self.__class__.__name__)
for handler in log.handlers:
self.log.addHandler(handler)
self.log.setLevel(log.getEffectiveLevel())
# these might not be needed if we override the functions with other heuristics.
self.EPSILON = 1e-5
self.min_bin_preference = None
self.improvement_score_limit = improvement_score_limit
# compulsory parameters
self.time_interval_count = time_interval_count
self.battery_threshold = battery_threshold
self.coverage_threshold = coverage_threshold
# variable to communicate between the new best bins and the item move improvement step functions
self.possible_bins_needed = []
self.infra = None
self.ns = None
# list of BinCapacityViolationChecker objects instantiated in the save_global_mapping_task_information fucntion
self.violation_checkers = None
self.hashes_of_visited_mappings = set()
self.chosen_ap_ids = InvalidableAPSelectionStruct()
def add_stdout_handler(logger, formatter):
try:
from rainbow_logging_handler import RainbowLoggingHandler
handler = RainbowLoggingHandler(sys.stderr, color_funcName=(
'black', 'black', True))
except ImportError:
handler = logging.StreamHandler()
pass
handler.setFormatter(formatter)
logger.addHandler(handler)
def set_up_logger():
logger: logging.Logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
formatter = logging.Formatter(
"[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s")
handler = RainbowLoggingHandler(stderr,
color_funcName=('black', 'yellow', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.raiseExceptions = False
return logger
def __init__(self,
device=None,
username=None,
password=None,
verify_cert=False,
timeout=120,
loglevel=20,
rate_limit=9):
self.logger = logging.getLogger('FireREST')
self.logger.setLevel(loglevel)
formatter = logging.Formatter(
'%(asctime)s [%(name)s] [%(levelname)s] %(message)s')
handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'yellow',
True))
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.device = device
self.username = username
self.password = password
self.verify_cert = verify_cert
self.timeout = timeout
self.cred = HTTPBasicAuth(self.username, self.password)
self.api_platform_request_url = API_PLATFORM_REQ_URL
self.api_config_request_url = API_CONFIG_REQ_URL
self.headers = HEADERS
self.url_policy = {
'accesspolicy': 'accesspolicies',
'filepolicy': 'filepolicies',
'intrusionpolicy': 'intrusionpolicies',
'snmpalert': 'snmpalerts',
'syslogalert': 'syslogalerts'
}
self.rate_limit = rate_limit
self.rate_limit_count = 0
try:
request = requests.post('https://' + self.device + API_AUTH_URL,
headers=HEADERS,
auth=self.cred,
verify=self.verify_cert)
self.token = request.headers.get('X-auth-access-token',
default=None)
self.domains = json.loads(
request.headers.get('DOMAINS', default=None))
self.headers['X-auth-access-token'] = self.token
except Exception as error:
self.logger.error(
'Could not generate Authentication Token, check connection parameters'
)
self.logger.error('Exception: %s ' % error.message)
sys.exit()
def add_stdout_handler(logger, formatter):
try:
from rainbow_logging_handler import RainbowLoggingHandler
handler = RainbowLoggingHandler(sys.stderr, color_funcName=(
'black', 'black', True))
except ImportError:
handler = logging.StreamHandler()
pass
handler.setFormatter(formatter)
logger.addHandler(handler)
def setup_logging():
# Setup Python root logger to DEBUG level
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
"[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s"
) # same as default
# Add colored log handlign to sys.stderr
handler = RainbowLoggingHandler(sys.stderr)
handler.setFormatter(formatter)
logger.addHandler(handler)
def __init__(
self,
name: str,
level: int = logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'):
super().__init__(name, level)
formatter = logging.Formatter(format)
handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'yellow',
True))
handler.setFormatter(formatter)
self.addHandler(handler)
def setup_custom_logger(szPath="", szFileName="logger"):
global g_logger
if g_logger is not None:
for handler in g_logger.handlers:
g_logger.removeHandler(handler)
LOG_PATH = "."
if szPath is None or 0 == len(szPath):
LOG_PATH = '.'
create_folder_if_not_exists(LOG_PATH)
LOG_FILE = "{0}/{1}".format(LOG_PATH, szFileName)
formatter = logging.Formatter(
"[%(asctime)s] %(threadName)s - %(pathname)s %(funcName)s():%(lineno)d %(levelname)s \t%(message)s"
) # same as default
# formatter = logging.Formatter('%(asctime)s [%(pathname)s: %(lineno)d] %(levelname)s %(message)s')
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
file_handler = ParallelTimedRotatingFileHandler(LOG_FILE, when='H')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# console_handler = logging.StreamHandler(sys.stdout)
# console_handler.formatter = formatter
# logger.addHandler(console_handler)
# setup `RainbowLoggingHandler`
handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'yellow', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
#Add file handler
handler = TimedRotatingFileHandler(LOG_FILE,
when="h",
interval=1,
backupCount=48)
# try:
# raise RuntimeError("Opa!")
# except Exception as e:
# logger.exception(e)
g_logger = logger
return logger
def setup_logging(logfile=None, verbose=False):
if logfile:
if os.path.exists(os.path.dirname(logfile)):
# Setup default file logging and set the handler to recieve everything
fh = logging.FileHandler(logfile)
fh.setFormatter(logging.Formatter(CONST_LOG_FORMAT_FILE))
fh.setLevel(logging.INFO)
log.addHandler(fh)
else:
raise ("log directory does not exist (" +
os.path.dirname(logfile) + ")")
clean_up(-1)
# Add a log handler for stdout and set the handler to recieve everything
csh = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'yellow', True))
csh.setFormatter(logging.Formatter(CONST_LOG_FORMAT_CONSOLE))
csh.setLevel(logging.DEBUG)
log.addHandler(csh)
# Now set the root logger to INFO
log.setLevel(logging.INFO)
# Check for verbose logging enabled
if verbose is True:
log.setLevel(logging.DEBUG)
if logfile:
fh.setLevel(logging.DEBUG)
csh.setLevel(logging.DEBUG)
log.debug('Debug logging enabled')
return log
def __init__(self, module_name):
self.logger_tmp = None
logger = logging.getLogger(module_name)
logging.basicConfig(filename='/tmp/r2als.log',level=logging.DEBUG,format='%(asctime)s %(levelname)s %(message)s')
# logging.basicConfig(level=logging.DEBUG)
formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # same as default
# setup `RainbowLoggingHandler`
handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'gray', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
self.logger_tmp = logger
def setup_logging(verbose=False, silent=False, debug=False):
log = logging.getLogger("")
handler = RainbowLoggingHandler(sys.stderr)
handler._column_color['%(asctime)s'] = ('cyan', None, False)
handler._column_color['%(levelname)-7s'] = ('green', None, False)
handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False)
handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)-15s %(message)s"))
log.addHandler(handler)
log.setLevel([logging.INFO, logging.DEBUG][verbose or debug])
if silent:
log.setLevel(logging.ERROR)
logging.getLogger("requests").setLevel([logging.CRITICAL, logging.ERROR][verbose or debug])
return handler
def test_custom_format():
logger = logging.getLogger('test_logging_custom_format')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter("MESSAGE ONLY => %(message)s")
handler = RainbowLoggingHandler(sys.stderr)
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.debug("debug msg")
logger.info("info msg")
logger.warn("warn msg")
logger.error("error msg")
logger.critical("critical msg")
def test_custom_format():
logger = logging.getLogger('test_logging_custom_format')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter("MESSAGE ONLY => %(message)s")
handler = RainbowLoggingHandler(sys.stderr)
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.debug("debug msg")
logger.info("info msg")
logger.warn("warn msg")
logger.error("error msg")
logger.critical("critical msg")
def setup():
# prepare log file
global f_log, logpath
(fd, logpath) = mkstemp(prefix='raibow-', suffix='.txt')
f_log = os.fdopen(fd, 'w')
# prepare 'test_format' logger
logger = logging.getLogger('test_format')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter("AAA %(name)s - %(levelname)s - %(message)s ZZZ") # testing whether this format is used
handler = RainbowLoggingHandler(f_log)
handler.setFormatter(formatter)
logger.addHandler(handler)
def get_logger():
global logger
if logger == None:
logger = logging.getLogger('freesprints')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # same as default
# setup colored logging
handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
return logger
def add_stdout_handler(logger):
formatter = Formatter(
"[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s")
try:
# Si está instalado rainbow_logging_handler (coloriza el output
# de consola) lo usamos, sino defaulteamos al módulo logging
from rainbow_logging_handler import RainbowLoggingHandler
handler = RainbowLoggingHandler(sys.stderr, color_funcName=(
'black', 'black', True))
except ImportError:
handler = StreamHandler()
pass
handler.setFormatter(formatter)
logger.addHandler(handler)
def setup_logging(self, args, verbose=False, silent=False, debug=False, logging_name=""):
"""Setup the RainbowLoggingHandler for the logs and call setup_other_logging"""
log = logging.getLogger(logging_name)
handler = RainbowLoggingHandler(self.logging_handler_file)
handler._column_color['%(asctime)s'] = ('cyan', None, False)
handler._column_color['%(levelname)-7s'] = ('green', None, False)
handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False)
handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)-15s %(message)s"))
log.addHandler(handler)
log.setLevel([logging.INFO, logging.DEBUG][verbose or debug])
if silent:
log.setLevel(logging.ERROR)
self.setup_other_logging(args, verbose, silent, debug)
return handler
def setup_TerminalLogger(log_level, logger_name='TerminalLogger'):
"""Setup colorful logger
*Usage*
.. code-block:: python
setup_TerminalLogger(logging.DEBUG)
logger = logging.getLogger('TerminalLogger')
logger.debug('hello')
"""
logger = logging.getLogger(logger_name)
logger.setLevel(log_level)
handler = RainbowLoggingHandler(sys.stderr, datefmt=None)
handler.setFormatter(logging.Formatter("[%(asctime)s] %(filename)s %(funcName)s():%(lineno)d\t%(message)s"))
logger.addHandler(handler)
def execute(args=None, parser=None):
parser = build_parser(parent=parser)
parser.add_argument(
'--max-cycles',
metavar='N',
default=None,
type=int,
help=
'limit number of fuzz job cycles to %(metavar)s (default: no limit)')
arguments = parser.parse_args(args)
logger = logging.getLogger('fuzzinator')
logger.addHandler(RainbowLoggingHandler(sys.stdout))
logger.setLevel(arguments.log_level)
config = configparser.ConfigParser(
interpolation=configparser.ExtendedInterpolation())
config.read(arguments.config)
controller = Controller(config=config)
controller.listener = CliListener()
try:
controller.run(max_cycles=arguments.max_cycles)
except KeyboardInterrupt:
pass
def setup():
# prepare log file
global f_log, logpath
(fd, logpath) = mkstemp(prefix='raibow-', suffix='.txt')
f_log = os.fdopen(fd, 'w')
# prepare 'test_format' logger
logger = logging.getLogger('test_format')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
"AAA %(name)s - %(levelname)s - %(message)s ZZZ"
) # testing whether this format is used
handler = RainbowLoggingHandler(f_log)
handler.setFormatter(formatter)
logger.addHandler(handler)
def colorlogs():
try:
from rainbow_logging_handler import RainbowLoggingHandler
import sys
# setup `RainbowLoggingHandler`
logger = logging.root
formatter = logging.Formatter(
"[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s")
# ^^^ same as default
handler = RainbowLoggingHandler(
sys.stderr, color_funcName=('black', 'gray', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
except ImportError:
# rainbow logger not found, that's ok
pass
def _setupLogging(stream, level, color=True): # pragma: no cover
"Setup logging according to the command line parameters"
if isinstance(stream, str):
class Stream(file):
"""
File subclass that allows RainbowLoggingHandler to write
with colors
"""
def isatty(self):
return color
stream = Stream(stream, 'ab', buffering=1)
from rainbow_logging_handler import RainbowLoggingHandler
rainbow_stream_handler = RainbowLoggingHandler(
stream,
# Customizing each column's color
# pylint: disable=bad-whitespace
color_asctime = ('dim white', 'black'),
color_name = ('dim white', 'black'),
color_funcName = ('green', 'black'),
color_lineno = ('dim white', 'black'),
color_pathname = ('black', 'red'),
color_module = ('yellow', None),
color_message_debug = ('color_59', None),
color_message_info = (None, None),
color_message_warning = ('color_226', None),
color_message_error = ('red', None),
color_message_critical = ('bold white', 'red'))
# pylint: enable=bad-whitespace
logging.root.addHandler(rainbow_stream_handler)
logging.root.setLevel(level)
def colorlogs():
try:
from rainbow_logging_handler import RainbowLoggingHandler
import sys
# setup `RainbowLoggingHandler`
logger = logging.root
formatter = logging.Formatter(
"[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s")
# ^^^ same as default
handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'gray', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
except ImportError:
# rainbow logger not found, that's ok
pass
def __init__(self, name, mode, maxsize, rotate):
logging.Handler.__init__(self)
#self._handler = RotatingFileHandler(name, mode, maxsize, rotate)
formatter = logging.Formatter(
"[%(asctime)s.%(msecs)03d] %(filename)16s Line %(lineno)3d %(funcName)s():\t %(message)s"
)
self._handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('green', 'none',
True))
self._handler.setFormatter(formatter)
self.queue = multiprocessing.Queue(-1)
t = threading.Thread(target=self.receive)
t.daemon = True
t.start()
def __init__(self,
device=None,
username=None,
password=None,
verify_cert=False,
loglevel=20):
self.logger = logging.getLogger('ASA')
self.logger.setLevel(loglevel)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s: %(message)s')
handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'yellow',
True))
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.api = AsaREST(device, username, password, verify_cert)
def __init__(self):
"""
初始化类
"""
self.formatter = logging.Formatter(
'%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s'
)
self.local_time = time.strftime("%Y%m%d-%H%M%S")
self.path = 'result\log'
if not os.path.exists(self.path):
os.makedirs(self.path)
# 日志文件
self.file_handler = logging.FileHandler('result\log\Testlog_%s.log' %
self.local_time)
# 控制台日志
self.color_handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black',
'yellow',
True))
def main_func():
# Check the number of inputs
numofinputs = len(sys.argv)
# Conditional expressions
if numofinputs > 5 :
print ("Invalid arguments \nGood BYE")
else :
# Get the input arguments
filename = argv.pop(1) # EXE name, File Name, Module Name
operation = argv.pop(1) # DEBUG, INFO, WARN, ERROR, CRITICAL, EXCEPTION
message = argv.pop(1) # Message to be printed
logFile = argv.pop(1) # Log file
# setup `logging` module
logger = logging.getLogger(filename)
fileHandler = logging.FileHandler('Logger.log')
logger.setLevel(logging.INFO)
formatter = logging.Formatter("[%(asctime)s] [%(name)s] : %(message)s")
# setup `RainbowLoggingHandler`
handler = RainbowLoggingHandler(sys.stderr, color_name=('grey', None , True),color_asctime=('green', None , True))
handler.setFormatter(formatter)
fileHandler.setFormatter(formatter)
logger.addHandler(fileHandler)
logger.addHandler(handler)
if operation == 'DEBUG' :
logger.debug(message)
if operation == 'INFO' :
logger.info(message)
if operation == 'WARN' :
logger.warn(message)
if operation == 'ERROR' :
logger.error(message)
if operation == 'CRITICAL' :
logger.critical(message)
if operation == 'EXCEPTION' :
raise RuntimeError("InstallException!")
logger.exception(message)
logger.exception(e)
def colorlogs(format="short"):
"""Append a rainbow logging handler and a formatter to the root logger"""
try:
from rainbow_logging_handler import RainbowLoggingHandler
import sys
# setup `RainbowLoggingHandler`
logger = logging.root
# same as default
if format == "short":
fmt = "%(message)s "
else:
fmt = "[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s [%(levelname)s]"
formatter = logging.Formatter(fmt)
handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'gray', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
except ImportError:
# rainbow logger not found, that's ok
pass
def setup_console_logging(log_level=None):
"""Setup console logging.
Aimed to give easy sane defaults for loggig in command line applications.
Don't use logging settings from INI, but use hardcoded defaults.
"""
formatter = logging.Formatter("[%(asctime)s] [%(name)s %(funcName)s:%(lineno)d] %(message)s") # same as default
# setup `RainbowLoggingHandler`
# and quiet some logs for the test output
handler = RainbowLoggingHandler(sys.stdout)
handler.setFormatter(formatter)
logger = logging.getLogger()
logger.handlers = [handler]
env_level = os.environ.get("LOG_LEVEL", "info")
log_level = log_level or getattr(logging, env_level.upper())
logger.setLevel(log_level)
def execute(arguments):
if not root_logger.hasHandlers():
root_logger.addHandler(RainbowLoggingHandler(sys.stdout))
controller = Controller(config=arguments.config)
controller.listener += CliListener()
try:
controller.run(max_cycles=arguments.max_cycles)
except KeyboardInterrupt:
Controller.kill_process_tree(os.getpid(), kill_root=False)
def colorlogs(format="short"):
"""Append a rainbow logging handler and a formatter to the root logger"""
try:
from rainbow_logging_handler import RainbowLoggingHandler
import sys
# setup `RainbowLoggingHandler`
logger = logging.root
# same as default
if format == "short":
fmt = "%(message)s "
else:
fmt = "[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s [%(levelname)s]"
formatter = logging.Formatter(fmt)
handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'gray', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
except ImportError:
# rainbow logger not found, that's ok
pass
def test_usage():
root_logger = logging.getLogger()
root_logger.setLevel(logging.DEBUG)
handler = RainbowLoggingHandler(sys.stderr)
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
handler.setFormatter(formatter)
root_logger.addHandler(handler)
logger = logging.getLogger('test')
logger.debug("debug msg")
logger.info("info msg")
logger.warn("warn msg")
logger.error("error msg")
logger.critical("critical msg")
try:
raise RuntimeError("Opa!")
except Exception as e:
logger.exception(e)
def get_logger(name):
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
handler = logging.FileHandler(os.path.join(config.logs_dir, '{}.log'.format(name)))
handler.setFormatter(log_formatter)
handler.setLevel(logging.DEBUG)
handler2 = RainbowLoggingHandler(
sys.stdout,
'%Y-%m-%d %H:%M:%S',
color_asctime=('white', None, False)
)
handler2.setFormatter(log_formatter)
handler2.setLevel(logging.DEBUG)
logger.addHandler(handler)
logger.addHandler(handler2)
return logger
def __init__(self, application_object, plugin_object):
# setup logger
self.logger = logging.getLogger('Needles')
self.logger.setLevel(logging.DEBUG)
formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # same as default
# setup colored logging
handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True))
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.logger.debug("init in Needles plugin")
self.application = application_object
self.plugin_object = plugin_object
self.display_surface = self.application.get_window_surface()
font_path = "./fonts/Cave-Story.ttf"
distance_font_path = "./fonts/Warenhaus-Standard.ttf"
self.font_big = pygame.font.Font(distance_font_path, 68)
self.font_distance = pygame.font.Font(distance_font_path, 50)
def setup_custom_logger():
LOG_PATH = 'log'
FileUtils.create_folder_if_not_exists(LOG_PATH)
LOG_FILE = "{0}/{1}".format(LOG_PATH, "thinklog")
# logging.Formatter.converter = time.gmtime
formatter = logging.Formatter(
"[%(asctime)s] %(threadName)s - %(pathname)s %(funcName)s():%(lineno)d %(levelname)s \t%(message)s"
) # same as default
# formatter = logging.Formatter('%(asctime)s [%(pathname)s: %(lineno)d] %(levelname)s %(message)s')
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
file_handler = ParallelTimedRotatingFileHandler(LOG_FILE, when='H')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# console_handler = logging.StreamHandler(sys.stdout)
# console_handler.formatter = formatter
# logger.addHandler(console_handler)
# setup `RainbowLoggingHandler`
handler = RainbowLoggingHandler(sys.stderr,
color_funcName=('black', 'yellow', True))
handler.setFormatter(formatter)
logger.addHandler(handler)
#Add file handler
handler = TimedRotatingFileHandler(LOG_FILE,
when="h",
interval=1,
backupCount=24)
# try:
# raise RuntimeError("Opa!")
# except Exception as e:
# logger.exception(e)
return logger
def enable_logging(filename: str, level: str):
class Squelch(logging.Filter):
def filter(self, record):
if record.levelno == logging.DEBUG:
return not record.name.startswith('asyncio') and \
not record.name.startswith('websockets') and \
not record.name.startswith('aiohttp')
elif record.levelno == logging.INFO and record.name.startswith('asyncio'):
return False
return True
formatter = logging.Formatter(fmt='%(asctime)s.%(msecs)03d:%(levelname)s:%(name)s:%(message)s')
# File logger captures everything.
file_handler = logging.FileHandler(filename)
file_handler.setLevel(logging.DEBUG)
# Console output level is configurable.
stream_handler = RainbowLoggingHandler(
sys.stdout,
color_asctime=('cyan', None, False),
color_msecs=('cyan', None, False),
color_levelname=('gray', None, False),
color_module=('yellow', None, False),
color_name=('blue', None, False),
color_lineno=('green', None, False),
datefmt="%Y-%m-%d %H:%M:%S"
)
stream_handler.setLevel(getattr(logging, level))
stream_handler.addFilter(Squelch())
# Set an output format.
stream_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
file_handler.addFilter(Squelch())
# Add handlers to root.
root = logging.getLogger('')
root.setLevel(logging.DEBUG)
root.addHandler(stream_handler)
root.addHandler(file_handler)
import logging, traceback, sys
from rainbow_logging_handler import RainbowLoggingHandler
# logging.basicConfig(level=logging.DEBUG, format='%(filename)-15s:%(lineno)-4d %(levelname)s: %(message)s')
handler = RainbowLoggingHandler(sys.stderr)
handler.setFormatter(logging.Formatter("%(filename)s:%(lineno)d\t%(levelname)s: %(message)s"))
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.addHandler(handler)
logging.getLogger("OpenGL").setLevel(99)
# allow importing from the repository root
import sys, os, json
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
import apc.baxter_scoop as baxter
from integration.visualization import debug_cloud
from integration.camera import uvtexture, invalid_mask
from integration.io import pcd
from perception.segmentation.color import rgb2yuv, make_uv_hist
from klampt.robotsim import WorldModel
from klampt import se3, so3
from time import sleep, time
import numpy, math
from matplotlib import pyplot
def load_histogram(obj, n):
import logging
from rainbow_logging_handler import RainbowLoggingHandler
import datetime
if __name__ == "__main__":
# logger取得
logger = logging.getLogger("log")
# レベル設定
logger.setLevel(logging.DEBUG)
# 出力フォーマット
formatter = logging.Formatter(fmt="%(asctime)s %(message)s")
# 色付け出力ハンドラの登録
rainbow_handler = RainbowLoggingHandler(sys.stderr, color_message_info=("green", None, True))
rainbow_handler.setFormatter(formatter)
logger.addHandler(rainbow_handler)
# ファイル出力用ハンドラの登録
date_obj = datetime.datetime.now()
date_str = date_obj.strftime("%Y-%m-%d-%H:%M:%S")
logfilename = "./log/%s.log" % (date_str)
file_handler = logging.FileHandler(logfilename, "w")
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.debug("this is debug")
logger.info("this is info")
logger.warning("this is warning")
logger.error("this is error")
def initialize_logger(args, script_name, syslog_server=None):
"""
Initialize the logging instance with the values provided
by the user and return the logging object.
"""
LOGGER = logging.getLogger(script_name)
FORMATTER = logging.Formatter(
""+script_name+" : "+str(getpass.getuser())+" : %(asctime)s : %(levelname)s : %(message)s",
datefmt='%m/%d/%Y %I:%M:%S %p')
# create console handler and set level to info
logging.StreamHandler()
# setup `RainbowLoggingHandler`
handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'white', True))
handler.setFormatter(FORMATTER)
LOGGER.addHandler(handler)
# setup log level from arguments
if args.log:
if contains('DEBUG', args.log.upper()):
handler.setLevel(logging.DEBUG)
LOGGER.setLevel(logging.DEBUG)
elif contains('WARNING', args.log.upper()):
handler.setLevel(logging.WARNING)
LOGGER.setLevel(logging.WARNING)
elif contains('ERROR', args.log.upper()):
handler.setLevel(logging.ERROR)
LOGGER.setLevel(logging.ERROR)
else:
handler.setLevel(logging.INFO)
LOGGER.setLevel(logging.INFO)
LOGGER.info('Logging level has been set to {}'.format(args.log.upper()))
# setup logging directory to store log files
if args.log_dir:
if not os.path.isdir(args.log_dir):
os.makedirs(args.log_dir)
output_dir = args.log_dir
else:
output_dir = create_log_dir()
LOGGER.info('Logging directory has been set to {}'.format(output_dir))
# create optional syslog handler, if the argument has been supplied to support it
if args.syslog:
DESIG_SYSLOG_SERVER = syslog_server
handler = logging.handlers.SysLogHandler(address=(DESIG_SYSLOG_SERVER,
logging.handlers.SYSLOG_UDP_PORT))
syslog_format = logging.Formatter(
'[appname]: %(name)s: [alias]: '+str(getpass.getuser())+' %(message)s')
handler.setFormatter(syslog_format)
if args.syslog_level:
# Set syslog level to the user specified level
if args.syslog_level == 'info':
handler.setLevel(logging.INFO)
elif args.syslog_level == 'warning':
handler.setLevel(logging.WARNING)
elif args.syslog_level == 'error':
handler.setLevel(logging.ERROR)
LOGGER.info(
'Syslog has been enabled for [{}] logging level, sent to syslog server [{}]'.format(
args.syslog_level,
DESIG_SYSLOG_SERVER))
# Add syslog handler to logging object
LOGGER.addHandler(handler)
# create error file handler and set level to error
handler = logging.FileHandler(os.path.join(
output_dir, "error.log"),"a", encoding=None, delay="true")
handler.setLevel(logging.ERROR)
handler.setFormatter(FORMATTER)
LOGGER.addHandler(handler)
# create debug file handler and set level to debug
handler = logging.FileHandler(os.path.join(output_dir, "all.log"),"a")
handler.setLevel(logging.DEBUG)
handler.setFormatter(FORMATTER)
LOGGER.addHandler(handler)
if args.logfile_rotate:
'''
User has specified they would like to create a daily rotating logfile.
Create an instance and DO NOT create a single serving logfile.
'''
LOGGER.info('Logfiles are now set to auto-rotate at midnight UTC.')
filepath_and_name_format = ('{}/{}'.format(output_dir, script_name.replace('.py','')))
LOGGER.info('Logfiles are now being written at {}'.format(filepath_and_name_format))
log_filename=filepath_and_name_format
# maxBytes takes the max file size in MB and bit-shift converts to bytes
handler=SizedTimedRotatingFileHandler(
log_filename, maxBytes=args.logsize<<20)
handler.setLevel(logging.DEBUG)
handler.setFormatter(FORMATTER)
handler.suffix = "%Y-%m-%d.log"
LOGGER.addHandler(handler)
else:
# create individual execution file handler and set level to debug
now = datetime.datetime.now()
datetime_stamp = now.strftime("%Y-%m-%d_%H-%M-%S")
datetime_stamp = ('{}_{}.log'.format(datetime_stamp, script_name.replace('.py','')))
filename = os.path.join(output_dir, datetime_stamp)
handler = logging.FileHandler(filename, "a")
if contains('DEBUG', args.log.upper()):
handler.setLevel(logging.DEBUG)
elif contains('WARNING', args.log.upper()):
handler.setLevel(logging.WARNING)
elif contains('ERROR', args.log.upper()):
handler.setLevel(logging.ERROR)
else:
handler.setLevel(logging.INFO)
handler.setFormatter(FORMATTER)
LOGGER.addHandler(handler)
# display the exact file name / path to the user
LOGGER.info('Logs for this session now being written to {}'.format(filename))
# Attach filepath / filename string to logger
LOGGER.filename = filename
return LOGGER
"""
Initialise the application.
@author: Chris Scott
"""
import sys
import platform
import logging
try:
from rainbow_logging_handler import RainbowLoggingHandler
root = logging.getLogger()
root.setLevel(logging.NOTSET)
formatter = logging.Formatter("%(name)s:%(funcName)s():%(lineno)d: %(message)s")
handler = RainbowLoggingHandler(sys.stderr)
handler.setFormatter(formatter)
root.addHandler(handler)
except ImportError:
# configure logging (we have to set logging.NOTSET here as global for root logger)
logging.basicConfig(format="%(levelname)s: %(name)s: %(message)s", level=logging.NOTSET)
from PySide import QtGui, QtCore
# set default for stream handler (we don't want it to be NOTSET by default)
_argLevel = None
if len(sys.argv) > 1:
if "DEBUG" in sys.argv:
_argLevel = logging.DEBUG
elif "INFO" in sys.argv:
_argLevel = logging.INFO
import logging, sys
from rainbow_logging_handler import RainbowLoggingHandler
logging.VERBOSE = VERBOSE = 5
logging.SUCCESS = SUCCESS = logging.INFO + 5
logging.addLevelName(VERBOSE, "VERBOSE")
logging.addLevelName(SUCCESS, "SUCCESS")
def verbose(self, message, *args, **kws):
# Yes, logger takes its '*args' as 'args'.
if self.isEnabledFor(VERBOSE):
self._log(VERBOSE, message, args, **kws)
logging.Logger.verbose = verbose
logging.Logger.v = verbose
def success(self, message, *args, **kws):
# Yes, logger takes its '*args' as 'args'.
if self.isEnabledFor(SUCCESS):
self._log(SUCCESS, message, args, **kws)
logging.Logger.success = success
logging.Logger.ok = success
logger = logging.getLogger('dj')
formatter = logging.Formatter("[%(asctime)s] %(name)s:\t%(message)s") # same as default
# setup `RainbowLoggingHandler`
handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True))
handler.setFormatter(formatter)
handler._column_color['%(message)s'][VERBOSE] = ('magenta', None, False)
handler._column_color['%(message)s'][SUCCESS] = ('green', None, False)
logger.addHandler(handler)
logger.setLevel(VERBOSE)
log_level = logging.DEBUG
elif args.verbose[0] == "NOTSET":
log_level = logging.NOTSET
else: # aka default - just the crazy stuff
log_level = logging.CRITICAL
# set up logging to file
logging.basicConfig(level=logging.DEBUG,
format='[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s',
datefmt='%m-%d %H:%M',
filename='spam.log',
filemode='w')
# define a Handler which writes INFO messages or higher to the sys.stderr
console = RainbowLoggingHandler(sys.stdout) #logging.StreamHandler()
# handler = RainbowLoggingHandler(sys.stdout)
# get level from command input
console.setLevel(log_level)
formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s")
# tell the handler to use this format
console.setFormatter(formatter)
# add the handler to the root logger
logging.getLogger('').addHandler(console)
logger = logging.getLogger('nrk2013')
# tell requests lib to chill out
requests_log = logging.getLogger("requests")
requests_log.setLevel(logging.WARNING)