appmap 2.0.7__tar.gz → 2.0.9__tar.gz

{appmap-2.0.7 → appmap-2.0.9}/PKG-INFO

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

{appmap-2.0.7 → appmap-2.0.9}/_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.7 → appmap-2.0.9}/_appmap/event.py

@@ -111,7 +111,9 @@ def describe_value(name, val, max_depth=5):
         "object_id": id(val),
         "value": display_string(val),
     }
-    ret.update(_describe_schema(name, val, 0, max_depth))
+    if Env.current.display_params:
+        ret.update(_describe_schema(name, val, 0, max_depth))
+
     if any(_is_list_or_dict(type(val))):
         ret["size"] = len(val)
 

{appmap-2.0.7 → appmap-2.0.9}/_appmap/instrument.py

@@ -6,7 +6,7 @@ from contextlib import contextmanager
 from . import event
 from .env import Env
 from .event import CallEvent
-from .recorder import Recorder, AppMapTooManyEvents
+from .recorder import Recorder, AppMapLimitExceeded
 from .utils import appmap_tls
 
 logger = Env.current.getLogger(__name__)
@@ -90,6 +90,7 @@ def call_instrumented(f, instance, args, kwargs):
     call_event_id = call_event.id
     start_time = time.time()
     try:
+        Recorder.check_time(start_time)
         ret = f.fn(*args, **kwargs)
         elapsed_time = time.time() - start_time
 
@@ -98,7 +99,7 @@ def call_instrumented(f, instance, args, kwargs):
         )
         Recorder.add_event(return_event)
         return ret
-    except AppMapTooManyEvents:
+    except AppMapLimitExceeded:
         raise
     except Exception:  # noqa: E722
         elapsed_time = time.time() - start_time

{appmap-2.0.7 → appmap-2.0.9}/_appmap/recorder.py

@@ -1,4 +1,5 @@
 import threading
+import time
 import traceback
 from abc import ABC, abstractmethod
 
@@ -17,11 +18,23 @@ _MAX_EVENTS = Env.current.get("APPMAP_MAX_EVENTS")
 if _MAX_EVENTS is not None:
     _MAX_EVENTS = int(_MAX_EVENTS)
 
+_MAX_TIME = Env.current.get("APPMAP_MAX_TIME")
+if _MAX_TIME is not None:
+    _MAX_TIME = int(_MAX_TIME)
 
-class AppMapTooManyEvents(RuntimeError):
+
+class AppMapLimitExceeded(RuntimeError):
+    """Class of events thrown when some limit has been exceeded"""
+
+
+class AppMapTooManyEvents(AppMapLimitExceeded):
     """Thrown when a recorder has more than APPMAP_MAX_EVENTS"""
 
 
+class AppMapSessionTooLong(AppMapLimitExceeded):
+    """Throw when an individual recording session has exceeded APPMAP_MAX_TIME"""
+
+
 class Recorder(ABC):
     """
     A base class for Recorders.
@@ -97,6 +110,13 @@ class Recorder(ABC):
     def stop_recording(cls):
         return cls.get_current()._stop_recording()  # pylint: disable=protected-access
 
+    @classmethod
+    def check_time(cls, event_time):
+        if _MAX_TIME is None:
+            return
+        if event_time - cls.get_current()._start_time > _MAX_TIME:
+            raise AppMapSessionTooLong(f"Session exceeded {_MAX_TIME} seconds")
+
     @classmethod
     def add_event(cls, event):
         """
@@ -124,6 +144,7 @@ class Recorder(ABC):
         self._events = []
         self._enabled = enabled
         self.start_tb = None
+        self._start_time = None
 
     @abstractmethod
     def _start_recording(self):
@@ -134,6 +155,7 @@ class Recorder(ABC):
             raise RuntimeError("Recording already in progress")
         self.start_tb = traceback.extract_stack()
         self._enabled = True
+        self._start_time = time.time()
 
     @abstractmethod
     def _stop_recording(self):
@@ -150,7 +172,7 @@ class Recorder(ABC):
         self._events.append(event)
         if _MAX_EVENTS is not None and len(self._events) > _MAX_EVENTS:
             Recorder._aborting = True
-            raise AppMapTooManyEvents()
+            raise AppMapTooManyEvents(f"Session exceeded {_MAX_EVENTS} events")
 
     @staticmethod
     def _initialize():

{appmap-2.0.7 → appmap-2.0.9}/pyproject.toml

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

{appmap-2.0.7 → appmap-2.0.9}/vendor/_appmap/wrapt/wrappers.py

@@ -457,9 +457,11 @@ 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):
-        raise NotImplementedError(
-                'object proxy must define __reduce_ex__()')
+         return self.__wrapped__.__qualname__
 
 class CallableObjectProxy(ObjectProxy):
 
@@ -740,12 +742,9 @@ class FunctionWrapper(_FunctionWrapperBase):
     # 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.
     #
-    # Update: We'll return the qualname of the wrapped function instead of a tuple allows a
-    # FunctionWrapper to be pickled (as the function it wraps). This seems to be adequate for
-    # generating AppMaps, so go with that.
 
-    def __reduce_ex__(self, protocol):
-         return self.__wrapped__.__qualname__
+    # def __reduce_ex__(self, protocol):
+    #      return self.__wrapped__.__qualname__
  
          # return FunctionWrapper, (
          #     self.__wrapped__,