Merge pull request #320 from dagansandler/add_support_for_thread_logs

Add support for thread logs

Author: HardNorth

README.rst

@@ -113,6 +113,7 @@ The following parameters are optional:
 - :code:`rp_issue_id_marks = True` - Enables adding marks for issue ids (e.g. "issue:123456")
 - :code:`rp_verify_ssl = True` - Verify SSL when connecting to the server
 - :code:`rp_mode = DEFAULT` - DEBUG or DEFAULT launch mode. DEBUG launches are displayed in a separate tab and not visible to anyone except owner
+- :code:`rp_thread_logging` - EXPERIMENTAL - Enables support for reporting logs from threads by patching the builtin Thread class. Use with caution.
 
 
 If you like to override the above parameters from command line, or from CI environment based on your build, then pass

examples/threads/__init__.py

@@ -0,0 +1,19 @@
+import logging
+import threading
+
+from reportportal_client.steps import step
+
+log = logging.getLogger(__name__)
+
+
+def worker():
+    log.info("TEST_INFO")
+    log.debug("TEST_DEBUG")
+
+
+def test_log():
+    t = threading.Thread(target=worker)
+    log.info("TEST_BEFORE_THREADING")
+    with step("Some nesting where the thread logs should go"):
+        t.start()
+    t.join()

examples/threads/test_thread_logging.py

@@ -60,6 +60,9 @@ def __init__(self, pytest_config):
         self.rp_log_level = get_actual_log_level(pytest_config, 'rp_log_level')
         self.rp_log_format = self.find_option(pytest_config, 'rp_log_format')
         self.rp_mode = self.find_option(pytest_config, 'rp_mode')
+        self.rp_thread_logging = self.find_option(
+            pytest_config, 'rp_thread_logging'
+        )
         self.rp_parent_item_id = self.find_option(pytest_config,
                                                   'rp_parent_item_id')
         self.rp_project = self.find_option(pytest_config,

pytest_reportportal/config.py

@@ -16,7 +16,7 @@
 
 from pytest_reportportal import LAUNCH_WAIT_TIMEOUT
 from .config import AgentConfig
-from .rp_logging import patching_logger_class
+from .rp_logging import patching_logger_class, patching_thread_class
 from .service import PyTestServiceClass
 
 log = logging.getLogger(__name__)
@@ -204,6 +204,24 @@ def pytest_configure(config):
             config.workerinput['py_test_service'])
 
 
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtestloop(session):
+    """
+    Control start and finish of all test items in the session.
+
+    :param session: pytest.Session
+    :return:     generator object
+    """
+    config = session.config
+    if not config._rp_enabled:
+        yield
+        return
+
+    agent_config = config._reporter_config
+    with patching_thread_class(agent_config):
+        yield
+
+
 @pytest.hookimpl(hookwrapper=True)
 def pytest_runtest_protocol(item):
     """
@@ -341,6 +359,14 @@ def add_shared_option(name, help, default=None, action='store'):
         help='Visibility of current launch [DEFAULT, DEBUG]',
         default='DEFAULT'
     )
+    add_shared_option(
+        name='rp_thread_logging',
+        help='EXPERIMENTAL: Report logs from threads. '
+             'This option applies a patch to the builtin Thread class, '
+             'and so it is turned off by default. Use with caution.',
+        default=False,
+        action='store_true'
+    )
 
     parser.addini(
         'rp_launch_attributes',

pytest_reportportal/plugin.py

@@ -1,11 +1,94 @@
 """RPLogger class for low-level logging in tests."""
 
 import logging
+import threading
 from contextlib import contextmanager
 from functools import wraps
+
+from reportportal_client.client import RPClient
+
+from reportportal_client._local import current, set_current
 from reportportal_client import RPLogger
 
 
+@contextmanager
+def patching_thread_class(config):
+    """
+    Add patch for Thread class.
+
+    Set the parent thread client as the child thread's local client
+    """
+    if not config.rp_thread_logging:
+        # Do nothing
+        yield
+    else:
+        original_start = threading.Thread.start
+        original_run = threading.Thread.run
+        try:
+            def wrap_start(original_func):
+                @wraps(original_func)
+                def _start(self, *args, **kwargs):
+                    """Save the invoking thread's client if there is one."""
+                    # Prevent an endless loop of workers being spawned
+                    if "_monitor" not in self.name:
+                        current_client = current()
+                        self.parent_rp_client = current_client
+                    return original_func(self, *args, **kwargs)
+
+                return _start
+
+            def wrap_run(original_func):
+                @wraps(original_func)
+                def _run(self, *args, **kwargs):
+                    """Create a new client for the invoked thread."""
+                    client = None
+                    if (
+                        hasattr(self, "parent_rp_client")
+                        and self.parent_rp_client
+                        and not current()
+                    ):
+                        parent = self.parent_rp_client
+                        client = RPClient(
+                            endpoint=parent.endpoint,
+                            project=parent.project,
+                            token=parent.token,
+                            log_batch_size=parent.log_batch_size,
+                            is_skipped_an_issue=parent.is_skipped_an_issue,
+                            verify_ssl=parent.verify_ssl,
+                            retries=config.rp_retries,
+                            launch_id=parent.launch_id
+                        )
+                        if parent.current_item():
+                            client._item_stack.append(
+                                parent.current_item()
+                            )
+                        client.start()
+                    try:
+                        return original_func(self, *args, **kwargs)
+                    finally:
+                        if client:
+                            # Stop the client and remove any references
+                            client.terminate()
+                            self.parent_rp_client = None
+                            del self.parent_rp_client
+                            set_current(None)
+
+                return _run
+
+            if not hasattr(threading.Thread, "patched"):
+                # patch
+                threading.Thread.patched = True
+                threading.Thread.start = wrap_start(original_start)
+                threading.Thread.run = wrap_run(original_run)
+            yield
+
+        finally:
+            if hasattr(threading.Thread, "patched"):
+                threading.Thread.start = original_start
+                threading.Thread.run = original_run
+                del threading.Thread.patched
+
+
 @contextmanager
 def patching_logger_class():
     """

pytest_reportportal/rp_logging.py

@@ -34,9 +34,9 @@ def test_empty_run(mock_client_init):
 
     :param mock_client_init: Pytest fixture
     """
-    result = utils.run_pytest_tests(tests=['examples/epmty/'])
+    result = utils.run_pytest_tests(tests=['examples/empty/'])
 
-    assert int(result) == 4, 'Exit code should be 4 (no tests)'
+    assert int(result) == 5, 'Exit code should be 5 (no tests)'
 
     mock_client = mock_client_init.return_value
     expect(mock_client.start_launch.call_count == 1,

tests/integration/test_empty_run.py

@@ -0,0 +1,32 @@
+from six.moves import mock
+
+from tests import REPORT_PORTAL_SERVICE
+from tests.helpers import utils
+
+
+@mock.patch('pytest_reportportal.rp_logging.RPClient')
+@mock.patch(REPORT_PORTAL_SERVICE)
+def test_rp_thread_logs_reporting(mock_client_init, mock_thread_client_init):
+    """Verify logs from threads are sent to correct items`.
+
+    :param mock_client_init: Pytest fixture
+    """
+    mock_client = mock_client_init.return_value
+    mock_thread_client = mock_thread_client_init.return_value
+
+    def init_thread_client(*_, **__):
+        from reportportal_client._local import set_current
+        set_current(mock_thread_client)
+        return mock_thread_client
+    mock_thread_client_init.side_effect = init_thread_client
+    result = utils.run_tests_with_client(
+        mock_client,
+        ['examples/threads/'],
+        args=["--rp-thread-logging"]
+    )
+
+    assert int(result) == 0, 'Exit code should be 0 (no errors)'
+    assert mock_client.start_launch.call_count == 1, \
+        '"start_launch" method was not called'
+    assert mock_client.log.call_count == 1
+    assert mock_thread_client.log.call_count == 2

tests/integration/test_threads_logs.py

@@ -318,6 +318,7 @@ def test_pytest_addoption_adds_correct_ini_file_arguments():
         'rp_uuid',
         'rp_endpoint',
         'rp_mode',
+        'rp_thread_logging',
         'rp_launch_attributes',
         'rp_tests_attributes',
         'rp_log_batch_size',
@@ -361,7 +362,8 @@ def test_pytest_addoption_adds_correct_command_line_arguments():
         '--rp-parent-item-id',
         '--rp-uuid',
         '--rp-endpoint',
-        '--rp-mode'
+        '--rp-mode',
+        '--rp-thread-logging'
     )
     mock_parser = mock.MagicMock(spec=Parser)
     mock_reporting_group = mock_parser.getgroup.return_value