Skip to main content

Django: Using Caching to Track Online Users

Recently I wanted a simple solution to track whether a user is online on a given Django site.  The definition of "online" on a site is kind of ambiguous, so I'll define that a user is considered to be online if they have made any request to the site in the last five minutes.

I found that one approach is to use Django's caching framework to track when a user last accessed the site.  For example, upon each request, I can have a middleware set the current time as a cache value associated with a given user.  This allows us to store some basic information about logged-in user's online state without having to hit the database on each request and easily retrieve it by accessing the cache.

My approach below.  Comments welcome.

In settings.py:
# add the middleware that you are about to create to settings
MIDDLEWARE_CLASSES = (
    ....
    'middleware.activeuser_middleware.ActiveUserMiddleware',
    ....
)

# Setup caching per Django docs. In actuality, you'd probably use memcached instead of local memory.
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'default-cache'
    }
}

# Number of seconds of inactivity before a user is marked offline
USER_ONLINE_TIMEOUT = 300

# Number of seconds that we will keep track of inactive users for before 
# their last seen is removed from the cache
USER_LASTSEEN_TIMEOUT = 60 * 60 * 24 * 7

In activeuser_middleware.py:
import datetime
from django.core.cache import cache
from django.conf import settings

class ActiveUserMiddleware:

    def process_request(self, request):
        current_user = request.user
        if request.user.is_authenticated():
            now = datetime.datetime.now()
            cache.set('seen_%s' % (current_user.username), now, 
                           settings.USER_LASTSEEN_TIMEOUT)

In your UserProfile module or some other model associated with the user:
class UserProfile(models.Model):
    ....
    ....

    def last_seen(self):
        return cache.get('seen_%s' % self.user.username)

    def online(self):
        if self.last_seen():
            now = datetime.datetime.now()
            if now > self.last_seen() + datetime.timedelta(
                         seconds=settings.USER_ONLINE_TIMEOUT):
                return False
            else:
                return True
        else:
            return False

Then in the template where you want to display whether the user is online or not:
{% with request.user.get_profile as profile %}

 <table>
   <tr><th>Last Seen</th><td>{% if profile.last_seen %}{{ profile.last_seen|timesince }}{% else %}awhile{% endif %} ago</td></tr>
   <tr><th>Online</th><td>{{ profile.online }}</td></tr>
 </table>

{% endwith %}

Pros:
 - Simple solution
 - Doesn't need to hit the database for saving the timestamp each request

Cons:
  - Last user access times are cleared if the server is rebooted or cache is reset
  - Last user access times are accessible only as long as they exist in the cache.

Comments

  1. there is a typo in the title ;)

    ReplyDelete
  2. There is also a gist from Eric Florenzano https://gist.github.com/268379 which uses similar approach, but stores list of user ids under one key.

    ReplyDelete
  3. Redis is a really good fit for this type of data due to supporting data structures. A sorted set of user ids by last seen time does the trick for this scenario.

    This is how I did it in my forum app using Redis, including tracking of where in the app a user was last seen for display on their profile page:

    https://github.com/insin/forum/blob/master/forum/redis_connection.py#L69-96

    ReplyDelete
  4. Typo fixed :-) Thanks for the other approaches. I noticed that a limitation of my approach above is that there is currently no easy way to obtain a full list of users.

    ReplyDelete
  5. I thought about about the same technique and put it in practice recently.
    The difference is that it seems to combine your technique and Eric Florenzano's one : I have a set of keys, one per user, with the last access, and another key, which is a list of online users.
    Offline users are deleted from the list when needed.

    ReplyDelete
  6. Joe - Looking to speak to you. I came across your website here and would like to talk to you about this Python/Django role in Lake Success, NY I'm currently working on. When would be a good time to talk?

    Jason

    ReplyDelete
  7. i got an error, running the project....
    ImproperlyConfigured: Error importing middleware middleware.activeuser_middleware: "No module named middleware.activeuser_middleware"

    ReplyDelete
  8. Good tutorial!
    How about if I want to track who's viewed my user profile on django just like on LinkedIn?

    ReplyDelete
    Replies
    1. write a decorator around view function which render your user profile or user detail and track who wants to see this page. and your request has the current user surely

      Delete
  9. mw_instance = middleware(handler)
    TypeError: ActiveUserMiddleware() takes no arguments

    ReplyDelete

Post a Comment

Popular posts from this blog

Django Models Mixins

One thing I've been experimenting with is model Mixins.  For example, the aim is to create small abstract classes that are each focused around a particular function.  These abstract classes can then be added to arbitrary models to apply those functions to models as desired.

For example, say I define a RatingsFields abstract class and a TrackingFields abstract class.  These abstract classes can be mixed into any other model that we wish to add rating or tracking functionality to.

core/mixins.py
from djangoratings.fields import RatingField # 3rd party moduleclass RatingFields(models.Model): rating = RatingField(range=5) # 5 possible rating values, 1-5 class Meta: abstract = Trueclass TrackingFields(models.Model): deleted_on = models.DateTimeField(blank=True, null=True) created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) class Meta: abstract = True
Since we applied the abstract classes to the Post …

Django Admin Override Save for Model

Sometimes it's nice to be able to add custom code to the save method of objects in the Django Admin.  So, when editing an object on the Admin object detail page (change form), adding the following method override to your ModelAdmin in admin.py will allow you to add custom code to the save function.

In admin.py:  
class MyModelAdmin(admin.ModelAdmin): def save_model(self, request, obj, form, change): # custom stuff here obj.save()
This is documented in the Django Docs, but I found it particularly useful.