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 _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 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 _setup_color_logs(frmt):
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),
)
## NOTE: CLUDGE backreference to `polyvers`!!!
from .. import NOTICE, TRACE
color_handler._column_color['%(message)s'][NOTICE] = ('green', None, False)
color_handler._column_color['%(message)s'][TRACE] = ('grey', None, False)
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 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 _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 _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 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 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_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 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 __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 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 __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 __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 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 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 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 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 _createLogger(self, name):
formatter = logging.Formatter(
fmt=
'(%(levelname)s) [%(asctime)s,%(msecs)03d] %(name)s %(filename)s:%(lineno)d\t%(message)s',
datefmt='%H:%M:%S')
logger = logging.getLogger(name)
logger.setLevel(self.level)
handler = RainbowLoggingHandler(sys.stdout, datefmt='%H:%M:%S')
handler.setLevel(self.level)
handler.setFormatter(formatter)
logger.addHandler(handler)
return logger
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 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 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 _setupLogging(stream, level): # pragma: no cover
"Setup logging according to the command line parameters"
color = False
if stream is sys.stdout:
class Stream(object):
def isatty(self):
return True
def write(self, *args, **kwargs):
return sys.stdout.write(*args, **kwargs)
_stream = Stream()
else:
_stream = stream
color = False
try:
color = _stream.isatty()
except AttributeError:
pass
if color:
try:
from rainbow_logging_handler import ( # type: ignore
RainbowLoggingHandler, )
color = True
except ImportError:
color = False
if color:
rainbow_stream_handler = RainbowLoggingHandler(_stream)
logging.root.addHandler(rainbow_stream_handler)
logging.root.setLevel(level)
else:
handler = logging.StreamHandler(_stream)
handler.formatter = logging.Formatter(
"%(levelname)-7s | %(asctime)s | " +
"%(name)s @ %(funcName)s():%(lineno)d %(threadName)s " +
"|\t%(message)s",
datefmt="%H:%M:%S",
)
logging.root.addHandler(handler)
logging.root.setLevel(level)
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 __init__(self,
context=LOG_CONTEXT,
level=_DEFAULT_LOG_LEVEL,
log_format_string=_DEFAULT_LOG_FORMAT_FILE,
console_format_string=_DEFAULT_LOG_FORMAT_CONSOLE):
self.context = os.path.basename(context)
self.logger = logging.getLogger(LOG_CONTEXT)
self.file_handler = None
self.console_handler = None
self.cloud_handler = None
AWSH_ROOT = os.getenv('AWSH_ROOT', '/tmp')
AWSH_LOG_ROOT = os.getenv('HOME', '/tmp')
log_filename = '{}/.awsh/log/{}.log'.format(AWSH_LOG_ROOT,
self.context)
if os.path.exists(os.path.dirname(log_filename)):
if self.file_handler is None:
# Setup default file logging and set the handler to recieve everything
fh = logging.FileHandler(log_filename)
fh.setFormatter(logging.Formatter(log_format_string))
fh.setLevel(level)
self.logger.addHandler(fh)
self.file_handler = fh
if self.console_handler is None:
# 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(console_format_string))
csh.setLevel(level)
self.logger.addHandler(csh)
self.console_handler = csh
# Now set the root logger to the specified level
logging.getLogger(LOG_CONTEXT).setLevel(level)
else:
# If logging can't be initialised we need to exit on the assumption
# that we should not run without audit logging at the very least
m = 'log directory does not exist {}'.format(
os.path.dirname(log_filename))
raise IOError(m)
exit(1)
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)
