def get_attrs(self, item_list, user):
attrs = super(StreamGroupSerializer, self).get_attrs(item_list, user)
# we need to compute stats at 1d (1h resolution), and 14d
group_ids = [g.id for g in item_list]
now = timezone.now()
hourly_stats = tsdb.rollup(tsdb.get_range(
model=tsdb.models.group,
keys=group_ids,
end=now,
start=now - timedelta(days=1),
), 3600)
daily_stats = tsdb.rollup(tsdb.get_range(
model=tsdb.models.group,
keys=group_ids,
end=now,
start=now - timedelta(days=14),
), 3600 * 24)
for item in item_list:
attrs[item].update({
'hourly_stats': hourly_stats[item.id],
'daily_stats': daily_stats[item.id],
})
return attrs
def get(self, request, project):
now = timezone.now()
then = now - timedelta(days=30)
results = tsdb.rollup(tsdb.get_distinct_counts_series(
tsdb.models.users_affected_by_project,
(project.id,),
then,
now,
), 3600 * 24)[project.id]
return Response(results)
def get_attrs(self, item_list, user):
attrs = super(StreamGroupSerializer, self).get_attrs(item_list, user)
# we need to compute stats at 1d (1h resolution), and 14d
group_ids = [g.id for g in item_list]
if self.stats_period:
days = 14 if self.stats_period == '14d' else 1
now = timezone.now()
stats = tsdb.rollup(tsdb.get_range(
model=tsdb.models.group,
keys=group_ids,
end=now,
start=now - timedelta(days=days),
), 3600 * days)
for item in item_list:
attrs[item].update({
'stats': stats[item.id],
})
return attrs
def get_attrs(self, item_list, user):
attrs = super(StreamGroupSerializer, self).get_attrs(item_list, user)
# we need to compute stats at 1d (1h resolution), and 14d
group_ids = [g.id for g in item_list]
if self.stats_period:
days = 14 if self.stats_period == '14d' else 1
now = timezone.now()
stats = tsdb.rollup(
tsdb.get_range(
model=tsdb.models.group,
keys=group_ids,
end=now,
start=now - timedelta(days=days),
), 3600 * days)
for item in item_list:
attrs[item].update({
'stats': stats[item.id],
})
return attrs
def get(self, request, project):
try:
environment_id = self._get_environment_id_from_request(
request,
project.organization_id,
)
except Environment.DoesNotExist:
raise ResourceDoesNotExist
now = timezone.now()
then = now - timedelta(days=30)
# TODO(tkaemming): Rollup doesn't actually work correctly here
results = tsdb.rollup(
tsdb.get_distinct_counts_series(
tsdb.models.users_affected_by_project,
(project.id, ),
then,
now,
environment_id=environment_id,
), 3600 * 24)[project.id]
return Response(results)
def get(self, request, group):
"""
Retrieve an aggregate
Return details on an individual aggregate.
{method} {path}
"""
# TODO(dcramer): handle unauthenticated/public response
data = serialize(group, request.user)
# TODO: these probably should be another endpoint
activity = self._get_activity(request, group, num=7)
seen_by = self._get_seen_by(request, group)
# find first seen release
if group.first_release is None:
try:
first_release = GroupTagValue.objects.filter(
group=group,
key='sentry:release',
).order_by('first_seen')[0]
except IndexError:
first_release = None
else:
first_release = {
'version': first_release.value,
# TODO(dcramer): this should look it up in Release
'dateCreated': first_release.first_seen,
}
else:
first_release = group.first_release.version
if first_release is not None:
# find last seen release
try:
last_release = GroupTagValue.objects.filter(
group=group,
key='sentry:release',
).order_by('-last_seen')[0]
except IndexError:
last_release = None
else:
last_release = {
'version': last_release.value,
# TODO(dcramer): this should look it up in Release
'dateCreated': last_release.first_seen,
}
else:
last_release = None
action_list = self._get_actions(request, group)
now = timezone.now()
hourly_stats = tsdb.rollup(tsdb.get_range(
model=tsdb.models.group,
keys=[group.id],
end=now,
start=now - timedelta(days=1),
), 3600)[group.id]
daily_stats = tsdb.rollup(tsdb.get_range(
model=tsdb.models.group,
keys=[group.id],
end=now,
start=now - timedelta(days=30),
), 3600 * 24)[group.id]
data.update({
'firstRelease': first_release,
'lastRelease': last_release,
'activity': serialize(activity, request.user),
'seenBy': serialize(seen_by, request.user),
'pluginActions': action_list,
'stats': {
'24h': hourly_stats,
'30d': daily_stats,
}
})
return Response(data)
def get(self, request, group):
"""
Retrieve an Issue
`````````````````
Return details on an individual issue. This returns the basic stats for
the issue (title, last seen, first seen), some overall numbers (number
of comments, user reports) as well as the summarized event data.
:pparam string issue_id: the ID of the issue to retrieve.
:auth: required
"""
# TODO(dcramer): handle unauthenticated/public response
data = serialize(group, request.user)
# TODO: these probably should be another endpoint
activity = self._get_activity(request, group, num=100)
seen_by = self._get_seen_by(request, group)
# find first seen release
if group.first_release is None:
try:
first_release = GroupTagValue.objects.filter(
group=group,
key__in=('sentry:release', 'release'),
).order_by('first_seen')[0]
except IndexError:
first_release = None
else:
first_release = first_release.value
else:
first_release = group.first_release.version
if first_release is not None:
# find last seen release
try:
last_release = GroupTagValue.objects.filter(
group=group,
key__in=('sentry:release', 'release'),
).order_by('-last_seen')[0]
except IndexError:
last_release = None
else:
last_release = last_release.value
else:
last_release = None
action_list = self._get_actions(request, group)
now = timezone.now()
hourly_stats = tsdb.rollup(
tsdb.get_range(
model=tsdb.models.group,
keys=[group.id],
end=now,
start=now - timedelta(days=1),
), 3600)[group.id]
daily_stats = tsdb.rollup(
tsdb.get_range(
model=tsdb.models.group,
keys=[group.id],
end=now,
start=now - timedelta(days=30),
), 3600 * 24)[group.id]
if first_release:
first_release = self._get_release_info(request, group,
first_release)
if last_release:
last_release = self._get_release_info(request, group, last_release)
tags = list(GroupTagKey.objects.filter(group=group, )[:100])
data.update({
'firstRelease':
first_release,
'lastRelease':
last_release,
'activity':
serialize(activity, request.user),
'seenBy':
seen_by,
'pluginActions':
action_list,
'userReportCount':
UserReport.objects.filter(group=group).count(),
'tags':
sorted(serialize(tags, request.user), key=lambda x: x['name']),
'stats': {
'24h': hourly_stats,
'30d': daily_stats,
}
})
return Response(data)
def get(self, request, group):
"""
Retrieve an Issue
`````````````````
Return details on an individual issue. This returns the basic stats for
the issue (title, last seen, first seen), some overall numbers (number
of comments, user reports) as well as the summarized event data.
:pparam string issue_id: the ID of the issue to retrieve.
:auth: required
"""
# TODO(dcramer): handle unauthenticated/public response
data = serialize(group, request.user)
# TODO: these probably should be another endpoint
activity = self._get_activity(request, group, num=100)
seen_by = self._get_seen_by(request, group)
# find first seen release
if group.first_release is None:
try:
first_release = GroupTagValue.objects.filter(
group=group,
key__in=('sentry:release', 'release'),
).order_by('first_seen')[0]
except IndexError:
first_release = None
else:
first_release = first_release.value
else:
first_release = group.first_release.version
if first_release is not None:
# find last seen release
try:
last_release = GroupTagValue.objects.filter(
group=group,
key__in=('sentry:release', 'release'),
).order_by('-last_seen')[0]
except IndexError:
last_release = None
else:
last_release = last_release.value
else:
last_release = None
action_list = self._get_actions(request, group)
now = timezone.now()
hourly_stats = tsdb.rollup(tsdb.get_range(
model=tsdb.models.group,
keys=[group.id],
end=now,
start=now - timedelta(days=1),
), 3600)[group.id]
daily_stats = tsdb.rollup(tsdb.get_range(
model=tsdb.models.group,
keys=[group.id],
end=now,
start=now - timedelta(days=30),
), 3600 * 24)[group.id]
if first_release:
first_release = self._get_release_info(request, group, first_release)
if last_release:
last_release = self._get_release_info(request, group, last_release)
tags = list(GroupTagKey.objects.filter(
group=group,
)[:100])
participants = list(User.objects.filter(
groupsubscription__is_active=True,
groupsubscription__group=group,
))
data.update({
'firstRelease': first_release,
'lastRelease': last_release,
'activity': serialize(activity, request.user),
'seenBy': seen_by,
'participants': serialize(participants, request.user),
'pluginActions': action_list,
'pluginIssues': self._get_available_issue_plugins(request, group),
'userReportCount': UserReport.objects.filter(group=group).count(),
'tags': sorted(serialize(tags, request.user), key=lambda x: x['name']),
'stats': {
'24h': hourly_stats,
'30d': daily_stats,
}
})
return Response(data)
def get(self, request, group):
"""
Retrieve an aggregate
Return details on an individual aggregate.
{method} {path}
"""
# TODO(dcramer): handle unauthenticated/public response
data = serialize(group, request.user)
# TODO: these probably should be another endpoint
activity = self._get_activity(request, group, num=100)
seen_by = self._get_seen_by(request, group)
# find first seen release
if group.first_release is None:
try:
first_release = GroupTagValue.objects.filter(
group=group,
key__in=('sentry:release', 'release'),
).order_by('first_seen')[0]
except IndexError:
first_release = None
else:
first_release = first_release.value
else:
first_release = group.first_release.version
if first_release is not None:
# find last seen release
try:
last_release = GroupTagValue.objects.filter(
group=group,
key__in=('sentry:release', 'release'),
).order_by('-last_seen')[0]
except IndexError:
last_release = None
else:
last_release = last_release.value
else:
last_release = None
action_list = self._get_actions(request, group)
now = timezone.now()
hourly_stats = tsdb.rollup(
tsdb.get_range(
model=tsdb.models.group,
keys=[group.id],
end=now,
start=now - timedelta(days=1),
), 3600)[group.id]
daily_stats = tsdb.rollup(
tsdb.get_range(
model=tsdb.models.group,
keys=[group.id],
end=now,
start=now - timedelta(days=30),
), 3600 * 24)[group.id]
if first_release:
first_release = self._get_release_info(request, group,
first_release)
if last_release:
last_release = self._get_release_info(request, group, last_release)
data.update({
'firstRelease':
first_release,
'lastRelease':
last_release,
'activity':
serialize(activity, request.user),
'seenBy':
seen_by,
'pluginActions':
action_list,
'userReportCount':
UserReport.objects.filter(group=group).count(),
'stats': {
'24h': hourly_stats,
'30d': daily_stats,
}
})
return Response(data)
def get(self, request, group):
"""
Retrieve an Issue
`````````````````
Return details on an individual issue. This returns the basic stats for
the issue (title, last seen, first seen), some overall numbers (number
of comments, user reports) as well as the summarized event data.
:pparam string issue_id: the ID of the issue to retrieve.
:auth: required
"""
# TODO(dcramer): handle unauthenticated/public response
data = serialize(group, request.user)
# TODO: these probably should be another endpoint
activity = self._get_activity(request, group, num=100)
seen_by = self._get_seen_by(request, group)
# find first seen release
if group.first_release is None:
try:
first_release = GroupTagValue.objects.filter(
group=group, key__in=("sentry:release", "release")
).order_by("first_seen")[0]
except IndexError:
first_release = None
else:
first_release = first_release.value
else:
first_release = group.first_release.version
if first_release is not None:
# find last seen release
try:
last_release = GroupTagValue.objects.filter(
group=group, key__in=("sentry:release", "release")
).order_by("-last_seen")[0]
except IndexError:
last_release = None
else:
last_release = last_release.value
else:
last_release = None
action_list = self._get_actions(request, group)
now = timezone.now()
hourly_stats = tsdb.rollup(
tsdb.get_range(model=tsdb.models.group, keys=[group.id], end=now, start=now - timedelta(days=1)), 3600
)[group.id]
daily_stats = tsdb.rollup(
tsdb.get_range(model=tsdb.models.group, keys=[group.id], end=now, start=now - timedelta(days=30)), 3600 * 24
)[group.id]
if first_release:
first_release = self._get_release_info(request, group, first_release)
if last_release:
last_release = self._get_release_info(request, group, last_release)
tags = list(GroupTagKey.objects.filter(group=group)[:100])
data.update(
{
"firstRelease": first_release,
"lastRelease": last_release,
"activity": serialize(activity, request.user),
"seenBy": seen_by,
"pluginActions": action_list,
"userReportCount": UserReport.objects.filter(group=group).count(),
"tags": sorted(serialize(tags, request.user), key=lambda x: x["name"]),
"stats": {"24h": hourly_stats, "30d": daily_stats},
}
)
return Response(data)
