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