def _get_tags_with_meta(self, event):
meta = get_path(event.data, '_meta', 'tags') or {}
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,
}
# TODO this should be using event.tags but there are some weird
# issues around that because event.tags re-sorts the tags and
# this function relies on them being in the original order to
# look up meta.
for i, kv in enumerate(event.data.get('tags') or ())
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 serialize(self, obj, attrs, user):
tags = [{
'key': key.split('sentry:', 1)[-1],
'value': value,
} for key, value in obj.tags]
for tag in tags:
query = convert_user_tag_to_query(tag['key'], tag['value'])
if query:
tag['query'] = query
user = obj.get_minimal_user()
return {
'id': six.text_type(obj.id),
'event.type': six.text_type(obj.type),
'groupID': six.text_type(obj.group_id),
'eventID': six.text_type(obj.event_id),
'projectID': six.text_type(obj.project_id),
# XXX for 'message' this doesn't do the proper resolution of logentry
# etc. that _get_legacy_message_with_meta does.
'message': obj.message,
'title': obj.title,
'location': obj.location,
'culprit': obj.culprit,
'user': user and user.get_api_context(),
'tags': tags,
'platform': obj.platform,
'dateCreated': obj.datetime,
# Needed to generate minidump links in UI
'crashFile': attrs['crash_file'],
}
def serialize(self, obj, attrs, user):
tags = [{
'key': key.split('sentry:', 1)[-1],
'value': value,
} for key, value in obj.tags]
for tag in tags:
query = convert_user_tag_to_query(tag['key'], tag['value'])
if query:
tag['query'] = query
user = obj.get_minimal_user()
return {
'id': six.text_type(obj.id),
'groupID': six.text_type(obj.group_id),
'eventID': six.text_type(obj.event_id),
'projectID': six.text_type(obj.project_id),
# XXX for 'message' this doesn't do the proper resolution of logentry
# etc. that _get_legacy_message_with_meta does.
'message': obj.message,
'title': obj.title,
'location': obj.location,
'culprit': obj.culprit,
'user': user and user.get_api_context(),
'tags': tags,
'platform': obj.platform,
'dateCreated': obj.datetime,
}
def serialize(self, obj, attrs, user):
tags = [{
"key": key.split("sentry:", 1)[-1],
"value": value
} for key, value in obj.tags]
for tag in tags:
query = convert_user_tag_to_query(tag["key"], tag["value"])
if query:
tag["query"] = query
user = obj.get_minimal_user()
return {
"groupID": str(obj.group_id) if obj.group_id else None,
"eventID": str(obj.event_id),
"project": str(obj.project_id),
# XXX for 'message' this doesn't do the proper resolution of logentry
# etc. that _get_legacy_message_with_meta does.
"message": obj.message,
"title": obj.title,
"location": obj.location,
"culprit": obj.culprit,
"user": user and user.get_api_context(),
"tags": tags,
"platform": obj.platform,
"datetime": obj.datetime.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
}
def serialize(self, obj, attrs, user):
tags = [{
"key": key.split("sentry:", 1)[-1],
"value": value
} for key, value in obj.tags]
for tag in tags:
query = convert_user_tag_to_query(tag["key"], tag["value"])
if query:
tag["query"] = query
user = obj.get_minimal_user()
return {
"id": str(obj.event_id),
"event.type": str(obj.get_event_type()),
"groupID": str(obj.group_id) if obj.group_id else None,
"eventID": str(obj.event_id),
"projectID": str(obj.project_id),
# XXX for 'message' this doesn't do the proper resolution of logentry
# etc. that _get_legacy_message_with_meta does.
"message": obj.message,
"title": obj.title,
"location": obj.location,
"culprit": obj.culprit,
"user": user and user.get_api_context(),
"tags": tags,
"platform": obj.platform,
"dateCreated": obj.datetime,
# Needed to generate minidump links in UI
"crashFile": attrs["crash_file"],
}
def get_tags_dict(self, obj):
keys = getattr(obj, 'tags.key', None)
values = getattr(obj, 'tags.value', None)
if keys and values and len(keys) == len(values):
results = []
for key, value in zip(keys, values):
key = key.split('sentry:', 1)[-1]
result = {'key': key, 'value': value}
query = convert_user_tag_to_query(key, value)
if query:
result['query'] = query
results.append(result)
results.sort(key=lambda x: x['key'])
return results
return []
def serialize(self, obj, attrs, user):
from sentry import tagstore
key = tagstore.get_standardized_key(obj.key)
serialized = {
'key': key,
'name': tagstore.get_tag_value_label(obj.key, obj.value),
'value': obj.value,
'count': obj.times_seen,
'lastSeen': obj.last_seen,
'firstSeen': obj.first_seen,
}
query = convert_user_tag_to_query(key, obj.value)
if query:
serialized['query'] = query
return serialized
def serialize(self, obj, attrs, user):
if not attrs["user"]:
result = {"id": None}
else:
result = serialize(attrs["user"], user)
query = convert_user_tag_to_query("user", obj.value)
if query:
result["query"] = query
result.update({
"value": obj.value,
"count": obj.times_seen,
"lastSeen": obj.last_seen,
"firstSeen": obj.first_seen,
})
return result
def serialize(self, obj, attrs, user):
from sentry import tagstore
key = tagstore.get_standardized_key(obj.key)
serialized = {
'key': key,
'name': tagstore.get_tag_value_label(obj.key, obj.value),
'value': obj.value,
'count': obj.times_seen,
'lastSeen': obj.last_seen,
'firstSeen': obj.first_seen,
}
query = convert_user_tag_to_query(key, obj.value)
if query:
serialized['query'] = query
return serialized
def serialize(self, obj, attrs, user):
from sentry import tagstore
key = tagstore.get_standardized_key(obj.key)
serialized = {
"key": key,
"name": tagstore.get_tag_value_label(obj.key, obj.value),
"value": obj.value,
"count": obj.times_seen,
"lastSeen": obj.last_seen,
"firstSeen": obj.first_seen,
}
query = convert_user_tag_to_query(key, obj.value)
if query:
serialized["query"] = query
return serialized
def serialize(self, obj, attrs, user):
if not attrs['user']:
result = {
'id': None,
}
else:
result = serialize(attrs['user'], user)
query = convert_user_tag_to_query('user', obj.value)
if query:
result['query'] = query
result.update({
'value': obj.value,
'count': obj.times_seen,
'lastSeen': obj.last_seen,
'firstSeen': obj.first_seen,
})
return result
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_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 test_non_user_tag(self):
assert convert_user_tag_to_query("user", 'fake:123"456') is None
def test_user_tag_with_space(self):
assert convert_user_tag_to_query("user",
"id:123 456") == 'user.id:"123 456"'
def test_user_tag_with_quote(self):
assert convert_user_tag_to_query("user",
'id:123"456') == 'user.id:"123\\"456"'
def test_simple_user_tag(self):
assert convert_user_tag_to_query("user",
"id:123456") == 'user.id:"123456"'
