Skip to main content

Keep detailed records of the performance of your Django code.

Project description

“Keep detailed records of the performance of your Django code.”

django-perf-rec is like Django’s assertNumQueries on steroids. It lets you track the individual queries and cache operations that occur in your code. Use it in your tests like so:

def test_home(self):
    with django_perf_rec.record():

It then stores a YAML file alongside the test file that tracks the queries and operations, looking something like:

- cache|get: home_data.user_id.#
- db: 'SELECT ... FROM myapp_table WHERE ( = #)'
- db: 'SELECT ... FROM myapp_table WHERE ( = #)'

When the test is run again, the new record will be compared with the one in the YAML file. If they are different, an assertion failure will be raised, failing the test. Magic!

The queries and keys are ‘fingerprinted’, replacing information that seems variable with # and . This is done to avoid spurious failures when e.g. primary keys are different, random data is used, new columns are added to tables, etc.

If you check the YAML file in along with your tests, you’ll have unbreakable performance with much better information about any regressions compared to assertNumQueries. If you are fine with the changes from a failing test, just remove the file and rerun the test to regenerate it.

For more information, see our introductory blog post that says a little more about why we made it.


Use pip:

pip install django-perf-rec


Tested with all combinations of:

  • Python: 2.7, 3.6
  • Django: 1.8, 1.9, 1.10, 1.11, 2.0

N.B. When using Django 1.8 and SQLite the queries won’t be rendered in SQL, but a format like ‘QUERY = … PARAMS = …’. You can workaround this by backporting the query rendering code from Django 1.9 as django-perf-rec’s test suite does.


record(record_name=None, path=None)

Return a context manager that will be used for a single performance test.

The arguments must be passed as keyword arguments.

path is the path to a directory or file in which to store the record. If it ends with '/', or is left as None, the filename will be automatically determined by looking at the filename the calling code is in and replacing the .py[c] extension with .perf.yml. If it points to a directory that doesn’t exist, that directory will be created.

record_name is the name of the record inside the performance file to use. If left as None, the code assumes you are inside a Django TestCase and uses magic stack inspection to find that test case, and uses a name based upon the test case name + the test method name + an optional counter if you invoke record() multiple times inside the same test method.

Whilst open, the context manager tracks all DB queries on all connections, and all cache operations on all defined caches. It names the connection/cache in the tracked operation it uses, except from for the default one.

When the context manager exits, it will use the list of operations it has gathered. If the relevant file specified using path doesn’t exist, or doesn’t contain data for the specific record_name, it will be created and saved and the test will pass with no assertions. However if the record does exist inside the file, the collected record will be compared with the original one, and if different, an AssertionError will be raised. When running on pytest, this will use its fancy assertion rewriting; in other test runners/uses the full diff will be attached to the message.


import django_perf_rec

from app.models import Author

class AuthorPerformanceTests(TestCase):

    def test_special_method(self):
        with django_perf_rec.record():


A mixin class to be added to your custom TestCase subclass so you can use django-perf-rec across your codebase without needing to import it in each individual test file. It adds one method, record_performance(), whose signature is the same as record() above.


# yplan/
from django.test import TestCase as OrigTestCase
from django_perf_rec import TestCaseMixin

class TestCase(TestCaseMixin, OrigTestCase):

# app/tests/models/
from app.models import Author
from yplan.test import TestCase

class AuthorPerformanceTests(TestCase):

    def test_special_method(self):
        with self.record_performance():


Encapsulates the logic used in record() to form path from the path of the file containing the currently running test, mostly swapping ‘.py’ or ‘.pyc’ for ‘.perf.yml’. You might want to use this when calling record() from somewhere other than inside a test (which causes the automatic inspection to fail), to match the same filename.

get_record_name(test_name, class_name=None)

Encapsulates the logic used in record() to form a record_name from details of the currently running test. You might want to use this when calling record() from somewhere other than inside a test (which causes the automatic inspection to fail), to match the same record_name.


Behaviour can be customized with a dictionary called PERF_REC in your Django settings, for example:

    'MODE': 'once'

The possible keys to this dictionary are explained below.


The HIDE_COLUMNS setting may be used to change the way django-perf-rec simplifies SQL in the recording files it makes. It takes a boolean:

  • True (default) causes column lists in queries to be collapsed, e.g. SELECT a, b, c FROM t becomes SELECT ... FROM t. This is useful because selected columns often don’t affect query time in typical Django applications, it makes the records easier to read, and they then don’t need updating every time model fields are changed.
  • False stops the collapsing behaviour, causing all the columns to be output in the files.


The MODE setting may be used to change the way django-perf-rec behaves when a performance record does not exist during a test run.

  • 'once' (default) creates missing records silently.
  • 'none' raises AssertionError when a record does not exist. You probably want to use this mode in CI, to ensure new tests fail if their corresponding performance records were not committed.
  • 'all' creates missing records and then raises AssertionError.

Usage in Pytest

If you’re using Pytest, you might want to call record() from within a Pytest fixture and have it automatically apply to all your tests. We have an example of this, see the file in the test suite.


Pending release

3.1.1 (2018-12-03)

  • Fix to actually obey the HIDE_COLUMNS option.

3.1.0 (2018-12-02)

  • Add the HIDE_COLUMNS option in settings to disable replacing column lists with ... in all places.

3.0.0 (2018-07-17)

  • Don’t replace columns in ORDER BY, GROUP BY and HAVING clauses.

2.2.0 (2018-01-24)

  • Use kwargs-only library rather than vendored copy.
  • Erase volatile part of PostgreSQL cursor name.

2.1.0 (2017-05-29)

  • Exposed the automatic naming logic used in record() in two new functions get_perf_path() and get_record_name(), in order to ease creation of test records from calls outside of tests.
  • Made the automatic test detection work when running under a Pytest fixture.
  • Stopped throwing warnings on Python 3.
  • Fixed loading empty performance record files.

2.0.1 (2017-03-02)

  • Make cascaded delete queries deterministic on Django <1.10, with another Patchy patch to make it match the order from 1.10+.

2.0.0 (2017-02-09)

  • Arguments to record must be passed as keyword arguments.
  • file_name is removed as an argument to record following its deprecation in release 1.1.0.

1.1.1 (2016-10-30)

  • Fix django session keys not being fingerprinted.
  • Show diff when records don’t match (when not on pytest).
  • Add new ‘MODE’ setting with three modes. This allows customization of the behaviour for missing performance records. The new 'none' mode is particularly useful for CI servers as it makes tests fail if their corresponding performance records have not been committed.

1.1.0 (2016-10-26)

  • Fix automatic filenames for tests in .pyc files.
  • Add the path argument to record which allows specifying a relative directory or filename to use. This deprecates the file_name argument, which will be removed in a future major release. For more info see the README.

1.0.4 (2016-10-23)

  • Work with sqlparse 0.2.2

1.0.3 (2016-10-07)

  • Stopped installing tests module.

1.0.2 (2016-09-23)

  • Confirmed Django 1.8 and 1.10 support.

1.0.1 (2016-09-20)

  • Fix install_requires in

1.0.0 (2016-09-19)

  • Initial version with record() that can record database queries and cache operations and error if they change between test runs.

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Filename, size & hash SHA256 hash help File type Python version Upload date
django_perf_rec-3.1.1-py2.py3-none-any.whl (17.1 kB) Copy SHA256 hash SHA256 Wheel 2.7
django-perf-rec-3.1.1.tar.gz (25.1 kB) Copy SHA256 hash SHA256 Source None

Supported by

Elastic Elastic Search Pingdom Pingdom Monitoring Google Google BigQuery Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN SignalFx SignalFx Supporter DigiCert DigiCert EV certificate StatusPage StatusPage Status page