mirror of
https://github.com/zulip/zulip.git
synced 2025-11-05 22:43:42 +00:00
97840da0d2
After this change, the memcached time consumed by doing get_old_messages for 200 and 1000 messages respectively now look like this: 200 63ms (mem: 6ms/3) (db: 4ms/2q) /json/get_old_messages 200 178ms (mem: 67ms/2) (db: 6ms/1q) /json/get_old_messages which might help explain where the time is going on prod for some of our slower queries. (imported from commit b8fe83b175914b6796922a65a1c5537f4e7a9429)
139 lines
4.3 KiB
Python
139 lines
4.3 KiB
Python
from __future__ import absolute_import
|
|
|
|
from functools import wraps
|
|
|
|
from django.core.cache import cache as djcache
|
|
from django.core.cache import get_cache
|
|
|
|
from zephyr.lib.utils import statsd, statsd_key, make_safe_digest
|
|
import time
|
|
|
|
memcached_time_start = 0
|
|
memcached_total_time = 0
|
|
memcached_total_requests = 0
|
|
|
|
def get_memcached_time():
|
|
return memcached_total_time
|
|
|
|
def get_memcached_requests():
|
|
return memcached_total_requests
|
|
|
|
def memcached_stats_start():
|
|
global memcached_time_start
|
|
memcached_time_start = time.time()
|
|
|
|
def memcached_stats_finish():
|
|
global memcached_total_time
|
|
global memcached_total_requests
|
|
global memcached_time_start
|
|
memcached_total_requests += 1
|
|
memcached_total_time += (time.time() - memcached_time_start)
|
|
|
|
def cache_with_key(keyfunc, cache_name=None, timeout=None):
|
|
"""Decorator which applies Django caching to a function.
|
|
|
|
Decorator argument is a function which computes a cache key
|
|
from the original function's arguments. You are responsible
|
|
for avoiding collisions with other uses of this decorator or
|
|
other uses of caching."""
|
|
|
|
def decorator(func):
|
|
@wraps(func)
|
|
def func_with_caching(*args, **kwargs):
|
|
key = keyfunc(*args, **kwargs)
|
|
|
|
memcached_stats_start()
|
|
if cache_name is None:
|
|
cache_backend = djcache
|
|
else:
|
|
cache_backend = get_cache(cache_name)
|
|
|
|
val = cache_backend.get(key)
|
|
memcached_stats_finish()
|
|
|
|
if val is not None:
|
|
statsd.incr("cache.%s.hit" % (statsd_key(key),))
|
|
else:
|
|
statsd.incr("cache.%s.miss" % (statsd_key(key),))
|
|
|
|
# Values are singleton tuples so that we can distinguish
|
|
# a result of None from a missing key.
|
|
if val is not None:
|
|
return val[0]
|
|
|
|
val = func(*args, **kwargs)
|
|
|
|
memcached_stats_start()
|
|
cache_backend.set(key, (val,), timeout=timeout)
|
|
memcached_stats_finish()
|
|
|
|
return val
|
|
|
|
return func_with_caching
|
|
|
|
return decorator
|
|
|
|
def cache_get_many(keys, cache_name=None):
|
|
memcached_stats_start()
|
|
if cache_name is None:
|
|
cache_backend = djcache
|
|
else:
|
|
cache_backend = get_cache(cache_name)
|
|
ret = cache_backend.get_many(keys)
|
|
memcached_stats_finish()
|
|
return ret
|
|
|
|
def cache_set_many(items, cache_name=None):
|
|
memcached_stats_start()
|
|
if cache_name is None:
|
|
cache_backend = djcache
|
|
else:
|
|
cache_backend = get_cache(cache_name)
|
|
ret = cache_backend.set_many(items)
|
|
memcached_stats_finish()
|
|
return ret
|
|
|
|
def cache(func):
|
|
"""Decorator which applies Django caching to a function.
|
|
|
|
Uses a key based on the function's name, filename, and
|
|
the repr() of its arguments."""
|
|
|
|
func_uniqifier = '%s-%s' % (func.func_code.co_filename, func.func_name)
|
|
|
|
@wraps(func)
|
|
def keyfunc(*args, **kwargs):
|
|
# Django complains about spaces because memcached rejects them
|
|
key = func_uniqifier + repr((args, kwargs))
|
|
return key.replace('-','--').replace(' ','-s')
|
|
|
|
return cache_with_key(keyfunc)(func)
|
|
|
|
def message_cache_key(message_id):
|
|
return "message:%d" % (message_id,)
|
|
|
|
def user_profile_by_email_cache_key(email):
|
|
# See the comment in zephyr/lib/avatar.py:gravatar_hash for why we
|
|
# are proactively encoding email addresses even though they will
|
|
# with high likelihood be ASCII-only for the foreseeable future.
|
|
return 'user_profile_by_email:%s' % (make_safe_digest(email),)
|
|
|
|
def user_profile_by_id_cache_key(user_profile_id):
|
|
return "user_profile_by_id:%s" % (user_profile_id,)
|
|
|
|
# Called by models.py to flush the user_profile cache whenever we save
|
|
# a user_profile object
|
|
def update_user_profile_cache(sender, **kwargs):
|
|
user_profile = kwargs['instance']
|
|
items_for_memcached = {}
|
|
items_for_memcached[user_profile_by_email_cache_key(user_profile.email)] = (user_profile,)
|
|
items_for_memcached[user_profile_by_id_cache_key(user_profile.id)] = (user_profile,)
|
|
djcache.set_many(items_for_memcached)
|
|
|
|
def status_dict_cache_key(user_profile):
|
|
return "status_dict:%d" % (user_profile.realm_id,)
|
|
|
|
def update_user_presence_cache(sender, **kwargs):
|
|
user_profile = kwargs['instance'].user_profile
|
|
djcache.delete(status_dict_cache_key(user_profile))
|