def _get_entries(self, event, user, is_public=False):
# XXX(dcramer): These are called entries for future-proofing
platform = event.platform
meta = event.data.get("_meta") or {}
interface_list = []
for key, interface in six.iteritems(event.interfaces):
# we treat user as a special contextual item
if key in self._reserved_keys:
continue
data = interface.get_api_context(is_public=is_public, platform=platform)
# data might not be returned for e.g. a public HTTP repr
# However, spans can be an empty list and should still be included.
if not data and interface.path != "spans":
continue
entry = {"data": data, "type": interface.external_type}
api_meta = None
if meta.get(key):
api_meta = interface.get_api_meta(meta[key], is_public=is_public, platform=platform)
api_meta = meta_with_chunks(data, api_meta)
interface_list.append((interface, entry, api_meta))
interface_list.sort(key=lambda x: x[0].get_display_score(), reverse=True)
return (
[i[1] for i in interface_list],
{k: {"data": i[2]} for k, i in enumerate(interface_list) if i[2]},
)
def _get_legacy_message_with_meta(self, event):
meta = event.data.get("_meta")
message = get_path(event.data, "logentry", "formatted")
msg_meta = get_path(meta, "logentry", "formatted")
if not message:
message = get_path(event.data, "logentry", "message")
msg_meta = get_path(meta, "logentry", "message")
if not message:
message = event.message
msg_meta = None
return (message, meta_with_chunks(message, msg_meta))
def _get_interface_with_meta(self, event, name, is_public=False):
interface = event.get_interface(name)
if not interface:
return (None, None)
platform = event.platform
data = interface.get_api_context(is_public=is_public, platform=platform)
event_meta = event.data.get("_meta") or {}
if not data or not event_meta.get(name):
return (data, None)
api_meta = interface.get_api_meta(event_meta[name], is_public=is_public, platform=platform)
# data might not be returned for e.g. a public HTTP repr
if not api_meta:
return (data, None)
return (data, meta_with_chunks(data, api_meta))
def _get_tags_with_meta(self, event):
meta = get_path(event.data, "_meta", "tags") or {}
# If we have meta, we need to get the tags in their original order
# from the raw event body as the indexes need to line up with the
# metadata indexes. In other cases we can use event.tags
if meta:
raw_tags = event.data.get("tags") or []
else:
raw_tags = event.tags
tags = sorted(
[{
"key":
kv[0].split("sentry:", 1)[-1],
"value":
kv[1],
"_meta":
meta.get(kv[0]) or get_path(meta, six.text_type(i), "1")
or None,
} for i, kv in enumerate(raw_tags)
if kv is not None and kv[0] is not None and kv[1] is not None],
key=lambda x: x["key"],
)
# Add 'query' for each tag to tell the UI what to use as query
# params for this tag.
for tag in tags:
query = convert_user_tag_to_query(tag["key"], tag["value"])
if query:
tag["query"] = query
tags_meta = {
six.text_type(i): {
"value": e.pop("_meta")
}
for i, e in enumerate(tags) if e.get("_meta")
}
return (tags, meta_with_chunks(tags, tags_meta))
def get_tags_with_meta(event):
meta = get_path(event.data, "_meta", "tags") or {}
# If we have meta, we need to get the tags in their original order
# from the raw event body as the indexes need to line up with the
# metadata indexes. In other cases we can use event.tags
if meta:
raw_tags = event.data.get("tags") or []
else:
raw_tags = event.tags
tags = sorted(
({
"key":
kv[0] and kv[0].split("sentry:", 1)[-1],
"value":
kv[1],
"_meta":
prune_empty_keys({
"key": get_path(meta, str(i), "0"),
"value": get_path(meta, str(i), "1"),
}) or None,
} for i, kv in enumerate(raw_tags) if kv is not None),
key=lambda x: x["key"] if x["key"] is not None else "",
)
# Add 'query' for each tag to tell the UI what to use as query
# params for this tag.
for tag in tags:
query = convert_user_tag_to_query(tag["key"], tag["value"])
if query:
tag["query"] = query
tags_meta = prune_empty_keys(
{str(i): e.pop("_meta")
for i, e in enumerate(tags)})
return (tags, meta_with_chunks(tags, tags_meta))
def _get_attr_with_meta(self, event, attr, default=None):
value = event.data.get(attr, default)
meta = get_path(event.data, "_meta", attr)
return (value, meta_with_chunks(value, meta))
def test_meta_with_chunks_missing_non_string():
meta = sentry_relay.meta_with_chunks(True, META)
assert meta == META
def test_meta_with_chunks_missing_value():
meta = sentry_relay.meta_with_chunks(None, META)
assert meta == META
def test_meta_with_chunks_list():
meta = sentry_relay.meta_with_chunks(["other", TEXT], {"1": META})
assert meta == {"1": META_WITH_CHUNKS}
def test_meta_with_chunks_dict():
meta = sentry_relay.meta_with_chunks({"test": TEXT, "other": 1}, {"test": META})
assert meta == {"test": META_WITH_CHUNKS}
def test_meta_with_chunks_empty_remarks():
meta = sentry_relay.meta_with_chunks(TEXT, {"rem": []})
assert meta == {"rem": []}
def test_meta_with_chunks_empty():
meta = sentry_relay.meta_with_chunks(TEXT, {})
assert meta == {}
def test_meta_with_chunks_none():
meta = sentry_relay.meta_with_chunks(TEXT, None)
assert meta is None
def test_meta_with_chunks():
meta = sentry_relay.meta_with_chunks(TEXT, META)
assert meta == META_WITH_CHUNKS
