Merge pull request #176 from reportportal/logging-context

Logging context

Author: HardNorth

reportportal_client/__init__.py

@@ -14,12 +14,15 @@
 limitations under the License.
 """
 
+from ._local import current
+from .logs import RPLogger, RPLogHandler
 from .service import ReportPortalService
 from .steps import step
-from ._local import current
 
 __all__ = [
+    'current',
+    "RPLogger",
+    "RPLogHandler",
     'ReportPortalService',
     'step',
-    'current'
 ]

reportportal_client/client.py

@@ -57,6 +57,7 @@ def __init__(self,
                  retries=None,
                  max_pool_size=50,
                  launch_id=None,
+                 http_timeout=(10, 10),
                  **_):
         """Initialize required attributes.
 
@@ -70,6 +71,11 @@ def __init__(self,
         :param verify_ssl:           Option to skip ssl verification
         :param max_pool_size:        Option to set the maximum number of
                                      connections to save the pool.
+        :param launch_id:            a launch id to use instead of starting own
+                                     one
+        :param http_timeout:         a float in seconds for connect and read
+                                     timeout. Use a Tuple to specific connect
+                                     and read separately.
         """
         set_current(self)
         self._batch_logs = []
@@ -85,6 +91,7 @@ def __init__(self,
         self.log_batch_size = log_batch_size
         self.token = token
         self.verify_ssl = verify_ssl
+        self.http_timeout = http_timeout
         self.session = requests.Session()
         self.step_reporter = StepReporter(self)
         self._item_stack = []

reportportal_client/client.pyi

@@ -23,18 +23,22 @@ class RPClient:
     project: Text = ...
     token: Text = ...
     verify_ssl: bool = ...
+    http_timeout: Union[float, Tuple[float, float]] = ...
     session: Session = ...
     step_reporter: StepReporter = ...
 
-    def __init__(self,
-                 endpoint: Text,
-                 project: Text, token: Text,
-                 log_batch_size: int = ...,
-                 is_skipped_an_issue: bool = ...,
-                 verify_ssl: bool = ...,
-                 retries: int = ...,
-                 max_pool_size: int = ...,
-                 launch_id: Text = ...) -> None: ...
+    def __init__(
+            self,
+            endpoint: Text,
+            project: Text, token: Text,
+            log_batch_size: int = ...,
+            is_skipped_an_issue: bool = ...,
+            verify_ssl: bool = ...,
+            retries: int = ...,
+            max_pool_size: int = ...,
+            launch_id: Text = ...,
+            http_timeout: Union[float, Tuple[float, float]] = ...
+    ) -> None: ...
 
     def finish_launch(self,
                       end_time: Text,

reportportal_client/core/rp_requests.py

@@ -42,30 +42,35 @@ class HttpRequest:
     """This model stores attributes related to RP HTTP requests."""
 
     def __init__(self, session_method, url, data=None, json=None,
-                 files=None, verify_ssl=True):
+                 files=None, verify_ssl=True, http_timeout=(10, 10)):
         """Initialize instance attributes.
 
         :param session_method: Method of the requests.Session instance
         :param url:            Request URL
         :param data:           Dictionary, list of tuples, bytes, or file-like
                                object to send in the body of the request
-        :param json:           JSON to be send in the body of the request
-        :param verify:         Is certificate verification required
+        :param json:           JSON to be sent in the body of the request
+        :param verify_ssl:     Is SSL certificate verification required
+        :param http_timeout:   a float in seconds for connect and read
+                               timeout. Use a Tuple to specific connect and
+                               read separately.
         """
         self.data = data
         self.files = files
         self.json = json
         self.session_method = session_method
         self.url = url
         self.verify_ssl = verify_ssl
+        self.http_timeout = http_timeout
 
     def make(self):
         """Make HTTP request to the Report Portal API."""
         for attempt in range(SEND_RETRY_COUNT):
             try:
                 return RPResponse(self.session_method(
                     self.url, data=self.data, json=self.json,
-                    files=self.files, verify=self.verify_ssl)
+                    files=self.files, verify=self.verify_ssl,
+                    timeout=self.http_timeout)
                 )
             # https://github.com/reportportal/client-Python/issues/39
             except KeyError:

reportportal_client/core/rp_requests.pyi

@@ -3,15 +3,18 @@ from reportportal_client.core.rp_issues import Issue as Issue
 from reportportal_client.core.rp_responses import RPResponse as RPResponse
 from reportportal_client.static.abstract import AbstractBaseClass
 from reportportal_client.static.defines import Priority as Priority
-from typing import Any, Callable, ByteString, Dict, IO, List, Optional, Text, Union
+from typing import Any, Callable, ByteString, Dict, IO, List, Optional, Text, \
+    Union, Tuple
+
 
 class HttpRequest:
     session_method: Callable = ...
     url: Text = ...
-    files: Optional[Dict]
-    data = Optional[Union[Dict, List[Union[tuple, ByteString]], IO]] = ...
-    json = Optional[Dict] = ...
-    verify_ssl = Optional[bool]
+    files: Optional[Dict] = ...
+    data: Optional[Union[Dict, List[Union[tuple, ByteString]], IO]] = ...
+    json: Optional[Dict] = ...
+    verify_ssl: Optional[bool] = ...
+    http_timeout: Union[float, Tuple[float, float]] = ...
     def __init__(self,
                  session_method: Callable,
                  url: Text,

reportportal_client/core/worker.py

@@ -179,10 +179,15 @@ def __perform_stop(self, stop_command):
         if not self.is_alive():
             # Already stopped or already dead or not even started
             return
-        if not self._stop_lock.acquire(blocking=False):
+        with self._stop_lock:
+            if not self.is_alive():
+                # Already stopped by previous thread
+                return
             self.send(stop_command)
+            # Do not release main thread until worker process all requests,
+            # since main thread might forcibly quit python interpreter as in
+            # pytest
             self._stop_lock.wait(THREAD_TIMEOUT)
-        self._stop_lock.release()
 
     def stop(self):
         """Stop the worker.

reportportal_client/logs/__init__.py

@@ -0,0 +1,161 @@
+#  Copyright (c) 2022 https://reportportal.io .
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License
+"""Report portal logging handling module."""
+
+import logging
+import sys
+
+from six import PY2
+from six.moves.urllib.parse import urlparse
+
+from reportportal_client._local import current
+from reportportal_client.helpers import timestamp
+
+
+class RPLogger(logging.getLoggerClass()):
+    """RPLogger class for low-level logging in tests."""
+
+    def __init__(self, name, level=0):
+        """
+        Initialize RPLogger instance.
+
+        :param name:  logger name
+        :param level: level of logs
+        """
+        super(RPLogger, self).__init__(name, level=level)
+
+    def _log(self, level, msg, args,
+             exc_info=None, extra=None, stack_info=False, attachment=None):
+        """
+        Low-level logging routine which creates a LogRecord and then calls.
+
+        all the handlers of this logger to handle the record
+        :param level:      level of log
+        :param msg:        message in log body
+        :param args:       additional args
+        :param exc_info:   system exclusion info
+        :param extra:      extra info
+        :param stack_info: stacktrace info
+        :param attachment: attachment file
+        """
+        sinfo = None
+        if logging._srcfile:
+            # IronPython doesn't track Python frames, so findCaller raises an
+            # exception on some versions of IronPython. We trap it here so that
+            # IronPython can use logging.
+            try:
+                if PY2:
+                    # In python2.7 findCaller() don't accept any parameters
+                    # and returns 3 elements
+                    fn, lno, func = self.findCaller()
+                else:
+                    fn, lno, func, sinfo = self.findCaller(stack_info)
+
+            except ValueError:  # pragma: no cover
+                fn, lno, func = '(unknown file)', 0, '(unknown function)'
+        else:
+            fn, lno, func = '(unknown file)', 0, '(unknown function)'
+
+        if exc_info and not isinstance(exc_info, tuple):
+            exc_info = sys.exc_info()
+
+        if PY2:
+            # In python2.7 makeRecord() accepts everything but sinfo
+            record = self.makeRecord(self.name, level, fn, lno, msg, args,
+                                     exc_info, func, extra)
+        else:
+            record = self.makeRecord(self.name, level, fn, lno, msg, args,
+                                     exc_info, func, extra, sinfo)
+
+        if not getattr(record, 'attachment', None):
+            record.attachment = attachment
+        self.handle(record)
+
+
+class RPLogHandler(logging.Handler):
+    """RPLogHandler class for logging tests."""
+
+    # Map loglevel codes from `logging` module to ReportPortal text names:
+    _loglevel_map = {
+        logging.NOTSET: 'TRACE',
+        logging.DEBUG: 'DEBUG',
+        logging.INFO: 'INFO',
+        logging.WARNING: 'WARN',
+        logging.ERROR: 'ERROR',
+        logging.CRITICAL: 'ERROR',
+    }
+    _sorted_levelnos = sorted(_loglevel_map.keys(), reverse=True)
+
+    def __init__(self, level=logging.NOTSET, filter_client_logs=False,
+                 endpoint=None,
+                 ignored_record_names=tuple('reportportal_client')):
+        """
+        Initialize RPLogHandler instance.
+
+        :param level:                level of logging
+        :param filter_client_logs:   if True throw away logs emitted by a
+        ReportPortal client
+        :param endpoint:             link to send reports
+        :param ignored_record_names: a tuple of record names which will be
+        filtered out by the handler (with startswith method)
+        """
+        super(RPLogHandler, self).__init__(level)
+        self.filter_client_logs = filter_client_logs
+        self.ignored_record_names = ignored_record_names
+        self.endpoint = endpoint
+
+    def filter(self, record):
+        """Filter specific records to avoid sending those to RP.
+
+        :param record: A log record to be filtered
+        :return:       False if the given record does no fit for sending
+                       to RP, otherwise True.
+        """
+        if not self.filter_client_logs:
+            return True
+        if record.name.startswith(self.ignored_record_names):
+            return False
+        if record.name.startswith('urllib3.connectionpool'):
+            # Filter the reportportal_client requests instance
+            # urllib3 usage
+            hostname = urlparse(self.endpoint).hostname
+            if hostname in self.format(record):
+                return False
+        return True
+
+    def emit(self, record):
+        """
+        Emit function.
+
+        :param record: a log Record of requests
+        :return: log ID
+        """
+        msg = ''
+
+        try:
+            msg = self.format(record)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception:
+            self.handleError(record)
+
+        for level in self._sorted_levelnos:
+            if level <= record.levelno:
+                rp_client = current()
+                return rp_client.log(
+                    timestamp(),
+                    msg,
+                    level=self._loglevel_map[level],
+                    attachment=getattr(record, 'attachment'),
+                    item_id=rp_client.current_item()
+                )