Debugging memory leaks

In Scrapy, objects such as requests, responses and items have a finite lifetime: they are created, used for a while, and finally destroyed.

From all those objects, the Request is probably the one with the longest lifetime, as it stays waiting in the Scheduler queue until it’s time to process it. For more info see Architecture overview.

As these Scrapy objects have a (rather long) lifetime, there is always the risk of accumulating them in memory without releasing them properly and thus causing what is known as a “memory leak”.

To help debugging memory leaks, Scrapy provides a built-in mechanism for tracking objects references called trackref, and you can also use a third-party library called muppy for more advanced memory debugging (see below for more info). Both mechanisms must be used from the Telnet Console.

Common causes of memory leaks

It happens quite often (sometimes by accident, sometimes on purpose) that the Scrapy developer passes objects referenced in Requests (for example, using the cb_kwargs or meta attributes or the request callback function) and that effectively bounds the lifetime of those referenced objects to the lifetime of the Request. This is, by far, the most common cause of memory leaks in Scrapy projects, and a quite difficult one to debug for newcomers.

In big projects, the spiders are typically written by different people and some of those spiders could be “leaking” and thus affecting the rest of the other (well-written) spiders when they get to run concurrently, which, in turn, affects the whole crawling process.

The leak could also come from a custom middleware, pipeline or extension that you have written, if you are not releasing the (previously allocated) resources properly. For example, allocating resources on spider_opened but not releasing them on spider_closed may cause problems if you’re running multiple spiders per process.

Too Many Requests?

By default Scrapy keeps the request queue in memory; it includes Request objects and all objects referenced in Request attributes (e.g. in cb_kwargs and meta). While not necessarily a leak, this can take a lot of memory. Enabling persistent job queue could help keeping memory usage in control.

Debugging memory leaks with trackref

trackref is a module provided by Scrapy to debug the most common cases of memory leaks. It basically tracks the references to all live Request, Response, Item, Spider and Selector objects.

You can enter the telnet console and inspect how many objects (of the classes mentioned above) are currently alive using the prefs() function which is an alias to the print_live_refs() function:

  1. telnet localhost 6023
  2. >>> prefs()
  3. LiveReferences
  4. ExampleSpider1 oldest:15s ago
  5. HtmlResponse10 oldest:1s ago
  6. Selector2 oldest:0s ago
  7. FormRequest878 oldest:7s ago

As you can see, that report also shows the “age” of the oldest object in each class. If you’re running multiple spiders per process chances are you can figure out which spider is leaking by looking at the oldest request or response. You can get the oldest object of each class using the get_oldest() function (from the telnet console).

Which objects are tracked?

The objects tracked by trackrefs are all from these classes (and all its subclasses):

A real example

Let’s see a concrete example of a hypothetical case of memory leaks. Suppose we have some spider with a line similar to this one:

  1. returnRequest(f"http://www.somenastyspider.com/product.php?pid={product_id}",
  2. callback=self.parse, cb_kwargs={'referer': response})

That line is passing a response reference inside a request which effectively ties the response lifetime to the requests’ one, and that would definitely cause memory leaks.

Let’s see how we can discover the cause (without knowing it a priori, of course) by using the trackref tool.

After the crawler is running for a few minutes and we notice its memory usage has grown a lot, we can enter its telnet console and check the live references:

  1. >>> prefs()
  2. LiveReferences
  3. SomenastySpider1 oldest:15s ago
  4. HtmlResponse3890 oldest:265s ago
  5. Selector2 oldest:0s ago
  6. Request3878 oldest:250s ago

The fact that there are so many live responses (and that they’re so old) is definitely suspicious, as responses should have a relatively short lifetime compared to Requests. The number of responses is similar to the number of requests, so it looks like they are tied in a some way. We can now go and check the code of the spider to discover the nasty line that is generating the leaks (passing response references inside requests).

Sometimes extra information about live objects can be helpful. Let’s check the oldest response:

  1. >>>from scrapy.utils.trackref import get_oldest
  2. >>> r = get_oldest('HtmlResponse')
  3. >>> r.url
  4. 'http://www.somenastyspider.com/product.php?pid=123'

If you want to iterate over all objects, instead of getting the oldest one, you can use the scrapy.utils.trackref.iter_all() function:

  1. >>>from scrapy.utils.trackref import iter_all
  2. >>>[r.url for r in iter_all('HtmlResponse')]
  3. ['http://www.somenastyspider.com/product.php?pid=123',
  4. 'http://www.somenastyspider.com/product.php?pid=584',
  5. ...]

Too many spiders?

If your project has too many spiders executed in parallel, the output of prefs() can be difficult to read. For this reason, that function has a ignore argument which can be used to ignore a particular class (and all its subclases). For example, this won’t show any live references to spiders:

  1. >>>from scrapy.spiders importSpider
  2. >>> prefs(ignore=Spider)

scrapy.utils.trackref module

Here are the functions available in the trackref module.

classscrapy.utils.trackref.``object_ref[source]

Inherit from this class if you want to track live instances with the trackref module.

scrapy.utils.trackref.``print_live_refs(class_name, ignore=NoneType)[source]

Print a report of live references, grouped by class name.

  • Parameters

    ignore (typeortuple) – if given, all objects from the specified class (or tuple of classes) will be ignored.

scrapy.utils.trackref.``get_oldest(class_name)[source]

Return the oldest object alive with the given class name, or None if none is found. Use print_live_refs() first to get a list of all tracked live objects per class name.

scrapy.utils.trackref.``iter_all(class_name)[source]

Return an iterator over all objects alive with the given class name, or None if none is found. Use print_live_refs() first to get a list of all tracked live objects per class name.

Debugging memory leaks with muppy

trackref provides a very convenient mechanism for tracking down memory leaks, but it only keeps track of the objects that are more likely to cause memory leaks. However, there are other cases where the memory leaks could come from other (more or less obscure) objects. If this is your case, and you can’t find your leaks using trackref, you still have another resource: the muppy library.

You can use muppy from Pympler.

If you use pip, you can install muppy with the following command:

  1. pip install Pympler

Here’s an example to view all Python objects available in the heap using muppy:

  1. >>>from pympler import muppy
  2. >>> all_objects = muppy.get_objects()
  3. >>> len(all_objects)
  4. 28667
  5. >>>from pympler import summary
  6. >>> suml = summary.summarize(all_objects)
  7. >>> summary.print_(suml)
  8. types |# objects | total size
  9. ====================================|===========|============
  10. <class'str | 9822 | 1.10 MB
  11. <class 'dict |1658|856.62 KB
  12. <class'type | 436 | 443.60 KB
  13. <class 'code |2974|419.56 KB
  14. <class'_io.BufferedWriter | 2 | 256.34 KB
  15. <class 'set|420|159.88 KB
  16. <class'_io.BufferedReader | 1 | 128.17 KB
  17. <class 'wrapper_descriptor |1130|88.28 KB
  18. <class'tuple | 1304 | 86.57 KB
  19. <class 'weakref |1013|79.14 KB
  20. <class'builtin_function_or_method | 958 | 67.36 KB
  21. <class 'method_descriptor |865|60.82 KB
  22. <class'abc.ABCMeta | 62 | 59.96 KB
  23. <class 'list |446|58.52 KB
  24. <class'int | 1425 | 43.20 KB

For more info about muppy, refer to the muppy documentation.

Leaks without leaks

Sometimes, you may notice that the memory usage of your Scrapy process will only increase, but never decrease. Unfortunately, this could happen even though neither Scrapy nor your project are leaking memory. This is due to a (not so well) known problem of Python, which may not return released memory to the operating system in some cases. For more information on this issue see:

The improvements proposed by Evan Jones, which are detailed in this paper, got merged in Python 2.5, but this only reduces the problem, it doesn’t fix it completely. To quote the paper:

Unfortunately, this patch can only free an arena if there are no more objects allocated in it anymore. This means that fragmentation is a large issue. An application could have many megabytes of free memory, scattered throughout all the arenas, but it will be unable to free any of it. This is a problem experienced by all memory allocators. The only way to solve it is to move to a compacting garbage collector, which is able to move objects in memory. This would require significant changes to the Python interpreter.

To keep memory consumption reasonable you can split the job into several smaller jobs or enable persistent job queue and stop/start spider from time to time.