appmap 2.1.5__tar.gz → 2.1.6__tar.gz

{appmap-2.1.5 → appmap-2.1.6}/PKG-INFO

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

{appmap-2.1.5 → appmap-2.1.6}/_appmap/event.py

@@ -6,7 +6,6 @@ import threading
 from functools import lru_cache, partial
 from inspect import Parameter, Signature
 from itertools import chain
-import types
 
 from .env import Env
 from .recorder import Recorder

{appmap-2.1.5 → appmap-2.1.6}/_appmap/importer.py

@@ -5,7 +5,7 @@ import types
 from abc import ABC, abstractmethod
 from collections import namedtuple
 from collections.abc import MutableSequence
-from functools import partial, reduce
+from functools import reduce
 
 from _appmap import wrapt
 

{appmap-2.1.5 → appmap-2.1.6}/_appmap/instrument.py

@@ -119,7 +119,6 @@ def call_instrumented(f, instance, args, kwargs):
 def instrument(filterable):
     """return an instrumented function"""
     logger.debug("hooking %s", filterable.fqname)
-    fn = filterable.obj
 
     make_call_event = event.CallEvent.make(filterable)
     params = CallEvent.make_params(filterable)

{appmap-2.1.5 → appmap-2.1.6}/_appmap/recording.py

@@ -62,6 +62,7 @@ class NoopRecording:
 
     def __init__(self, exit_hook=None):
         self.exit_hook = exit_hook
+        self.events = []
 
     def start(self):
         pass

{appmap-2.1.5 → appmap-2.1.6}/_appmap/test/data/django/djangoapp/settings.py

@@ -1,3 +1,9 @@
+from pathlib import Path
+
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
 # If the SECRET_KEY isn't defined we get the misleading error message
 # CommandError: You must set settings.ALLOWED_HOSTS if DEBUG is False.
 SECRET_KEY = "3*+d^_kjnr2gz)4q2m(&&^%$p4fj5dk3%lz4pl3g4m-%6!gf&)"
@@ -10,3 +16,10 @@ ROOT_URLCONF = "djangoapp.urls"
 
 # Turn off deprecation warning
 USE_TZ = True
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": BASE_DIR / "db.sqlite3",
+    }
+}

appmap-2.1.6/_appmap/test/data/django/test/test_request.py

@@ -0,0 +1,8 @@
+from django.test import TestCase
+from django.test import Client
+
+
+class TestRequest(TestCase):
+    def test_request_test(self):
+        resp = self.client.get("/test")
+        assert resp.status_code == 200

{appmap-2.1.5 → appmap-2.1.6}/_appmap/test/test_django.py

@@ -198,7 +198,7 @@ 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=5, failed=0, errors=0)
+        result.assert_outcomes(passed=6, 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"
@@ -212,7 +212,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=2, failed=0, errors=0)
+        result.assert_outcomes(passed=3, failed=0, errors=0)
         assert not (pytester.path / "tmp").exists()
 
     def test_disabled_for_process(self, pytester, monkeypatch):
@@ -222,7 +222,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=3, failed=2, errors=0)
+        result.assert_outcomes(passed=4, failed=2, errors=0)
 
         assert (pytester.path / "tmp" / "appmap" / "process").exists()
         assert not (pytester.path / "tmp" / "appmap" / "requests").exists()

{appmap-2.1.5 → appmap-2.1.6}/_appmap/test/test_properties.py

@@ -145,4 +145,4 @@ def test_functools_partial(events):
     from properties_class import PropertiesClass
 
     PropertiesClass.static_partial_method()
-    assert len(events) > 0
+    assert len(events) > 0

{appmap-2.1.5 → appmap-2.1.6}/_appmap/test/test_recording.py

@@ -9,6 +9,7 @@ from threading import Thread
 import pytest
 
 import appmap
+from _appmap.configuration import Config
 from _appmap.event import Event
 from _appmap.recorder import Recorder, ThreadRecorder
 from _appmap.wrapt import FunctionWrapper
@@ -16,6 +17,17 @@ from _appmap.wrapt import FunctionWrapper
 from .normalize import normalize_appmap, remove_line_numbers
 
 
+def _call_modfunc(q):
+    r = appmap.Recording()
+    with r:
+        f = q.get()
+        f()
+    events = r.events
+    assert len(events) == 2
+    assert events[0].event == "call"
+    assert events[0].method_id == "modfunc"
+
+
 @pytest.mark.appmap_enabled
 @pytest.mark.usefixtures("with_data_dir")
 class TestRecordingWhenEnabled:
@@ -47,11 +59,12 @@ class TestRecordingWhenEnabled:
         ), f"expected path {expected_path}"
 
     def test_recording_clears(self):
-        from example_class import (  # pyright: ignore[reportMissingImports] pylint: disable=import-error
-            ExampleClass,
-        )
+        #  pylint: disable=import-error
+        from example_class import ExampleClass  # pyright: ignore[reportMissingImports]
+        #  pylint: enable=import-error
 
-        with appmap.Recording():
+        rec = appmap.Recording()
+        with rec:
             ExampleClass.static_method()
 
         # fresh recording shouldn't contain previous traces
@@ -68,9 +81,9 @@ class TestRecordingWhenEnabled:
         assert rec.events[2].method_id == "instance_method"
 
     def test_recording_shallow(self):
-        from example_class import (  # pyright: ignore[reportMissingImports] pylint: disable=import-error
-            ExampleClass,
-        )
+        #  pylint: disable=import-error
+        from example_class import ExampleClass  # pyright: ignore[reportMissingImports]
+        #  pylint: enable=import-error
 
         rec = appmap.Recording()
         with rec:
@@ -82,9 +95,9 @@ class TestRecordingWhenEnabled:
         assert len(rec.events) == 8
 
     def test_recording_wrapped(self):
-        from example_class import (  # pyright: ignore[reportMissingImports] pylint: disable=import-error
-            ExampleClass,
-        )
+        #  pylint: disable=import-error
+        from example_class import ExampleClass  # pyright: ignore[reportMissingImports]
+        #  pylint: enable=import-error
 
         rec = appmap.Recording()
         with rec:
@@ -117,21 +130,23 @@ class TestRecordingWhenEnabled:
             f1 = deepcopy(modfunc)
             f1()
 
-    def test_can_pickle(self):
-        import pickle
+    def test_can_pickle(self, monkeypatch):
+        # Make sure subprocesses see whatever config is set for us.
+        monkeypatch.setenv("APPMAP_CONFIG", str(Config.current._file))  # pylint: disable=protected-access
 
-        from example_class import (  # pyright: ignore[reportMissingImports] pylint: disable=import-error
-            modfunc,
-        )
+        from multiprocessing import Process, Queue
 
-        rec = appmap.Recording()
-        with rec:
-            assert isinstance(modfunc, FunctionWrapper)
-            f = pickle.loads(pickle.dumps(modfunc))
-            f()
-        evt = rec.events[-2]
-        assert evt.event == "call"
-        assert evt.method_id == "modfunc"
+        #  pylint: disable=import-error
+        from example_class import modfunc  # pyright: ignore[reportMissingImports]
+        #  pylint: enable=import-error
+
+        assert isinstance(modfunc, FunctionWrapper), "modfunc isn't instrumented?"
+
+        q = Queue()
+        q.put(modfunc)
+        p = Process(target=_call_modfunc, args=(q,))
+        p.start()
+        p.join()
 
 
 @pytest.mark.appmap_enabled

{appmap-2.1.5 → appmap-2.1.6}/_appmap/test/test_test_frameworks.py

@@ -122,6 +122,20 @@ class TestPytestRunnerPytest(_TestTestRunner):
         verify_expected_appmap(testdir, f"-numpy{numpy_version.major}-no-test-cases")
         verify_expected_metadata(testdir)
 
+@pytest.mark.example_dir("django")
+def test_pytest_django(testdir):
+    result = testdir.runpytest("-svv", "-k", "test_request_test")
+    result.assert_outcomes(passed=1)
+    # django.test.TestCase is a subclass of unittest.TestCase, so recorder type is unittest
+    assert (
+        testdir.path
+        / "tmp"
+        / "appmap"
+        / "unittest"
+        / "test_test_request_TestRequest_test_request_test.appmap.json"
+    ).exists()
+    assert not (testdir.path / "tmp" / "appmap" / "requests").exists()
+
 
 @pytest.mark.example_dir("trial")
 class TestPytestRunnerTrial(_TestTestRunner):

{appmap-2.1.5 → appmap-2.1.6}/appmap/pytest.py

@@ -1,6 +1,13 @@
 from importlib.metadata import version
 
 import pytest
+try:
+    from pytest_django.django_compat import is_django_unittest
+except ImportError:
+
+    def is_django_unittest(item):
+        return False
+
 
 from _appmap import noappmap, testing_framework, wrapt
 from _appmap.env import Env
@@ -51,7 +58,7 @@ if not Env.current.is_appmap_repo and Env.current.enables("tests"):
         # running the test case. (This nesting of function calls is
         # verified by the expected appmap in the test for a unittest
         # TestCase run by pytest.)
-        if hasattr(item, "_testcase"):
+        if hasattr(item, "_testcase") and not is_django_unittest(item):
             setattr(
                 item._testcase,  # pylint: disable=protected-access
                 "_appmap_pytest_recording",

{appmap-2.1.5 → appmap-2.1.6}/pyproject.toml

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

{appmap-2.1.5 → appmap-2.1.6}/vendor/_appmap/wrapt/wrappers.py

@@ -457,11 +457,8 @@ class ObjectProxy(with_metaclass(_ObjectProxyMetaType)):
         raise NotImplementedError(
                 'object proxy must define __reduce_ex__()')
 
-    # Return the qualname of the wrapped function instead of a tuple. This allows an instance of
-    # subclasses to be pickled as the function it wraps. This seems to be adequate for generating
-    # AppMaps.
-    def __reduce_ex__(self, protocol):
-         return self.__wrapped__.__qualname__
+    def __reduce_ex__(self):
+        raise NotImplementedError("object proxy must define __reduce_ex__()")
 
 class CallableObjectProxy(ObjectProxy):
 
@@ -508,6 +505,20 @@ class PartialCallableObjectProxy(ObjectProxy):
 
         return self.__wrapped__(*_args, **_kwargs)
 
+def _unpickle_functionwrapper(modname, qualname):
+    """
+    Given the module name and qualname of a function, return a FunctionWrapper instance for it. This
+    simply imports the module, then fetches the appropriate function. Provided AppMap
+    instrumentation has been configured correctly when unpickling, the attribute for the function
+    will be a FunctionWrapper. If it hasn't been configured correctly, the attribute will simply be
+    the original function. (This means the application will function correctly, but no events will
+    get generated when the function is called.)
+    """
+    _, _, original = resolve_path(modname, qualname)
+
+    return original
+
+
 class _FunctionWrapperBase(ObjectProxy):
     __slots__ = (
         "_self_instance",
@@ -656,6 +667,20 @@ class _FunctionWrapperBase(ObjectProxy):
         else:
             return issubclass(subclass, self.__wrapped__)
 
+    # Implement this here, rather than in ObjectProxy, because _unpickle_functionwrapper will only
+    # create new instances of subclasses of _FunctionWrapperBase via the agent's import hooks.
+    def __reduce_ex__(self, _):
+        modname = self.__wrapped__.__module__
+        qualname = getattr(self.__wrapped__, "__qualname__", None)
+        if qualname is None:
+            qualname = self.__wrapped__.__name__
+
+        return (
+            _unpickle_functionwrapper,
+            (modname, qualname),
+        )
+
+
 class BoundFunctionWrapper(_FunctionWrapperBase):
 
     def __new__(cls, *args, **kwargs):
@@ -738,24 +763,18 @@ class BoundFunctionWrapper(_FunctionWrapperBase):
             return self._self_wrapper(self.__wrapped__, instance, args,
                     kwargs)
 
-class FunctionWrapper(_FunctionWrapperBase):
+    def __getattribute__(self, name):
+        if name == "__func__":
+            # The __func__ attribute of a bound method is the unbound method. The corresponding
+            # attribute of a BoundFunctionWrapper is the associated FunctionWrapper (saved in
+            # _self_parent when the BFW is created).
+            return self._self_parent
 
-    __bound_function_wrapper__ = BoundFunctionWrapper
+        return super().__getattribute__(name)
 
-    # The code here is pretty complicated (see the comment below), and it's not completely clear to
-    # me whether it actually keeps any state. If it does, __reduce_ex__ needs to return a tuple so a
-    # new FunctionWrapper will be created. If it doesn't, then __reduce_ex__ can simply return a
-    # string, which would cause deepcopy to return the original FunctionWrapper.
-    #
-
-    # def __reduce_ex__(self, protocol):
-    #      return self.__wrapped__.__qualname__
- 
-         # return FunctionWrapper, (
-         #     self.__wrapped__,
-         #     self._self_wrapper,
-         #     self._self_enabled,
-         # )
+
+class FunctionWrapper(_FunctionWrapperBase):
+    __bound_function_wrapper__ = BoundFunctionWrapper
 
     def __init__(self, wrapped, wrapper, enabled=None):
         # What it is we are wrapping here could be anything. We need to