def references(self, request: request.Request,
**kwargs) -> response.Response:
reference_id = request.GET.get("id", None)
offset = request.GET.get("offset", None)
if not reference_id or not offset:
return response.Response({})
offset_value = int(offset)
cached_result = get_safe_cache(reference_id)
if cached_result:
return response.Response({
"result":
cached_result[offset_value:offset_value + 100],
"offset":
offset_value +
100 if len(cached_result) > offset_value + 100 else None,
})
else:
return response.Response({})
def save_query(sql: str, params: Dict, execution_time: float) -> None:
"""
Save query for debugging purposes
"""
try:
key = "save_query_{}".format(_save_query_user_id)
queries = json.loads(get_safe_cache(key) or "[]")
queries.insert(
0,
{
"timestamp": now().isoformat(),
"query": format_sql(sql, params, colorize=False),
"execution_time": execution_time,
},
)
cache.set(key, json.dumps(queries), timeout=120)
except Exception as e:
capture_exception(e)
def test_stickiness_regression(self, patch_update_cache_item: MagicMock,
patch_apply_async: MagicMock) -> None:
# We moved Stickiness from being a "shown_as" item to its own insight
# This move caused issues hence a regression test
filter_stickiness = StickinessFilter(
data={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$browser",
"value": "Mac OS X"
}],
"date_from": "2012-01-10",
"date_to": "2012-01-15",
"insight": INSIGHT_STICKINESS,
"shown_as": "Stickiness",
},
team=self.team,
get_earliest_timestamp=Event.objects.earliest_timestamp,
)
filter = Filter(
data={
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$browser",
"value": "Mac OS X"
}],
"date_from": "2012-01-10",
"date_to": "2012-01-15",
})
shared_dashboard = Dashboard.objects.create(team=self.team,
is_shared=True)
Insight.objects.create(dashboard=shared_dashboard,
filters=filter_stickiness.to_dict(),
team=self.team)
Insight.objects.create(dashboard=shared_dashboard,
filters=filter.to_dict(),
team=self.team)
item_stickiness_key = generate_cache_key(filter_stickiness.toJSON() +
"_" + str(self.team.pk))
item_key = generate_cache_key(filter.toJSON() + "_" +
str(self.team.pk))
update_cached_items()
for call_item in patch_update_cache_item.call_args_list:
update_cache_item(*call_item[0])
self.assertEqual(
get_safe_cache(item_stickiness_key)["result"][0]["labels"],
["1 day", "2 days", "3 days", "4 days", "5 days", "6 days"],
)
self.assertEqual(
get_safe_cache(item_key)["result"][0]["labels"],
[
"10-Jan-2012",
"11-Jan-2012",
"12-Jan-2012",
"13-Jan-2012",
"14-Jan-2012",
"15-Jan-2012",
],
)
def test_refresh_dashboard_cache(self, patch_update_cache_item: MagicMock,
patch_apply_async: MagicMock) -> None:
# There's two things we want to refresh
# Any shared dashboard, as we only use cached items to show those
# Any dashboard accessed in the last 7 days
filter_dict = {
"events": [{
"id": "$pageview"
}],
"properties": [{
"key": "$browser",
"value": "Mac OS X"
}],
}
filter = Filter(data=filter_dict)
shared_dashboard = Dashboard.objects.create(team=self.team,
is_shared=True)
funnel_filter = Filter(data={
"events": [
{
"id": "user signed up",
"type": "events",
"order": 0
},
],
})
item = Insight.objects.create(dashboard=shared_dashboard,
filters=filter.to_dict(),
team=self.team)
funnel_item = Insight.objects.create(dashboard=shared_dashboard,
filters=funnel_filter.to_dict(),
team=self.team)
dashboard_to_cache = Dashboard.objects.create(team=self.team,
is_shared=True,
last_accessed_at=now())
item_to_cache = Insight.objects.create(
dashboard=dashboard_to_cache,
filters=Filter(data={
"events": [{
"id": "cache this"
}]
}).to_dict(),
team=self.team,
)
dashboard_do_not_cache = Dashboard.objects.create(
team=self.team,
is_shared=True,
last_accessed_at="2020-01-01T12:00:00Z")
item_do_not_cache = Insight.objects.create(
dashboard=dashboard_do_not_cache,
filters=Filter(data={
"events": [{
"id": "do not cache this"
}]
}).to_dict(),
team=self.team,
)
item_key = generate_cache_key(filter.toJSON() + "_" +
str(self.team.pk))
funnel_key = generate_cache_key(filter.toJSON() + "_" +
str(self.team.pk))
update_cached_items()
# pass the caught calls straight to the function
# we do this to skip Redis
for call_item in patch_update_cache_item.call_args_list:
update_cache_item(*call_item[0])
self.assertIsNotNone(Insight.objects.get(pk=item.pk).last_refresh)
self.assertIsNotNone(
Insight.objects.get(pk=item_to_cache.pk).last_refresh)
self.assertIsNotNone(
Insight.objects.get(pk=item_do_not_cache.pk).last_refresh)
self.assertEqual(get_safe_cache(item_key)["result"][0]["count"], 0)
self.assertEqual(get_safe_cache(funnel_key)["result"][0]["count"], 0)
def list(self, request):
return Response(
json.loads(
get_safe_cache("save_query_{}".format(request.user.pk))
or "[]"))