Make error handling callbacks more useful: full exception info is

now available.
log() not accepts attachment= argument to be file contents. In this case
name and mime are being set automatically.
Updated README.md to reflect recent changes.

Author: frizzby

README.md

@@ -33,13 +33,11 @@ Basic usage example:
 ```python
 import os
 import subprocess
-from time import time
+import traceback
 from mimetypes import guess_type
+from time import time
 
-from reportportal_client import (ReportPortalService,
-                                 FinishExecutionRQ,
-                                 StartLaunchRQ, StartTestItemRQ,
-                                 FinishTestItemRQ, SaveLogRQ)
+from reportportal_client import ReportPortalServiceAsync
 
 
 def timestamp():
@@ -53,73 +51,75 @@ token = "1adf271d-505f-44a8-ad71-0afbdf8c83bd"
 launch_name = "Test launch"
 launch_doc = "Testing logging with attachment."
 
-service = ReportPortalService(endpoint=endpoint, project=project, token=token)
 
-# Create start launch request.
-sl_rq = StartLaunchRQ(name=launch_name,
-                      start_time=timestamp(),
-                      description=launch_doc)
+def my_error_handler(exc_info):
+    """
+    This callback function will be called by async service client when error occurs.
+    Return True if error is not critical and you want to continue work.
+    :param exc_info: result of sys.exc_info() -> (type, value, traceback)
+    :return: 
+    """
+    print("Error occured: {}".format(exc_info[1]))
+    traceback.print_exception(*exc_info)
 
-# Start launch.
-launch = service.start_launch(sl_rq)
 
-# Create start test item request.
-sti_rq = StartTestItemRQ(name="Test Case",
-                         description="First Test Case",
-                         tags=["Image", "Smoke"],
-                         start_time=timestamp(),
-                         launch_id=launch.id,
-                         type="TEST")
+service = ReportPortalServiceAsync(endpoint=endpoint, project=project,
+                                   token=token, error_handler=my_error_handler)
+
+# Start launch.
+launch = service.start_launch(name=launch_name,
+                              start_time=timestamp(),
+                              description=launch_doc)
 
 # Start test item.
-test = service.start_test_item(parent_item_id=None, start_test_item_rq=sti_rq)
+test = service.start_test_item(name="Test Case",
+                               description="First Test Case",
+                               tags=["Image", "Smoke"],
+                               start_time=timestamp(),
+                               item_type="TEST")
 
 # Create text log message with INFO level.
-service.log(SaveLogRQ(item_id=test.id,
-                      time=timestamp(),
-                      message="Hello World!",
-                      level="INFO"))
+service.log(time=timestamp(),
+            message="Hello World!",
+            level="INFO")
 
 # Create log message with attached text output and WARN level.
-service.attach(SaveLogRQ(item_id=test.id,
-                         time=timestamp(),
-                         message="Too high memory usage!",
-                         level="WARN"),
-               name="free_memory.txt",
-               data=subprocess.check_output("free -h".split()))
-
-# Create log message with piped binary file, INFO level and custom mimetype.
+service.log(time=timestamp(),
+            message="Too high memory usage!",
+            level="WARN",
+            attachment={
+                "name": "free_memory.txt",
+                "data": subprocess.check_output("ps".split()),
+                "mime": "text/plain"
+            })
+
+# Create log message with binary file, INFO level and custom mimetype.
 image = "/tmp/image.png"
-sl_rq = SaveLogRQ(test.id, timestamp(), "Screen shot of issue.", "INFO")
 with open(image, "rb") as fh:
-    service.attach(save_log_rq=sl_rq,
-                   name=os.path.basename(image),
-                   data=fh,
-                   mime=guess_type(image)[0] or "application/octet-stream")
-
-# Create log message with binary data and INFO level.
-filebin = "/tmp/file.bin"
-with open(filebin, "rb") as fd:
-    bindata = fd.read()
-# Note here that we pass binary data instead of file handle.
-service.attach(SaveLogRQ(item_id=test.id,
-                         time=timestamp(),
-                         message="Binary data file.",
-                         level="INFO"),
-               name="file.bin",
-               data=bindata,
-               mime="application/octet-stream")
-
-# Create finish test item request.
-fti_rq = FinishTestItemRQ(end_time=timestamp(), status="PASSED")
+    attachment = {
+        "name": os.path.basename(image),
+        "data": fh.read(),
+        "mime": guess_type(image)[0] or "application/octet-stream"
+    }
+    service.log(timestamp(), "Screen shot of issue.", "INFO", attachment)
+
+# Create log message supplying only contents
+service.log(
+    timestamp(),
+    "running processes",
+    "INFO",
+    attachment=subprocess.check_output("ps aux".split()))
 
 # Finish test item.
-service.finish_test_item(item_id=test.id, finish_test_item_rq=fti_rq)
+service.finish_test_item(end_time=timestamp(), status="PASSED")
 
-# Create finish launch request.
-fl_rq = FinishExecutionRQ(end_time=timestamp(), status="PASSED")
 # Finish launch.
-service.finish_launch(launch.id, fl_rq)
+service.finish_launch(end_time=timestamp())
+
+# Due to async nature of the service we need to call terminate() method which
+# ensures all pending requests to server are proccessed.
+# Failure to call terminate() may result in lost data.
+service.terminate()
 ```
 
 

reportportal_client/service.py

@@ -1,5 +1,6 @@
 import json
 import requests
+import uuid
 from logging import getLogger
 
 from .errors import ResponseError, EntryCreatedError, OperationCompletionError
@@ -212,19 +213,29 @@ def log_batch(self, log_data):
         for log_item in log_data:
             log_item["item_id"] = self.stack[-1]
             attachment = log_item.get("attachment", None)
-            del log_item["attachment"]
+
+            if "attachment" in log_item:
+                del log_item["attachment"]
 
             if attachment:
-                log_item["file"] = {"name": attachment["name"]}
+                if not isinstance(attachment, dict):
+                    attachment = {"data": attachment}
+
+                name = attachment.get("name", str(uuid.uuid4()))
+                log_item["file"] = {"name": name}
                 attachments.append(("file", (
-                    attachment["name"],
+                    name,
                     attachment["data"],
-                    attachment["mime"]
+                    attachment.get("mime", "application/octet-stream")
                 )))
 
-        files = [
-            ("json_request_part", (None, json.dumps(log_data), "application/json")),
-        ]
+        files = [(
+            "json_request_part", (
+                None,
+                json.dumps(log_data),
+                "application/json"
+            )
+        )]
         files.extend(attachments)
         r = self.session.post(url=url, files=files)
         logger.debug("log_batch - Stack: %s", self.stack)

reportportal_client/service_async.py

@@ -1,5 +1,6 @@
-from logging import getLogger
+import sys
 import threading
+from logging import getLogger
 
 from six.moves import queue
 
@@ -158,7 +159,7 @@ def terminate(self, nowait=False):
                 self._post_log_batch()
         except Exception as err:
             if self.error_handler:
-                self.error_handler(err)
+                self.error_handler(sys.exc_info())
             else:
                 raise
         finally:
@@ -168,8 +169,10 @@ def terminate(self, nowait=False):
     def _post_log_batch(self):
         logger.debug("Posting log batch size: %s", len(self.log_batch))
         if self.log_batch:
-            self.rp_client.log_batch(self.log_batch)
-            self.log_batch = []
+            try:
+                self.rp_client.log_batch(self.log_batch)
+            finally:
+                self.log_batch = []
 
     def process_log(self, **log_item):
         """
@@ -200,7 +203,7 @@ def process_item(self, item):
                 getattr(self.rp_client, method)(**kwargs)
         except Exception as err:
             if self.error_handler:
-                if not self.error_handler(err):
+                if not self.error_handler(sys.exc_info()):
                     self.terminate(nowait=True)
             else:
                 self.terminate(nowait=True)