def format(self, record):
data = {
"timestamp": int(record.created * 1000),
"message": record.msg,
"name": record.name,
"level": record.levelno,
}
if record.exc_info is not None:
data["exception"] = "".join(
traceback.format_exception(*record.exc_info))
if self.flatten:
items = {
k: v
for d in [
record.__dict__,
flatten_dict(self.discover_context(), "context")
] for k, v in d.items()
if k not in self.reserved and k not in data
}
merge(data, flatten_dict(items))
else:
items = {
k: v
for k, v in record.__dict__.items()
if k not in self.reserved and k not in data
}
merge(data, {"extra": items, "context": self.discover_context()})
return json.dumps(data)
def __has_emf(config):
if len(config) == 0:
return False
handler_config = {}
for i in [DEFAULT_HANDLER_FULL_PATH, DEFAULT_HANDLER_CLASS]:
merge(handler_config, config.get(i, {}))
emf_metrics = handler_config.get("emf_metrics", [])
return len(emf_metrics) > 0
def autodiscover(name=None, level=logging.INFO, **kwargs):
global is_configured
refresh = kwargs.pop("refresh", False)
if not refresh and is_configured:
return logging.getLogger(name)
logs_client = kwargs.pop("logs_client", None)
sts_client = kwargs.pop("sts_client", None)
config = kwargs.pop("config", {})
discover_context = kwargs.pop("discover_context", None)
flatten = kwargs.pop("flatten", __has_emf(config))
if "handlers" not in config:
use_threading = kwargs.pop("use_threading", True)
merge(
config,
{
"handlers": [DEFAULT_HANDLER_FULL_PATH],
DEFAULT_HANDLER_CLASS: {
"use_threading": use_threading
},
},
)
if logs_client is not None:
merge(
config,
{
DEFAULT_HANDLER_CLASS: {
"logs_client": logs_client
},
},
)
if discover_context is None:
discover_context = lambda: discover_context_base(sts_client=sts_client,
refresh=refresh)
is_configured = True
return autodiscover_base(name=name,
level=level,
config=config,
refresh=refresh,
flatten=flatten,
discover_context=discover_context,
**kwargs)
def __get_handlers(config, formatter):
config = {k.lower(): v for k, v in config.items()}
handlers = [(i, ) + tuple(i.rsplit(".", 1)) for i in config["handlers"]]
classes = [i[2] for i in handlers]
for handler, module_name, class_name in handlers:
HandlerClass = getattr(importlib.import_module(module_name),
class_name)
instance = None
args = {}
if config.get(handler.lower()) is not None:
merge(args, config[handler.lower()])
if classes.count(class_name) == 1 and config.get(
class_name.lower()) is not None:
merge(args, config[class_name.lower()])
instance = HandlerClass(**args)
instance.setFormatter(formatter)
yield instance
def discover_config(existing=None):
config = deepcopy(DEFAULT_CONFIG)
if existing is None:
existing = {}
# Read default config file
merge(config, read_config_file(DEFAULT_CONFIG_FILE))
# Read env vars
merge(config, parse_env(ENV_PREFIX))
# Read explicit config
if isinstance(existing, str):
merge(config, read_config_file(existing))
else:
merge(config, existing)
return config
def test_merge_dict():
a = {
"a": {
"b": {
"c": 1234
}
},
"foo": "bar",
}
b = {"a": {"b": {"c": 123, "d": "hi"}}}
result = merge(a, b)
assert result["a"]["b"]["d"] == "hi"
assert result["a"]["b"]["c"] == 123
assert a["a"]["b"]["d"] == "hi"
assert a["a"]["b"]["c"] == 123