def get(self, request, project):
try:
environment_id = self._get_environment_id_from_request(request, project.organization_id)
except Environment.DoesNotExist:
tag_keys = []
else:
tag_keys = sorted(
tagstore.get_tag_keys(
project.id,
environment_id,
),
key=lambda x: x.key)
data = []
for tag_key in tag_keys:
data.append(
{
'id': six.text_type(tag_key.id),
'key': tagstore.get_standardized_key(tag_key.key),
'name': tagstore.get_tag_key_label(tag_key.key),
'uniqueValues': tag_key.values_seen,
'canDelete': tag_key.key not in PROTECTED_TAG_KEYS,
}
)
return Response(data)
def get_group_tag_keys_and_top_values(self, project_id, group_id, environment_id, user=None):
from sentry import tagstore
start, end = self.get_time_range()
filters = {
'project_id': [project_id],
'environment': [environment_id],
'issue': [group_id],
}
aggregations = [
['count()', '', 'count'],
['topK(10)', 'tags_value', 'top'],
['uniq', 'tags_value', 'uniq'],
]
conditions = [
['tags_value', 'IS NOT NULL', None],
]
results = snuba.query(start, end, ['tags_key'], conditions, filters, aggregations)
return [{
'id': key,
'name': tagstore.get_tag_key_label(key),
'key': tagstore.get_standardized_key(key),
'uniqueValues': res['uniq'],
'totalValues': res['count'],
'topValues': [{
'id': val,
'name': tagstore.get_tag_value_label(key, val),
'key': tagstore.get_standardized_key(key),
'value': val,
} for val in res['top']],
} for key, res in six.iteritems(results)]
def get(self, request, project):
try:
environment_id = self._get_environment_id_from_request(request, project.organization_id)
except Environment.DoesNotExist:
tag_keys = []
else:
tag_keys = sorted(
tagstore.get_tag_keys(
project.id,
environment_id,
# We might be able to stop including these values, but this
# is a pretty old endpoint, so concerned about breaking
# existing api consumers.
include_values_seen=True,
),
key=lambda x: x.key)
data = []
for tag_key in tag_keys:
data.append(
{
'key': tagstore.get_standardized_key(tag_key.key),
'name': tagstore.get_tag_key_label(tag_key.key),
'uniqueValues': tag_key.values_seen,
'canDelete': tag_key.key not in PROTECTED_TAG_KEYS,
}
)
return Response(data)
def _get_tags(self, event):
tag_list = event.get_tags()
if not tag_list:
return ()
return ((tagstore.get_tag_key_label(k), tagstore.get_tag_value_label(k, v))
for k, v in tag_list)
def get(self, request, group):
group_tag_keys = tagstore.get_group_tag_keys(group.id)
# O(N) db access
data = []
all_top_values = []
for group_tag_key in group_tag_keys:
total_values = tagstore.get_group_tag_value_count(group.id, group_tag_key.key)
top_values = tagstore.get_top_group_tag_values(group.id, group_tag_key.key, limit=10)
all_top_values.extend(top_values)
data.append(
{
'id': six.text_type(group_tag_key.id),
'key': tagstore.get_standardized_key(group_tag_key.key),
'name': tagstore.get_tag_key_label(group_tag_key.key),
'uniqueValues': group_tag_key.values_seen,
'totalValues': total_values,
}
)
# Serialize all of the values at once to avoid O(n) serialize/db queries
top_values_by_key = defaultdict(list)
for value in serialize(all_top_values, request.user):
top_values_by_key[value['key']].append(value)
for d in data:
d['topValues'] = top_values_by_key[d['key']]
return Response(data)
def serialize(self, obj, attrs, user):
from sentry import tagstore
return {
'key': tagstore.get_standardized_key(obj.key),
'name': tagstore.get_tag_key_label(obj.key),
'uniqueValues': obj.values_seen,
}
def get_attrs(self, item_list, user):
from sentry import tagstore
result = {}
for item in item_list:
key = tagstore.get_standardized_key(item.key)
result[item] = {
'name': tagstore.get_tag_key_label(item.key),
'key': key,
}
return result
def serialize(self, obj, attrs, user):
from sentry import tagstore
output = {
'key': tagstore.get_standardized_key(obj.key),
'name': tagstore.get_tag_key_label(obj.key),
'uniqueValues': obj.values_seen,
}
if obj.count is not None:
output['totalValues'] = obj.count
if obj.top_values is not None:
output['topValues'] = serialize(obj.top_values, user)
return output
def get_tags(self):
if not hasattr(self, '_tag_cache'):
group_tags = [gtk.key for gtk in tagstore.get_group_tag_keys(self.id)]
results = []
for key in group_tags:
results.append({
'key': key,
'label': tagstore.get_tag_key_label(key),
})
self._tag_cache = sorted(results, key=lambda x: x['label'])
return self._tag_cache
def get(self, request, project):
tag_keys = sorted(tagstore.get_tag_keys(project.id), key=lambda x: x.key)
data = []
for tag_key in tag_keys:
data.append(
{
'id': six.text_type(tag_key.id),
'key': tagstore.get_standardized_key(tag_key.key),
'name': tagstore.get_tag_key_label(tag_key.key),
'uniqueValues': tag_key.values_seen,
}
)
return Response(data)
def get(self, request, group, key):
"""
Retrieve Tag Details
````````````````````
Returns details for given tag key related to an issue.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
environment_id = self._get_environment_id_from_request(
request, group.project.organization_id)
except Environment.DoesNotExist:
# if the environment doesn't exist then the tag can't possibly exist
raise ResourceDoesNotExist
try:
group_tag_key = tagstore.get_group_tag_key(
group.project_id, group.id, environment_id, lookup_key)
except tagstore.GroupTagKeyNotFound:
raise ResourceDoesNotExist
if group_tag_key.count is None:
total_values = tagstore.get_group_tag_value_count(
group.project_id, group.id, environment_id, lookup_key)
else:
total_values = group_tag_key.count
if group_tag_key.top_values is None:
top_values = tagstore.get_top_group_tag_values(
group.project_id, group.id, environment_id, lookup_key, limit=9)
else:
top_values = group_tag_key.top_values
data = {
'key': key,
'name': tagstore.get_tag_key_label(group_tag_key.key),
'uniqueValues': group_tag_key.values_seen,
'totalValues': total_values,
'topValues': serialize(top_values, request.user),
}
return Response(data)
def get_group_tag_keys_and_top_values(self,
project_id,
group_id,
environment_id,
user=None):
from sentry import tagstore
start, end = self.get_time_range()
filters = {
'project_id': [project_id],
'environment': [environment_id],
'issue': [group_id],
}
aggregations = [
['count()', '', 'count'],
['topK(10)', 'tags_value', 'top'],
['uniq', 'tags_value', 'uniq'],
]
conditions = [
['tags_value', 'IS NOT NULL', None],
]
results = snuba.query(start, end, ['tags_key'], conditions, filters,
aggregations)
return [{
'id':
key,
'name':
tagstore.get_tag_key_label(key),
'key':
tagstore.get_standardized_key(key),
'uniqueValues':
res['uniq'],
'totalValues':
res['count'],
'topValues': [{
'id': val,
'name': tagstore.get_tag_value_label(key, val),
'key': tagstore.get_standardized_key(key),
'value': val,
} for val in res['top']],
} for key, res in six.iteritems(results)]
def get(self, request, group):
try:
environment_id = self._get_environment_id_from_request(
request, group.project.organization_id)
except Environment.DoesNotExist:
group_tag_keys = []
else:
group_tag_keys = tagstore.get_group_tag_keys(
group.id, environment_id)
# O(N) db access
data = []
all_top_values = []
for group_tag_key in group_tag_keys:
total_values = tagstore.get_group_tag_value_count(
group.id, environment_id, group_tag_key.key)
top_values = tagstore.get_top_group_tag_values(group.id,
environment_id,
group_tag_key.key,
limit=10)
all_top_values.extend(top_values)
data.append({
'id': six.text_type(group_tag_key.id),
'key': tagstore.get_standardized_key(group_tag_key.key),
'name': tagstore.get_tag_key_label(group_tag_key.key),
'uniqueValues': group_tag_key.values_seen,
'totalValues': total_values,
})
# Serialize all of the values at once to avoid O(n) serialize/db queries
top_values_by_key = defaultdict(list)
for value in serialize(all_top_values, request.user):
top_values_by_key[value['key']].append(value)
for d in data:
d['topValues'] = top_values_by_key[d['key']]
return Response(data)
def get(self, request, group, key):
"""
Retrieve Tag Details
````````````````````
Returns details for given tag key related to an issue.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
tag_key = tagstore.get_tag_key(group.project_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
try:
group_tag_key = tagstore.get_group_tag_key(group.id, lookup_key)
except tagstore.GroupTagKeyNotFound:
raise ResourceDoesNotExist
total_values = tagstore.get_group_tag_value_count(group.id, lookup_key)
top_values = tagstore.get_top_group_tag_values(group.id,
lookup_key,
limit=9)
data = {
'id': six.text_type(tag_key.id),
'key': key,
'name': tagstore.get_tag_key_label(tag_key.key),
'uniqueValues': group_tag_key.values_seen,
'totalValues': total_values,
'topValues': serialize(top_values, request.user),
}
return Response(data)
def get(self, request, project):
try:
environment_id = self._get_environment_id_from_request(
request, project.organization_id)
except Environment.DoesNotExist:
tag_keys = []
else:
tag_keys = sorted(tagstore.get_tag_keys(
project.id,
environment_id,
),
key=lambda x: x.key)
data = []
for tag_key in tag_keys:
data.append({
'id': six.text_type(tag_key.id),
'key': tagstore.get_standardized_key(tag_key.key),
'name': tagstore.get_tag_key_label(tag_key.key),
'uniqueValues': tag_key.values_seen,
})
return Response(data)
def get(self, request, group):
grouptagkeys = [
gtk.key for gtk in tagstore.get_group_tag_keys(group.id)
]
tag_keys = tagstore.get_tag_keys(group.project_id, grouptagkeys)
# O(N) db access
data = []
all_top_values = []
for tag_key in tag_keys:
total_values = tagstore.get_group_tag_value_count(
group.id, tag_key.key)
top_values = tagstore.get_top_group_tag_values(group.id,
tag_key.key,
limit=10)
all_top_values.extend(top_values)
data.append({
'id': six.text_type(tag_key.id),
'key': tagstore.get_standardized_key(tag_key.key),
'name': tagstore.get_tag_key_label(tag_key.key),
'uniqueValues': tag_key.values_seen,
'totalValues': total_values,
})
# Serialize all of the values at once to avoid O(n) serialize/db queries
top_values_by_key = defaultdict(list)
for value in serialize(all_top_values, request.user):
top_values_by_key[value['key']].append(value)
for d in data:
d['topValues'] = top_values_by_key[d['key']]
return Response(data)
def get(self, request, group, key):
"""
Retrieve Tag Details
````````````````````
Returns details for given tag key related to an issue.
:pparam string issue_id: the ID of the issue to retrieve.
:pparam string key: the tag key to look the values up for.
:auth: required
"""
lookup_key = tagstore.prefix_reserved_key(key)
try:
tag_key = tagstore.get_tag_key(group.project_id, lookup_key)
except tagstore.TagKeyNotFound:
raise ResourceDoesNotExist
try:
group_tag_key = tagstore.get_group_tag_key(group.id, lookup_key)
except tagstore.GroupTagKeyNotFound:
raise ResourceDoesNotExist
total_values = tagstore.get_group_tag_value_count(group.id, lookup_key)
top_values = tagstore.get_top_group_tag_values(group.id, lookup_key, limit=9)
data = {
'id': six.text_type(tag_key.id),
'key': key,
'name': tagstore.get_tag_key_label(tag_key.key),
'uniqueValues': group_tag_key.values_seen,
'totalValues': total_values,
'topValues': serialize(top_values, request.user),
}
return Response(data)
def get_label(self):
from sentry import tagstore
return tagstore.get_tag_key_label(self.key)
def notify(self, notification, raise_exception=None):
"""
notify
Send Event Notifications
"""
event = notification.event
group = event.group
project = group.project
# Make sure we're configured
if not self.is_configured(project):
return
webhook_url = self.get_option('webhook_url', project)
project_name = project.get_full_name().encode('utf-8')
notification_link = self.create_markdown_link(
'Click Here',
self.add_notification_referrer_param(group.get_absolute_url()))
try:
# Sentry 9
title = event.message_short.encode('utf-8')
error_message = event.error().encode('utf-8')
except AttributeError:
# Sentry 10
title = event.title.encode('utf-8')
error_message = event.message.encode('utf-8')
message_facts = []
message_facts.append({'name': 'Project', 'value': project_name})
if error_message:
message_facts.append({'name': 'Error', 'value': error_message})
if group.times_seen:
message_facts.append({
'name': 'Times Seen',
'value': 'Seen %s Times' % group.times_seen
})
if group.culprit and title != group.culprit:
message_facts.append({
'name': 'Culprit',
'value': group.culprit.encode('utf-8')
})
message_object = {
'sections': [{
'activityTitle': '[%s] %s' % (project_name, title),
'activityText':
'%s to View this Event in Sentry' % notification_link,
'facts': message_facts
}],
'@type':
'MessageCard',
'summary':
'[%s] %s' % (project_name, title)
}
if self.get_option('show_tags', project):
tags = []
try:
# Sentry 9
sentry_tags = event.get_tags()
except AttributeError:
# Sentry 10
sentry_tags = event.tags
if sentry_tags:
sentry_tag_tuples = ((tagstore.get_tag_key_label(tagname),
tagstore.get_tag_value_label(
tagname, tagvalue))
for tagname, tagvalue in sentry_tags)
for tag_name, tag_value in sentry_tag_tuples:
tags.append({
'name': tag_name.encode('utf-8'),
'value': tag_value.encode('utf-8')
})
section = {
'activityTitle': 'Tags on Event',
'activityText':
'The following Tags were attached to the Event',
'facts': tags
}
message_object['sections'].append(section)
return http.safe_urlopen(webhook_url,
method='POST',
data=json.dumps(message_object))
def get_label(self):
from sentry import tagstore
return tagstore.get_tag_key_label(self.key)
