appmap 2.0.10__tar.gz → 2.1.1__tar.gz

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

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

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

@@ -39,6 +39,8 @@ class Env(metaclass=SingletonMeta):
 
         self.log_file_creation_failed = False
         self._configure_logging()
+        # This uses _APPMAP, rather than APPMAP, to control whether instrumentation is enabled. The
+        # tests use this split to make it easier to control recording.
         enabled = self._env.get("_APPMAP", "false")
         self._enabled = enabled is None or enabled.lower() != "false"
 

{appmap-2.0.10 → appmap-2.1.1}/_appmap/event.py

@@ -94,7 +94,8 @@ def _describe_schema(name, val, depth, max_depth):
     if islist:
         elts = [(None, v) for v in val]
         schema_key = "items"
-    elif isdict:
+    else:
+        assert isdict
         elts = val.items()
         schema_key = "properties"
 
@@ -176,7 +177,7 @@ class Param:
 
 class CallEvent(Event):
     # pylint: disable=method-cache-max-size-none
-    __slots__ = ["_fn", "_fqfn", "static", "receiver", "parameters", "labels"]
+    __slots__ = ["_fn", "_fqfn", "static", "receiver", "parameters", "labels", "auxtype"]
 
     @staticmethod
     def make(fn, fntype):
@@ -283,7 +284,10 @@ class CallEvent(Event):
     @property
     @lru_cache(maxsize=None)
     def method_id(self):
-        return self._fqfn.fqfn[1]
+        ret = self._fqfn.fqfn[1]
+        if self.auxtype is not None:
+            ret = f"{ret} ({self.auxtype})"
+        return ret
 
     @property
     @lru_cache(maxsize=None)
@@ -319,6 +323,13 @@ class CallEvent(Event):
             parameters = parameters[1:]
         self.parameters = parameters
         self.labels = labels
+        self.auxtype = None
+        if fntype & FnType.GET:
+            self.auxtype = "get"
+        elif fntype & FnType.SET:
+            self.auxtype = "set"
+        elif fntype & FnType.DEL:
+            self.auxtype = "del"
 
     def to_dict(self, attrs=None):
         ret = super().to_dict()  # get the attrs defined in __slots__
@@ -469,18 +480,19 @@ class HttpResponseEvent(ReturnEvent):
 
     def __init__(self, status_code, headers=None, **kwargs):
         super().__init__(**kwargs)
+        self.response = {}
+        self.update(status_code, headers)
 
-        response = {"status_code": status_code}
+    def update(self, status_code, headers):
+        if status_code is not None:
+            self.response.update({"status_code": status_code})
 
         if headers is not None:
-            response.update(
-                {
-                    "mime_type": headers.get("Content-Type"),
-                    "headers": none_if_empty(dict(headers)),
-                }
-            )
-
-        self.response = compact_dict(response)
+            if "Content-Type" in headers:
+                self.response.update({"mime_type": headers.get("Content-Type")})
+            updated_headers = dict(headers)
+            if len(updated_headers) > 0:
+                self.response.update({"headers": updated_headers})
 
 
 # pylint: disable=too-few-public-methods

{appmap-2.0.10 → appmap-2.1.1}/_appmap/importer.py

@@ -37,14 +37,14 @@ class FilterableCls(Filterable):
 class FilterableFn(
     namedtuple(
         "FilterableFn",
-        Filterable._fields + ("static_fn",),
+        Filterable._fields + ("static_fn", "auxtype"),
     )
 ):
     __slots__ = ()
 
-    def __new__(cls, scope, fn, static_fn):
+    def __new__(cls, scope, fn, static_fn, auxtype=None):
         fqname = "%s.%s" % (scope.fqname, fn.__name__)
-        self = super(FilterableFn, cls).__new__(cls, scope.scope, fqname, fn, static_fn)
+        self = super(FilterableFn, cls).__new__(cls, scope.scope, fqname, fn, static_fn, auxtype)
         return self
 
     @property
@@ -52,7 +52,10 @@ class FilterableFn(
         if self.scope == Scope.MODULE:
             return FnType.MODULE
 
-        return FnType.classify(self.static_fn)
+        ret = FnType.classify(self.static_fn)
+        if self.auxtype is not None:
+            ret |= self.auxtype
+        return ret
 
 
 class Filter(ABC):  # pylint: disable=too-few-public-methods
@@ -122,19 +125,31 @@ def get_members(cls):
     # instead iterate over dir(cls), we would see functions from
     # superclasses, too. Those don't need to be instrumented here,
     # they'll get taken care of when the superclass is imported.
-    ret = []
+    functions = []
+    properties = {}
     modname = cls.__module__ if hasattr(cls, "__module__") else cls.__name__
     for key in cls.__dict__:
         if key.startswith("__"):
             continue
         static_value = inspect.getattr_static(cls, key)
-        if not is_member_func(static_value):
-            continue
-        value = getattr(cls, key)
-        if value.__module__ != modname:
-            continue
-        ret.append((key, static_value, value))
-    return ret
+        if isinstance(static_value, property):
+            properties[key] = (
+                static_value,
+                {
+                    "fget": (static_value.fget, FnType.GET),
+                    "fset": (static_value.fset, FnType.SET),
+                    "fdel": (static_value.fdel, FnType.DEL),
+                },
+            )
+        else:
+            if not is_member_func(static_value):
+                continue
+            value = getattr(cls, key)
+            if value.__module__ != modname:
+                continue
+            functions.append((key, static_value, value))
+
+    return (functions, properties)
 
 
 class Importer:
@@ -177,7 +192,7 @@ class Importer:
 
         def instrument_functions(filterable, selected_functions=None):
             logger.trace("  looking for members of %s", filterable.obj)
-            functions = get_members(filterable.obj)
+            functions, properties = get_members(filterable.obj)
             logger.trace("  functions %s", functions)
 
             for fn_name, static_fn, fn in functions:
@@ -185,6 +200,22 @@ class Importer:
                 new_fn = cls.instrument_function(fn_name, filterableFn, selected_functions)
                 if new_fn != fn:
                     wrapt.wrap_function_wrapper(filterable.obj, fn_name, new_fn)
+            # Now that we've instrumented all the functions, go through the properties and update
+            # them
+            for prop_name, (prop, prop_fns) in properties.items():
+                instrumented_fns = {}
+                for k, (fn, auxtype) in prop_fns.items():
+                    if fn is None or getattr(fn, "_appmap_wrapped", None):
+                        continue
+                    filterableFn = FilterableFn(filterable, fn, fn, auxtype)
+                    new_fn = cls.instrument_function(fn.__name__, filterableFn, selected_functions)
+                    if new_fn != fn:
+                        new_fn = wrapt.FunctionWrapper(fn, new_fn)
+                        setattr(new_fn, "_appmap_wrapped", True)
+                    instrumented_fns[k] = new_fn
+                if len(instrumented_fns) > 0:
+                    instrumented_fns["doc"] = prop.__doc__
+                    setattr(filterable.obj, prop_name, property(**instrumented_fns))
 
         # Import Config here, to avoid circular top-level imports.
         from .configuration import Config  # pylint: disable=import-outside-toplevel

{appmap-2.0.10 → appmap-2.1.1}/_appmap/recorder.py

@@ -114,7 +114,8 @@ class Recorder(ABC):
     def check_time(cls, event_time):
         if _MAX_TIME is None:
             return
-        if event_time - cls.get_current()._start_time > _MAX_TIME:
+        delta = event_time - cls.get_current()._start_time  # pylint: disable=protected-access
+        if delta > _MAX_TIME:
             raise AppMapSessionTooLong(f"Session exceeded {_MAX_TIME} seconds")
 
     @classmethod

{appmap-2.0.10 → appmap-2.1.1}/_appmap/test/conftest.py

@@ -2,7 +2,7 @@ import importlib
 import os
 import socket
 import sys
-from distutils.dir_util import copy_tree
+from shutil import copytree
 from functools import partial, partialmethod
 from pathlib import Path
 from typing import Any
@@ -14,7 +14,7 @@ from xprocess import ProcessStarter
 
 import _appmap
 import appmap
-from _appmap.test.web_framework import TEST_HOST, TEST_PORT
+from _appmap.test.web_framework import TEST_HOST
 from appmap import generation
 
 from .. import utils
@@ -98,7 +98,7 @@ def git_directory_fixture(tmp_path_factory):
 
 @pytest.fixture(name="git")
 def tmp_git(git_directory, tmp_path):
-    copy_tree(git_directory, str(tmp_path))
+    copytree(git_directory, str(tmp_path), dirs_exist_ok=True)
     return utils.git(cwd=tmp_path)
 
 
@@ -198,14 +198,55 @@ def server_starter(info, name, cmd, pattern, env=None):
 
     return _starter
 
+@pytest.fixture(name="server_port")
+def server_port_fixture(worker_id):
+    if worker_id == "master":
+        offset = "0"
+    else:
+        offset = worker_id[2:]
+    return 8000 + int(offset)
+
 
 @pytest.fixture(name="server_base")
-def server_base_fixture(request):
+def server_base_fixture(request, server_port):
     marker = request.node.get_closest_marker("server")
     debug = marker.kwargs.get("debug", False)
     server_env = os.environ.copy()
     server_env.update(marker.kwargs.get("env", {}))
 
-    info = ServerInfo(debug=debug, host=TEST_HOST, port=TEST_PORT, env=server_env)
+    info = ServerInfo(debug=debug, host=TEST_HOST, port=server_port, env=server_env)
     info.factory = partial(server_starter, info)
     return info
+
+@pytest.fixture(name="testdir")
+def testdir_fixture(request, data_dir, pytester, monkeypatch):
+    # We need to set environment variables to control how tests are run. This will only work
+    # properly if pytester runs pytest in a subprocess.
+    assert (
+        pytester._method == "subprocess"  # pylint:disable=protected-access
+    ), "must run pytest in a subprocess"
+
+    # The init subdirectory contains a sitecustomize.py file that
+    # imports the appmap module. This simulates the way a real
+    # installation works, performing the same function as the the
+    # appmap.pth file that gets put in site-packages.
+    monkeypatch.setenv("PYTHONPATH", "init")
+
+    # Make sure _APPMAP isn't in the environment, to test that recording-by-default is working as
+    # expected. Individual test cases may set it as necessary.
+    monkeypatch.delenv("_APPMAP", raising=False)
+
+    marker = request.node.get_closest_marker("example_dir")
+    test_type = "unittest" if marker is None else marker.args[0]
+    pytester.copy_example(test_type)
+
+    pytester.expected = data_dir / test_type / "expected"
+    pytester.test_type = test_type
+
+    # this is so test_type can be overriden in test cases
+    def output_dir():
+        return pytester.path / "tmp" / "appmap" / pytester.test_type
+
+    pytester.output = output_dir
+
+    return pytester

{appmap-2.0.10 → appmap-2.1.1}/_appmap/test/data/example_class.py

@@ -113,6 +113,53 @@ 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 modfunc():
     return "Hello world!"
+
+if __name__ == "__main__":
+    ec = ExampleClass()
+    ec.fully_accessible = "updated"
+    print(ec.fully_accessible)

{appmap-2.0.10 → appmap-2.1.1}/_appmap/test/data/flask/flaskapp.py

@@ -6,8 +6,9 @@ testing of record-by-default.
 """
 # pylint: disable=missing-function-docstring
 
-from flask import Flask, make_response
+from flask import Flask, make_response, request
 from markupsafe import escape
+import werkzeug
 
 app = Flask(__name__)
 
@@ -50,3 +51,13 @@ def show_org_user_posts(org, username):
 @app.route("/exception")
 def raise_exception():
     raise Exception("An exception")
+
+@app.post("/do_post")
+def do_post():
+    _ = request.get_json()
+    return "Got post request"
+
+
+@app.errorhandler(werkzeug.exceptions.BadRequest)
+def handle_bad_request(e):
+    return "That's a bad request!", 400

appmap-2.1.1/_appmap/test/data/flask/test_app.py

@@ -0,0 +1,26 @@
+import pytest
+from flaskapp import app
+
+
+@pytest.fixture(name="client")
+def test_client():
+    with app.test_client() as c:  # pylint: disable=no-member
+        yield c
+
+
+def test_request(client):
+    response = client.get("/")
+
+    assert response.status_code == 200
+
+def test_not_found(client):
+    response = client.get("/not_found")
+
+    assert response.status_code == 404
+
+
+def test_errorhandler(client):
+    response = client.post("/do_post", content_type="application/json")
+
+    assert response.status_code == 400
+    assert response.text == "That's a bad request!"

appmap-2.1.1/_appmap/test/data/flask-instrumented/appmap.yml

@@ -0,0 +1,4 @@
+name: FlaskTest
+packages:
+- path: flaskapp
+- path: flask

appmap-2.1.1/_appmap/test/data/flask-instrumented/flaskapp.py

@@ -0,0 +1,30 @@
+"""
+Rudimentary Flask application for testing.
+"""
+# pylint: disable=missing-function-docstring
+
+import werkzeug
+from appmap.flask import AppmapFlask
+from flask import Flask, request
+
+app = Flask(__name__)
+AppmapFlask(app).init_app()
+
+
+@app.route("/")
+def hello_world():
+    return "Hello, World!"
+
+@app.route("/exception")
+def raise_exception():
+    raise Exception("An exception")
+
+@app.post("/do_post")
+def do_post():
+    _ = request.get_json()
+    return "Got post request"
+
+
+@app.errorhandler(werkzeug.exceptions.BadRequest)
+def handle_bad_request(e):
+    return "That's a bad request!", 400

appmap-2.1.1/_appmap/test/data/flask-instrumented/test_app.py

@@ -0,0 +1,31 @@
+import pytest
+from flaskapp import app
+
+
+@pytest.fixture(name="client")
+def test_client():
+    with app.test_client() as c:  # pylint: disable=no-member
+        yield c
+
+
+def test_request(client):
+    response = client.get("/")
+
+    assert response.status_code == 200
+
+def test_exception(client):
+    response = client.get("/exception")
+
+    assert response.status_code == 500
+
+def test_not_found(client):
+    response = client.get("/not_found")
+
+    assert response.status_code == 404
+
+
+def test_errorhandler(client):
+    response = client.post("/do_post", content_type="application/json")
+
+    assert response.status_code == 400
+    assert response.text == "That's a bad request!"