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