refactor: introduce enabled product interface method

We extend the product plugin interface with a new mandatory `enabled`
function. This is used to determine whether a product is enabled and
needs its lifecycle managed by the product plugin protocol. The main
reason behind this change is to fix an issue with configuration
telemetry reporting whereby products are reported as activated simply
when they are started, but not necessarily enabled. This change now
moves the responsibility for checking enablement to the plugin protocol,
which can then make a more accurate configuration telemetry reporting
when it comes to product enablement. This also removes some boilerplate
code in product plugin implementations by not requiring them to include
an explicit enablement check.

Author: P403n1x87

ddtrace/_trace/product.py

@@ -36,14 +36,17 @@ def post_preload():
         _patch_all(**modules_to_bool)
 
 
+def enabled():
+    return _config.enabled
+
+
 def start():
-    if _config.enabled:
-        from ddtrace.internal.settings._config import config
+    from ddtrace.internal.settings._config import config
 
-        if config._trace_methods:
-            from ddtrace.internal.tracemethods import _install_trace_methods
+    if config._trace_methods:
+        from ddtrace.internal.tracemethods import _install_trace_methods
 
-            _install_trace_methods(config._trace_methods)
+        _install_trace_methods(config._trace_methods)
 
 
 def restart(join=False):

ddtrace/debugging/_products/code_origin/span.py

@@ -20,50 +20,42 @@
 # requires = ["tracer"]
 
 
-def post_preload() -> None:
-    pass
+# We need to instrument the entrypoints on boot because this is the only
+# time the tracer will notify us of entrypoints being registered.
+@partial(core.on, "service_entrypoint.patch")
+def _(f: t.Union[FunctionType, MethodType]) -> None:
+    from ddtrace.debugging._origin.span import SpanCodeOriginProcessorEntry
 
+    SpanCodeOriginProcessorEntry.instrument_view(f)
 
-def _start() -> None:
-    from ddtrace.debugging._origin.span import SpanCodeOriginProcessorEntry
 
-    SpanCodeOriginProcessorEntry.enable()
+def post_preload() -> None:
+    pass
 
 
 def start() -> None:
-    # We need to instrument the entrypoints on boot because this is the only
-    # time the tracer will notify us of entrypoints being registered.
-    @partial(core.on, "service_entrypoint.patch")
-    def _(f: t.Union[FunctionType, MethodType]) -> None:
-        from ddtrace.debugging._origin.span import SpanCodeOriginProcessorEntry
+    from ddtrace.debugging._origin.span import SpanCodeOriginProcessorEntry
 
-        SpanCodeOriginProcessorEntry.instrument_view(f)
+    SpanCodeOriginProcessorEntry.enable()
 
-    log.debug("Registered entrypoint patching hook for code origin for spans")
 
+def enabled() -> bool:
     # If dynamic instrumentation is enabled, and code origin for spans is not explicitly disabled,
     # we'll enable code origin for spans.
     di_enabled = product_manager.is_enabled(DI_PRODUCT_KEY) and config.value_source(CO_ENABLED) == ValueSource.DEFAULT
-    if config.span.enabled or di_enabled:
-        _start()
+    return config.span.enabled or di_enabled
 
 
 def restart(join: bool = False) -> None:
     pass
 
 
-def _stop() -> None:
+def stop(join: bool = False) -> None:
     from ddtrace.debugging._origin.span import SpanCodeOriginProcessorEntry
 
     SpanCodeOriginProcessorEntry.disable()
 
 
-def stop(join: bool = False) -> None:
-    di_enabled = product_manager.is_enabled(DI_PRODUCT_KEY) and config.value_source(CO_ENABLED) == ValueSource.DEFAULT
-    if config.span.enabled or di_enabled:
-        _stop()
-
-
 def at_exit(join: bool = False) -> None:
     stop(join=join)
 
@@ -75,4 +67,4 @@ class APMCapabilities(enum.IntFlag):
 def apm_tracing_rc(lib_config: t.Any, _config: t.Any) -> None:
     if (enabled := lib_config.get("code_origin_enabled")) is not None:
         should_start = (config.span.spec.enabled.full_name not in config.source or config.span.enabled) and enabled
-        _start() if should_start else _stop()
+        start() if should_start else stop()

ddtrace/debugging/_products/dynamic_instrumentation.py

@@ -1,32 +1,30 @@
 import enum
 from typing import Any
 
+from ddtrace.debugging._import import DebuggerModuleWatchdog
 from ddtrace.internal.settings.dynamic_instrumentation import config
 
 
+# We need to install this on start-up because if DI gets enabled remotely
+# we won't be able to capture many of the code objects from the modules
+# that are already loaded.
+DebuggerModuleWatchdog.install()
+
 requires = ["remote-configuration"]
 
 
 def post_preload() -> None:
     pass
 
 
-def _start() -> None:
+def start() -> None:
     from ddtrace.debugging import DynamicInstrumentation
 
     DynamicInstrumentation.enable()
 
 
-def start() -> None:
-    from ddtrace.debugging._import import DebuggerModuleWatchdog
-
-    # We need to install this on start-up because if DI gets enabled remotely
-    # we won't be able to capture many of the code objects from the modules
-    # that are already loaded.
-    DebuggerModuleWatchdog.install()
-
-    if config.enabled:
-        _start()
+def enabled() -> bool:
+    return config.enabled
 
 
 def before_fork() -> None:
@@ -40,10 +38,9 @@ def restart(join: bool = False) -> None:
 
 
 def stop(join: bool = False) -> None:
-    if config.enabled:
-        from ddtrace.debugging import DynamicInstrumentation
+    from ddtrace.debugging import DynamicInstrumentation
 
-        DynamicInstrumentation.disable(join=join)
+    DynamicInstrumentation.disable(join=join)
 
 
 def at_exit(join: bool = False) -> None:
@@ -57,4 +54,4 @@ class APMCapabilities(enum.IntFlag):
 def apm_tracing_rc(lib_config: Any, _config: Any) -> None:
     if (enabled := lib_config.get("dynamic_instrumentation_enabled")) is not None:
         should_start = (config.spec.enabled.full_name not in config.source or config.enabled) and enabled
-        _start() if should_start else stop()
+        start() if should_start else stop()

ddtrace/debugging/_products/exception_replay.py

@@ -12,32 +12,26 @@ def post_preload() -> None:
     pass
 
 
-def _start() -> None:
+def start() -> None:
     from ddtrace.debugging._exception.replay import SpanExceptionHandler
 
     SpanExceptionHandler.enable()
 
 
-def start() -> None:
-    if config.enabled:
-        _start()
+def enabled() -> bool:
+    return config.enabled
 
 
 def restart(join: bool = False) -> None:
     pass
 
 
-def _stop() -> None:
+def stop(join: bool = False) -> None:
     from ddtrace.debugging._exception.replay import SpanExceptionHandler
 
     SpanExceptionHandler.disable()
 
 
-def stop(join: bool = False) -> None:
-    if config.enabled:
-        _stop()
-
-
 def at_exit(join: bool = False) -> None:
     stop(join=join)
 
@@ -49,4 +43,4 @@ class APMCapabilities(enum.IntFlag):
 def apm_tracing_rc(lib_config: Any, _config: Any) -> None:
     if (enabled := lib_config.get("exception_replay_enabled")) is not None:
         should_start = (config.spec.enabled.full_name not in config.source or config.enabled) and enabled
-        _start() if should_start else _stop()
+        start() if should_start else stop()

ddtrace/debugging/_products/live_debugger.py

@@ -9,22 +9,24 @@ def post_preload() -> None:
     pass
 
 
+def enabled() -> bool:
+    return config.enabled
+
+
 def start() -> None:
-    if config.enabled:
-        from ddtrace.debugging._live import enable
+    from ddtrace.debugging._live import enable
 
-        enable()
+    enable()
 
 
 def restart(join: bool = False) -> None:
     pass
 
 
 def stop(join: bool = False) -> None:
-    if config.enabled:
-        from ddtrace.debugging._live import disable
+    from ddtrace.debugging._live import disable
 
-        disable()
+    disable()
 
 
 def at_exit(join: bool = False) -> None:

ddtrace/errortracking/product.py

@@ -12,22 +12,24 @@ def post_preload():
     pass
 
 
+def enabled() -> bool:
+    return config.enabled
+
+
 def start() -> None:
-    if config.enabled:
-        from ddtrace.errortracking._handled_exceptions.collector import HandledExceptionCollector
+    from ddtrace.errortracking._handled_exceptions.collector import HandledExceptionCollector
 
-        HandledExceptionCollector.enable()
+    HandledExceptionCollector.enable()
 
 
 def restart(join: bool = False) -> None:
     pass
 
 
 def stop(join: bool = False):
-    if config.enabled:
-        from ddtrace.errortracking._handled_exceptions.collector import HandledExceptionCollector
+    from ddtrace.errortracking._handled_exceptions.collector import HandledExceptionCollector
 
-        HandledExceptionCollector.disable()
+    HandledExceptionCollector.disable()
 
 
 def at_exit(join: bool = False):

ddtrace/internal/README.md

@@ -15,11 +15,12 @@ object that implements the product protocol. This consists of a Python object
 
 | Attribute | Description |
 |-----------|-------------|
-| `start() -> None` | A function with the logic required to start the product |
+| `post_preload() -> None` | A function with the logic required to finish initialization after the library  preload stage |
+| `enabled() -> bool` | A function that returns whether the product should be started; called before `start()` by the product manager |
+| `start() -> None` | A function with the logic required to enable the product (called only when `enabled()` returns `True`) |
 | `restart(join: bool = False) -> None` | A function with the logic required to restart the product after a fork |
 | `stop(join: bool = False) -> None` | A function with the logic required to stop the product |
 | `at_exit(join: bool = False) -> None` | A function with the logic required to stop the product at exit |
-| `post_preload() -> None` | A function with the logic required to finish initialization after the library  preload stage |
 
 The product object needs to be made available to the Python plugin system by
 defining an entry point in the `project.entry-points.'ddtrace.products'` section

ddtrace/internal/appsec/product.py

@@ -9,6 +9,12 @@ def post_preload():
     pass
 
 
+def enabled():
+    return (
+        config._asm_enabled or config._asm_can_be_enabled or config._asm_rc_enabled or ai_guard_config._ai_guard_enabled
+    )
+
+
 def start():
     if config._asm_enabled or config._asm_can_be_enabled:
         from ddtrace.appsec._listeners import load_common_appsec_modules

ddtrace/internal/iast/product.py

@@ -91,14 +91,20 @@ def post_preload():
         # Dropping inspect causes: "unexpected object <Signature> in __signature__ attribute"
 
 
+def enabled():
+    """
+    Return whether the IAST product is enabled.
+    """
+    return asm_config._iast_enabled
+
+
 def start():
     """
     Start the IAST product.
     """
-    if asm_config._iast_enabled:
-        from ddtrace.appsec._iast.processor import AppSecIastSpanProcessor
+    from ddtrace.appsec._iast.processor import AppSecIastSpanProcessor
 
-        AppSecIastSpanProcessor.enable()
+    AppSecIastSpanProcessor.enable()
 
 
 def restart(join=False):

ddtrace/internal/openfeature/product.py

@@ -8,22 +8,24 @@ def post_preload():
     pass
 
 
+def enabled():
+    return ffe_config.experimental_flagging_provider_enabled
+
+
 def start():
-    if ffe_config.experimental_flagging_provider_enabled:
-        from ddtrace.internal.openfeature._remoteconfiguration import enable_featureflags_rc
+    from ddtrace.internal.openfeature._remoteconfiguration import enable_featureflags_rc
 
-        enable_featureflags_rc()
+    enable_featureflags_rc()
 
 
 def restart(join=False):
     pass
 
 
 def stop(join=False):
-    if ffe_config.experimental_flagging_provider_enabled:
-        from ddtrace.internal.openfeature._remoteconfiguration import disable_featureflags_rc
+    from ddtrace.internal.openfeature._remoteconfiguration import disable_featureflags_rc
 
-        disable_featureflags_rc()
+    disable_featureflags_rc()
 
 
 def at_exit(join=False):