def adjust_log_level(self): """ Change the log level of all handlers if needed """ self.logger.debug("Adjust log level if needed") if not self.parsed_arguments.verbose: self.logger.debug("Log level remains unchanged") return self.logger.debug("Changing log level to " + str(logging.DEBUG)) logging.getLogger(self.base_logger_name).setLevel(logging.DEBUG) for handler in logging.getLogger(self.base_logger_name).handlers: # When upgrading to python 2.7 # handler.setStream(sys.stderr) if self.parsed_arguments.verbose == 1: handler.setFormatter( coloredlogs.ColoredFormatter( self.log_format_verbose_1, level_styles=self.log_level_styles, field_styles=self.log_field_styles)) elif self.parsed_arguments.verbose >= 2: handler.setLevel(logging.DEBUG) handler.setFormatter( coloredlogs.ColoredFormatter( self.log_format_verbose_2, level_styles=self.log_level_styles, field_styles=self.log_field_styles)) self.logger.debug("Log level changed to " + str(logging.DEBUG))
def initLogger(self): self.logger.handlers = [] if config.params['debug']: self.logger.setLevel(logging.DEBUG) formatter = logging.Formatter('%(asctime)s ' + '%(levelname)s - %(filename)s:%(lineno)s - %(message)s') else: self.logger.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s %(levelname)s - %(message)s') fn = self.logDir + '/' + self.baseName + '.log' if os.path.exists(fn): os.rename(fn, fn + '.prev') fh = logging.FileHandler(filename=fn) fh.setLevel(logging.DEBUG) fh.setFormatter(formatter) self.logger.addHandler(fh) if config.params['verbose'] is True: if config.params['debug']: #sformatter = logging.Formatter('%(asctime)s %(levelname)s - %(filename)s:%(lineno)s - %(message)s') sformatter = coloredlogs.ColoredFormatter(fmt='%(asctime)s,%(msecs)03d %(levelname)s - %(filename)s:%(lineno)s - %(message)s', field_styles={'levelname': {'color': 'cyan'}}) else: #sformatter = logging.Formatter('%(asctime)s %(levelname)s - %(message)s') sformatter = coloredlogs.ColoredFormatter(fmt='%(asctime)s,%(msecs)03d %(levelname)s - %(message)s', field_styles={'levelname': {'color': 'cyan'}}) sh = logging.StreamHandler() sh.setLevel(logging.DEBUG) sh.setFormatter(sformatter) self.logger.addHandler(sh)
def init_log(logger, loglevel=0, no_ansi=False): """ Initializes logging. Prints logs to console with level defined by loglevel Also prints verbose log to the multiqc data directory if available. (multiqc_data/multiqc.log) Args: loglevel (str): Determines the level of the log output. """ # File for logging global log_tmp_dir, log_tmp_fn log_tmp_dir = tempfile.mkdtemp() log_tmp_fn = os.path.join(log_tmp_dir, "multiqc.log") # Logging templates debug_template = "[%(asctime)s] %(name)-50s [%(levelname)-7s] %(message)s" info_template = "|%(module)18s | %(message)s" # Base level setup logger.setLevel(getattr(logging, "DEBUG")) # Automatically set no_ansi if not a tty terminal if not no_ansi: if sys.stderr.isatty() and not force_term_colors(): no_ansi = True # Set up the console logging stream console = logging.StreamHandler() console.setLevel(getattr(logging, loglevel)) level_styles = coloredlogs.DEFAULT_LEVEL_STYLES level_styles["debug"] = {"faint": True} field_styles = coloredlogs.DEFAULT_FIELD_STYLES field_styles["module"] = {"color": "blue"} if loglevel == "DEBUG": if no_ansi: console.setFormatter(logging.Formatter(debug_template)) else: console.setFormatter( coloredlogs.ColoredFormatter(fmt=debug_template, level_styles=level_styles, field_styles=field_styles)) else: if no_ansi: console.setFormatter(logging.Formatter(info_template)) else: console.setFormatter( coloredlogs.ColoredFormatter(fmt=info_template, level_styles=level_styles, field_styles=field_styles)) logger.addHandler(console) # Now set up the file logging stream if we have a data directory file_handler = logging.FileHandler(log_tmp_fn, encoding="utf-8") file_handler.setLevel(getattr(logging, "DEBUG")) # always DEBUG for the file file_handler.setFormatter(logging.Formatter(debug_template)) logger.addHandler(file_handler)
def init_log(logger, loglevel=0, no_ansi=False): """ Initializes logging. Prints logs to console with level defined by loglevel Also prints verbose log to the multiqc data directory if available. (multiqc_data/multiqc.log) Args: loglevel (str): Determines the level of the log output. """ # File for logging global log_tmp_dir, log_tmp_fn log_tmp_dir = tempfile.mkdtemp() log_tmp_fn = os.path.join(log_tmp_dir, 'multiqc.log') # Logging templates debug_template = '[%(asctime)s] %(name)-50s [%(levelname)-7s] %(message)s' info_template = '[%(levelname)-7s] %(module)15s : %(message)s' # Base level setup logger.setLevel(getattr(logging, 'DEBUG')) # Set up the console logging stream console = logging.StreamHandler() console.setLevel(getattr(logging, loglevel)) level_styes = coloredlogs.DEFAULT_LEVEL_STYLES level_styes['debug'] = {'faint': True} if loglevel == 'DEBUG': if no_ansi or not sys.stderr.isatty(): console.setFormatter(logging.Formatter(debug_template)) else: console.setFormatter( coloredlogs.ColoredFormatter(fmt=debug_template, level_styles=level_styes)) else: if no_ansi or not sys.stderr.isatty(): console.setFormatter(logging.Formatter(info_template)) else: console.setFormatter( coloredlogs.ColoredFormatter(fmt=info_template, level_styles=level_styes)) logger.addHandler(console) # Now set up the file logging stream if we have a data directory file_handler = logging.FileHandler(log_tmp_fn, encoding='utf-8') file_handler.setLevel(getattr(logging, 'DEBUG')) # always DEBUG for the file file_handler.setFormatter(logging.Formatter(debug_template)) logger.addHandler(file_handler)
def __init__(self): super(OutputLogger, self).__init__() self.logger = logging.getLogger() self.logger.setLevel(logging.NOTSET) self.handler = logging.StreamHandler() self.handler.setLevel(logging.NOTSET) try: import coloredlogs self.formatter = coloredlogs.ColoredFormatter("%(asctime)s " "[%(threadName)s] " "[%(name)s] " "[%(levelname)s] " "%(message)s") except ImportError: self.formatter = logging.Formatter("%(asctime)s " "[%(threadName)s] " "[%(name)s] " "[%(levelname)s] " "%(message)s") self.handler.setFormatter(self.formatter) self.logger.addHandler(self.handler) self.logger.info("Logger enabled")
def setup_logging(self): logging_path = "../../.mlsc/" logging_file = "mlsc.log" format_string_file = "%(asctime)s - %(levelname)-8s - %(name)-30s - %(message)s" format_string_console = "%(levelname)-8s - %(name)-30s - %(message)s" logging_level_root = logging.NOTSET logging_level_console = logging.INFO logging_level_file = logging.INFO logging_file_enabled = False logging_level_map = { "notset": logging.NOTSET, "debug": logging.DEBUG, "info": logging.INFO, "warning": logging.WARNING, "error": logging.ERROR, "critical": logging.CRITICAL } if self.config is not None: try: logging_level_console = logging_level_map[ self.config["general_settings"]["log_level_console"]] logging_level_file = logging_level_map[ self.config["general_settings"]["log_level_file"]] logging_file_enabled = self.config["general_settings"][ "log_file_enabled"] except Exception as e: print(f"Could not load logging settings. Exception {e}") pass if not os.path.exists(logging_path): Path(logging_path).mkdir(exist_ok=True) root_logger = logging.getLogger() # Reset Handlers root_logger.handlers = [] root_logger.setLevel(logging_level_root) if logging_file_enabled: file_formatter = logging.Formatter(format_string_file) rotating_file_handler = RotatingFileHandler( logging_path + logging_file, mode='a', maxBytes=5 * 1024 * 1024, backupCount=5, encoding='utf-8') rotating_file_handler.setLevel(logging_level_file) rotating_file_handler.setFormatter(file_formatter) root_logger.addHandler(rotating_file_handler) console_formatter = coloredlogs.ColoredFormatter( fmt=format_string_console) stream_handler = logging.StreamHandler(stream=sys.stderr) stream_handler.setFormatter(console_formatter) stream_handler.setLevel(logging_level_console) root_logger.addHandler(stream_handler)
async def run(url, girder_api_key): from stemworker import socketio global _pipelines root = logging.getLogger() root.setLevel(logging.DEBUG) handler = logging.StreamHandler(sys.stdout) handler.setLevel(logging.INFO) formatter = coloredlogs.ColoredFormatter( '%(asctime)s,%(msecs)03d - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) root.addHandler(handler) logger.info('Loading pipelines.') load_pipelines() comm = MPI.COMM_WORLD rank = comm.Get_rank() worker_id = None if rank == 0: worker_id = uuid.uuid4().hex worker_id = comm.bcast(worker_id, root=0) cookie = await authenticate(url, girder_api_key) await socketio.connect(_pipelines, worker_id, url, cookie)
def get_logger(log_to_console=True, log_to_file=True): """Initialize Python logger that outputs to file and console.""" assert log_to_console or log_to_file logger = logging.getLogger("main_logger") logger.setLevel(logging.DEBUG) formatter = coloredlogs.ColoredFormatter( "%(asctime)s | %(filename)12s | %(levelname)8s | %(message)s") if log_to_file: fh = logging.FileHandler("run.log") fh.setLevel(logging.DEBUG) fh.setFormatter(formatter) logger.addHandler(fh) if log_to_console: ch = logging.StreamHandler() ch.setLevel(logging.INFO) ch.setFormatter(formatter) logger.addHandler(ch) # Fix TensorFlow doubling logs # https://stackoverflow.com/questions/33662648/tensorflow-causes-logging-messages-to-double logger.propagate = False return logger
def setup_logging(stream_log_level=None, log_path=None, file_log_level=None, **kwargs): global PKG_FILE_HANDLER, PKG_STREAM_HANDLER if log_path: if PKG_FILE_HANDLER: PKG_LOGGER.removeHandler(PKG_FILE_HANDLER) PKG_FILE_HANDLER = logging.FileHandler(log_path) ROOT_LOGGER.addHandler(PKG_FILE_HANDLER) if file_log_level: PKG_FILE_HANDLER.setLevel(file_log_level) if stream_log_level: if not PKG_STREAM_HANDLER: PKG_STREAM_HANDLER = logging.StreamHandler() if os.name != 'nt': PKG_STREAM_HANDLER.setFormatter(coloredlogs.ColoredFormatter()) PKG_STREAM_HANDLER.addFilter(coloredlogs.HostNameFilter()) PKG_STREAM_HANDLER.addFilter(coloredlogs.ProgramNameFilter()) ROOT_LOGGER.addHandler(PKG_STREAM_HANDLER) PKG_STREAM_HANDLER.setLevel(stream_log_level) # TODO: maybe process quiet differently so that it does not add a stream handler if PKG_STREAM_HANDLER: logging.info("stream log level: %s", PKG_STREAM_HANDLER.level) if PKG_FILE_HANDLER: logging.info("file log level: %s", PKG_FILE_HANDLER.level)
def __new__(cls, name, level, file=None, logger_format=None, file_format=None, file_level=None): levels = { 'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR, 'critical': logging.CRITICAL } logger = logging.getLogger(name) level = levels[level.lower()] stream_handler = logging.StreamHandler() stream_handler.setLevel(level) stream_format = logger_format or '%(name)s - (%(levelname)s) - %(message)s' stream_handler.setFormatter( coloredlogs.ColoredFormatter(stream_format)) logger.addHandler(stream_handler) if file is not None: file_handler = logging.FileHandler(file) if file_level is not None: file_handler.setLevel(levels[file_level.lower()]) else: file_handler.setLevel(level) file_format = file_format or '%(asctime)s - %(name)s - (%(levelname)s) - %(message)s' file_handler.setFormatter(logging.Formatter(file_format)) logger.addHandler(file_handler) coloredlogs.install(fmt=stream_format, logger=logger, level=level) return logger
def __init__(self, log_file_name): """ Initializes the logging manager: - Uses a different colored format for each log level (see LEVEL_STYLES) - Defines a FileHandler with the given log_file_name. - Defines a SteamHandler for stdout. - Defines a logger for real time logs with those handlers Args: log_file_name: The path to where the log file will be saved """ if not hasattr(logging, 'success'): _add_logging_level('SUCCESS', 25) self.log_file_name = log_file_name formatter = coloredlogs.ColoredFormatter(fmt=LOGGING_FORMAT, level_styles=LEVEL_STYLES) self.console_handler = logging.StreamHandler(sys.stdout) self.console_handler.setFormatter(formatter) log_file_path = os.path.join( ARTIFACTS_PATH, 'logs', log_file_name) if os.path.exists( os.path.join(ARTIFACTS_PATH, 'logs')) else os.path.join( ARTIFACTS_PATH, log_file_name) self.file_handler = logging.FileHandler(log_file_path) self.file_handler.setFormatter(formatter) self.console_handler.setLevel(logging.INFO) self.file_handler.setLevel(logging.DEBUG) self.real_time_logger = logging.getLogger(f'real_time-{log_file_path}') self.real_time_logger.addHandler(self.file_handler) self.real_time_logger.addHandler(self.console_handler) self.real_time_logger.setLevel(logging.DEBUG) self.loggers = {} self.listeners = {} self.logs_lock = Lock() self.thread_names = set()
def getFileHandler(): log_file_formatter = coloredlogs.ColoredFormatter( log_format, field_styles=field_styles, level_styles=level_styles) log_file_handler = TimedRotatingFileHandler(LOG_FILE, when='midnight') log_file_handler.addFilter(coloredlogs.ProgramNameFilter()) log_file_handler.setFormatter(log_file_formatter) return log_file_handler
def setup(config: DynaBox, name: str): fmt = "%(asctime)s %(levelname)-8s [%(name)s] %(message)s" colored_formatter = coloredlogs.ColoredFormatter(fmt) plain_formatter = logging.Formatter(fmt) logger = logging.getLogger(name) if config.file: fh = logging.FileHandler(config.filename) fhLevel = logging.getLevelName(config.file_verbosity.upper()) logger.setLevel(fhLevel) fh.setLevel(fhLevel) fh.setFormatter(plain_formatter) logger.addHandler(fh) if config.console: ch = logging.StreamHandler() chLevel = logging.getLevelName(config.console_verbosity.upper()) ch.setLevel(chLevel) if logger.level > chLevel or logger.level == 0: logger.setLevel(chLevel) ch.setFormatter(colored_formatter) logger.addHandler(ch) class ShutdownHandler(logging.Handler): """Exit application with CRITICAL logs""" def emit(self, record): logging.shutdown() sys.exit(1) sh = ShutdownHandler(level=50) sh.setFormatter(colored_formatter) logger.addHandler(sh) return logger
def __init__(self, name, sub_directory=''): self._ensure_logs_directory_exists( os.path.join(self.LOGS_DIRECTORY, sub_directory)) if type(name) is not str: name = name.__class__.__name__ self._logger = logging.getLogger(name) if len(self._logger.handlers) > 0: return self._logger.setLevel(logging.DEBUG) stream_handler = logging.StreamHandler() stream_handler.setFormatter( coloredlogs.ColoredFormatter( '[%(name)s] [%(levelname)s] %(message)s')) self._logger.addHandler(stream_handler) file_name = utils.camel_case_to_underscore(name) + '.log' file_path = os.path.join(self.LOGS_DIRECTORY, sub_directory, file_name) file_handler = logging.FileHandler(file_path) file_handler.setFormatter( logging.Formatter('%(asctime)s [%(levelname)s] %(message)s')) self._logger.addHandler(file_handler)
def __init__(self, game_state_interface, cache_count=30, log_level=logging.DEBUG): # this is cheaper to store ''' :type self.gsi: GameStateInterface :param game_state_interface: GameStateInterface :type game_state_interface: GameStateInterface :param cache_count: How many score ticks to cache :type cache_count: int ''' self.gsi = game_state_interface self.single_tick_score_cache = LRUCache(cache_count) self._total_scores = {} log = logging.getLogger('gamebot_scoring') log.setLevel(log_level) log_formatter = coloredlogs.ColoredFormatter(ScoringInterface.LOG_FMT) log_handler = logging.StreamHandler() log_handler.setFormatter(log_formatter) log.addHandler(log_handler) self.log = log
def setup_logging( verbosity='INFO', log_file='simulation.log', log_file_verbosity='DEBUG', results_dir='', ): root_logger = logging.getLogger() root_logger.setLevel(logging.DEBUG) # possibly overridden from args later # ^ TODO: how does this impact performance? stream_handler = logging.StreamHandler(stream=sys.stdout) stream_handler.setFormatter( coloredlogs.ColoredFormatter( style='{', fmt='{asctime} {levelname} {name}:\n\t{message}', datefmt='%Y-%m-%d %H:%M:%S')) stream_handler.setLevel(verbosity) root_logger.addHandler(stream_handler) if results_dir != '': os.makedirs(results_dir, exist_ok=True) log_file = os.path.join(results_dir, log_file) file_handler = logging.FileHandler(filename=log_file, mode='w') file_handler.setFormatter( logging.Formatter(style='{', fmt='{asctime} {levelname} {name}: {message}', datefmt='%Y-%m-%d %H:%M:%S')) file_handler.setLevel(log_file_verbosity) root_logger.addHandler(file_handler)
def __init__(self, db_api, log_level=logging.INFO): self.db_api = db_api # Set up logging log = logging.getLogger('gamebot_scripts') log.addHandler(logstash.TCPLogstashHandler(LOGSTASH_IP, LOGSTASH_PORT, version=1)) log.setLevel(log_level) log_formatter = coloredlogs.ColoredFormatter(ScriptsFacade.LOG_FMT) log_handler = logging.StreamHandler() log_handler.setFormatter(log_formatter) log.addHandler(log_handler) self.log = log # Test connection to RabbitMQ server host = settings.RABBIT_ENDPOINT username = settings.RABBIT_USERNAME password = settings.RABBIT_PASSWORD credentials = pika.PlainCredentials(username, password) self.conn_params = pika.ConnectionParameters(host=host, credentials=credentials) while True: try: connection = pika.BlockingConnection(self.conn_params) log.info("Connection to RabbitMQ dispatcher verified") break except pika.exceptions.AMQPConnectionError as ex: log.info("The RabbitMQ server is not ready yet...") time.sleep(5) continue connection.close()
def setupLogger(settings): if settings.logfile is not None: fmt = "%(asctime)s [%(levelname)s] %(message)s" date_fmt = "%Y-%m-%d %H:%M" try: consoleFormatter = coloredlogs.ColoredFormatter(fmt, date_fmt) except NameError: consoleFormatter = logging.Formatter(fmt, date_fmt) consoleHandler = logging.StreamHandler() consoleHandler.setLevel(settings.loglevel_stderr) consoleHandler.setFormatter(consoleFormatter) fileFormatter = logging.Formatter(fmt, date_fmt) fileHandler = logging.FileHandler(settings.logfile) fileHandler.setLevel(settings.loglevel_file) fileHandler.setFormatter(fileFormatter) logging.getLogger().setLevel(0) logging.getLogger().addHandler(fileHandler) logging.getLogger().addHandler(consoleHandler) else: try: coloredlogs.install(fmt=fmt, datefmt=date_fmt, level=settings.loglevel_stderr) except NameError: logging.basicConfig(format=fmt, datefmt=date_fmt, level=settings.loglevel_stderr)
def setup_logger(self, tract, patch): """ Setup the python logger. """ name = 'hugs-pipe: {} | {}'.format(tract, patch) self.logger = logging.getLogger(name) self.logger.setLevel(getattr(logging, self.log_level.upper())) fmt = '%(name)s: %(asctime)s %(levelname)s: %(message)s' try: formatter = coloredlogs.ColoredFormatter(fmt=fmt, datefmt='%m/%d %H:%M:%S') except: formatter = logging.Formatter(fmt=fmt, datefmt='%m/%d %H:%M:%S') if not self.logger.handlers: sh = logging.StreamHandler(sys.stdout) sh.setFormatter(formatter) self.logger.addHandler(sh) if self.log_fn: fh = logging.FileHandler(self.log_fn) fh.setFormatter(formatter) self.logger.addHandler(fh) msg = 'starting hugs-pipe with config file ' + self.config_fn self.logger.info(msg)
def install_logging(log_file_name: str, include_process_name=False) -> str: """ This method install the logging mechanism so that info level logs will be sent to the console and debug level logs will be sent to the log_file_name only. Args: include_process_name: Whether to include the process name in the logs format, Should be used when using multiprocessing log_file_name: The name of the file in which the debug logs will be saved """ if not hasattr(logging, 'success'): _add_logging_level('SUCCESS', 25) logging_format = LOGGING_FORMAT if include_process_name: logging_format = '[%(asctime)s] - [%(processName)s] - [%(threadName)s] - [%(levelname)s] - %(message)s' formatter = coloredlogs.ColoredFormatter(fmt=logging_format, level_styles=LEVEL_STYLES) ch = logging.StreamHandler(sys.stdout) ch.setFormatter(formatter) log_file_path = os.path.join( ARTIFACTS_PATH, 'logs', log_file_name) if os.path.exists( os.path.join(ARTIFACTS_PATH, 'logs')) else os.path.join( ARTIFACTS_PATH, log_file_name) fh = logging.FileHandler(log_file_path) fh.setFormatter(formatter) ch.setLevel(logging.INFO) fh.setLevel(logging.DEBUG) logging.basicConfig(level=logging.DEBUG, handlers=[ch, fh], force=True) return log_file_path
def configure_logging(): tf.logging.set_verbosity(tf.logging.INFO) coloredlogs.install(level="INFO") coloredlogs.DEFAULT_LEVEL_STYLES = { "debug": { "color": "white", "bold": False }, "info": { "color": "white", "bold": True }, "warning": { "color": "yellow", "bold": True }, "error": { "color": "red", "bold": True }, "fatal": { "color": "magenta", "bold": True }, } logger = logging.getLogger("tensorflow") log_format = "%(asctime)s %(levelname)s %(message)s" formatter = coloredlogs.ColoredFormatter(log_format) for handler in logger.handlers: handler.setFormatter(formatter) logger.propagate = False
def init(): initialize_logger(os.getcwd()) coloredlogs.install(level='DEBUG') coloredlogs.ColoredFormatter() c = Cassandra() syncTables() g = Goodreads() return (c, g)
def setup_logging(level: str = 'DEBUG'): log = logging.getLogger('prairiedog') coloredlogs.install(level=level) fmt = '%(asctime)s %(name)s[%(process)d] %(levelname)s %(message)s' formatter = coloredlogs.ColoredFormatter(fmt) fh = logging.FileHandler('prairiedog.log') fh.setFormatter(formatter) log.addHandler(fh)
def __init__(self, color=False): if not color: self._formatter = logging.Formatter( "%(asctime)s.%(msecs)03d | %(source)s %(type)s %(threadName)s: " "%(message)s", "%H:%M:%S") else: self._formatter = coloredlogs.ColoredFormatter( "%(asctime)s.%(msecs)03d | %(source)s %(type)s %(threadName)s: " "%(message)s", "%H:%M:%S", LEVEL_FORMATS, FIELD_STYLES)
def main(): root = logging.getLogger() root.setLevel(logging.DEBUG) handler = logging.StreamHandler(sys.stdout) handler.setLevel(logging.DEBUG) formatter = coloredlogs.ColoredFormatter('%(asctime)s,%(msecs)03d - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) root.addHandler(handler)
def main(): # logger initialize logger = logging.getLogger(__name__) handler = logging.StreamHandler() handler.setLevel(logging.INFO) handler.setFormatter( # logging.Formatter("[%(asctime)s] [%(threadName)s] %(message)s") coloredlogs.ColoredFormatter( fmt="[%(asctime)s] [%(threadName)s] %(message)s")) logger.setLevel(logging.DEBUG) logger.addHandler(handler) logger.propagate = False # initialize photostand configure photostand_config = PhotostandConfig() try: photostand_config.read() except (FailedToReadSerialNumber): logger.critical('Failed to read cpu serial number.') exit(1) except (FileNotFoundError, ParsingError, MissingSectionHeaderError, NoSectionError, NoOptionError, ValueError): logger.critical('Failed to read photostand config.\n' + format_exc()) exit(1) if not photostand_config.get_sensor_is_active(): logger.info('Sensor daemon disabled by photostand_config.') exit(0) # initialize last sensor variable last_sensor_value = LastSensorValue(logger) # initialize socket server thread server_thread = AfUnixServerThread(logger, photostand_config, last_sensor_value) server_thread.start() try: # Initialize serial port watcher serial_port_watcher = SerialPortWatcher( logger, photostand_config, last_sensor_value, ) serial_port_watcher.main() except KeyboardInterrupt: server_thread.stop()
def setup_logging(level): level = logging.getLevelName(level) root_logger = logging.getLogger() root_logger.setLevel(level) handler = logging.StreamHandler() handler.setLevel(level) formatter = coloredlogs.ColoredFormatter( "%(asctime)s %(levelname)s %(message)s") handler.setFormatter(formatter) root_logger.addHandler(handler)
def main(): """The core code of the program""" # Logs initialization log = logging.getLogger(__name__) logging.root.setLevel(config["Logging"]["level"]) stream_handler = logging.StreamHandler() if coloredlogs is not None: stream_handler.formatter = coloredlogs.ColoredFormatter( config["Logging"]["format"], style="{", level_styles=logs_level_styles) else: stream_handler.formatter = logging.Formatter( config["Logging"]["format"], style="{") logging.root.handlers.clear() logging.root.addHandler(stream_handler) log.debug("Logging setup successfully!") # Ignore most python-telegram-bot logs, as they are useless most of the time logging.getLogger("urllib3.connectionpool").setLevel("ERROR") # logging.getLogger("Telegram").setLevel("ERROR") # Trying to connect with the Telegram bot by the token try: bot = telebot.TeleBot(config["Telegram"]["token"]) bot.get_me() log.debug('Connection to the bot was successful!') except telebot.apihelper.ApiException: log.error('A request to the Telegram API was unsuccessful.') log.fatal( 'Write the valid token in the config file and restart the script') sys.exit(1) log.debug("Bot connection is valid!") log.info("avarice is started!") @bot.message_handler(commands=["start"]) def start(message): bf.sending_start_message(bot, message, types) bf.start_func(message) @bot.message_handler(commands=["help"]) def helping(message): bf.sending_help_message(bot, message) @bot.message_handler(content_types=["text"]) def message_handler(message): if message.chat.type == 'private': bf.handler(bot, types, message, None) @bot.callback_query_handler(func=lambda call: True) def callback_inline(call): bf.handler(bot, types, None, call) bot.polling(none_stop=True)
async def startup_event(): global logger if ver == 'local': log_folder = 'logs' if not os.path.exists(log_folder): os.mkdir(log_folder) # config logger console_formatter = coloredlogs.ColoredFormatter('%(asctime)s [%(levelname)s] (%(name)s:%(funcName)s) %(message)s', "%H:%M:%S") console_handler = logging.StreamHandler() console_handler.setFormatter(console_formatter) time_formatter = logging.Formatter('%(asctime)s [%(levelname)s] (%(name)s:%(funcName)s) %(message)s', "%y-%m-%d %H:%M:%S") # time_handler = TimedRotatingFileHandler(f'{log_folder}/slides_ws.log', when='D', backupCount=7) # m H D : minutes hours days time_handler = logging.FileHandler(f'{log_folder}/slides_ws.log') time_handler.setFormatter(time_formatter) # clear uvicorn logger logging.getLogger("uvicorn").handlers.clear() access_log = logging.getLogger("uvicorn.access") access_log.handlers.clear() access_log.addHandler(console_handler) access_log.addHandler(time_handler) logging.basicConfig( level=logging.DEBUG, handlers=[ time_handler, # log file handler console_handler # console stream handler ] ) else: log_folder = '/output/logs' if not os.path.exists(log_folder): os.makedirs(log_folder) time_formatter = logging.Formatter('%(asctime)s [%(process)d] [%(levelname)s] (%(name)s) %(message)s', "%y%m%d %H:%M:%S") # time_handler = TimedRotatingFileHandler(f'{log_folder}/slides_ws.log', when='D', backupCount=7) # m H D : minutes hours days time_handler = logging.FileHandler(f'{log_folder}/slides_ws.log') time_handler.setFormatter(time_formatter) logging.basicConfig( level=logging.DEBUG, handlers=[ time_handler ] ) logging.getLogger('matplotlib').setLevel(logging.WARNING) logging.getLogger('urllib3').setLevel(logging.WARNING) logging.getLogger('shapely').setLevel(logging.WARNING) logging.getLogger('passlib').setLevel(logging.WARNING) logging.getLogger('multipart').setLevel(logging.WARNING) logger = logging.getLogger('slides_ws') logger.info(f'Setting logger config for version : {ver}')
def main(api_url, api_key, data_file, chunk_size): root = logging.getLogger() root.setLevel(logging.INFO) handler = logging.StreamHandler(sys.stdout) handler.setLevel(logging.INFO) formatter = coloredlogs.ColoredFormatter( '%(asctime)s,%(msecs)03d - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) root.addHandler(handler) asyncio.run(ingest(api_url, api_key, data_file, chunk_size))