appmap 2.1.4__tar.gz → 2.1.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: appmap
-Version: 2.1.4
+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.4 → appmap-2.1.6}/_appmap/event.py

@@ -1,6 +1,7 @@
 # pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring
 import inspect
 import logging
+import operator
 import threading
 from functools import lru_cache, partial
 from inspect import Parameter, Signature
@@ -174,24 +175,50 @@ class Param:
         ret.update(describe_value(self.name, value))
         return ret
 
+def _get_name_parts(filterable):
+    """
+    Return the module name and qualname for filterable.obj.
+
+    If filterable.obj is an operator.attrgetter that we've determined is associated with a property,
+    compute the names from the fqname of the filterable. If it's anything else, try to get its
+    __module__ and __qualname__, falling back to default values if they're not available.
+    """
+    fn = filterable.obj
+    assert callable(fn), f"{filterable} doesn't have a callable obj"
+
+    if (
+        type(fn) is operator.attrgetter
+        and (parts := filterable.fqname.split("."))
+        and len(parts) > 2
+    ):
+        # filterable.fqname was set when we identified this filterable as a property
+        modname = ".".join(parts[:-2])
+        qualname = ".".join(parts[-2:])
+    else:
+        modname = getattr(fn, "__module__", "unknown")
+        qualname = getattr(fn, "__qualname__", None)
+        if qualname is None:
+            qualname = getattr(fn.__class__, "__name__", "unknown")
+    return modname, qualname
 
 class CallEvent(Event):
     # pylint: disable=method-cache-max-size-none
     __slots__ = ["_fn", "_fqfn", "static", "receiver", "parameters", "labels", "auxtype"]
 
     @staticmethod
-    def make(fn, fntype):
+    def make(filterable):
         """
         Return a factory for creating new CallEvents based on
         introspecting the given function.
         """
 
         # Delete the labels so the app doesn't see them.
+        fn = filterable.obj
         labels = getattr(fn, "_appmap_labels", None)
         if labels:
             del fn._appmap_labels
 
-        return partial(CallEvent, fn, fntype, labels=labels)
+        return partial(CallEvent, filterable, labels=labels)
 
     @staticmethod
     def make_params(filterable):
@@ -312,10 +339,14 @@ class CallEvent(Event):
             comment = inspect.getcomments(self._fn)
         return comment
 
-    def __init__(self, fn, fntype, parameters, labels):
+    def __init__(self, filterable, parameters, labels):
         super().__init__("call")
+        fn = filterable.obj
         self._fn = fn
-        self._fqfn = FqFnName(fn)
+        modname, qualname = _get_name_parts(filterable)
+        self._fqfn = FqFnName(modname, qualname)
+
+        fntype = filterable.fntype
         self.static = fntype in FnType.STATIC | FnType.CLASS | FnType.MODULE
         self.receiver = None
         if fntype in FnType.CLASS | FnType.INSTANCE:

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

@@ -134,7 +134,7 @@ def get_members(cls):
         static_value = inspect.getattr_static(cls, key)
         # Don't use isinstance to check the type of static_value -- we don't want to invoke the
         # descriptor protocol.
-        if Importer.instrument_properties and type(static_value) is property:  # pylint: disable=unidiomatic-typecheck
+        if Importer.instrument_properties and type(static_value) is property:
             properties[key] = (
                 static_value,
                 {
@@ -147,7 +147,7 @@ def get_members(cls):
             if not is_member_func(static_value):
                 continue
             value = getattr(cls, key)
-            if value.__module__ != modname:
+            if (m := getattr(value, "__module__", None)) and (m is None or m != modname):
                 continue
             functions.append((key, static_value, value))
 
@@ -167,7 +167,7 @@ class Importer:
         cls.filter_chain = []
         cls._skip_instrumenting = ("appmap", "_appmap")
         cls.instrument_properties = (
-            Env.current.get("APPMAP_INSTRUMENT_PROPERTIES", "false").lower() == "true"
+            Env.current.get("APPMAP_INSTRUMENT_PROPERTIES", "true").lower() == "true"
         )
 
     @classmethod
@@ -202,7 +202,7 @@ class Importer:
             logger.trace("  functions %s", functions)
 
             for fn_name, static_fn, fn in functions:
-                filterableFn = FilterableFn(filterable, fn.__name__, fn, static_fn)
+                filterableFn = FilterableFn(filterable, fn_name, fn, static_fn)
                 new_fn = cls.instrument_function(fn_name, filterableFn, selected_functions)
                 if new_fn != fn:
                     fw = wrapt.wrap_function_wrapper(filterable.obj, fn_name, new_fn)
@@ -221,7 +221,8 @@ class Importer:
                     new_fn = cls.instrument_function(prop_name, filterableFn, selected_functions)
                     if new_fn != fn:
                         new_fn = wrapt.FunctionWrapper(fn, new_fn)
-                        # Set _appmap_instrumented on the FunctionWrapper, not on the wrapped function
+                        # Set _appmap_instrumented on the FunctionWrapper, not on the wrapped
+                        # function.
                         new_fn._appmap_instrumented = True  # pylint: disable=protected-access
 
                     instrumented_fns[k] = new_fn

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

@@ -119,9 +119,8 @@ 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(fn, filterable.fntype)
+    make_call_event = event.CallEvent.make(filterable)
     params = CallEvent.make_params(filterable)
 
     # django depends on being able to find the cache_clear attribute

{appmap-2.1.4 → 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.4 → appmap-2.1.6}/_appmap/test/data/appmap.yml

@@ -4,6 +4,7 @@ packages:
 - path: example_class.Super
   shallow: true
 - path: example_class
+- path: properties_class
 - path: appmap_testing
 - path: package1
 - dist: PyYAML

{appmap-2.1.4 → 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.4 → appmap-2.1.6}/_appmap/test/data/example_class.py

@@ -114,55 +114,6 @@ class ExampleClass(Super, ClassMethodMixin):
     def return_self(self):
         return self
 
-    def __init__(self):
-        self._read_only = "read only"
-        self._fully_accessible = "fully accessible"
-        self._undecorated = "undecorated"
-
-    @property
-    def read_only(self):
-        """Read-only"""
-        return self._read_only
-
-    @property
-    def fully_accessible(self):
-        """Fully-accessible"""
-        return self._fully_accessible
-
-    @fully_accessible.setter
-    def fully_accessible(self, v):
-        self._fully_accessible = v
-
-    @fully_accessible.deleter
-    def fully_accessible(self):
-        del self._fully_accessible
-
-    def get_undecorated(self):
-        return self._undecorated
-
-    def set_undecorated(self, value):
-        self._undecorated = value
-
-    def delete_undecorated(self):
-        del self._undecorated
-
-    undecorated_property = property(get_undecorated, set_undecorated, delete_undecorated)
-
-    def set_write_only(self, v):
-        self._write_only = v
-
-    def del_write_only(self):
-        del self._write_only
-
-    write_only = property(None, set_write_only, del_write_only, "Write-only")
-
-    def raise_base_exception(self) -> NoReturn:
-        raise BaseException("not derived from Exception") # pylint: disable=broad-exception-raised
 
 def modfunc():
     return "Hello world!"
-
-if __name__ == "__main__":
-    ec = ExampleClass()
-    ec.fully_accessible = "updated"
-    print(ec.fully_accessible)

appmap-2.1.6/_appmap/test/data/properties_class.py

@@ -0,0 +1,71 @@
+from functools import cached_property, partial
+import operator
+from typing import NoReturn
+
+def free_read_only(self):
+    return self._read_only
+
+def free_func():
+    return "hello world"
+class PropertiesClass:
+    def __init__(self):
+        self._read_only = "read only"
+        self._fully_accessible = "fully accessible"
+        self._undecorated = "undecorated"
+
+    @property
+    def read_only(self):
+        """Read-only"""
+        return self._read_only
+
+    @property
+    def fully_accessible(self):
+        """Fully-accessible"""
+        return self._fully_accessible
+
+    @fully_accessible.setter
+    def fully_accessible(self, v):
+        self._fully_accessible = v
+
+    @fully_accessible.deleter
+    def fully_accessible(self):
+        del self._fully_accessible
+
+    def get_undecorated(self):
+        return self._undecorated
+
+    def set_undecorated(self, value):
+        self._undecorated = value
+
+    def delete_undecorated(self):
+        del self._undecorated
+
+    undecorated_property = property(get_undecorated, set_undecorated, delete_undecorated)
+
+    def set_write_only(self, v):
+        self._write_only = v
+
+    def del_write_only(self):
+        del self._write_only
+
+    write_only = property(None, set_write_only, del_write_only, "Write-only")
+
+    def raise_base_exception(self) -> NoReturn:
+        raise BaseException("not derived from Exception")  # pylint: disable=broad-exception-raised
+
+    @cached_property
+    def cached_read_only(self):
+        return self._read_only
+
+    operator_read_only = property(operator.attrgetter("cached_read_only"))
+
+    tastes = {"bacon": "yum"}
+
+    def __getitem__(self, key):
+        return self.tastes[key]
+
+    taste = property(operator.itemgetter("bacon"))
+
+    free_read_only_prop = property(free_read_only)
+
+    static_partial_method = staticmethod(partial(free_func))

{appmap-2.1.4 → 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.4 → appmap-2.1.6}/_appmap/test/test_params.py

@@ -28,8 +28,7 @@ class _params:
 
     @classmethod
     def prepare(cls, ffn):
-        fn = ffn.obj
-        make_call_event = CallEvent.make(fn, ffn.fntype)
+        make_call_event = CallEvent.make(ffn)
         params = CallEvent.make_params(ffn)
 
         def wrapped_fn(_, instance, args, kwargs):

appmap-2.1.6/_appmap/test/test_properties.py

@@ -0,0 +1,148 @@
+"""Tests for methods decorated with @property"""
+
+# pyright: reportMissingImports=false
+# pylint: disable=import-error,import-outside-toplevel
+import pytest
+from _appmap.test.helpers import DictIncluding
+
+pytestmark = pytest.mark.appmap_enabled
+
+@pytest.fixture(autouse=True)
+def setup(with_data_dir):  # pylint: disable=unused-argument
+    # with_data_dir sets up sys.path so properties_class can be imported
+    pass
+
+
+def test_getter_instrumented(events):
+    from properties_class import PropertiesClass
+
+    ec = PropertiesClass()
+
+    actual = PropertiesClass.read_only.__doc__
+    assert actual == "Read-only"
+
+    assert ec.read_only == "read only"
+
+    with pytest.raises(AttributeError, match=r".*(has no setter|can't set attribute).*"):
+        ec.read_only = "not allowed"
+
+    with pytest.raises(AttributeError, match=r".*(has no deleter|can't delete attribute).*"):
+        del ec.read_only
+
+    assert len(events) == 2
+    assert events[0].to_dict() == DictIncluding({
+        "event": "call",
+        "defined_class": "properties_class.PropertiesClass",
+        "method_id": "read_only (get)",
+    })
+
+
+def test_accessible_instrumented(events):
+    from properties_class import PropertiesClass
+
+    ec = PropertiesClass()
+    assert PropertiesClass.fully_accessible.__doc__ == "Fully-accessible"
+
+    assert ec.fully_accessible == "fully accessible"
+
+    ec.fully_accessible = "updated"
+    # Check the value of the attribute directly, to avoid extra events
+    assert ec._fully_accessible == "updated"  # pylint: disable=protected-access
+
+    del ec.fully_accessible
+
+    assert len(events) == 6
+    assert events[0].to_dict() == DictIncluding({
+        "event": "call",
+        "defined_class": "properties_class.PropertiesClass",
+        "method_id": "fully_accessible (get)",
+    })
+
+    assert events[2].to_dict() == DictIncluding({
+        "event": "call",
+        "defined_class": "properties_class.PropertiesClass",
+        "method_id": "fully_accessible (set)",
+    })
+
+    assert events[4].to_dict() == DictIncluding({
+        "event": "call",
+        "defined_class": "properties_class.PropertiesClass",
+        "method_id": "fully_accessible (del)",
+    })
+
+
+def test_writable_instrumented(events):
+    from properties_class import PropertiesClass
+
+    ec = PropertiesClass()
+    assert PropertiesClass.write_only.__doc__ == "Write-only"
+
+    with pytest.raises(AttributeError, match=r".*(has no getter|unreadable attribute).*"):
+        _ = ec.write_only
+
+    ec.write_only = "updated example"
+
+    assert len(events) == 2
+    assert events[0].to_dict() == DictIncluding({
+        "event": "call",
+        "defined_class": "properties_class.PropertiesClass",
+        "method_id": "set_write_only (set)",
+    })
+
+
+def test_operator_attrgetter(events):
+    from properties_class import PropertiesClass
+
+    ec = PropertiesClass()
+
+    assert ec.operator_read_only == "read only"
+
+    with pytest.raises(AttributeError, match=r".*(has no setter|can't set attribute).*"):
+        ec.operator_read_only = "not allowed"
+
+    with pytest.raises(AttributeError, match=r".*(has no deleter|can't delete attribute).*"):
+        del ec.operator_read_only
+
+    assert len(events) == 2
+    assert events[0].to_dict() == DictIncluding({
+        "event": "call",
+        "defined_class": "properties_class.PropertiesClass",
+        "method_id": "operator_read_only (get)",
+    })
+
+def test_operator_itemgetter(events):
+    from properties_class import PropertiesClass
+
+    ec = PropertiesClass()
+    assert ec.taste == "yum"
+    assert len(events) == 2
+    assert events[0].to_dict() == DictIncluding({
+        "event": "call",
+        # operator.itemgetter.__module__ isn't available before 3.10
+        # "defined_class": "operator",
+        "method_id": "itemgetter (get)",
+    })
+
+
+def test_free_function(events):
+    from properties_class import PropertiesClass
+
+    ec = PropertiesClass()
+    assert ec.free_read_only_prop == "read only"
+    assert len(events) == 2
+    assert events[0].to_dict() == DictIncluding({
+        "event": "call",
+        "defined_class": "properties_class",
+        "method_id": "free_read_only (get)",
+    })
+
+
+@pytest.mark.xfail(
+    raises=AssertionError,
+    reason="needs fix for https://github.com/getappmap/appmap-python/issues/365",
+)
+def test_functools_partial(events):
+    from properties_class import PropertiesClass
+
+    PropertiesClass.static_partial_method()
+    assert len(events) > 0

{appmap-2.1.4 → 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.4 → 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.4 → appmap-2.1.6}/_appmap/utils.py

@@ -8,7 +8,6 @@ from contextlib import contextmanager
 from contextvars import ContextVar
 from enum import Enum, IntFlag, auto
 from pathlib import Path
-from typing import Any, Callable
 
 from .env import Env
 
@@ -79,10 +78,8 @@ class FqFnName:
     FqFnName makes it easy to reference the parts of the fully-qualified name of a callable.
     """
 
-    def __init__(self, fn: Callable[..., Any]):
-
-        self._modname = fn.__module__
-        qualname = fn.__qualname__
+    def __init__(self, modname, qualname):
+        self._modname = modname
         if "." in qualname:
             self._scope = Scope.CLASS
             self._class_name, self._fn_name = qualname.rsplit(".", 1)
@@ -112,8 +109,6 @@ class FqFnName:
     def fn_name(self):
         return self._fn_name
 
-FqFnName(fqname)
-
 def root_relative_path(path):
     """Returns the path relative to the current root_dir.
 

{appmap-2.1.4 → appmap-2.1.6}/appmap/fastapi.py

@@ -31,7 +31,7 @@ def _add_api_route(wrapped, _, args, kwargs):
 
     fn = args[1]
 
-    fqn = utils.FqFnName(fn)
+    fqn = utils.FqFnName(fn.__module__, fn.__qualname__)
     scope = Filterable(fqn.scope, fqn.fqclass, None)
 
     filterable_fn = FilterableFn(scope, fn.__name__, fn, fn)