def test_get_config_is_configured(self):
"""
Return value of structlog.get_config() works as input for
structlog.configure(). is_configured() reflects the state of
configuration.
"""
assert False is structlog.is_configured()
structlog.configure(**structlog.get_config())
assert True is structlog.is_configured()
structlog.reset_defaults()
assert False is structlog.is_configured()
def test_get_config_is_configured(self):
"""
Return value of structlog.get_config() works as input for
structlog.configure(). is_configured() reflects the state of
configuration.
"""
assert False is structlog.is_configured()
structlog.configure(**structlog.get_config())
assert True is structlog.is_configured()
structlog.reset_defaults()
assert False is structlog.is_configured()
def get_logger(name: Optional[str] = None) -> Any:
"""
Convenience function that returns a logger
Returns: A proxy that creates a correctly configured logger bound to
the __name__ of the calling module
"""
del name
caller_name = get_caller_name_from_frames()
if not _CONFIGS.stdlib_logging_config_already_configured:
set_logging_config(caller_name)
_CONFIGS.stdlib_logging_config_already_configured = True
if not structlog.is_configured():
if (
_feature_flags.is_prettified_output_formatting_requested()
or _feature_flags.is_stdlib_based_structlog_configuration_requested()
):
set_stdlib_based_structlog_config()
else:
set_optimized_structlog_config()
logger = structlog.get_logger(caller_name).bind(logger=caller_name)
if hasattr(logger, "setLevel"): # stdlib-based logger
logger.setLevel(_LOG_LEVEL)
return logger
def load(cls, env_prefix: str = 'TG_ODESLI_BOT_'):
"""Load config merging default variables and environment variables.
:param env_prefix: prefix for environment variables
:return: filled config object
"""
config = cls()
# Load environment from .env file
dotenv.load_dotenv()
# Update config object with environment variables
for env_var_name, value in os.environ.items():
if env_var_name.startswith(env_prefix):
var_name = env_var_name[len(env_prefix):]
# Do not override config vars in testing mode
if hasattr(config, 'TESTING') and hasattr(config, var_name):
continue
setattr(config, var_name, value)
if config.SENTRY_DSN:
sentry_sdk.init(
dsn=config.SENTRY_DSN,
integrations=[AioHttpIntegration()],
environment=config.SENTRY_ENVIRONMENT,
)
if not structlog.is_configured():
config.init_logging()
return config
def configure_logging(
dict_config: Dict = DEFAULT_CONFIG, file_config: Optional[Path] = None
) -> None:
"""Configures logging for the application.
This is usually called by valiant.config.Config.__init__
If a file_config is provided, the dict_config is ignored.
If logging has already been configured further calls to this function will
just be silently ignored.
See: https://docs.python.org/3/library/logging.config.html#logging.config.dictConfig
Args:
dict_config: A dictionary acceptable to logging.config.dictConfig
file_config: Path to a logging config file - see
https://docs.python.org/3/library/logging.config.html#logging-config-fileformat
Raises:
ValueError: When the file provided in file_config does not exist.
"""
from copy import deepcopy
import structlog
from structlog.stdlib import LoggerFactory
if structlog.is_configured():
return
if file_config:
if not file_config.exists():
raise ValueError(
(
f"The logging configuration file does not exist: {file_config}."
f" CWD is {Path.cwd()}."
)
)
fileConfig(file_config)
else:
dictConfig(deepcopy(dict_config))
# See: http://www.structlog.org/en/stable/standard-library.html#rendering-within-structlog
structlog.configure_once(
processors=[
structlog.stdlib.filter_by_level,
structlog.stdlib.add_logger_name,
structlog.stdlib.add_log_level,
structlog.stdlib.PositionalArgumentsFormatter(),
structlog.processors.TimeStamper(fmt="iso"),
structlog.processors.StackInfoRenderer(),
structlog.processors.format_exc_info,
structlog.processors.UnicodeDecoder(),
structlog.processors.JSONRenderer(),
],
context_class=dict,
logger_factory=structlog.stdlib.LoggerFactory(),
wrapper_class=structlog.stdlib.BoundLogger,
cache_logger_on_first_use=True,
)
def getLogger(logger=None):
if not logger:
logger = logging.getLogger()
if not structlog.is_configured():
configure_structlog()
logger = structlog.wrap_logger(logger=logger)
return logger
def init_app(app, app_config: Config = None):
_suppress_warnings()
if app_config is None:
app_config = _config_by_environment(app.env)
app.config.from_object(app_config)
if not structlog.is_configured():
from property_app.logging import initialize_logging
initialize_logging()
def get_logger(self):
if not structlog.is_configured():
structlog.configure(
processors=self.chain,
context_class=structlog.threadlocal.wrap_dict(dict),
logger_factory=structlog.stdlib.LoggerFactory(),
wrapper_class=structlog.stdlib.BoundLogger,
cache_logger_on_first_use=True,
)
logger = structlog.get_logger(self.service_name).new()
return logger.bind(**self.initial_values)
def init_app(self, app: Flask) -> None:
"""init_app
Patches the builtin Flask logger and replaces it with a structlog logger.
:param app:
The Flask app for which to patch the logger.
"""
if not structlog.is_configured():
app.logger.warning(
'The structlog module is not configured yet. Refusing to patch the Flask logger.'
)
return None
self._patch_flask_logger(app)
import re
from collections import OrderedDict
import cachetools
import more_itertools
import requests
import structlog
from greynoise.__version__ import __version__
from greynoise.api.analyzer import Analyzer
from greynoise.api.filter import Filter
from greynoise.exceptions import RateLimitError, RequestFailure
from greynoise.util import configure_logging, load_config, validate_ip
if not structlog.is_configured():
configure_logging()
LOGGER = structlog.get_logger()
def initialize_cache(cache_max_size, cache_ttl):
"""A function to initialize cache"""
cache = cachetools.TTLCache(maxsize=cache_max_size, ttl=cache_ttl)
return cache
class GreyNoise(object):
"""GreyNoise API client.
:param api_key: Key use to access the API.
def __init__(self):
if not structlog.is_configured():
configure_structlog()
def __init__(self, get_response):
self.get_response = get_response
if not structlog.is_configured():
configure_structlog()
def __init__(self, app):
self.app = app
if not structlog.is_configured():
configure_structlog()
def main():
"""GreyNoise CLI."""
if not structlog.is_configured():
configure_logging()
