Pass successfully sent events through to on_success callback (closes #228)

Author: adatzer

snowplow_tracker/emitters.py

@@ -191,9 +191,15 @@ def http_post(self, data):
         """
         logger.info("Sending POST request to %s..." % self.endpoint)
         logger.debug("Payload: %s" % data)
-        r = requests.post(self.endpoint, data=data, headers={'Content-Type': 'application/json; charset=utf-8'})
-        getattr(logger, "info" if self.is_good_status_code(r.status_code) else "warning")("POST request finished with status code: " + str(r.status_code))
-        return r
+        post_succeeded = False
+        try:
+            r = requests.post(self.endpoint, data=data, headers={'Content-Type': 'application/json; charset=utf-8'})
+            post_succeeded= Emitter.is_good_status_code(r.status_code)
+            getattr(logger, "info" if post_succeeded else "warning")("POST request finished with status code: " + str(r.status_code))
+        except requests.RequestException as e:
+            logger.warning(e)
+
+        return post_succeeded
 
     @contract
     def http_get(self, payload):
@@ -203,9 +209,15 @@ def http_get(self, payload):
         """
         logger.info("Sending GET request to %s..." % self.endpoint)
         logger.debug("Payload: %s" % payload)
-        r = requests.get(self.endpoint, params=payload)
-        getattr(logger, "info" if self.is_good_status_code(r.status_code) else "warning")("GET request finished with status code: " + str(r.status_code))
-        return r
+        get_succeeded = False
+        try:
+            r = requests.get(self.endpoint, params=payload)
+            get_succeeded = Emitter.is_good_status_code(r.status_code)
+            getattr(logger, "info" if get_succeeded else "warning")("GET request finished with status code: " + str(r.status_code))
+        except requests.RequestException as e:
+            logger.warning(e)
+
+        return get_succeeded
 
     def sync_flush(self):
         """
@@ -233,41 +245,33 @@ def send_events(self, evts):
             :type  evts: list(dict(string:*))
         """
         if len(evts) > 0:
-            logger.info("Attempting to send %s requests" % len(evts))
+            logger.info("Attempting to send %s events" % len(evts))
+
             Emitter.attach_sent_timestamp(evts)
+            success_events = []
+            failure_events = []
+
             if self.method == 'post':
                 data = SelfDescribingJson(PAYLOAD_DATA_SCHEMA, evts).to_string()
-                post_succeeded = False
-                try:
-                    status_code = self.http_post(data).status_code
-                    post_succeeded = self.is_good_status_code(status_code)
-                except requests.RequestException as e:
-                    logger.warning(e)
-                if post_succeeded:
-                    if self.on_success is not None:
-                        self.on_success(len(evts))
-                elif self.on_failure is not None:
-                    self.on_failure(0, evts)
+                request_succeeded = self.http_post(data)
+                if request_succeeded:
+                    success_events += evts
+                else:
+                    failure_events += evts
 
             elif self.method == 'get':
-                success_count = 0
-                unsent_requests = []
                 for evt in evts:
-                    get_succeeded = False
-                    try:
-                        status_code = self.http_get(evt).status_code
-                        get_succeeded = self.is_good_status_code(status_code)
-                    except requests.RequestException as e:
-                        logger.warning(e)
-                    if get_succeeded:
-                        success_count += 1
+                    request_succeeded = self.http_get(evt)
+                    if request_succeeded:
+                        success_events += [evt]
                     else:
-                        unsent_requests.append(evt)
-                if len(unsent_requests) == 0:
-                    if self.on_success is not None:
-                        self.on_success(success_count)
-                elif self.on_failure is not None:
-                    self.on_failure(success_count, unsent_requests)
+                        failure_events += [evt]
+
+            if self.on_success is not None and len(success_events) > 0:
+                self.on_success(success_events)
+            if self.on_failure is not None and len(failure_events) > 0:
+                self.on_failure(len(success_events), failure_events)
+
         else:
             logger.info("Skipping flush since buffer is empty")
 

snowplow_tracker/test/integration/test_integration.py

@@ -289,7 +289,13 @@ def test_integration_success_callback(self):
         t = tracker.Tracker([callback_emitter], default_subject)
         with HTTMock(pass_response_content):
             t.track_page_view("http://www.example.com")
-        self.assertEqual(callback_success_queue[0], 1)
+        expected = {
+            "e": "pv",
+            "url": "http://www.example.com",
+        }
+        self.assertEqual(len(callback_success_queue), 1)
+        for k in expected.keys():
+            self.assertEqual(callback_success_queue[0][0][k], expected[k])
         self.assertEqual(callback_failure_queue, [])
 
     def test_integration_failure_callback(self):

snowplow_tracker/test/unit/test_emitters.py

@@ -39,15 +39,11 @@ def mocked_flush(*args):
 def mocked_send_events(*args):
     pass
 
-class MockRequest():
-    def __init__(self, code):
-        self.status_code = code
-
 def mocked_http_success(*args):
-    return MockRequest(200)
+    return True
 
 def mocked_http_failure(*args):
-    return MockRequest(404)
+    return False
 
 
 class TestEmitters(unittest.TestCase):
@@ -229,7 +225,7 @@ def test_send_events_get_success(self, mok_http_get):
 
         evBuffer = [{"a":"aa"}, {"b": "bb"}, {"c": "cc"}]
         e.send_events(evBuffer)
-        mok_success.assert_called_once_with(3)
+        mok_success.assert_called_once_with(evBuffer)
         mok_failure.assert_not_called()
 
     @mock.patch('snowplow_tracker.Emitter.http_get')
@@ -255,7 +251,7 @@ def test_send_events_post_success(self, mok_http_post):
 
         evBuffer = [{"a":"aa"}, {"b": "bb"}, {"c": "cc"}]
         e.send_events(evBuffer)
-        mok_success.assert_called_once_with(3)
+        mok_success.assert_called_once_with(evBuffer)
         mok_failure.assert_not_called()
 
     @mock.patch('snowplow_tracker.Emitter.http_post')
@@ -318,7 +314,7 @@ def test_async_send_events_get_success(self, mok_http_get):
 
         evBuffer = [{"a":"aa"}, {"b": "bb"}, {"c": "cc"}]
         ae.send_events(evBuffer)
-        mok_success.assert_called_once_with(3)
+        mok_success.assert_called_once_with(evBuffer)
         mok_failure.assert_not_called()
 
     @mock.patch('snowplow_tracker.Emitter.http_get')
@@ -344,7 +340,7 @@ def test_async_send_events_post_success(self, mok_http_post):
 
         evBuffer = [{"a":"aa"}, {"b": "bb"}, {"c": "cc"}]
         ae.send_events(evBuffer)
-        mok_success.assert_called_once_with(3)
+        mok_success.assert_called_once_with(evBuffer)
         mok_failure.assert_not_called()
 
     @mock.patch('snowplow_tracker.Emitter.http_post')