appmap 3.0.0__tar.gz → 4.0.0__tar.gz

{appmap-3.0.0 → appmap-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: appmap
-Version: 3.0.0
+Version: 4.0.0
 Summary: Create AppMap files by recording a Python application.
 Project-URL: Homepage, https://github.com/applandinc/appmap-python
 Author-email: Alan Potter <alan@app.land>, Viraj Kanwade <viraj.kanwade@forgeahead.io>, Rafał Rzepecki <rafal@app.land>
@@ -9,14 +9,24 @@ License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
 Classifier: Framework :: Flask
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Debuggers
 Classifier: Topic :: Software Development :: Documentation
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Requires-Dist: importlib-resources>=5.4.0
 Requires-Dist: inflection>=0.3.0
 Requires-Dist: packaging>=19.0
@@ -33,8 +43,7 @@ Requires-Dist: httpretty<2.0,>=1.0.5; extra == 'dev'
 Requires-Dist: httpx<1.0,>=0.27.0; extra == 'dev'
 Requires-Dist: incremental<24.7.0; extra == 'dev'
 Requires-Dist: isort<6.0,>=5.10.1; extra == 'dev'
-Requires-Dist: numpy<2.0,>=1.24.4; (python_version < '3.9') and extra == 'dev'
-Requires-Dist: numpy>=2.0; (python_version >= '3.9') and extra == 'dev'
+Requires-Dist: numpy>=2.0; extra == 'dev'
 Requires-Dist: pprintpp<1.0,>=0.4.0; extra == 'dev'
 Requires-Dist: psutil<7.0,>=6.0.0; extra == 'dev'
 Requires-Dist: pyfakefs<6.0,>=5.3.5; extra == 'dev'
@@ -66,8 +75,7 @@ Requires-Dist: flask; extra == 'test'
 Requires-Dist: httpretty<2.0,>=1.0.5; extra == 'test'
 Requires-Dist: httpx<1.0,>=0.27.0; extra == 'test'
 Requires-Dist: incremental<24.7.0; extra == 'test'
-Requires-Dist: numpy<2.0,>=1.24.4; (python_version < '3.9') and extra == 'test'
-Requires-Dist: numpy>=2.0; (python_version >= '3.9') and extra == 'test'
+Requires-Dist: numpy>=2.0; extra == 'test'
 Requires-Dist: psutil<7.0,>=6.0.0; extra == 'test'
 Requires-Dist: pyfakefs<6.0,>=5.3.5; extra == 'test'
 Requires-Dist: pytest-console-scripts<2.0,>=1.4.1; extra == 'test'
@@ -185,7 +193,7 @@ cd appmap-python
 APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest
 
 # Run tests with a specific Python version
-APPMAP_DISPLAY_PARAMS=true uv run --python 3.9 appmap-python pytest
+APPMAP_DISPLAY_PARAMS=true uv run --python 3.11 appmap-python pytest
 
 # Run tests in parallel
 APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest -n auto

{appmap-3.0.0 → appmap-4.0.0}/README.md

@@ -96,7 +96,7 @@ cd appmap-python
 APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest
 
 # Run tests with a specific Python version
-APPMAP_DISPLAY_PARAMS=true uv run --python 3.9 appmap-python pytest
+APPMAP_DISPLAY_PARAMS=true uv run --python 3.11 appmap-python pytest
 
 # Run tests in parallel
 APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest -n auto

{appmap-3.0.0 → appmap-4.0.0}/_appmap/__init__.py

@@ -12,6 +12,7 @@ def initialize(**kwargs):
     importer.initialize()
     recorder.initialize()
     configuration.initialize()  # needs to be initialized after recorder
+    importer.install()  # needs the filters registered by configuration
     metadata.initialize()
     web_framework.initialize()
     recording.initialize()

{appmap-3.0.0 → appmap-4.0.0}/_appmap/configuration.py

@@ -185,13 +185,10 @@ class Config(metaclass=SingletonMeta):
         env = Env.current
         output_dir = env.output_dir
         root_dir = env.root_dir
-        try:
+        # If output_dir isn't relative to root_dir, APPMAP_OUTPUT_DIR is set, and we've already
+        # logged a warning.
+        if output_dir.is_relative_to(root_dir):
             ret["appmap_dir"] = str(output_dir.relative_to(root_dir))
-        except ValueError:
-            # The only way we can get here is if APPMAP_OUTPUT_DIR is set, and we've already logged
-            # a warning. (Note that PurePath.is_relative_to wasn't added till 3.9, so it can't be
-            # used here.)
-            pass
 
         return ret
 
@@ -508,5 +505,13 @@ if _startup_messages_shown is None:
     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)
+    # Only log AppMap's own settings, never the full environment: arbitrary
+    # environment variables (API keys, credentials, tokens, etc.) must never
+    # end up in application logs.
+    appmap_env = {
+        k: v
+        for k, v in os.environ.items()
+        if k in ("APPMAP", "_APPMAP") or k.startswith(("APPMAP_", "_APPMAP_"))
+    }
+    logger.info("env: %r", appmap_env)
     os.environ["_APPMAP_MESSAGES_SHOWN"] = "true"

{appmap-3.0.0 → appmap-4.0.0}/_appmap/env.py

@@ -168,7 +168,10 @@ class Env(metaclass=SingletonMeta):
         trace_logger.install()
 
         log_level = self.get("APPMAP_LOG_LEVEL", "warn").upper()
-        disable_log = os.environ.get("APPMAP_DISABLE_LOG_FILE", "false").upper() != "FALSE"
+        # No log file unless the user opts in: it can contain data (e.g.
+        # rendered parameter values) that shouldn't be written to disk or
+        # committed to source control by default.
+        disable_log = os.environ.get("APPMAP_DISABLE_LOG_FILE", "true").upper() != "FALSE"
         log_config = self.get("APPMAP_LOG_CONFIG")
         config_dict = {
             "version": 1,

{appmap-3.0.0 → appmap-4.0.0}/_appmap/event.py

@@ -156,10 +156,11 @@ class Event:
 
 
 class Param:
-    __slots__ = ["name", "kind", "default", "default_class"]
+    __slots__ = ["name", "kind", "positional_only", "default", "default_class"]
 
     def __init__(self, sigp):
         self.name = sigp.name
+        self.positional_only = sigp.kind == Parameter.POSITIONAL_ONLY
         has_default = sigp.default is not Signature.empty
         if sigp.kind in (Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD):
             self.kind = "opt" if has_default else "req"
@@ -275,28 +276,34 @@ class CallEvent(Event):
             # we're popping the front repeatedly, lists are better at this
             args = list(args)
 
+        # Names of keyword arguments bound to named parameters. Python
+        # doesn't include them in **kwargs, so neither do we.
+        bound = set()
         for p in params:
-            if p.kind == "req":
-                # A 'req' argument can be either keyword or
-                # positional.
-                if p.name in kwargs:
+            if p.kind in ("req", "opt"):
+                # These can be either keyword or positional, unless
+                # they're positional-only.
+                if not p.positional_only and p.name in kwargs:
                     value = kwargs[p.name]
+                    bound.add(p.name)
+                elif args:
+                    value = args.pop(0)
+                elif p.kind == "opt":
+                    value = p.default
                 else:
-                    if args:
-                        value = args.pop(0)
-                    else:
-                        continue  # required argument missing
-            elif p.kind == "keyreq":
+                    continue  # required argument missing
+            elif p.kind in ("keyreq", "key"):
                 if p.name in kwargs:
                     value = kwargs[p.name]
+                    bound.add(p.name)
+                elif p.kind == "key":
+                    value = p.default
                 else:
                     continue  # required argument missing
-            elif p.kind in ("opt", "key"):
-                value = kwargs.get(p.name, p.default)
             elif p.kind == "rest":
                 value = tuple(args)
             elif p.kind == "keyrest":
-                value = kwargs
+                value = {k: v for k, v in kwargs.items() if k not in bound} if bound else kwargs
             else:
                 # If all the parameter types are handled, this
                 # shouldn't ever happen...

{appmap-3.0.0 → appmap-4.0.0}/_appmap/importer.py

@@ -166,7 +166,7 @@ class Importer:
     @classmethod
     def initialize(cls):
         cls.filter_stack = []
-        cls.filter_chain = []
+        cls.filter_chain = None
         cls._skip_instrumenting = ("appmap", "_appmap")
         cls.instrument_properties = (
             Env.current.get("APPMAP_INSTRUMENT_PROPERTIES", "true").lower() == "true"
@@ -176,6 +176,10 @@ class Importer:
     def use_filter(cls, filter_class):
         cls.filter_stack.append(filter_class)
 
+    @classmethod
+    def build_filter_chain(cls):
+        cls.filter_chain = reduce(lambda acc, e: e(acc), cls.filter_stack, NullFilter(None))
+
     @classmethod
     def instrument_function(cls, fn_name, filterableFn: FilterableFn, selected_functions=None):
         # Only instrument the function if it was specifically called out for the package
@@ -194,8 +198,10 @@ class Importer:
             return
 
         logger.trace("do_import, mod %s args %s kwargs %s", mod, args, kwargs)
-        if not cls.filter_chain:
-            cls.filter_chain = reduce(lambda acc, e: e(acc), cls.filter_stack, NullFilter(None))
+        if cls.filter_chain is None:
+            # Only possible while _appmap is being (re)initialized, before install() has run.
+            logger.trace("no filter chain yet, not instrumenting %s", mod.__name__)
+            return
 
         def instrument_functions(filterable, selected_functions=None):
             # pylint: disable=too-many-locals
@@ -314,26 +320,18 @@ def wrapped_find_spec(find_spec, _, args, kwargs):
 
 
 def wrap_finder_find_spec(finder):
-    # Prior to 3.11, it worked fine to just grab find_spec from the finder and wrap it. The
-    # implementation of builtin finders must have changed with 3.11, because we now need the same
-    # kind of workaround we use above for exec_module.
-    if sys.version_info[1] < 11:
-        find_spec = getattr(finder, "find_spec", None)
-        if find_spec is None:
-            logger.trace("no find_spec for finder %r", finder)
-            return
-
+    # Builtin finders define find_spec as a classmethod or staticmethod, which wrapt has trouble
+    # identifying (see the comment in wrapped_find_spec above), so wrap the descriptor found in
+    # __dict__ instead.
+    find_spec = inspect.getattr_static(finder, "find_spec", None)
+    if find_spec is None:
+        logger.trace("no find_spec for finder %r", finder)
+        return
+
+    if isinstance(find_spec, (classmethod, staticmethod)):
         finder.find_spec = wrap_finder_function(find_spec, wrapped_find_spec)
     else:
-        find_spec = inspect.getattr_static(finder, "find_spec", None)
-        if find_spec is None:
-            logger.trace("no find_spec for finder %r", finder)
-            return
-
-        if isinstance(find_spec, (classmethod, staticmethod)):
-            finder.find_spec = wrap_finder_function(find_spec, wrapped_find_spec)
-        else:
-            finder.find_spec = wrap_finder_function(finder.find_spec, wrapped_find_spec)
+        finder.find_spec = wrap_finder_function(finder.find_spec, wrapped_find_spec)
 
 
 class MetapathObserver(MutableSequence):
@@ -362,6 +360,18 @@ class MetapathObserver(MutableSequence):
 
 def initialize():
     Importer.initialize()
+
+
+def install():
+    """
+    Build the filter chain and hook the finders. Must run after the filters have been registered
+    (i.e. after configuration.initialize()).
+
+    The chain is built before the finders are hooked because building it can import modules (e.g.
+    since 3.13, importlib.metadata.files imports csv lazily). If the hooks were already in place,
+    those imports would need the chain that's still being built.
+    """
+    Importer.build_filter_chain()
     # If we're not enabled, there's no reason to hook the finders.
     if Env.current.enabled:
         logger.trace("sys.metapath: %s", sys.meta_path)

{appmap-3.0.0 → appmap-4.0.0}/_appmap/py_version_check.py

@@ -17,7 +17,7 @@ def _get_platform_version():
 
 
 def check_py_version():
-    req = (3, 8)
+    req = (3, 11)
     actual = _get_platform_version()
     if _get_py_version() < req:
         raise AppMapPyVerException(

{appmap-3.0.0 → appmap-4.0.0}/_appmap/test/data/params.py

@@ -22,6 +22,9 @@ class C:
     def with_defaults(self, p1=1, p2=2):
         return "%s %s" % (p1, p2)
 
+    def mixed(self, a, b=None, c="dflt", *args, d, e="e", **kwargs):
+        return "%s %s %s %s %s %s %s" % (a, b, c, args, d, e, kwargs)
+
 
 if sys.version_info >= (3, 8):
     exec(
@@ -33,5 +36,9 @@ C.positional_only = positional_only
 def keyword_only(self, *, p1, p2):
     return '%s %s' % (p1, p2)
 C.keyword_only = keyword_only
+
+def positional_only_kwargs(self, a, b="dflt", /, **kwargs):
+    return '%s %s %s' % (a, b, kwargs)
+C.positional_only_kwargs = positional_only_kwargs
     """
     )

{appmap-3.0.0 → appmap-4.0.0}/_appmap/test/test_command.py

@@ -115,14 +115,14 @@ class TestAgentValidate:
     def test_python_version(self, capsys, mocker):
         mocker.patch(
             "_appmap.py_version_check._get_py_version",
-            return_value=(3, 5),
+            return_value=(3, 10),
         )
         mocker.patch(
             "_appmap.py_version_check._get_platform_version",
-            return_value="3.5",
+            return_value="3.10",
         )
 
-        self.check_errors(capsys, 1, 1, r"Minimum Python version supported is \d\.\d, found")
+        self.check_errors(capsys, 1, 1, r"Minimum Python version supported is \d+\.\d+, found")
 
     def test_django_version(self, capsys, mocker):
         mocker.patch(

{appmap-3.0.0 → appmap-4.0.0}/_appmap/test/test_params.py

@@ -266,9 +266,6 @@ class TestInstanceMethods(TestMethodBase):
             },
         )
 
-    @pytest.mark.skipif(
-        sys.version_info < (3, 8), reason="positional-only added in 3.8"
-    )
     @pytest.mark.parametrize("params", ["positional_only"], indirect=True)
     def test_positional_only(self, params):
         evt = params.C().positional_only(1, 2)
@@ -282,7 +279,6 @@ class TestInstanceMethods(TestMethodBase):
             evt, 1, {"class": "builtins.int", "kind": "req", "name": "p2", "value": "2"}
         )
 
-    @pytest.mark.skipif(sys.version_info < (3, 8), reason="keyword-only added in 3.8")
     @pytest.mark.parametrize("params", ["keyword_only"], indirect=True)
     def test_keyword_only(self, params):
         evt = params.C().keyword_only(p2=2, p1=1)
@@ -325,3 +321,161 @@ class TestInstanceMethods(TestMethodBase):
         self.assert_parameter(
             evt, 1, {"class": "builtins.int", "kind": "opt", "name": "p2", "value": "4"}
         )
+
+    @pytest.mark.parametrize("params", ["with_defaults"], indirect=True)
+    def test_defaults_positional(self, params):
+        evt = params.C().with_defaults(3, 4)
+        assert len(evt.parameters) == 2
+
+        self.assert_parameter(
+            evt, 0, {"class": "builtins.int", "kind": "opt", "name": "p1", "value": "3"}
+        )
+
+        self.assert_parameter(
+            evt, 1, {"class": "builtins.int", "kind": "opt", "name": "p2", "value": "4"}
+        )
+
+    @pytest.mark.parametrize("params", ["with_defaults"], indirect=True)
+    def test_defaults_positional_and_keyword(self, params):
+        evt = params.C().with_defaults(3, p2=4)
+        assert len(evt.parameters) == 2
+
+        self.assert_parameter(
+            evt, 0, {"class": "builtins.int", "kind": "opt", "name": "p1", "value": "3"}
+        )
+
+        self.assert_parameter(
+            evt, 1, {"class": "builtins.int", "kind": "opt", "name": "p2", "value": "4"}
+        )
+
+
+class TestMixedParams(TestMethodBase):
+    """
+    C.mixed has the signature (self, a, b=None, c="dflt", *args, d, e="e", **kwargs),
+    covering every parameter kind.
+    """
+
+    def assert_values(self, evt, expected):
+        actual = {p["name"]: (p["kind"], p["value"]) for p in evt.parameters}
+        assert actual == expected
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_positional_opt(self, params):
+        evt = params.C().mixed("A", "B", "C", d="D")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "B"),
+                "c": ("opt", "C"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_partial_positional_opt(self, params):
+        evt = params.C().mixed("A", "B", d="D")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "B"),
+                "c": ("opt", "dflt"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_keyword_opt(self, params):
+        evt = params.C().mixed("A", c="C", d="D")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "None"),
+                "c": ("opt", "C"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_rest_after_opt(self, params):
+        evt = params.C().mixed("A", "B", "C", "X", "Y", d="D")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "B"),
+                "c": ("opt", "C"),
+                "args": ("rest", "('X', 'Y')"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_keyword_only(self, params):
+        evt = params.C().mixed("A", d="D", e="E", f="F")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "None"),
+                "c": ("opt", "dflt"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "E"),
+                "kwargs": ("keyrest", "{'f': 'F'}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_keyword_req(self, params):
+        evt = params.C().mixed(a="A", d="D", f="F")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "None"),
+                "c": ("opt", "dflt"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{'f': 'F'}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["positional_only_kwargs"], indirect=True)
+    def test_positional_only_name_in_kwargs(self, params):
+        # Keyword arguments named like positional-only parameters go to **kwargs
+        evt = params.C().positional_only_kwargs("A", "B", a="X", b="Y")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "B"),
+                "kwargs": ("keyrest", "{'a': 'X', 'b': 'Y'}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["positional_only_kwargs"], indirect=True)
+    def test_positional_only_default_name_in_kwargs(self, params):
+        evt = params.C().positional_only_kwargs("A", b="Y")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "dflt"),
+                "kwargs": ("keyrest", "{'b': 'Y'}"),
+            },
+        )

{appmap-3.0.0 → appmap-4.0.0}/_appmap/test/test_properties.py

@@ -118,8 +118,7 @@ def test_operator_itemgetter(events):
     assert len(events) == 2
     assert events[0].to_dict() == DictIncluding({
         "event": "call",
-        # operator.itemgetter.__module__ isn't available before 3.10
-        # "defined_class": "operator",
+        "defined_class": "operator",
         "method_id": "itemgetter (get)",
     })
 

{appmap-3.0.0 → appmap-4.0.0}/_appmap/test/test_runner.py

@@ -1,3 +1,4 @@
+import os
 import re
 
 import pytest
@@ -37,6 +38,20 @@ def test_runner_multi_recording_type(script_runner, flag, expected):
     assert len(re.findall("(?m)^APPMAP_RECORD_PYTEST=true$", result.stdout)) == expected
 
 
+@pytest.mark.parametrize(
+    "flags,expected",
+    [
+        ([], "true"),
+        (["--no-enable-log"], "true"),
+        (["--enable-log"], "false"),
+    ],
+)
+def test_runner_log_file_disabled_by_default(script_runner, flags, expected):
+    result = script_runner.run(["appmap-python", *flags, "--record", "process"])
+    assert result.returncode == 0
+    assert re.search(f"(?m)^APPMAP_DISABLE_LOG_FILE={expected}$", result.stdout) is not None
+
+
 @pytest.mark.script_launch_mode("subprocess")
 class TestEnv:
     def test_appmap_present(self, script_runner):
@@ -50,3 +65,19 @@ class TestEnv:
         )
         assert result.returncode == 0
         assert re.match(r"true", result.stdout) is not None
+
+    def test_internal_state_not_leaked_to_child(self, script_runner):
+        # appmap-python is itself instrumented at interpreter startup (via
+        # appmap.pth), which can set internal, process-scoped _APPMAP*
+        # markers using whatever it inherited, before this script has
+        # computed the environment the child command should actually run
+        # with. Simulate that by pre-setting one such marker (the
+        # once-per-process "startup messages already shown" guard) and
+        # confirm it doesn't leak into the child's environment, which would
+        # otherwise silently suppress the child's own startup logging.
+        env = {**os.environ, "_APPMAP_MESSAGES_SHOWN": "true"}
+        result = script_runner.run(
+            ["appmap-python", "printenv", "_APPMAP_MESSAGES_SHOWN"], env=env
+        )
+        assert result.returncode != 0
+        assert result.stdout == ""

{appmap-3.0.0 → appmap-4.0.0}/appmap/command/runner.py

@@ -53,29 +53,12 @@ _parser.add_argument(
     default=argparse.SUPPRESS,
 )
 
-if sys.version_info >= (3, 9):
-    _parser.add_argument(
-        "--enable-log",
-        help="create a log file",
-        action=argparse.BooleanOptionalAction,
-        default=False,
-    )
-else:
-    # You can see why BooleanOptionalAction was added. This is close, though not
-    # really as good....
-    _enable_log_group = _parser.add_mutually_exclusive_group()
-    _enable_log_group.add_argument(
-        "--enable-log",
-        help="create a log file",
-        dest="enable_log",
-        action="store_true",
-    )
-    _enable_log_group.add_argument(
-        "--no-enable-log",
-        help="don't create a log file",
-        dest="enable_log",
-        action="store_false",
-    )
+_parser.add_argument(
+    "--enable-log",
+    help="create a log file",
+    action=argparse.BooleanOptionalAction,
+    default=False,
+)
 
 _parser.add_argument(
     "command",
@@ -122,7 +105,7 @@ def run():
         envvars[f"APPMAP_RECORD_{disabled.upper()}"] = "false"
 
     envvars["APPMAP_DISABLE_LOG_FILE"] = (
-        "true" if parsed_args.get("no_enable_log", set()) else "false"
+        "false" if parsed_args.get("enable_log", False) else "true"
     )
 
     if len(cmd) == 0:
@@ -130,7 +113,17 @@ def run():
             print(f"{k}={v}")
         sys.exit(0)
 
-    os.execvpe(cmd[0], cmd, {**os.environ, **envvars})
+    # appmap-python is itself instrumented on interpreter startup (via
+    # appmap.pth), before this point, using whatever environment it inherited
+    # rather than the envvars computed above. That incidental self-init can
+    # set internal, process-scoped state under _APPMAP*-prefixed names (e.g.
+    # the once-per-process "startup messages already shown" guard); left in
+    # place, it would carry over into the child's environment and suppress
+    # or corrupt the child's own startup behavior. Drop all of it and let
+    # envvars below re-set whatever the child actually needs.
+    child_env = {k: v for k, v in os.environ.items() if not k.startswith("_APPMAP")}
+    child_env.update(envvars)
+    os.execvpe(cmd[0], cmd, child_env)
 
 
 if __name__ == "__main__":