appmap 2.1.2__tar.gz → 2.1.4__tar.gz

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

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

{appmap-2.1.2 → appmap-2.1.4}/_appmap/configuration.py

@@ -5,13 +5,16 @@ Manage Configuration AppMap recorder for Python.
 import ast
 import importlib.metadata
 import inspect
+import json
 import os
+import re
 import sys
 from os.path import realpath
 from pathlib import Path
 from textwrap import dedent
 
 import yaml
+from yaml import SafeLoader
 from yaml.parser import ParserError
 
 from _appmap.labels import LabelSet
@@ -49,20 +52,19 @@ def _get_sys_prefix():
     return realpath(sys.prefix)
 
 
+_EXCLUDE_PATTERN = re.compile(r"\..*|node_modules|.*test.*|site-packages")
+
+
 def find_top_packages(rootdir):
     """
-    Scan a directory tree for packages that should appear in the
-    default config file.
+    Scan a directory tree for packages that should appear in the default config file.
 
-    Examine directories in rootdir, to see if they contains an
-    __init__.py.  If it does, add it to the list of packages and don't
-    scan any of its subdirectories.  If it doesn't, scan its
+    Examine each directory in rootdir, to see if it contains an __init__.py.  If it does, add it to
+    the list of packages and don't scan any of its subdirectories.  If it doesn't, scan its
     subdirectories to find __init__.py.
 
-    Some directories are automatically excluded from the search:
-      * sys.prefix
-      * Hidden directories (i.e. those that start with a '.')
-      * node_modules
+    Directory traversal will stop at directories that match _EXCLUDE_PATTERN. Such a directory (and
+    its subdirectories) will not be added to the returned packages.
 
     For example, in a directory like this
 
@@ -70,7 +72,7 @@ def find_top_packages(rootdir):
         LICENSE Makefile appveyor.yml docs/ src/ tests/
         MANIFEST.in README.rst blog/ setup.py tddium.yml tox.ini
 
-    docs, src, tests, and blog will get scanned.
+    docs, src, blog will get scanned. tests will be ignored.
 
     Only src has a subdirectory containing an __init__.py:
 
@@ -104,7 +106,7 @@ def find_top_packages(rootdir):
     packages = set()
 
     def excluded(d):
-        excluded = d == "node_modules" or d[0] == "."
+        excluded = _EXCLUDE_PATTERN.search(d) is not None
         if excluded:
             logger.trace("excluding dir %s", d)
         return excluded
@@ -129,6 +131,19 @@ def find_top_packages(rootdir):
 class AppMapInvalidConfigException(Exception):
     pass
 
+# We don't have any control over the PyYAML class hierarchy, so we can't control how many ancestors
+# SafeLoader has....
+class _ConfigLoader(SafeLoader):  # pylint: disable=too-many-ancestors
+    def construct_mapping(self, node, deep=False):
+        mapping = super().construct_mapping(node, deep=deep)
+        # Allow record_test_cases to be set using a string (in addition to allowing a boolean).
+        if "record_test_cases" in mapping:
+            val = mapping["record_test_cases"]
+            if isinstance(val, str):
+                mapping["record_test_cases"] = val.lower() == "true"
+        return mapping
+
+
 class Config(metaclass=SingletonMeta):
     """Singleton Config class"""
 
@@ -144,6 +159,9 @@ class Config(metaclass=SingletonMeta):
         if "labels" in self._config:
             self.labels.append(self._config["labels"])
 
+    def __repr__(self):
+        return json.dumps(self._config["packages"])
+
     @property
     def name(self):
         return self._config["name"]
@@ -152,11 +170,16 @@ class Config(metaclass=SingletonMeta):
     def packages(self):
         return self._config["packages"]
 
+    @property
+    def record_test_cases(self):
+        return self._config.get("record_test_cases", False)
+
     @property
     def default(self):
         ret = {
             "name": self.default_name,
             "language": "python",
+            "record_test_cases": False,
             "packages": self.default_packages,
         }
         env = Env.current
@@ -229,7 +252,7 @@ class Config(metaclass=SingletonMeta):
             Env.current.enabled = False
             self.file_valid = False
             try:
-                self._config = yaml.safe_load(path.read_text(encoding="utf-8"))
+                self._config = yaml.load(path.read_text(encoding="utf-8"), Loader=_ConfigLoader)
                 if not self._config:
                     # It parsed, but was (effectively) empty.
                     self._config = self.default
@@ -330,7 +353,6 @@ It will be created with this configuration:
         except SyntaxError:
             return False
 
-
 def startswith(prefix, sequence):
     """
     Check if a sequence starts with the prefix.
@@ -373,7 +395,8 @@ class DistMatcher(PathMatcher):
     def __init__(self, dist, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.dist = dist
-        self.files = [str(pp.locate()) for pp in importlib.metadata.files(dist)]
+        dist_files = importlib.metadata.files(dist)
+        self.files = [str(pp.locate()) for pp in dist_files] if dist_files is not None else []
 
     def matches(self, filterable):
         try:
@@ -419,8 +442,8 @@ class MatcherFilter(Filter):
         # appropriate.
         #
         rule = self.match(filterable)
-        wrapped = getattr(filterable.obj, "_appmap_wrapped", None)
-        if wrapped is None:
+        wrapped = getattr(filterable.obj, "_appmap_instrumented", None)
+        if not wrapped:
             logger.trace("  wrapping %s", filterable.fqname)
             Config.current.labels.apply(filterable)
             ret = instrument(filterable)
@@ -483,6 +506,7 @@ if _startup_messages_shown is None:
     # pylint: disable=protected-access
     c._load_config(show_warnings=True)
     logger.info("file: %s", c._file if c.file_present else "[no appmap.yml]")
+    logger.info("config: %r", c)
     logger.debug("package_functions: %s", c.package_functions)
     logger.info("env: %r", os.environ)
     os.environ["_APPMAP_MESSAGES_SHOWN"] = "true"

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

@@ -42,8 +42,8 @@ class FilterableFn(
 ):
     __slots__ = ()
 
-    def __new__(cls, scope, fn, static_fn, auxtype=None):
-        fqname = "%s.%s" % (scope.fqname, fn.__name__)
+    def __new__(cls, scope, fn_name, fn, static_fn, auxtype=None):  # pylint: disable=too-many-arguments
+        fqname = "%s.%s" % (scope.fqname, fn_name)
         self = super(FilterableFn, cls).__new__(cls, scope.scope, fqname, fn, static_fn, auxtype)
         return self
 
@@ -132,7 +132,9 @@ def get_members(cls):
         if key.startswith("__"):
             continue
         static_value = inspect.getattr_static(cls, key)
-        if isinstance(static_value, property):
+        # 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
             properties[key] = (
                 static_value,
                 {
@@ -164,6 +166,9 @@ class Importer:
         cls.filter_stack = []
         cls.filter_chain = []
         cls._skip_instrumenting = ("appmap", "_appmap")
+        cls.instrument_properties = (
+            Env.current.get("APPMAP_INSTRUMENT_PROPERTIES", "false").lower() == "true"
+        )
 
     @classmethod
     def use_filter(cls, filter_class):
@@ -191,27 +196,34 @@ class Importer:
             cls.filter_chain = reduce(lambda acc, e: e(acc), cls.filter_stack, NullFilter(None))
 
         def instrument_functions(filterable, selected_functions=None):
+            # pylint: disable=too-many-locals
             logger.trace("  looking for members of %s", filterable.obj)
             functions, properties = get_members(filterable.obj)
             logger.trace("  functions %s", functions)
 
             for fn_name, static_fn, fn in functions:
-                filterableFn = FilterableFn(filterable, 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:
-                    wrapt.wrap_function_wrapper(filterable.obj, fn_name, new_fn)
+                    fw = wrapt.wrap_function_wrapper(filterable.obj, fn_name, new_fn)
+                    fw._appmap_instrumented = True  # pylint: disable=protected-access
+
             # 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):
+                    if fn is None:
                         continue
-                    filterableFn = FilterableFn(filterable, fn, fn, auxtype)
-                    new_fn = cls.instrument_function(fn.__name__, filterableFn, selected_functions)
+                    filterableFn = FilterableFn(filterable, prop_name, fn, fn, auxtype)
+                    if getattr(fn, "_appmap_instrumented", None):
+                        continue
+                    new_fn = cls.instrument_function(prop_name, filterableFn, selected_functions)
                     if new_fn != fn:
                         new_fn = wrapt.FunctionWrapper(fn, new_fn)
-                        setattr(new_fn, "_appmap_wrapped", True)
+                        # 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
                 if len(instrumented_fns) > 0:
                     instrumented_fns["doc"] = prop.__doc__

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

@@ -138,5 +138,5 @@ def instrument(filterable):
             return call_instrumented(f, instance, args, kwargs)
 
     ret = instrumented_fn
-    setattr(ret, "_appmap_wrapped", True)
+    setattr(ret, "_appmap_instrumented", True)
     return ret

appmap-2.1.2/_appmap/test/data/unittest/appmap.yml → appmap-2.1.4/_appmap/test/data/pytest/appmap-no-test-cases.yml

@@ -1,3 +1,4 @@
 name: Simple
+record_test_cases: false
 packages:
 - path: simple

appmap-2.1.4/_appmap/test/data/pytest/appmap.yml

@@ -0,0 +1,5 @@
+name: Simple
+record_test_cases: true
+packages:
+- path: simple
+- path: tests

appmap-2.1.2/_appmap/test/data/pytest/expected/pytest-numpy1.appmap.json → appmap-2.1.4/_appmap/test/data/pytest/expected/pytest-numpy1-no-test-cases.appmap.json

@@ -13,7 +13,7 @@
       "name": "pytest",
       "type": "tests"
     },
-    "source_location": "test_simple.py:5",
+    "source_location": "tests/test_simple.py:5",
     "name": "hello world",
     "feature": "Hello world",
     "test_status": "succeeded"

appmap-2.1.4/_appmap/test/data/pytest/expected/pytest-numpy1.appmap.json

@@ -0,0 +1,281 @@
+{
+  "version": "1.9",
+  "metadata": {
+    "language": {
+      "name": "python"
+    },
+    "client": {
+      "name": "appmap",
+      "url": "https://github.com/applandinc/appmap-python"
+    },
+    "source_location": "tests/test_simple.py:5",
+    "name": "hello world",
+    "feature": "Hello world",
+    "app": "Simple",
+    "recorder": {
+      "name": "pytest",
+      "type": "tests"
+    },
+    "test_status": "succeeded"
+  },
+  "events": [
+    {
+      "static": true,
+      "parameters": [],
+      "id": 1,
+      "event": "call",
+      "thread_id": 1,
+      "defined_class": "tests.test_simple",
+      "method_id": "test_hello_world",
+      "path": "tests/test_simple.py",
+      "lineno": 6
+    },
+    {
+      "static": false,
+      "receiver": {
+        "kind": "req",
+        "value": "<simple.Simple object at 0xabcdef>",
+        "name": "self",
+        "class": "simple.Simple"
+      },
+      "parameters": [],
+      "id": 2,
+      "event": "call",
+      "thread_id": 1,
+      "defined_class": "simple.Simple",
+      "method_id": "hello_world",
+      "path": "simple.py",
+      "lineno": 8
+    },
+    {
+      "static": false,
+      "receiver": {
+        "kind": "req",
+        "value": "<simple.Simple object at 0xabcdef>",
+        "name": "self",
+        "class": "simple.Simple"
+      },
+      "parameters": [],
+      "id": 3,
+      "event": "call",
+      "thread_id": 1,
+      "defined_class": "simple.Simple",
+      "method_id": "hello",
+      "path": "simple.py",
+      "lineno": 2
+    },
+    {
+      "return_value": {
+        "value": "'Hello'",
+        "class": "builtins.str"
+      },
+      "parent_id": 3,
+      "id": 4,
+      "event": "return",
+      "thread_id": 1
+    },
+    {
+      "static": false,
+      "receiver": {
+        "kind": "req",
+        "value": "<simple.Simple object at 0xabcdef>",
+        "name": "self",
+        "class": "simple.Simple"
+      },
+      "parameters": [],
+      "id": 5,
+      "event": "call",
+      "thread_id": 1,
+      "defined_class": "simple.Simple",
+      "method_id": "world",
+      "path": "simple.py",
+      "lineno": 5
+    },
+    {
+      "return_value": {
+        "value": "'world!'",
+        "class": "builtins.str"
+      },
+      "parent_id": 5,
+      "id": 6,
+      "event": "return",
+      "thread_id": 1
+    },
+    {
+      "return_value": {
+        "value": "'Hello world!'",
+        "class": "builtins.str"
+      },
+      "parent_id": 2,
+      "id": 7,
+      "event": "return",
+      "thread_id": 1
+    },
+    {
+      "static": false,
+      "receiver": {
+        "kind": "req",
+        "value": "<simple.Simple object at 0xabcdef>",
+        "name": "self",
+        "class": "simple.Simple"
+      },
+      "parameters": [],
+      "id": 8,
+      "event": "call",
+      "thread_id": 1,
+      "defined_class": "simple.Simple",
+      "method_id": "show_numpy_dict",
+      "path": "simple.py",
+      "lineno": 11
+    },
+    {
+      "static": false,
+      "receiver": {
+        "kind": "req",
+        "value": "<simple.Simple object at 0xabcdef>",
+        "name": "self",
+        "class": "simple.Simple"
+      },
+      "parameters": [
+        {
+          "kind": "req",
+          "value": "{0: 'zero', 1: 'one'}",
+          "name": "d",
+          "class": "builtins.dict",
+          "properties": [
+            {
+              "name": "0",
+              "class": "builtins.str"
+            },
+            {
+              "name": "1",
+              "class": "builtins.str"
+            }
+          ],
+          "size": 2
+        }
+      ],
+      "id": 9,
+      "event": "call",
+      "thread_id": 1,
+      "defined_class": "simple.Simple",
+      "method_id": "get_numpy_dict",
+      "path": "simple.py",
+      "lineno": 18
+    },
+    {
+      "return_value": {
+        "value": "{0: 'zero', 1: 'one'}",
+        "class": "builtins.dict",
+        "properties": [
+          {
+            "name": "0",
+            "class": "builtins.str"
+          },
+          {
+            "name": "1",
+            "class": "builtins.str"
+          }
+        ],
+        "size": 2
+      },
+      "parent_id": 9,
+      "id": 10,
+      "event": "return",
+      "thread_id": 1
+    },
+    {
+      "return_value": {
+        "value": "{0: 'zero', 1: 'one'}",
+        "class": "builtins.dict",
+        "properties": [
+          {
+            "name": "0",
+            "class": "builtins.str"
+          },
+          {
+            "name": "1",
+            "class": "builtins.str"
+          }
+        ],
+        "size": 2
+      },
+      "parent_id": 8,
+      "id": 11,
+      "event": "return",
+      "thread_id": 1
+    },
+    {
+      "return_value": {
+        "value": "None",
+        "class": "builtins.NoneType"
+      },
+      "parent_id": 1,
+      "id": 12,
+      "event": "return",
+      "thread_id": 1
+    }
+  ],
+  "classMap": [
+    {
+      "name": "simple",
+      "type": "package",
+      "children": [
+        {
+          "name": "Simple",
+          "type": "class",
+          "children": [
+            {
+              "name": "get_numpy_dict",
+              "type": "function",
+              "location": "simple.py:18",
+              "static": false
+            },
+            {
+              "name": "hello",
+              "type": "function",
+              "location": "simple.py:2",
+              "static": false
+            },
+            {
+              "name": "hello_world",
+              "type": "function",
+              "location": "simple.py:8",
+              "static": false
+            },
+            {
+              "name": "show_numpy_dict",
+              "type": "function",
+              "location": "simple.py:11",
+              "static": false
+            },
+            {
+              "name": "world",
+              "type": "function",
+              "location": "simple.py:5",
+              "static": false
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "name": "tests",
+      "type": "package",
+      "children": [
+        {
+          "name": "test_simple",
+          "type": "class",
+          "children": [
+            {
+              "name": "test_hello_world",
+              "type": "function",
+              "location": "tests/test_simple.py:6",
+              "static": true
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

appmap-2.1.2/_appmap/test/data/pytest/expected/pytest-numpy2.appmap.json → appmap-2.1.4/_appmap/test/data/pytest/expected/pytest-numpy2-no-test-cases.appmap.json

@@ -13,7 +13,7 @@
       "name": "pytest",
       "type": "tests"
     },
-    "source_location": "test_simple.py:5",
+    "source_location": "tests/test_simple.py:5",
     "name": "hello world",
     "feature": "Hello world",
     "test_status": "succeeded"