retry stats

scrapy/downloadermiddlewares/retry.py

@@ -22,6 +22,7 @@ from twisted.web.client import ResponseFailed
 from scrapy.exceptions import NotConfigured
 from scrapy.utils.response import response_status_message
 from scrapy.core.downloader.handlers.http11 import TunnelError
+from scrapy.utils.python import global_object_name
 
 logger = logging.getLogger(__name__)
 
@@ -35,16 +36,18 @@ class RetryMiddleware(object):
                            ConnectionLost, TCPTimedOutError, ResponseFailed,
                            IOError, TunnelError)
 
-    def __init__(self, settings):
+    def __init__(self, crawler):
+        settings = crawler.settings
         if not settings.getbool('RETRY_ENABLED'):
             raise NotConfigured
         self.max_retry_times = settings.getint('RETRY_TIMES')
         self.retry_http_codes = set(int(x) for x in settings.getlist('RETRY_HTTP_CODES'))
         self.priority_adjust = settings.getint('RETRY_PRIORITY_ADJUST')
+        self.stats = crawler.stats
 
     @classmethod
     def from_crawler(cls, crawler):
-        return cls(crawler.settings)
+        return cls(crawler)
 
     def process_response(self, request, response, spider):
         if request.meta.get('dont_retry', False):
@@ -70,8 +73,15 @@ class RetryMiddleware(object):
             retryreq.meta['retry_times'] = retries
             retryreq.dont_filter = True
             retryreq.priority = request.priority + self.priority_adjust
+
+            if isinstance(reason, Exception):
+                reason = global_object_name(reason.__class__)
+
+            self.stats.inc_value('retry/count')
+            self.stats.inc_value('retry/reason_count/%s' % reason)
             return retryreq
         else:
+            self.stats.inc_value('retry/max_reached')
             logger.debug("Gave up retrying %(request)s (failed %(retries)d times): %(reason)s",
                          {'request': request, 'retries': retries, 'reason': reason},
                          extra={'spider': spider})

scrapy/downloadermiddlewares/stats.py

@@ -1,6 +1,8 @@
 from scrapy.exceptions import NotConfigured
 from scrapy.utils.request import request_httprepr
 from scrapy.utils.response import response_httprepr
+from scrapy.utils.python import global_object_name
+
 
 class DownloaderStats(object):
 
@@ -27,6 +29,6 @@ class DownloaderStats(object):
         return response
 
     def process_exception(self, request, exception, spider):
-        ex_class = "%s.%s" % (exception.__class__.__module__, exception.__class__.__name__)
+        ex_class = global_object_name(exception.__class__)
         self.stats.inc_value('downloader/exception_count', spider=spider)
         self.stats.inc_value('downloader/exception_type_count/%s' % ex_class, spider=spider)

scrapy/utils/misc.py

@@ -113,7 +113,7 @@ def md5sum(file):
         m.update(d)
     return m.hexdigest()
 
+
 def rel_has_nofollow(rel):
     """Return True if link rel attribute has nofollow type"""
     return True if rel is not None and 'nofollow' in rel.split() else False
-    

scrapy/utils/python.py

@@ -344,3 +344,14 @@ def without_none_values(iterable):
         return {k: v for k, v in six.iteritems(iterable) if v is not None}
     except AttributeError:
         return type(iterable)((v for v in iterable if v is not None))
+
+
+def global_object_name(obj):
+    """
+    Return full name of a global object.
+
+    >>> from scrapy import Request
+    >>> global_object_name(Request)
+    'scrapy.http.request.Request'
+    """
+    return "%s.%s" % (obj.__module__, obj.__name__)

scrapy/utils/response.py

@@ -43,7 +43,8 @@ def get_meta_refresh(response):
 def response_status_message(status):
     """Return status code plus status text descriptive message
     """
-    return '%s %s' % (status, to_native_str(http.RESPONSES.get(int(status), "Unknown Status")))
+    message = http.RESPONSES.get(int(status), "Unknown Status")
+    return '%s %s' % (status, to_native_str(message))
 
 
 def response_httprepr(response):

tests/test_downloadermiddleware_retry.py

@@ -13,9 +13,9 @@ from scrapy.utils.test import get_crawler
 
 class RetryTest(unittest.TestCase):
     def setUp(self):
-        crawler = get_crawler(Spider)
-        self.spider = crawler._create_spider('foo')
-        self.mw = RetryMiddleware.from_crawler(crawler)
+        self.crawler = get_crawler(Spider)
+        self.spider = self.crawler._create_spider('foo')
+        self.mw = RetryMiddleware.from_crawler(self.crawler)
         self.mw.max_retry_times = 2
 
     def test_priority_adjust(self):
@@ -70,6 +70,10 @@ class RetryTest(unittest.TestCase):
         # discard it
         assert self.mw.process_response(req, rsp, self.spider) is rsp
 
+        assert self.crawler.stats.get_value('retry/max_reached') == 1
+        assert self.crawler.stats.get_value('retry/reason_count/503 Service Unavailable') == 2
+        assert self.crawler.stats.get_value('retry/count') == 2
+
     def test_twistederrors(self):
         exceptions = [defer.TimeoutError, TCPTimedOutError, TimeoutError,
                 DNSLookupError, ConnectionRefusedError, ConnectionDone,
@@ -79,6 +83,11 @@ class RetryTest(unittest.TestCase):
             req = Request('http://www.scrapytest.org/%s' % exc.__name__)
             self._test_retry_exception(req, exc('foo'))
 
+        stats = self.crawler.stats
+        assert stats.get_value('retry/max_reached') == len(exceptions)
+        assert stats.get_value('retry/count') == len(exceptions) * 2
+        assert stats.get_value('retry/reason_count/twisted.internet.defer.TimeoutError') == 2
+
     def _test_retry_exception(self, req, exception):
         # first retry
         req = self.mw.process_exception(req, exception, self.spider)

tests/test_proxy_connect.py

@@ -101,7 +101,9 @@ class ProxyConnectTestCase(TestCase):
         self._assert_got_response_code(407, l)
 
     def _assert_got_response_code(self, code, log):
+        print(log)
         self.assertEqual(str(log).count('Crawled (%d)' % code), 1)
 
     def _assert_got_tunnel_error(self, log):
-        self.assertEqual(str(log).count('TunnelError'), 1)
+        print(log)
+        self.assertIn('TunnelError', str(log))