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)