def add_logging_directions(webhook_url=None, email={}): logger = logging.getLogger() if webhook_url is not None: slack_handler = SlackHandler(webhook_url) slack_handler.setFormatter( SlackFormatter( '[%(asctime)s][%(levelname)s](%(filename)s:%(lineno)s) %(message)s' )) logger.addHandler(slack_handler) if len(email) > 0: mail_handler = logging.handlers.SMTPHandler(mailhost=email['mailhost'], fromaddr=email['fromaddr'], toaddrs=email['toaddrs'], subject=email['subject']) logger.addHandler(mail_handler)
def setup_slack_logger(config): slack_logger = logging.getLogger(LoggerName.slack.value) slack_handler = SlackHandler( username="******", icon_emoji=":robot_face:", url=config["slack_webhook"] ) slack_handler.setLevel(config["whitelisted"]["loglevel"]) log_format = "[%(name)s][%(asctime)s][%(module)s:%(lineno)d:%(funcName)s][%(levelname)s]\t%(message)s" slack_formattter = SlackFormatter(log_format) slack_handler.setFormatter(slack_formattter) slack_logger.addHandler(slack_handler) return slack_logger
def format_logger(): hook_url = os.environ["SLACK_HOOK_URL"] logging.basicConfig(level=logging.INFO) logger = logging.getLogger("botosan.logger") logger.setLevel(logging.INFO) sh = SlackHandler(username='******', icon_emoji=':robot_face:', url=hook_url) sh.setLevel(logging.INFO) f = SlackFormatter() sh.setFormatter(f) logger.addHandler(sh) return logger
def _get_logger(url, channel): logger = logging.getLogger("metrics") logger.setLevel(logging.INFO) slackhandler = SlackHandler(username='******', icon_emoji=':robot_face:', url=url, channel=channel) slackhandler.setLevel(logging.INFO) formater = SlackFormatter() slackhandler.setFormatter(formater) logger.addHandler(slackhandler) return logger
def __init__(self): try: self.slack_webhook_url = os.environ['SLACK_WEBHOOK_URL'] self.logger = logging.getLogger("Update") self.logger.setLevel(logging.DEBUG) sh = SlackHandler(username='******', icon_emoji=':robot_face:', url=self.slack_webhook_url) sh.setLevel(logging.DEBUG) f = SlackFormatter() sh.setFormatter(f) self.logger.addHandler(sh) except KeyError: print("[!] SLACK_WEBHOOK_URL not set") exit(1)
def main(args=None): parser = cmd.get_parser() args = parser.parse_args(args) std = logging.StreamHandler(sys.stdout) logHandlers = [std] if args.slack_webhook_url: from slack_logger import SlackHandler, SlackFormatter sh = SlackHandler(username='******', icon_emoji=':robot_face:', url=args.slack_webhook_url) sh.addFilter(lambda x: x.levelno != logging.DEBUG) sh.setFormatter(SlackFormatter()) logHandlers.append(sh) logging.basicConfig( handlers=logHandlers, format="%(asctime)s %(levelname)s: %(message)s", level=logging.DEBUG if args.debug else logging.INFO, ) config_str = ", ".join(f"{k}={v}" for k, v in sorted(vars(args).items())) logger.info(f"Janitor v{__version__} started with {config_str}") if args.dry_run: logger.info("**DRY-RUN**: no deletions will be performed!") if args.rules_file: rules = load_rules_from_file(args.rules_file) logger.info(f"Loaded {len(rules)} rules from file {args.rules_file}") else: rules = [] return run_loop( args.once, args.include_resources, args.exclude_resources, args.include_namespaces, args.exclude_namespaces, rules, args.interval, args.delete_notification, args.deployment_time_annotation, args.resource_context_hook, args.wait_after_delete, args.dry_run, )
def log_setup(app): slack_log_endpoint = app.config.get('SLACK_LOG_ENDPOINT') ch = logging.StreamHandler() ch.setLevel(logging.INFO) handlers = [ch] if slack_log_endpoint: sh = SlackHandler(slack_log_endpoint) sh.setFormatter(SlackFormatter()) sh.setLevel(logging.WARN) handlers.append(sh) logging.basicConfig(handlers=handlers) logging.getLogger( 'botocore.vendored.requests.packages.urllib3.connectionpool').setLevel( logging.WARNING) logging.getLogger('botocore.credentials').setLevel(logging.WARNING)
def setup_logging(default_level=logging.INFO): """ Setup logging configuration """ try: logging.config.dictConfig(LOGGING) except Exception as ex: logging.basicConfig(level=default_level) SLACK_URL = os.getenv("MORPH_WEBHOOK_URL", None) if SLACK_URL: from slack_logger import SlackHandler, SlackFormatter log.setLevel(logging.WARNING) try: sh = SlackHandler(username='******', url=SLACK_URL) sh.setLevel(logging.WARNING) f = SlackFormatter() sh.setFormatter(f) log.addHandler(sh) except Exception as ex: log.error('Unable to add slack_logger', str(ex))
def init_logger(logging_config, run_id): try: with open(logging_config) as file: config = yaml.load(file) dictConfig(config) except: FORMAT = '[' + run_id + '] [%(asctime)-15s] %(levelname)s [%(name)s] %(message)s' logging.basicConfig(format=FORMAT, level=logging.INFO, stream=sys.stderr) logger = logging.getLogger('beta-static-generator') slack_handler = SlackHandler(SCRAPER_SLACK_URL) slack_filter = SlackLogFilter() slack_handler.addFilter(slack_filter) slack_handler.setFormatter(SlackFormatter()) logger.addHandler(slack_handler) def exception_handler(type, value, tb): logger.exception("Uncaught exception: {}".format(str(value)), exc_info=(type, value, tb)) sys.excepthook = exception_handler return logger
def set_up_logging(name: str, log_dir: str, main_logging_level: str = 'DEBUG', slack_logging_level: str = 'CRITICAL', slack_webhook_url: str = None, slack_id: str = None) -> logging.Logger: """ `set_up_logging` initialises and configures a custom logger for `satip`. The logging level of the file and Jupyter outputs are specified by `main_logging_level` whilst the Slack handler uses `slack_logging_level`. There are three core ways that logs are broadcasted: - Logging to a specified file - Logging to Jupyter cell outputs - Logging to Slack Note that the value passed for `main_logging_level` and `slack_logging_level` must be one of: - 'CRITICAL' - 'FATAL' - 'ERROR' - 'WARNING' - 'WARN' - 'INFO' - 'DEBUG' - 'NOTSET' Parameters: name: Name of the logger, if a logging.Logger object is passed then that will be used instead. log_dir: directory where the logs will be stored main_logging_level: Logging level for file and Jupyter slack_logging_level: Logging level for Slack slack_webhook_url: Webhook for the log Slack channel slack_id: Option user-id to mention in Slack Returns: logger: Custom satip logger Example: Here we'll create a custom logger that saves data to the file 'test_log.txt' and also sends Slack messages to the specified user and channel. >>> from satip.utils import set_up_logging >>> import logging >>> logger = set_up_logging('test_log', 'test_log.txt', slack_id=slack_id, slack_webhook_url=slack_webhook_url) >>> logger.log(logging.INFO, 'This will output to file and Jupyter but not to Slack as it is not critical') '2020-10-20 10:24:35,367 - INFO - This will output to file and Jupyter but not to Slack as it is not critical' """ # Initialising logger if isinstance(name, str): logger = logging.getLogger(name) else: # instance where a logger object is passed logger = name # Configuring log level logging_levels = [ 'CRITICAL', 'FATAL', 'ERROR', 'WARNING', 'WARN', 'INFO', 'DEBUG', 'NOTSET' ] assert main_logging_level in logging_levels, f"main_logging_level must be one of {', '.join(logging_levels)}" assert slack_logging_level in logging_levels, f"slack_logging_level must be one of {', '.join(logging_levels)}" logger.setLevel(getattr(logging, main_logging_level)) # Defining global formatter formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') # Configuring Jupyter output handler stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) # Configuring file output handler if not os.path.exists(log_dir): os.makedirs(log_dir) log_fp = f'{log_dir}/{name}.txt' file_handler = logging.FileHandler(log_fp, mode='a') file_handler.setFormatter(formatter) file_handler.setLevel(getattr(logging, main_logging_level)) logger.addHandler(file_handler) # Configuring slack output handler if slack_webhook_url is not None: slack_handler = SlackHandler(username='******', url=slack_webhook_url, mention=slack_id) slack_handler.setFormatter(SlackFormatter()) slack_handler.setLevel(getattr(logging, slack_logging_level)) logger.addHandler(slack_handler) return logger