appmap 2.0.8__tar.gz → 2.0.10__tar.gz

{appmap-2.0.8 → appmap-2.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: appmap
-Version: 2.0.8
+Version: 2.0.10
 Summary: Create AppMap files by recording a Python application.
 Home-page: https://github.com/applandinc/appmap-python
 License: MIT

{appmap-2.0.8 → appmap-2.0.10}/_appmap/env.py

@@ -37,6 +37,7 @@ class Env(metaclass=SingletonMeta):
                 else:
                     self._env.pop(k, None)
 
+        self.log_file_creation_failed = False
         self._configure_logging()
         enabled = self._env.get("_APPMAP", "false")
         self._enabled = enabled is None or enabled.lower() != "false"
@@ -133,6 +134,21 @@ class Env(metaclass=SingletonMeta):
     def getLogger(self, name) -> trace_logger.TraceLogger:
         return cast(trace_logger.TraceLogger, logging.getLogger(name))
 
+    def determine_log_file(self):
+        log_file = "appmap.log"
+
+        # Try creating the log file in the current directory
+        try:
+            with open(log_file, 'a', encoding='UTF8'):
+                pass
+        except IOError:
+            # The circumstances in which creation is going to fail
+            # are also those in which the user doesn't care whether
+            # there's a log file (e.g. when starting a REPL).
+            return None
+        return log_file
+
+
     def _configure_logging(self):
         trace_logger.install()
 
@@ -179,13 +195,19 @@ class Env(metaclass=SingletonMeta):
             log_level = self.get("APPMAP_LOG_LEVEL", "info").upper()
             loggers = config_dict["loggers"]
             loggers["appmap"]["level"] = loggers["_appmap"]["level"] = log_level
+
+            log_file = self.determine_log_file()
+            # Use NullHandler if log_file is None to avoid complicating the configuration
+            # with the absence of the "default" handler.
             config_dict["handlers"] = {
                 "default": {
                     "class": "logging.handlers.RotatingFileHandler",
                     "formatter": "default",
-                    "filename": "appmap.log",
+                    "filename": log_file,
                     "maxBytes": 50 * 1024 * 1024,
                     "backupCount": 1,
+                } if log_file is not None else {
+                    "class": "logging.NullHandler"
                 },
                 "stderr": {
                     "class": "logging.StreamHandler",
@@ -194,6 +216,7 @@ class Env(metaclass=SingletonMeta):
                     "stream": "ext://sys.stderr",
                 },
             }
+            self.log_file_creation_failed = log_file is None
 
         if log_config is not None:
             name, level = log_config.split("=", 2)
@@ -213,3 +236,7 @@ def initialize(**kwargs):
     Env.reset(**kwargs)
     logger = logging.getLogger(__name__)
     logger.info("appmap enabled: %s", Env.current.enabled)
+    if Env.current.log_file_creation_failed:
+        # Writing to stderr makes the REPL fail in vscode-python.
+        # https://github.com/microsoft/vscode-python/blob/c71c85ebf3749d5fac76899feefb21ee321a4b5b/src/client/common/process/rawProcessApis.ts#L268-L269
+        logger.info("appmap.log cannot be created")

appmap-2.0.10/_appmap/test/data/django/test/test_unittest_setup.py

@@ -0,0 +1,11 @@
+
+from unittest import TestCase
+
+from django.test import Client
+
+class DisabledRequestsRecordingTest(TestCase):
+    def setUp(self) -> None:
+        Client().get("/")
+
+    def test_request_in_setup(self):
+        pass

{appmap-2.0.8 → appmap-2.0.10}/_appmap/test/test_django.py

@@ -201,11 +201,13 @@ class TestDjangoApp:
         # To really check middleware reset, the tests must run in order,
         # so disable randomly.
         result = pytester.runpytest("-svv", "-p", "no:randomly")
-        result.assert_outcomes(passed=4, failed=0, errors=0)
+        result.assert_outcomes(passed=5, failed=0, errors=0)
         # Look for the http_server_request event in test_app's appmap. If
         # middleware reset is broken, it won't be there.
         appmap_file = pytester.path / "tmp" / "appmap" / "pytest" / "test_request.appmap.json"
-        assert not os.path.exists(pytester.path / "tmp" / "appmap" / "requests")
+        assert not os.path.exists(
+            pytester.path / "tmp" / "appmap" / "requests"
+        ), "django tests generated request recordings"
 
         events = json.loads(appmap_file.read_text())["events"]
         assert "http_server_request" in events[0]
@@ -213,7 +215,7 @@ class TestDjangoApp:
     def test_disabled(self, pytester, monkeypatch):
         monkeypatch.setenv("_APPMAP", "false")
         result = pytester.runpytest("-svv", "-p", "no:randomly", "-k", "test_request")
-        result.assert_outcomes(passed=1, failed=0, errors=0)
+        result.assert_outcomes(passed=2, failed=0, errors=0)
         assert not (pytester.path / "tmp").exists()
 
     def test_disabled_for_process(self, pytester, monkeypatch):
@@ -223,7 +225,7 @@ class TestDjangoApp:
 
         # There are two tests for remote recording. They should both fail,
         # because process recording should disable remote recording.
-        result.assert_outcomes(passed=2, failed=2, errors=0)
+        result.assert_outcomes(passed=3, failed=2, errors=0)
 
         assert (pytester.path / "tmp" / "appmap" / "process").exists()
         assert not (pytester.path / "tmp" / "appmap" / "requests").exists()

{appmap-2.0.8 → appmap-2.0.10}/_appmap/unittest.py

@@ -3,6 +3,7 @@ import unittest
 from contextlib import contextmanager
 
 from _appmap import noappmap, testing_framework, wrapt
+from _appmap.env import Env
 from _appmap.utils import get_function_location
 
 _session = testing_framework.session("unittest", "tests")
@@ -52,6 +53,17 @@ if sys.version_info[1] < 8:
                 yield
 
 else:
+    # We need to disable request recording in TestCase._callSetUp too
+    # in order to prevent creation of a request recording besides test
+    # recording when requests are made inside setUp method.
+    # This edge case can be observed in this test in django project:
+    #   $ APPMAP=TRUE ./runtests.py auth_tests.test_views.ChangelistTests.test_user_change_email
+    #   (ChangelistTests.setUp makes a request)
+    @wrapt.patch_function_wrapper("unittest.case", "TestCase._callSetUp")
+    def callSetUp(wrapped, test_case, args, kwargs): # pylint: disable=unused-argument
+        with Env.current.disabled("requests"):
+            wrapped(*args, **kwargs)
+
     # As of 3.8, unittest.case.TestCase now calls the test's method indirectly, through
     # TestCase._callTestMethod. Hook that to manage a recording session.
     @wrapt.patch_function_wrapper("unittest.case", "TestCase._callTestMethod")

{appmap-2.0.8 → appmap-2.0.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "appmap"
-version = "2.0.8"
+version = "2.0.10"
 description = "Create AppMap files by recording a Python application."
 readme = "README.md"
 authors = [