test(internal): check that ddtrace does not force-load lazy modules (#4855)

## Description

This change adds a test to ensure that the import of ddtrace does not
cause lazy modules to be force-loaded when the ModuleWatchdog is
installed on start-up.

## Checklist
- [x] Followed the [library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/contributing.html#Release-Note-Guidelines)
when writing a release note.
- [x] Add additional sections for `feat` and `fix` pull requests.
- [x] [Library
documentation](https://github.com/DataDog/dd-trace-py/tree/1.x/docs)
and/or [Datadog's documentation
site](https://github.com/DataDog/documentation/) is updated. Link to doc
PR in description.

## Reviewer Checklist
- [x] Title is accurate.
- [x] Description motivates each change.
- [x] No unnecessary changes were introduced in this PR.
- [x] Avoid breaking
[API](https://ddtrace.readthedocs.io/en/stable/versioning.html#interfaces)
changes unless absolutely necessary.
- [x] Tests provided or description of manual testing performed is
included in the code or PR.
- [x] Release note has been added and follows the [library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/contributing.html#Release-Note-Guidelines),
or else `changelog/no-changelog` label added.
- [x] All relevant GitHub issues are correctly linked.
- [x] Backports are identified and tagged with Mergifyio.

Author: P403n1x87

tests/conftest.py

@@ -11,6 +11,7 @@
 from _pytest.runner import CallInfo
 from _pytest.runner import TestReport
 from _pytest.runner import call_and_report
+from _pytest.runner import pytest_runtest_protocol as default_pytest_runtest_protocol
 import pytest
 from six import PY2
 
@@ -231,6 +232,13 @@ def _subprocess_wrapper():
 
 @pytest.hookimpl(tryfirst=True)
 def pytest_runtest_protocol(item):
+    if item.get_closest_marker("skip"):
+        return default_pytest_runtest_protocol(item, None)
+
+    skipif = item.get_closest_marker("skipif")
+    if skipif and skipif.args[0]:
+        return default_pytest_runtest_protocol(item, None)
+
     marker = item.get_closest_marker("subprocess")
     if marker:
         params = marker.kwargs.get("parametrize", None)

tests/internal/lazy.py

@@ -0,0 +1 @@
+print("lazy loaded")

tests/internal/test_module.py

@@ -339,3 +339,39 @@ def test_module_watchdog_dict_shallow_copy():
     assert original_modules == new_modules
 
     ModuleWatchdog.uninstall()
+
+
+@pytest.mark.skipif(sys.version_info < (3, 5), reason="LazyLoader was introduced in Python 3.5")
+@pytest.mark.subprocess(out="ddtrace imported\naccessing lazy module\nlazy loaded\n")
+def test_module_watchdog_no_lazy_force_load():
+    """Test that the module watchdog does not force-load lazy modules.
+
+    We use the LazyLoader to load a module lazily. On actual import, the module
+    emits a print statement. We check that the timing of other print statements
+    around the actual import is correct to ensure that the import of ddtrace is
+    not forcing the lazy module to be loaded.
+    """
+    import importlib.util
+    import sys
+
+    def lazy_import(name):
+        spec = importlib.util.find_spec(name)
+        loader = importlib.util.LazyLoader(spec.loader)
+        spec.loader = loader
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[name] = module
+        loader.exec_module(module)
+        return module
+
+    lazy = lazy_import("tests.internal.lazy")
+
+    import ddtrace  # noqa
+
+    print("ddtrace imported")
+
+    print("accessing lazy module")
+    try:
+        # This attribute access should cause the module to be loaded
+        lazy.__spec__
+    except AttributeError:
+        pass