def __init__(self, consumer_key, consumer_secret, access_key,
access_secret):
super(TwitterHandler, self).__init__()
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
self.api = tweepy.API(auth)
Handler.setFormatter(self, TwitterFormatter())
def configure_logging(
stderr_handler: logging.Handler,
quiet: bool,
debug: bool,
enable_color: bool,
timestamps: bool,
base_logger: logging.Logger = _logger,
) -> None:
"""Configure logging."""
rdflib_logger = logging.getLogger("rdflib.term")
rdflib_logger.addHandler(stderr_handler)
rdflib_logger.setLevel(logging.ERROR)
if quiet:
# Silence STDERR, not an eventual provenance log file
stderr_handler.setLevel(logging.WARN)
if debug:
# Increase to debug for both stderr and provenance log file
base_logger.setLevel(logging.DEBUG)
stderr_handler.setLevel(logging.DEBUG)
rdflib_logger.setLevel(logging.DEBUG)
fmtclass = coloredlogs.ColoredFormatter if enable_color else logging.Formatter
formatter = fmtclass("%(levelname)s %(message)s")
if timestamps:
formatter = fmtclass(
"[%(asctime)s] %(levelname)s %(message)s", "%Y-%m-%d %H:%M:%S"
)
stderr_handler.setFormatter(formatter)
def update_logger(self
, new_logging_level: int
, new_logging_handler: lg.Handler = None
, new_logging_formatter: lg.Formatter = None
) -> LoggableObject:
current_logger = self.logger(extend_logger_name = False)
if new_logging_level is not None:
current_logger.setLevel(new_logging_level)
if new_logging_handler is not None:
if new_logging_level is not None:
new_logging_handler.setLevel(new_logging_level)
if new_logging_formatter is not None:
new_logging_handler.setFormatter(new_logging_formatter)
for h in current_logger.handlers:
if str(h) == str(new_logging_handler):
current_logger.removeHandler(h)
current_logger.addHandler(new_logging_handler)
break
else:
current_logger.addHandler(new_logging_handler)
return self
def _register_handler(handler: Handler, level: int, tag: str = '_default_') -> None:
assert tag not in handlers
handlers[tag] = handler
handler.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(handler)
logger.setLevel(level)
def setup_logger(name: Optional[str] = 'default',
handler: logging.Handler = None) -> None:
if handler is None:
handler = logging.StreamHandler()
fmt = logging.Formatter("{asctime} [{levelname}]: {message}", style='{')
handler.setFormatter(fmt)
logger = logging.getLogger(name)
logger.addHandler(handler)
def _set_formatter(self, handler: logging.Handler, formatter_class: type,
formatter: Union[str, dict]):
"""
Set the formatter with the handler and formatter class specified
"""
args = self._get_formatter_args(formatter)
formatter_object = formatter_class(**args)
handler.setFormatter(formatter_object)
def set_logging_formatter(handler: logging.Handler, logging_level):
if logging_level == logging.DEBUG:
formatter = logging.Formatter("[%(asctime)s] > [%(threadName)s] > "
"[%(filename)s:%(lineno)d] %(message)s")
else:
formatter = logging.Formatter(
'[%(asctime)s %(levelname)s] %(message)s', "%b %d %H:%M:%S")
handler.setFormatter(formatter)
def __init__(self, username, password):
Handler.__init__(self)
self.username = username
self.screen_name = username
self.password = password
self._oauth_token = None
self._oauth_token_secret = None
self._consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET)
self._client = oauth2.Client(self._consumer)
Handler.setFormatter(self, TwitterFormatter())
def get_logger(name: str, log_level: int=logging.INFO,
handler: logging.Handler=static_handler,
formatter: logging.Formatter=colored_formatter):
logger = logging.getLogger(name)
logger.setLevel(log_level)
if len(logger.handlers) is 0:
logger.addHandler(handler)
if formatter is not None and handler is not static_handler:
handler.setFormatter(formatter)
return logger
def configure_handler(
handler: logging.Handler,
level: int,
formatter: logging.Formatter,
filter_: logging.Filter = None,
):
handler.setLevel(level)
handler.setFormatter(formatter)
if filter_:
handler.addFilter(filter_)
return handler
def __init__(self, username, password):
Handler.__init__(self)
self.username = username
self.screen_name = username
self.password = password
self._oauth_token = None
self._oauth_token_secret = None
self._consumer = oauth2.Consumer(CONSUMER_KEY,
CONSUMER_SECRET)
self._client = oauth2.Client(self._consumer)
Handler.setFormatter(self, TwitterFormatter())
def add_handler(self, handler: logging.Handler, fmt=None, date_fmt=None):
"""
Add a new log handler with format handlers.
:param handler:
:param fmt:
:param date_fmt:
:return:
"""
fmt = fmt or self.default_fmt
date_fmt = date_fmt or self.default_date_fmt
handler.setFormatter(logging.Formatter(fmt=fmt, datefmt=date_fmt, style='{'))
self._logger.addHandler(handler)
def register_handler(handler: logging.Handler, logger: logging.Logger, level: int, format_string: str, record_filter: logging.Filter, verbose: bool = True) -> None:
handler.setLevel(level)
formatter = logging.Formatter(format_string)
handler.setFormatter(formatter)
if record_filter:
handler.addFilter(record_filter)
logger.addHandler(handler)
if verbose:
print("------------- New Logging Handler ---------------")
print("Added handler: {}".format(str(handler)))
print("To Logger: {}".format(str(logger)))
if record_filter:
print("With Filter: {}".format(str(record_filter)))
def set_log_handler_formatter_prefix(handler: logging.Handler,
log_formatter_prefix: str) -> None:
if handler.formatter:
if handler.formatter._fmt:
handler.formatter._fmt = log_formatter_prefix + handler.formatter._fmt
handler.formatter._style._fmt = log_formatter_prefix + handler.formatter._style._fmt
else:
handler.formatter._fmt = log_formatter_prefix + '%(message)s'
handler.formatter._style._fmt = log_formatter_prefix + '%(message)s'
else:
datefmt = default_date_fmt
formatter = logging.Formatter(log_formatter_prefix + '%(message)s',
datefmt)
handler.setFormatter(formatter)
def add_handler(
self,
name: str,
handler: python_logging.Handler,
formatter: Optional[python_logging.Formatter] = None,
) -> None:
"""Add handler and optional formatter to a module name.
Args:
name: module name
handler: Logging Handler
formatter: Logging Formatter
"""
logger = python_logging.getLogger(name)
if formatter is not None:
handler.setFormatter(formatter)
logger.addHandler(handler)
def _add_handler(handler: logging.Handler,
logger: logging.Logger = logging.getLogger(),
name: str = 'log_handler',
level: int = logging.INFO,
fmt: str = default_fmt,
datefmt: str = default_date_fmt) -> logging.Handler:
"""
>>> result = set_stream_handler()
>>> result2 = set_stream_handler()
"""
handler.addFilter(HostnameFilter())
fmt = format_fmt(fmt)
formatter = logging.Formatter(fmt, datefmt)
handler.setFormatter(formatter)
handler.setLevel(level)
handler.name = name
logger.addHandler(handler)
return handler
def add_handler(handler: logging.Handler,
logger_name: Optional[str] = None,
level: int = logging.DEBUG,
log_format: Optional[str] = None):
"""
Adds a new handler to an existing logger, with the specified formatter
in ```init_logging```. If a new format is specified (is not None) then
it will be used for this handler.
:param handler: the new handler to be added.
:param logger_name: the logger name to which add the handler.
:param level: the logging level for that formatter.
:param log_format: the log format used if not formatter was created.
"""
logger = logging.getLogger(logger_name)
fmt = logging.Formatter(log_format) if log_format else logging.Formatter(
LOG_DEFAULT_FORMAT)
handler.setFormatter(fmt)
handler.setLevel(level)
logger.addHandler(handler)
def _configureHandler(logger: logging.Logger, handler: logging.Handler,
formatter: logging.Formatter,
level: typing.Optional[Level]) -> None:
"""Configures the handler
#. Sets the level to the given one or, if None, to the logger's level
#. Sets the formatter to the given one
#. Adds this handler to the logger
It is called by internally by this package's handler
"""
if level is None:
handler.setLevel(logger.level)
else:
if isinstance(level, Level):
level = level.value
elif isinstance(level, (int, str)):
handler.setLevel(level)
else:
raise TypeError("Wrong level type: %s" % type(level))
handler.setFormatter(formatter)
logger.addHandler(handler)
def configure_logging(
args: argparse.Namespace,
stderr_handler: logging.Handler,
runtimeContext: RuntimeContext,
) -> None:
rdflib_logger = logging.getLogger("rdflib.term")
rdflib_logger.addHandler(stderr_handler)
rdflib_logger.setLevel(logging.ERROR)
if args.quiet:
# Silence STDERR, not an eventual provenance log file
stderr_handler.setLevel(logging.WARN)
if runtimeContext.debug:
# Increase to debug for both stderr and provenance log file
_logger.setLevel(logging.DEBUG)
stderr_handler.setLevel(logging.DEBUG)
rdflib_logger.setLevel(logging.DEBUG)
fmtclass = coloredlogs.ColoredFormatter if args.enable_color else logging.Formatter
formatter = fmtclass("%(levelname)s %(message)s")
if args.timestamps:
formatter = fmtclass("[%(asctime)s] %(levelname)s %(message)s",
"%Y-%m-%d %H:%M:%S")
stderr_handler.setFormatter(formatter)
def __init__(self,
name: str,
strFormat: str,
handler: logging.Handler = logging.StreamHandler()):
"""
Parameters
----------
name: str
The name to give this logger.
strFormat: str
The formatting string to use.
handler: logging.StreamHandler, optional
The handler to use.
"""
self.log: logging.Logger = logging.getLogger(name)
self.log.setLevel(logging.INFO)
handler: logging.Handler = handler
handler.setLevel(logging.INFO)
handler.setFormatter(logging.Formatter(strFormat))
self.log.addHandler(handler)
def _config_handler(self,
handler: logging.Handler,
level: Union[str, int] = None,
formatter: str = None,
set_from_master: bool = False):
"""
Configure the handler's level and formatter
:param handler: logging.Handler type object
:param level: the level of the handler
:param formatter: the formatter of the handler
:param set_from_master: Set *level* or *formatter* from obj.master_level and obj.master_formatter
"""
# Set level
if level:
log_level = self._get_level(level)
handler.setLevel(log_level)
elif set_from_master:
handler.setLevel(self.master_level)
# Set formatter
if type(handler) == logging.StreamHandler:
formatter_class = partial(ColorFormatter,
color_config=self.color_config)
else:
formatter_class = logging.Formatter
if formatter:
formatter_object = formatter_class(formatter, style='{')
handler.setFormatter(formatter_object)
elif set_from_master:
formatter_object = formatter_class(self.master_formatter,
style='{')
handler.setFormatter(formatter_object)
def configure_loggers(app: Flask, default_handler: logging.Handler) -> None:
"""
Adds logging handlers to the app instance and
configures log formatting.
:param default_handler:
:param app: The flask app instance.
"""
mail_handler = SMTPHandler(mailhost=(app.config["SMTP_SERVER"],
app.config["SMTP_PORT"]),
fromaddr=app.config["SMTP_FROM_ADDRESS"],
toaddrs=[app.config["ADMIN_EMAIL"]],
subject='[Survey Tool] Application Error',
credentials=(app.config["SMTP_FROM_ADDRESS"],
app.config["SMTP_PASSWORD"]),
secure=())
log_formatter = LogFormatter(
'[%(asctime)s] %(levelname)s during %(method)s %(url)s as %(current_user)s@%(remote_addr)s in %(module)s: %(message)s'
)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(log_formatter)
default_handler.setFormatter(log_formatter)
if not app.config['DEBUG']:
# only use logging via email for production instances
app.logger.addHandler(mail_handler)
def get_logger(name: str = None,
handler: logging.Handler = None,
level=logging.INFO,
formatting: str = DEFAULT_FORMAT_STR,
propagate: bool = False,
print_trace_id: bool = True):
logger = logging.getLogger(name)
logger.setLevel(level)
logger.propagate = propagate
if not handler:
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(level)
# If APP_ENV is `test` or unset we use a colorful formatter 🌈.
# Else we use a plain formatter to avoid passing ANSI color characters
# into staging/prod env logs
app_env = os.getenv('APP_ENV', TEST_ENV)
if app_env == TEST_ENV:
formatter = ColorfulFormatter(formatting)
else:
formatter = logging.Formatter(formatting)
handler.setFormatter(formatter)
if logger.hasHandlers():
# To prevent the same stream handler from being added multiple times to the
# same logger. If the same handler (stdout in this case) is added multiple
# times to the same logger then each log will show up more and more times in
# that stream.
logger.handlers.clear()
logger.addHandler(handler)
if print_trace_id:
logger = KubricLogAdapter(logger, {})
return logger
def addHandler(self, handler: logging.Handler, handlerLevel: int):
handler.setLevel(handlerLevel)
handler.setFormatter(logging.Formatter(self.formatStr))
self.logger.addHandler(handler)
def add_handler(self, ch: logging.Handler, log_format: str):
formatter = Formatter(log_format)
formatter.set_formatter(self.formatter)
ch.setFormatter(formatter)
self.logger.addHandler(ch)
def add_handler(self, handler: logging.Handler):
handler.setFormatter(self.formatter)
self._logging.addHandler(handler)
def _setHandlerDefaults(self, handler: logging.Handler) -> None:
handler.setLevel(self.level)
handler.setFormatter(self.formatter)
def __init__(self, consumer_key, consumer_secret, access_key, access_secret):
super(TwitterHandler, self).__init__()
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
self.api = tweepy.API(auth)
Handler.setFormatter(self, TwitterFormatter())
def add_handler(handler: logging.Handler, level: int) -> None:
handler.setLevel(level)
handler.setFormatter(formatter)
logger.addHandler(handler)
def setFormatter(self, fmt):
LogHandler.setFormatter(self, fmt)
self._handler.setFormatter(fmt)
def __add_handler(self, handler: logging.Handler,
add_colors: bool) -> NoReturn:
handler.setLevel(self.log_level)
handler.setFormatter(self.__get_formatter(add_colors=add_colors))
self.__logger.addHandler(handler)
def _setup_logger(name: str, handler: Handler, level: int) -> None:
handler.setFormatter(formatter)
logger = logging.getLogger(name)
logger.addHandler(handler)
logger.setLevel(level)
logger.propagate = False