appmap 1.24.0__tar.gz → 2.0.0__tar.gz

{appmap-1.24.0 → appmap-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: appmap
-Version: 1.24.0
+Version: 2.0.0
 Summary: Create AppMap files by recording a Python application.
 Home-page: https://github.com/applandinc/appmap-python
 License: MIT
@@ -118,9 +118,13 @@ reenabled as soon as possible.]
 ### pytest
 
 Note that you must install the dependencies contained in
-[requirements-test.txt](requirements-test.txt) before running tests. See the explanation in
+[requirements-dev.txt](requirements-dev.txt) before running tests. See the explanation in
 [pyproject.toml](pyproject.toml) for details.
 
+Additionally, the tests currently require that you set `APPMAP=true`. You can
+either run `pytest` with `appmap-python` (see [tox.ini](tox.ini)), or you can explicitly
+set the environment variable.
+
 [pytest](https://docs.pytest.org/en/stable/) for testing:
 
 ```

{appmap-1.24.0 → appmap-2.0.0}/README.md

@@ -87,9 +87,13 @@ reenabled as soon as possible.]
 ### pytest
 
 Note that you must install the dependencies contained in
-[requirements-test.txt](requirements-test.txt) before running tests. See the explanation in
+[requirements-dev.txt](requirements-dev.txt) before running tests. See the explanation in
 [pyproject.toml](pyproject.toml) for details.
 
+Additionally, the tests currently require that you set `APPMAP=true`. You can
+either run `pytest` with `appmap-python` (see [tox.ini](tox.ini)), or you can explicitly
+set the environment variable.
+
 [pytest](https://docs.pytest.org/en/stable/) for testing:
 
 ```

{appmap-1.24.0 → appmap-2.0.0}/_appmap/configuration.py

@@ -196,6 +196,7 @@ class Config(metaclass=SingletonMeta):
             )
 
     def _load_config(self, show_warnings=False):
+        # pylint: disable=too-many-branches
         self._config = {"name": None, "packages": []}
 
         # Only use a default config if the user hasn't specified a
@@ -221,6 +222,7 @@ class Config(metaclass=SingletonMeta):
                 path = _resolve_relative_to(Path(env_config_filename), Path(config_dir))
 
         if path.is_file():
+            self._file = path
             self.file_present = True
 
             should_enable = Env.current.enabled
@@ -480,6 +482,7 @@ _startup_messages_shown = os.environ.get("_APPMAP_MESSAGES_SHOWN")
 if _startup_messages_shown is None:
     # pylint: disable=protected-access
     c._load_config(show_warnings=True)
+    logger.info("file: %s", c._file)
     logger.info("config: %s", c._config)
     logger.debug("package_functions: %s", c.package_functions)
     logger.info("env: %r", os.environ)

{appmap-1.24.0 → appmap-2.0.0}/_appmap/env.py

@@ -3,7 +3,6 @@
 import logging
 import logging.config
 import os
-import warnings
 from contextlib import contextmanager
 from os import environ
 from pathlib import Path
@@ -13,20 +12,6 @@ from _appmap.singleton import SingletonMeta
 
 from . import trace_logger
 
-_ENABLED_BY_DEFAULT_MSG = """
-
-The APPMAP environment variable is unset. Your code will be
-instrumented and recorded according to the configuration in appmap.yml.
-
-Starting with version 2, this behavior will change: when APPMAP is
-unset, no code will be instrumented. You will need to use the
-appmap-python script to run your application, or explicitly set
-APPMAP.
-
-Visit https://appmap.io/docs/reference/appmap-python.html#appmap-python-script for more
-details.
-"""
-
 _cwd = Path.cwd()
 _bootenv = environ.copy()
 
@@ -36,9 +21,9 @@ def _recording_method_key(recording_method):
 
 
 class Env(metaclass=SingletonMeta):
-    def __init__(self, env=None, cwd=None):
-        warnings.filterwarnings("once", _ENABLED_BY_DEFAULT_MSG)
+    RECORD_PROCESS_DEFAULT = "false"
 
+    def __init__(self, env=None, cwd=None):
         # root_dir and root_dir_len are going to be used when
         # instrumenting every function, so preprocess them as
         # much as possible.
@@ -54,7 +39,6 @@ class Env(metaclass=SingletonMeta):
 
         self._configure_logging()
         enabled = self._env.get("_APPMAP", None)
-        self._enabled_by_default = enabled is None
         self._enabled = enabled is None or enabled.lower() != "false"
 
         self._root_dir = str(self._cwd) + "/"
@@ -73,6 +57,9 @@ class Env(metaclass=SingletonMeta):
     def set(self, name, value):
         self._env[name] = value
 
+    def setdefault(self, name, default_value):
+        self._env.setdefault(name, default_value)
+
     def get(self, name, default=None):
         return self._env.get(name, default)
 
@@ -95,14 +82,6 @@ class Env(metaclass=SingletonMeta):
     def output_dir(self, value):
         self._output_dir = value
 
-    @property
-    def enabled_by_default(self):
-        return self._enabled_by_default
-
-    def warn_enabled_by_default(self):
-        if self._enabled_by_default:
-            warnings.warn(_ENABLED_BY_DEFAULT_MSG, category=DeprecationWarning, stacklevel=2)
-
     @property
     def enabled(self):
         return self._enabled
@@ -115,14 +94,25 @@ class Env(metaclass=SingletonMeta):
         if not self.enabled:
             return False
 
-        v = self.get(_recording_method_key(recording_method), default).lower()
-        return v != "false"
+        process_enabled = self._enables("process", self.RECORD_PROCESS_DEFAULT)
+        if recording_method == "process":
+            return process_enabled
+
+        # If process recording is enabled, others should be disabled
+        if process_enabled:
+            return False
+
+        # Otherwise, check the environment variable
+        return self._enables(recording_method, default)
+
+    def _enables(self, recording_method, default):
+        return self.get(_recording_method_key(recording_method), default).lower() != "false"
 
     @contextmanager
     def disabled(self, recording_method: str):
         key = _recording_method_key(recording_method)
         value = self.get(key)
-        self.set(key, "false")
+        self.setdefault(key, "false")
         try:
             yield
         finally:

{appmap-1.24.0 → appmap-2.0.0}/_appmap/event.py

@@ -173,6 +173,7 @@ class Param:
 
 
 class CallEvent(Event):
+    # pylint: disable=method-cache-max-size-none
     __slots__ = ["_fn", "_fqfn", "static", "receiver", "parameters", "labels"]
 
     @staticmethod
@@ -217,6 +218,7 @@ class CallEvent(Event):
 
     @staticmethod
     def set_params(params, instance, args, kwargs):
+        # pylint: disable=too-many-branches
         # Note that set_params expects args and kwargs as a tuple and
         # dict, respectively. It operates on them as collections, so
         # it doesn't unpack them.
@@ -400,6 +402,7 @@ class HttpServerRequestEvent(MessageEvent):
 
     __slots__ = ["http_server_request"]
 
+    # pylint: disable=too-many-arguments
     def __init__(
         self,
         request_method,

{appmap-1.24.0 → appmap-2.0.0}/_appmap/recording.py

@@ -44,7 +44,6 @@ class Recording:
         return Recorder.get_enabled()
 
     def __enter__(self):
-        Env.current.warn_enabled_by_default()
         self.start()
 
     def __exit__(self, exc_type, exc_value, tb):
@@ -80,9 +79,7 @@ def write_appmap(
 
 
 def initialize():
-    if Env.current.enables("process", "false"):
-        Env.current.warn_enabled_by_default()
-
+    if Env.current.enables("process", Env.RECORD_PROCESS_DEFAULT):
         r = Recording()
         r.start()
 

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/data/trial/test/test_deferred.py

@@ -1,4 +1,4 @@
-import time
+import time  # noqa: F401
 
 from twisted.internet import defer, reactor
 from twisted.trial import unittest

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/data/unittest/simple/test_simple.py

@@ -1,11 +1,11 @@
 import unittest
 from unittest.mock import patch
 
-import simple
+import simple  # isort: skip
 
 # Importing from decouple will cause a failure if we're not hooking
 # finders correctly.
-from decouple import config
+from decouple import config  # noqa: F401
 
 import appmap
 

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/normalize.py

@@ -67,6 +67,7 @@ def normalize_appmap(generated_appmap):
     """
 
     def normalize(dct):
+        # pylint: disable=too-many-branches
         if "classMap" in dct:
             dct["classMap"].sort(key=itemgetter("name"))
         if "children" in dct:

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_command.py

@@ -11,7 +11,7 @@ from appmap.command import appmap_agent_init, appmap_agent_status, appmap_agent_
 from .helpers import DictIncluding
 
 
-@pytest.fixture(name="cmd_setup")
+@pytest.fixture(name="_cmd_setup")
 def _cmd_setup(request, git, data_dir, monkeypatch):
     repo_root = git.cwd
     copy_tree(data_dir / request.param, str(repo_root))
@@ -23,8 +23,8 @@ def _cmd_setup(request, git, data_dir, monkeypatch):
     return monkeypatch
 
 
-@pytest.mark.parametrize("cmd_setup", ["config"], indirect=True)
-def test_agent_init(cmd_setup, capsys):
+@pytest.mark.parametrize("_cmd_setup", ["config"], indirect=True)
+def test_agent_init(_cmd_setup, capsys):
     rc = appmap_agent_init._run()  # pylint: disable=protected-access
 
     assert rc == 0
@@ -39,19 +39,23 @@ def test_agent_init(cmd_setup, capsys):
 
 
 class TestAgentStatus:
-    @pytest.mark.parametrize("cmd_setup", ["pytest"], indirect=True)
+    @pytest.mark.parametrize("_cmd_setup", ["pytest"], indirect=True)
     @pytest.mark.parametrize("do_discovery", [True, False])
-    def test_test_discovery_control(self, cmd_setup, do_discovery, mocker):
+    def test_test_discovery_control(self, _cmd_setup, do_discovery, mocker):
         mocker.patch("appmap.command.appmap_agent_status.discover_pytest_tests")
         rc = appmap_agent_status._run(  # pylint: disable=protected-access
             discover_tests=do_discovery
         )
         assert rc == 0
         call_count = 1 if do_discovery else 0
+
+        # Well, pylint, if it didn't have call_count, assertion would fail,
+        # wouldn't it?
+        # pylint: disable=no-member
         assert appmap_agent_status.discover_pytest_tests.call_count == call_count
 
-    @pytest.mark.parametrize("cmd_setup", ["pytest"], indirect=True)
-    def test_agent_status(self, cmd_setup, capsys):
+    @pytest.mark.parametrize("_cmd_setup", ["pytest"], indirect=True)
+    def test_agent_status(self, _cmd_setup, capsys):
         rc = appmap_agent_status._run(discover_tests=True)  # pylint: disable=protected-access
 
         assert rc == 0
@@ -77,8 +81,8 @@ class TestAgentStatus:
             {"args": [], "framework": "pytest", "command": "pytest"}
         )
 
-    @pytest.mark.parametrize("cmd_setup", ["package1"], indirect=True)
-    def test_agent_status_no_commands(self, cmd_setup, capsys):
+    @pytest.mark.parametrize("_cmd_setup", ["package1"], indirect=True)
+    def test_agent_status_no_commands(self, _cmd_setup, capsys):
         rc = appmap_agent_status._run(discover_tests=True)  # pylint: disable=protected-access
 
         assert rc == 0
@@ -103,7 +107,7 @@ class TestAgentValidate:
             assert err["level"] == "error"
             assert re.match(msg, err["message"]) is not None
 
-    def test_no_errors(self, capsys, mocker):
+    def test_no_errors(self, capsys):
         # Both Django and flask are installed in a dev environment, so
         # validation will succeed.
         self.check_errors(capsys, 0, 0, None)

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_configuration.py

@@ -4,6 +4,7 @@
 from contextlib import contextmanager
 from distutils.dir_util import copy_tree
 from pathlib import Path
+from textwrap import dedent
 
 import pytest
 import yaml
@@ -15,10 +16,6 @@ from _appmap.env import Env
 from _appmap.importer import Filterable, NullFilter
 
 
-def test_enabled_by_default():
-    assert appmap.enabled()
-
-
 @pytest.mark.appmap_enabled
 def test_can_be_configured():
     """
@@ -44,8 +41,6 @@ def test_reports_invalid():
 @pytest.mark.appmap_enabled(config="appmap-broken.yml")
 def test_is_disabled_when_unset():
     """Test that recording is disabled when APPMAP is unset but the config is broken"""
-    assert Env.current.get("_APPMAP", None) is None
-
     assert not appmap.enabled()
 
 
@@ -207,7 +202,7 @@ class TestDefaultConfig(DefaultHelpers):
         # pylint: disable=protected-access
         _appmap.initialize(cwd=repo_root)
 
-        Config.current  # write the file as a side-effect
+        Config.current  # pylint: disable=pointless-statement
         assert path.is_file()
         with open(path, encoding="utf-8") as cfg:
             actual_config = yaml.safe_load(cfg)
@@ -227,7 +222,7 @@ class TestDefaultConfig(DefaultHelpers):
         # pylint: disable=protected-access
         _appmap.initialize(cwd=repo_root, env={"_APPMAP": "false"})
 
-        Config.current
+        Config.current  # pylint: disable=pointless-statement
         assert not path.is_file()
 
 
@@ -240,7 +235,7 @@ class TestEmpty(DefaultHelpers):
     @contextmanager
     def incomplete_config(self):
         # pylint: disable=protected-access
-        with open("appmap-incomplete.yml", mode="w", buffering=1) as f:
+        with open("appmap-incomplete.yml", mode="w", buffering=1, encoding="utf-8") as f:
             print("# Incomplete file", file=f)
             yield f
 
@@ -271,42 +266,74 @@ class TestEmpty(DefaultHelpers):
             self.check_default_config(Path(tmpdir).name)
 
 class TestSearchConfig:
+    # pylint: disable=too-many-arguments
+
     def test_config_in_parent_folder(self, data_dir, tmpdir, monkeypatch):
         copy_tree(data_dir / "config-up", str(tmpdir))
-        project_root = tmpdir / "subprojects" / "p1"
-        monkeypatch.chdir(project_root)
+        wd = tmpdir / "project" / "p1"
+        monkeypatch.chdir(wd)
 
         # pylint: disable=protected-access
-        _appmap.initialize(cwd=project_root)
+        _appmap.initialize(cwd=wd)
         assert Config.current.name == "config-up-name"
         assert str(Env.current.output_dir).endswith(str(tmpdir / "tmp" / "appmap"))
 
-    def test_config_not_found_until_repo_root(self, data_dir, tmpdir, git_directory, monkeypatch):
+    def _init_repo(self, data_dir, tmpdir, git_directory, repo_root, appmapdir):
         copy_tree(data_dir / "config-up", str(tmpdir))
-        repo_root = tmpdir / "subprojects" / "p2"
         copy_tree(git_directory, str(repo_root))
-        project_root = repo_root / "sub1"
-        monkeypatch.chdir(project_root)
+        with open(appmapdir / "appmap.yml", "w+", encoding="utf-8") as f:
+            f.writelines(
+                dedent("""
+                name: project
+                packages: []
+                """)
+            )
+
+    @pytest.mark.parametrize("subdir", [Path("p1"), Path("p2", "sub1")])
+    def test_config_in_repo_root(self, data_dir, tmpdir, git_directory, monkeypatch, subdir):
+        repo_root = tmpdir / "project"
+        self._init_repo(data_dir, tmpdir, git_directory, repo_root, repo_root)
+
+        wd = repo_root / subdir
+        monkeypatch.chdir(wd)
 
         # pylint: disable=protected-access
-        _appmap.initialize(cwd=project_root)
-        # It should stop searching at repo_root.
-        # Check that it did not find appmap.yml
-        # in config-up folder.
-        assert Config.current.name != "config-up-name"
+        _appmap.initialize(cwd=wd)
+
+        # There's a config in the repo root. It should have been found, and have
+        # the correct contents.
+        assert Config.current.file_present
+        assert Config.current.name == "project"
+
+        assert Env.current.enabled
+
+    @pytest.mark.parametrize("subdir", [Path("p1"), Path("p2", "sub1")])
+    def test_config_above_repo_root(self, data_dir, tmpdir, git_directory, monkeypatch, subdir):
+        repo_root = tmpdir / "project"
+        self._init_repo(data_dir, tmpdir, git_directory, repo_root, tmpdir)
+
+        wd = repo_root / subdir
+        monkeypatch.chdir(wd)
+
+        # pylint: disable=protected-access
+        _appmap.initialize(cwd=wd)
+
+        # We should have stopped at the repo root without finding a config.
+        assert not Config.current.file_present
+
         # It should go on with default config
         assert Env.current.enabled
 
     def test_config_not_found_in_path_hierarchy(self, data_dir, tmpdir, monkeypatch):
         copy_tree(data_dir / "config-up", str(tmpdir))
-        project_root = tmpdir / "subprojects" / "p1"
-        monkeypatch.chdir(project_root)
+        wd = tmpdir / "project" / "p1"
+        monkeypatch.chdir(wd)
 
         # pylint: disable=protected-access
         _appmap.initialize(
-            cwd=project_root,
+            cwd=wd,
             env={"APPMAP_CONFIG": "notfound.yml"},
         )
-        Config.current
+        Config.current  # pylint: disable=pointless-statement
         # No default config since we specified APPMAP_CONFIG
         assert not Env.current.enabled

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_describe_value.py

@@ -13,7 +13,7 @@ def test_describe_value_does_not_call_class():
         # pylint: disable=missing-class-docstring,too-few-public-methods
         @property
         def __class__(self):
-            raise Exception("__class__ called")
+            raise RuntimeError("__class__ called")
 
     describe_value(None, WithOverloadedClass())
 

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_django.py

@@ -32,7 +32,8 @@ from .web_framework import (
 sys.path += [str(Path(__file__).parent / "data" / "django")]
 
 # Import app just for the side-effects. It must happen after sys.path has been modified.
-import djangoapp  # pyright: ignore pylint: disable=import-error, unused-import,wrong-import-order,wrong-import-position
+# pylint: disable=import-error, unused-import,wrong-import-order,wrong-import-position
+import djangoapp  # pyright: ignore  # noqa: F401
 
 
 class TestFormCapture(_TestFormCapture):
@@ -215,6 +216,19 @@ class TestDjangoApp:
         result.assert_outcomes(passed=1, failed=0, errors=0)
         assert not (pytester.path / "tmp").exists()
 
+    def test_disabled_for_process(self, pytester, monkeypatch):
+        monkeypatch.setenv("APPMAP_RECORD_PROCESS", "true")
+
+        result = pytester.runpytest("-svv")
+
+        # There are two tests for remote recording. They should both fail,
+        # because process recording should disable remote recording.
+        result.assert_outcomes(passed=2, failed=2, errors=0)
+
+        assert (pytester.path / "tmp" / "appmap" / "process").exists()
+        assert not (pytester.path / "tmp" / "appmap" / "requests").exists()
+        assert not (pytester.path / "tmp" / "appmap" / "pytest").exists()
+
 
 @pytest.fixture(name="server")
 def django_server(xprocess, server_base):

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_env.py

@@ -7,7 +7,7 @@ def test_disable_temporarily():
     try:
         with env.disabled("requests"):
             assert not env.enables("requests")
-            raise 'hell'
-    except:
+            raise RuntimeError("hell")
+    except RuntimeError:
         ...
     assert env.enables("requests")

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_flask.py

@@ -8,10 +8,10 @@ from types import SimpleNamespace as NS
 
 import flask
 import pytest
-from appmap.flask import AppmapFlask
 
 from _appmap.env import Env
 from _appmap.metadata import Metadata
+from appmap.flask import AppmapFlask
 
 from ..test.helpers import DictIncluding
 from .web_framework import (
@@ -144,7 +144,11 @@ class TestFlaskApp:
         appmap_file = (
             pytester.path / "tmp" / "appmap" / "pytest" / "test_request.appmap.json"
         )
+
+        # No request recordings should have been created
         assert not os.path.exists(pytester.path / "tmp" / "appmap" / "requests")
+
+        # but there should be a test recording
         assert appmap_file.exists()
 
     def test_disabled(self, pytester, monkeypatch):
@@ -154,3 +158,14 @@ class TestFlaskApp:
 
         result.assert_outcomes(passed=1, failed=0, errors=0)
         assert not (pytester.path / "tmp" / "appmap").exists()
+
+    def test_disabled_for_process(self, pytester, monkeypatch):
+        monkeypatch.setenv("APPMAP_RECORD_PROCESS", "true")
+
+        result = pytester.runpytest("-svv")
+
+        result.assert_outcomes(passed=1, failed=0, errors=0)
+
+        assert (pytester.path / "tmp" / "appmap" / "process").exists()
+        assert not (pytester.path / "tmp" / "appmap" / "requests").exists()
+        assert not (pytester.path / "tmp" / "appmap" / "pytest").exists()

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_http.py

@@ -4,13 +4,13 @@ import httpretty
 import pytest
 import requests
 
-import appmap.http
+import appmap.http  # noqa: F401
 
 from ..test.helpers import DictIncluding
 
 
 def test_http_client_capture(mock_requests, events):
-    requests.get("https://example.test/foo/bar?q=one&q=two&q2=%F0%9F%A6%A0")
+    requests.get("https://example.test/foo/bar?q=one&q=two&q2=%F0%9F%A6%A0", timeout=1)
 
     assert events[0].to_dict() == DictIncluding(
         {

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_runner.py

@@ -15,7 +15,7 @@ def test_runner_help(script_runner):
     assert result.stdout.startswith("usage")
 
 
-@pytest.mark.parametrize("recording_type", ["process", "pytest", "remote", "requests", "unittest"])
+@pytest.mark.parametrize("recording_type", ["process", "remote", "requests", "tests"])
 def test_runner_recording_type(script_runner, recording_type):
     result = script_runner.run(["appmap-python", "--record", recording_type])
     assert result.returncode == 0

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_test_frameworks.py

@@ -39,11 +39,18 @@ class _TestTestRunner(ABC):
         assert not testdir.output().exists()
 
     def test_disabled(self, testdir, monkeypatch):
-        monkeypatch.setenv(f"APPMAP_RECORD_{self._test_type.upper()}", "false")
+        monkeypatch.setenv("APPMAP_RECORD_TESTS", "false")
 
         self.run_tests(testdir)
         assert not testdir.output().exists()
 
+    def test_disabled_for_process(self, testdir, monkeypatch):
+        monkeypatch.setenv("APPMAP_RECORD_PROCESS", "true")
+
+        self.run_tests(testdir)
+        assert (testdir.path / "tmp" / "appmap" / "process").exists()
+        assert not testdir.output().exists()
+
 
 class TestUnittestRunner(_TestTestRunner):
     @classmethod

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/test_util.py

@@ -2,9 +2,8 @@
 Test util functionality
 """
 
-import os
-from pathlib import Path
 import uuid
+from pathlib import Path
 
 from _appmap.utils import locate_file_up, scenario_filename
 

{appmap-1.24.0 → appmap-2.0.0}/_appmap/test/web_framework.py

@@ -339,6 +339,7 @@ class _TestRecordRequests:
         return requests.get(cls.server_url() + "/test", timeout=30)
 
     def record_requests(self, record_remote):
+        # pylint: disable=too-many-locals
         if record_remote:
             # when remote recording is enabled, this test also
             # verifies the global recorder doesn't save duplicate

{appmap-1.24.0 → appmap-2.0.0}/_appmap/unittest.py

@@ -3,7 +3,6 @@ import unittest
 from contextlib import contextmanager
 
 from _appmap import noappmap, testing_framework, wrapt
-from _appmap.env import Env
 from _appmap.utils import get_function_location
 
 _session = testing_framework.session("unittest", "tests")
@@ -43,7 +42,6 @@ if sys.version_info[1] < 8:
         with _session.record(
             test_case.__class__, method_name, location=location
         ) as metadata:
-            Env.current.warn_enabled_by_default()
             if metadata:
                 with wrapped(
                     *args, **kwargs
@@ -69,7 +67,6 @@ else:
         method_name = test_case.id().split(".")[-1]
         location = _get_test_location(test_case.__class__, method_name)
         with _session.record(test_case.__class__, method_name, location=location) as metadata:
-            Env.current.warn_enabled_by_default()
             if metadata:
                 with testing_framework.collect_result_metadata(metadata):
                     wrapped(*args, **kwargs)