diff --git a/ddtrace/__init__.py b/ddtrace/__init__.py
index b555d1117ca..e480851926f 100644
--- a/ddtrace/__init__.py
+++ b/ddtrace/__init__.py
@@ -17,7 +17,7 @@
 # configure ddtrace logger before other modules log
 configure_ddtrace_logger()  # noqa: E402
 
-from .settings import _config as config
+from .settings import _global_config as config
 
 
 # Enable telemetry writer and excepthook as early as possible to ensure we capture any exceptions from initialization
diff --git a/ddtrace/_monkey.py b/ddtrace/_monkey.py
index 75c70114ef2..8ede9f49ca4 100644
--- a/ddtrace/_monkey.py
+++ b/ddtrace/_monkey.py
@@ -12,7 +12,7 @@
 from .internal import telemetry
 from .internal.logger import get_logger
 from .internal.utils import formats
-from .settings import _config as config
+from .settings import _global_config as config
 
 
 if TYPE_CHECKING:  # pragma: no cover
diff --git a/ddtrace/_trace/sampler.py b/ddtrace/_trace/sampler.py
index 961526e3f26..96d61b9adcf 100644
--- a/ddtrace/_trace/sampler.py
+++ b/ddtrace/_trace/sampler.py
@@ -22,7 +22,7 @@
 from ..internal.rate_limiter import RateLimiter
 from ..internal.sampling import _get_highest_precedence_rule_matching
 from ..internal.sampling import _set_sampling_tags
-from ..settings import _config as ddconfig
+from ..settings import _global_config as ddconfig
 from .sampling_rule import SamplingRule
 
 
diff --git a/ddtrace/contrib/flask/__init__.py b/ddtrace/contrib/flask/__init__.py
index 0562240d090..4b3c1afbf16 100644
--- a/ddtrace/contrib/flask/__init__.py
+++ b/ddtrace/contrib/flask/__init__.py
@@ -87,9 +87,6 @@ def index():
     # Override service name
     config.flask['service_name'] = 'custom-service-name'
 
-    # Report 401, and 403 responses as errors
-    config.http_server.error_statuses = '401,403'
-
 .. __: http://flask.pocoo.org/
 
 :ref:`All HTTP tags <http-tagging>` are supported for this integration.
diff --git a/ddtrace/contrib/httplib/__init__.py b/ddtrace/contrib/httplib/__init__.py
index ae85051517e..7c5247422a1 100644
--- a/ddtrace/contrib/httplib/__init__.py
+++ b/ddtrace/contrib/httplib/__init__.py
@@ -42,20 +42,8 @@
 
     # Disable distributed tracing globally.
     config.httplib['distributed_tracing'] = False
-
-    # Change the service distributed tracing option only for this HTTP
-    # connection.
-
-    # Python 2
-    connection = urllib.HTTPConnection('www.datadog.com')
-
-    # Python 3
     connection = http.client.HTTPConnection('www.datadog.com')
 
-    cfg = config.get_from(connection)
-    cfg['distributed_tracing'] = True
-
-
 :ref:`Headers tracing <http-headers-tracing>` is supported for this integration.
 """
 
diff --git a/ddtrace/contrib/internal/aiohttp/middlewares.py b/ddtrace/contrib/internal/aiohttp/middlewares.py
index 4f7abe5a12f..ddb2d35fbc6 100644
--- a/ddtrace/contrib/internal/aiohttp/middlewares.py
+++ b/ddtrace/contrib/internal/aiohttp/middlewares.py
@@ -108,7 +108,7 @@ def finish_request_span(request, response):
     # DEV: aiohttp is special case maintains separate configuration from config api
     trace_query_string = request[REQUEST_CONFIG_KEY].get("trace_query_string")
     if trace_query_string is None:
-        trace_query_string = config.http.trace_query_string
+        trace_query_string = config._http.trace_query_string
     if trace_query_string:
         request_span.set_tag_str(http.QUERY_STRING, request.query_string)
 
diff --git a/ddtrace/contrib/internal/botocore/patch.py b/ddtrace/contrib/internal/botocore/patch.py
index 734c429d798..61353e7b34e 100644
--- a/ddtrace/contrib/internal/botocore/patch.py
+++ b/ddtrace/contrib/internal/botocore/patch.py
@@ -33,7 +33,7 @@
 from ddtrace.internal.utils.formats import asbool
 from ddtrace.internal.utils.formats import deep_getattr
 from ddtrace.llmobs._integrations import BedrockIntegration
-from ddtrace.settings.config import Config
+from ddtrace.settings._config import Config
 from ddtrace.trace import Pin
 
 from .services.bedrock import patched_bedrock_api_call
diff --git a/ddtrace/contrib/internal/dramatiq/patch.py b/ddtrace/contrib/internal/dramatiq/patch.py
index 08daad9d93c..a6ecbbfd5d4 100644
--- a/ddtrace/contrib/internal/dramatiq/patch.py
+++ b/ddtrace/contrib/internal/dramatiq/patch.py
@@ -11,7 +11,7 @@
 from ddtrace.contrib import trace_utils
 from ddtrace.ext import SpanKind
 from ddtrace.ext import SpanTypes
-from ddtrace.settings.config import Config
+from ddtrace.settings._config import Config
 
 
 def get_version() -> str:
diff --git a/ddtrace/contrib/internal/httplib/patch.py b/ddtrace/contrib/internal/httplib/patch.py
index a1e367af3a1..79a8ea2816f 100644
--- a/ddtrace/contrib/internal/httplib/patch.py
+++ b/ddtrace/contrib/internal/httplib/patch.py
@@ -91,7 +91,7 @@ def _wrap_request(func, instance, args, kwargs):
     if should_skip_request(pin, instance):
         return func_to_call(*args, **kwargs)
 
-    cfg = config.get_from(instance)
+    cfg = config._get_from(instance)
 
     try:
         # Create a new span and attach to this instance (so we can retrieve/update/close later on the response)
diff --git a/ddtrace/contrib/internal/requests/connection.py b/ddtrace/contrib/internal/requests/connection.py
index c6d7706ef54..0b58f8b6dc5 100644
--- a/ddtrace/contrib/internal/requests/connection.py
+++ b/ddtrace/contrib/internal/requests/connection.py
@@ -75,7 +75,7 @@ def _wrap_send(func, instance, args, kwargs):
     hostname, path = _extract_hostname_and_path(url)
     host_without_port = hostname.split(":")[0] if hostname is not None else None
 
-    cfg = config.get_from(instance)
+    cfg = config._get_from(instance)
     service = None
     if cfg["split_by_domain"] and hostname:
         service = hostname
@@ -97,7 +97,7 @@ def _wrap_send(func, instance, args, kwargs):
 
         # Configure trace search sample rate
         # DEV: analytics enabled on per-session basis
-        cfg = config.get_from(instance)
+        cfg = config._get_from(instance)
         analytics_enabled = cfg.get("analytics_enabled")
         if analytics_enabled:
             span.set_tag(_ANALYTICS_SAMPLE_RATE_KEY, cfg.get("analytics_sample_rate", True))
diff --git a/ddtrace/contrib/internal/sanic/patch.py b/ddtrace/contrib/internal/sanic/patch.py
index 5d105cf2f32..8e53ed41dc8 100644
--- a/ddtrace/contrib/internal/sanic/patch.py
+++ b/ddtrace/contrib/internal/sanic/patch.py
@@ -273,7 +273,7 @@ async def sanic_http_lifecycle_exception(request, exception):
     # Do not attach exception for exceptions not considered as errors
     # ex: Http 400s
     # DEV: We still need to set `__dd_span_call_finish` below
-    if not hasattr(exception, "status_code") or config.http_server.is_error_code(exception.status_code):
+    if not hasattr(exception, "status_code") or config._http_server.is_error_code(exception.status_code):
         ex_type = type(exception)
         ex_tb = getattr(exception, "__traceback__", None)
         span.set_exc_info(ex_type, exception, ex_tb)
diff --git a/ddtrace/contrib/internal/tornado/handlers.py b/ddtrace/contrib/internal/tornado/handlers.py
index 3c4a046bfb9..f858e33ee29 100644
--- a/ddtrace/contrib/internal/tornado/handlers.py
+++ b/ddtrace/contrib/internal/tornado/handlers.py
@@ -140,7 +140,7 @@ def log_exception(func, handler, args, kwargs):
         # is not a 2xx. In this case we want to check the status code to be sure that
         # only 5xx are traced as errors, while any other HTTPError exception is handled as
         # usual.
-        if config.http_server.is_error_code(value.status_code):
+        if config._http_server.is_error_code(value.status_code):
             current_span.set_exc_info(*args)
     else:
         # any other uncaught exception should be reported as error
diff --git a/ddtrace/contrib/internal/trace_utils.py b/ddtrace/contrib/internal/trace_utils.py
index 56901934e83..5781c3f30df 100644
--- a/ddtrace/contrib/internal/trace_utils.py
+++ b/ddtrace/contrib/internal/trace_utils.py
@@ -485,7 +485,7 @@ def set_http_meta(
             log.debug("failed to convert http status code %r to int", status_code)
         else:
             span.set_tag_str(http.STATUS_CODE, str(status_code))
-            if config.http_server.is_error_code(int_status_code):
+            if config._http_server.is_error_code(int_status_code):
                 span.error = 1
 
     if status_msg is not None:
diff --git a/ddtrace/contrib/jinja2/__init__.py b/ddtrace/contrib/jinja2/__init__.py
index cc8c6786b02..8437a51d9de 100644
--- a/ddtrace/contrib/jinja2/__init__.py
+++ b/ddtrace/contrib/jinja2/__init__.py
@@ -16,13 +16,13 @@
 The library can be configured globally and per instance, using the Configuration API::
 
     from ddtrace import config
+    from ddtrace.trace import Pin
 
     # Change service name globally
     config.jinja2['service_name'] = 'jinja-templates'
 
     # change the service name only for this environment
-    cfg = config.get_from(env)
-    cfg['service_name'] = 'jinja-templates'
+    Pin.override(env, service='jinja-templates')
 
 By default, the service name is set to None, so it is inherited from the parent span.
 If there is no parent span and the service name is not overridden the agent will drop the traces.
diff --git a/ddtrace/contrib/requests/__init__.py b/ddtrace/contrib/requests/__init__.py
index efcb20f1219..7d034ce56bf 100644
--- a/ddtrace/contrib/requests/__init__.py
+++ b/ddtrace/contrib/requests/__init__.py
@@ -65,12 +65,11 @@
 use the config API::
 
     from ddtrace import config
+    from ddtrace.trace import Pin
     from requests import Session
 
     session = Session()
-    cfg = config.get_from(session)
-    cfg['service_name'] = 'auth-api'
-    cfg['distributed_tracing'] = False
+    Pin.override(session, service='auth-api')
 """
 
 
diff --git a/ddtrace/internal/remoteconfig/worker.py b/ddtrace/internal/remoteconfig/worker.py
index 7ad8c592d2e..5429e599e74 100644
--- a/ddtrace/internal/remoteconfig/worker.py
+++ b/ddtrace/internal/remoteconfig/worker.py
@@ -13,7 +13,7 @@
 from ddtrace.internal.remoteconfig.utils import get_poll_interval_seconds
 from ddtrace.internal.service import ServiceStatus
 from ddtrace.internal.utils.time import StopWatch
-from ddtrace.settings import _config as ddconfig
+from ddtrace.settings import _global_config as ddconfig
 
 
 log = get_logger(__name__)
diff --git a/ddtrace/internal/sampling.py b/ddtrace/internal/sampling.py
index b1d3f7957f4..e64c0e27bc5 100644
--- a/ddtrace/internal/sampling.py
+++ b/ddtrace/internal/sampling.py
@@ -27,7 +27,7 @@
 from ddtrace.internal.constants import SAMPLING_DECISION_TRACE_TAG_KEY
 from ddtrace.internal.glob_matching import GlobMatcher
 from ddtrace.internal.logger import get_logger
-from ddtrace.settings import _config as config
+from ddtrace.settings import _global_config as config
 
 from .rate_limiter import RateLimiter
 
diff --git a/ddtrace/internal/writer/writer.py b/ddtrace/internal/writer/writer.py
index c494aa206a2..357fcf3917f 100644
--- a/ddtrace/internal/writer/writer.py
+++ b/ddtrace/internal/writer/writer.py
@@ -14,7 +14,7 @@
 
 import ddtrace
 from ddtrace.internal.utils.retry import fibonacci_backoff_with_jitter
-from ddtrace.settings import _config as config
+from ddtrace.settings import _global_config as config
 from ddtrace.settings.asm import config as asm_config
 from ddtrace.vendor.dogstatsd import DogStatsd
 
diff --git a/ddtrace/propagation/_database_monitoring.py b/ddtrace/propagation/_database_monitoring.py
index 5b585b13210..817d23c4ebf 100644
--- a/ddtrace/propagation/_database_monitoring.py
+++ b/ddtrace/propagation/_database_monitoring.py
@@ -10,7 +10,7 @@
 from ..internal import compat
 from ..internal.utils import get_argument_value
 from ..internal.utils import set_argument_value
-from ..settings import _config as dd_config
+from ..settings import _global_config as dd_config
 from ..settings._database_monitoring import dbm_config
 
 
diff --git a/ddtrace/settings/__init__.py b/ddtrace/settings/__init__.py
index 2c3a0bf7807..ebbb0c31f7b 100644
--- a/ddtrace/settings/__init__.py
+++ b/ddtrace/settings/__init__.py
@@ -1,12 +1,12 @@
 from .._hooks import Hooks
-from .config import Config
+from ._config import Config
 from .exceptions import ConfigException
 from .http import HttpConfig
 from .integration import IntegrationConfig
 
 
 # Default global config
-_config = Config()
+_global_config = Config()
 
 __all__ = [
     "Config",
diff --git a/ddtrace/settings/_config.py b/ddtrace/settings/_config.py
new file mode 100644
index 00000000000..df3fe4177d1
--- /dev/null
+++ b/ddtrace/settings/_config.py
@@ -0,0 +1,1025 @@
+from copy import deepcopy
+import json
+import os
+import re
+import sys
+from typing import Any  # noqa:F401
+from typing import Callable  # noqa:F401
+from typing import Dict  # noqa:F401
+from typing import List  # noqa:F401
+from typing import Optional  # noqa:F401
+from typing import Tuple  # noqa:F401
+from typing import Union  # noqa:F401
+
+from ddtrace.internal._file_queue import File_Queue
+from ddtrace.internal.serverless import in_azure_function
+from ddtrace.internal.serverless import in_gcp_function
+from ddtrace.internal.telemetry import telemetry_writer
+from ddtrace.internal.utils.cache import cachedmethod
+from ddtrace.internal.utils.deprecations import DDTraceDeprecationWarning
+from ddtrace.vendor.debtcollector import deprecate
+
+from .._trace.pin import Pin
+from ..internal import gitmetadata
+from ..internal.constants import _PROPAGATION_BEHAVIOR_DEFAULT
+from ..internal.constants import _PROPAGATION_BEHAVIOR_IGNORE
+from ..internal.constants import _PROPAGATION_STYLE_DEFAULT
+from ..internal.constants import _PROPAGATION_STYLE_NONE
+from ..internal.constants import DEFAULT_BUFFER_SIZE
+from ..internal.constants import DEFAULT_MAX_PAYLOAD_SIZE
+from ..internal.constants import DEFAULT_PROCESSING_INTERVAL
+from ..internal.constants import DEFAULT_REUSE_CONNECTIONS
+from ..internal.constants import DEFAULT_SAMPLING_RATE_LIMIT
+from ..internal.constants import DEFAULT_TIMEOUT
+from ..internal.constants import PROPAGATION_STYLE_ALL
+from ..internal.constants import PROPAGATION_STYLE_B3_SINGLE
+from ..internal.logger import get_logger
+from ..internal.schema import DEFAULT_SPAN_SERVICE_NAME
+from ..internal.serverless import in_aws_lambda
+from ..internal.utils.formats import asbool
+from ..internal.utils.formats import parse_tags_str
+from ._core import get_config as _get_config
+from ._inferred_base_service import detect_service
+from ._otel_remapper import otel_remapping as _otel_remapping
+from .endpoint_config import fetch_config_from_endpoint
+from .http import HttpConfig
+from .integration import IntegrationConfig
+
+
+if sys.version_info >= (3, 8):
+    from typing import Literal  # noqa:F401
+else:
+    from typing_extensions import Literal
+
+
+log = get_logger(__name__)
+
+ENDPOINT_FETCHED_CONFIG = fetch_config_from_endpoint()
+
+DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP_DEFAULT = (
+    r"(?ix)"
+    r"(?:"  # JSON-ish leading quote
+    r'(?:"|%22)?'
+    r")"
+    r"(?:"  # common keys"
+    r"(?:old[-_]?|new[-_]?)?p(?:ass)?w(?:or)?d(?:1|2)?"  # pw, password variants
+    r"|pass(?:[-_]?phrase)?"  # pass, passphrase variants
+    r"|secret"
+    r"|(?:"  # key, key_id variants
+    r"api[-_]?"
+    r"|private[-_]?"
+    r"|public[-_]?"
+    r"|access[-_]?"
+    r"|secret[-_]?"
+    r"|app(?:lica"
+    r"tion)?[-_]?"
+    r")key(?:[-_]?id)?"
+    r"|token"
+    r"|consumer[-_]?(?:id|key|secret)"
+    r"|sign(?:ed|ature)?"
+    r"|auth(?:entication|orization)?"
+    r")"
+    r"(?:"
+    # '=' query string separator, plus value til next '&' separator
+    r"(?:\s|%20)*(?:=|%3D)[^&]+"
+    # JSON-ish '": "somevalue"', key being handled with case above, without the opening '"'
+    r'|(?:"|%22)'  # closing '"' at end of key
+    r"(?:\s|%20)*(?::|%3A)(?:\s|%20)*"  # ':' key-value separator, with surrounding spaces
+    r'(?:"|%22)'  # opening '"' at start of value
+    r'(?:%2[^2]|%[^2]|[^"%])+'  # value
+    r'(?:"|%22)'  # closing '"' at end of value
+    r")"
+    r"|(?:"  # other common secret values
+    r" bearer(?:\s|%20)+[a-z0-9._\-]+"
+    r"|token(?::|%3A)[a-z0-9]{13}"
+    r"|gh[opsu]_[0-9a-zA-Z]{36}"
+    r"|ey[I-L](?:[\w=-]|%3D)+\.ey[I-L](?:[\w=-]|%3D)+(?:\.(?:[\w.+/=-]|%3D|%2F|%2B)+)?"
+    r"|-{5}BEGIN(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY-{5}[^\-]+-{5}END"
+    r"(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY(?:-{5})?(?:\n|%0A)?"
+    r"|(?:ssh-(?:rsa|dss)|ecdsa-[a-z0-9]+-[a-z0-9]+)(?:\s|%20|%09)+(?:[a-z0-9/.+]"
+    r"|%2F|%5C|%2B){100,}(?:=|%3D)*(?:(?:\s|%20|%09)+[a-z0-9._-]+)?"
+    r")"
+)
+
+
+def _parse_propagation_styles(styles_str):
+    # type: (str) -> Optional[List[str]]
+    """Helper to parse http propagation extract/inject styles via env variables.
+
+    The expected format is::
+
+        <style>[,<style>...]
+
+
+    The allowed values are:
+
+    - "datadog"
+    - "b3multi"
+    - "b3" (formerly 'b3 single header')
+    - "b3 single header (deprecated for 'b3')"
+    - "tracecontext"
+    - "baggage"
+    - "none"
+
+
+    The default value is ``"datadog,tracecontext,baggage"``.
+
+
+    Examples::
+
+        # Extract and inject b3 headers:
+        DD_TRACE_PROPAGATION_STYLE="b3multi"
+
+        # Disable header propagation:
+        DD_TRACE_PROPAGATION_STYLE="none"
+
+        # Extract trace context from "x-datadog-*" or "x-b3-*" headers from upstream headers
+        DD_TRACE_PROPAGATION_STYLE_EXTRACT="datadog,b3multi"
+
+        # Inject the "b3: *" header into downstream requests headers
+        DD_TRACE_PROPAGATION_STYLE_INJECT="b3"
+    """
+    styles = []
+    for style in styles_str.split(","):
+        style = style.strip().lower()
+        if style == "b3 single header":
+            deprecate(
+                'Using DD_TRACE_PROPAGATION_STYLE="b3 single header" is deprecated',
+                message="Please use 'DD_TRACE_PROPAGATION_STYLE=\"b3\"' instead",
+                removal_version="3.0.0",
+                category=DDTraceDeprecationWarning,
+            )
+            style = PROPAGATION_STYLE_B3_SINGLE
+        # None has no propagator so we pull it out
+        if not style or style == _PROPAGATION_STYLE_NONE:
+            continue
+        if style not in PROPAGATION_STYLE_ALL:
+            log.warning("Unknown DD_TRACE_PROPAGATION_STYLE: {!r}, allowed values are %r", style, PROPAGATION_STYLE_ALL)
+            continue
+        styles.append(style)
+    return styles
+
+
+# Borrowed from: https://stackoverflow.com/questions/20656135/python-deep-merge-dictionary-data#20666342
+def _deepmerge(source, destination):
+    """
+    Merge the first provided ``dict`` into the second.
+
+    :param dict source: The ``dict`` to merge into ``destination``
+    :param dict destination: The ``dict`` that should get updated
+    :rtype: dict
+    :returns: ``destination`` modified
+    """
+    for key, value in source.items():
+        if isinstance(value, dict):
+            # get node or create one
+            node = destination.setdefault(key, {})
+            _deepmerge(value, node)
+        else:
+            destination[key] = value
+
+    return destination
+
+
+def get_error_ranges(error_range_str):
+    # type: (str) -> List[Tuple[int, int]]
+    error_ranges = []
+    error_range_str = error_range_str.strip()
+    error_ranges_str = error_range_str.split(",")
+    for error_range in error_ranges_str:
+        values = error_range.split("-")
+        try:
+            # Note: mypy does not like variable type changing
+            values = [int(v) for v in values]  # type: ignore[misc]
+        except ValueError:
+            log.exception("Error status codes was not a number %s", values)
+            continue
+        error_range = (min(values), max(values))  # type: ignore[assignment]
+        error_ranges.append(error_range)
+    return error_ranges  # type: ignore[return-value]
+
+
+_ConfigSource = Literal["default", "env_var", "code", "remote_config"]
+_JSONType = Union[None, int, float, str, bool, List["_JSONType"], Dict[str, "_JSONType"]]
+
+
+class _ConfigItem:
+    """Configuration item that tracks the value of a setting, and where it came from."""
+
+    def __init__(self, default, envs):
+        # type: (Union[_JSONType, Callable[[], _JSONType]], List[Tuple[str, Callable[[str], Any]]]) -> None
+        # _ConfigItem._name is only used in __repr__ and instrumentation telemetry
+        self._name = envs[0][0]
+        self._env_value: _JSONType = None
+        self._code_value: _JSONType = None
+        self._rc_value: _JSONType = None
+        if callable(default):
+            self._default_value = default()
+        else:
+            self._default_value = default
+        self._envs = envs
+        for env_var, parser in envs:
+            if env_var in os.environ:
+                self._env_value = parser(os.environ[env_var])
+                break
+        telemetry_writer.add_configuration(self._name, self.value(), self.source())
+
+    def set_value_source(self, value: Any, source: _ConfigSource) -> None:
+        if source == "code":
+            self._code_value = value
+        elif source == "remote_config":
+            self._rc_value = value
+        else:
+            log.warning("Invalid source: %s", source)
+
+    def set_code(self, value: _JSONType) -> None:
+        self._code_value = value
+
+    def unset_rc(self) -> None:
+        self._rc_value = None
+
+    def value(self) -> _JSONType:
+        if self._rc_value is not None:
+            return self._rc_value
+        if self._code_value is not None:
+            return self._code_value
+        if self._env_value is not None:
+            return self._env_value
+        return self._default_value
+
+    def source(self) -> _ConfigSource:
+        if self._rc_value is not None:
+            return "remote_config"
+        if self._code_value is not None:
+            return "code"
+        if self._env_value is not None:
+            return "env_var"
+        return "default"
+
+    def __repr__(self):
+        return "<{} name={} default={} env_value={} user_value={} remote_config_value={}>".format(
+            self.__class__.__name__,
+            self._name,
+            self._default_value,
+            self._env_value,
+            self._code_value,
+            self._rc_value,
+        )
+
+
+def _parse_global_tags(s):
+    # cleanup DD_TAGS, because values will be inserted back in the optimal way (via _dd.git.* tags)
+    return gitmetadata.clean_tags(parse_tags_str(s))
+
+
+def _default_config() -> Dict[str, _ConfigItem]:
+    return {
+        "_trace_sample_rate": _ConfigItem(
+            default=1.0,
+            envs=[("DD_TRACE_SAMPLE_RATE", float)],
+        ),
+        "_trace_sampling_rules": _ConfigItem(
+            default=lambda: "",
+            envs=[("DD_TRACE_SAMPLING_RULES", str)],
+        ),
+        "_logs_injection": _ConfigItem(
+            default=False,
+            envs=[("DD_LOGS_INJECTION", asbool)],
+        ),
+        "_trace_http_header_tags": _ConfigItem(
+            default=lambda: {},
+            envs=[("DD_TRACE_HEADER_TAGS", parse_tags_str)],
+        ),
+        "tags": _ConfigItem(
+            default=lambda: {},
+            envs=[("DD_TAGS", _parse_global_tags)],
+        ),
+        "_tracing_enabled": _ConfigItem(
+            default=True,
+            envs=[("DD_TRACE_ENABLED", asbool)],
+        ),
+        "_profiling_enabled": _ConfigItem(
+            default=False,
+            envs=[("DD_PROFILING_ENABLED", asbool)],
+        ),
+        "_asm_enabled": _ConfigItem(
+            default=False,
+            envs=[("DD_APPSEC_ENABLED", asbool)],
+        ),
+        "_sca_enabled": _ConfigItem(
+            default=None,
+            envs=[("DD_APPSEC_SCA_ENABLED", asbool)],
+        ),
+        "_dsm_enabled": _ConfigItem(
+            default=False,
+            envs=[("DD_DATA_STREAMS_ENABLED", asbool)],
+        ),
+    }
+
+
+class Config(object):
+    """Configuration object that exposes an API to set and retrieve
+    global settings for each integration. All integrations must use
+    this instance to register their defaults, so that they're public
+    available and can be updated by users.
+    """
+
+    # Maps deprecated configuration attributes to their corresponding environment variable and
+    # internalized attribute name
+    _DEPRECATED_ATTRS = {
+        "http_tag_query_string": ("_http_tag_query_string", "DD_TRACE_HTTP_CLIENT_TAG_QUERY_STRING"),
+        "trace_http_header_tags": ("_trace_http_header_tags", "DD_TRACE_HEADER_TAGS"),
+        "report_hostname": ("_report_hostname", "DD_TRACE_REPORT_HOSTNAME"),
+        "health_metrics_enabled": ("_health_metrics_enabled", "DD_TRACE_HEALTH_METRICS_ENABLED"),
+        "analytics_enabled": ("_analytics_enabled", "DD_TRACE_ANALYTICS_ENABLED"),
+        "client_ip_header": ("_client_ip_header", "DD_TRACE_CLIENT_IP_HEADER"),
+        "retrieve_client_ip": ("_retrieve_client_ip", "DD_TRACE_CLIENT_IP_ENABLED"),
+        "propagation_http_baggage_enabled": (
+            "_propagation_http_baggage_enabled",
+            "DD_TRACE_PROPAGATION_HTTP_BAGGAGE_ENABLED",
+        ),
+        "global_query_string_obfuscation_disabled": (
+            "_global_query_string_obfuscation_disabled",
+            'DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP=""',
+        ),
+        "trace_methods": ("_trace_methods", "DD_TRACE_METHODS"),
+        "ci_visibility_log_level": ("_ci_visibility_log_level", "DD_CIVISIBILITY_LOG_LEVEL"),
+        "test_session_name": ("_test_session_name", "DD_TEST_SESSION_NAME"),
+        "logs_injection": ("_logs_injection", "DD_LOGS_INJECTION"),
+        "http_server": ("_http_server", "DD_TRACE_HTTP_SERVER_ERROR_STATUSES"),
+        "http": ("_http", "DD_TRACE_HEADER_TAGS"),
+    }
+
+    class _HTTPServerConfig(object):
+        _error_statuses = _get_config("DD_TRACE_HTTP_SERVER_ERROR_STATUSES", "500-599")  # type: str
+        _error_ranges = get_error_ranges(_error_statuses)  # type: List[Tuple[int, int]]
+
+        @property
+        def error_statuses(self):
+            # type: () -> str
+            return self._error_statuses
+
+        @error_statuses.setter
+        def error_statuses(self, value):
+            # type: (str) -> None
+            self._error_statuses = value
+            self._error_ranges = get_error_ranges(value)
+            # Mypy can't catch cached method's invalidate()
+            self.is_error_code.invalidate()  # type: ignore[attr-defined]
+
+        @property
+        def error_ranges(self):
+            # type: () -> List[Tuple[int, int]]
+            return self._error_ranges
+
+        @cachedmethod()
+        def is_error_code(self, status_code):
+            # type: (int) -> bool
+            """Returns a boolean representing whether or not a status code is an error code."""
+            for error_range in self.error_ranges:
+                if error_range[0] <= status_code <= error_range[1]:
+                    return True
+            return False
+
+    def __init__(self):
+        # Must map Otel configurations to Datadog configurations before creating the config object.
+        _otel_remapping()
+        # Must come before _integration_configs due to __setattr__
+        self._from_endpoint = ENDPOINT_FETCHED_CONFIG
+        self._config = _default_config()
+
+        sample_rate = os.getenv("DD_TRACE_SAMPLE_RATE")
+        if sample_rate is not None:
+            deprecate(
+                "DD_TRACE_SAMPLE_RATE is deprecated",
+                message="Please use DD_TRACE_SAMPLING_RULES instead.",
+                removal_version="3.0.0",
+            )
+
+        # Use a dict as underlying storing mechanism for integration configs
+        self._integration_configs = {}
+
+        self._debug_mode = _get_config("DD_TRACE_DEBUG", False, asbool)
+        self._startup_logs_enabled = _get_config("DD_TRACE_STARTUP_LOGS", False, asbool)
+
+        rate_limit = os.getenv("DD_TRACE_RATE_LIMIT")
+        if rate_limit is not None and self._trace_sampling_rules in ("", "[]"):
+            # This warning will be logged when DD_TRACE_SAMPLE_RATE is set. This is intentional.
+            # Even though DD_TRACE_SAMPLE_RATE is treated as a global trace sampling rule, this configuration
+            # is deprecated. We should always encourage users to set DD_TRACE_SAMPLING_RULES instead.
+            log.warning(
+                "DD_TRACE_RATE_LIMIT is set to %s and DD_TRACE_SAMPLING_RULES is not set. "
+                "Tracer rate limiting is only applied to spans that match tracer sampling rules. "
+                "All other spans will be rate limited by the Datadog Agent via DD_APM_MAX_TPS.",
+                rate_limit,
+            )
+        self._trace_rate_limit = _get_config("DD_TRACE_RATE_LIMIT", DEFAULT_SAMPLING_RATE_LIMIT, int)
+        self._partial_flush_enabled = _get_config("DD_TRACE_PARTIAL_FLUSH_ENABLED", True, asbool)
+        self._partial_flush_min_spans = _get_config("DD_TRACE_PARTIAL_FLUSH_MIN_SPANS", 300, int)
+
+        self._http = HttpConfig(header_tags=self._trace_http_header_tags)
+        self._remote_config_enabled = _get_config("DD_REMOTE_CONFIGURATION_ENABLED", True, asbool)
+        self._remote_config_poll_interval = _get_config(
+            ["DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS", "DD_REMOTECONFIG_POLL_SECONDS"], 5.0, float
+        )
+        self._trace_api = _get_config("DD_TRACE_API_VERSION")
+        if self._trace_api == "v0.3":
+            deprecate(
+                "DD_TRACE_API_VERSION=v0.3 is deprecated",
+                message="Traces will be submitted to the v0.4/traces agent endpoint instead.",
+                removal_version="3.0.0",
+                category=DDTraceDeprecationWarning,
+            )
+            self._trace_api = "v0.4"
+        self._trace_writer_buffer_size = _get_config("DD_TRACE_WRITER_BUFFER_SIZE_BYTES", DEFAULT_BUFFER_SIZE, int)
+        self._trace_writer_payload_size = _get_config(
+            "DD_TRACE_WRITER_MAX_PAYLOAD_SIZE_BYTES", DEFAULT_MAX_PAYLOAD_SIZE, int
+        )
+        self._trace_writer_interval_seconds = _get_config(
+            "DD_TRACE_WRITER_INTERVAL_SECONDS", DEFAULT_PROCESSING_INTERVAL, float
+        )
+        self._trace_writer_connection_reuse = _get_config(
+            "DD_TRACE_WRITER_REUSE_CONNECTIONS", DEFAULT_REUSE_CONNECTIONS, asbool
+        )
+        self._trace_writer_log_err_payload = _get_config("_DD_TRACE_WRITER_LOG_ERROR_PAYLOADS", False, asbool)
+
+        self._trace_agent_hostname = _get_config(["DD_AGENT_HOST", "DD_TRACE_AGENT_HOSTNAME"])
+        self._trace_agent_port = _get_config(["DD_AGENT_PORT", "DD_TRACE_AGENT_PORT"])
+        self._trace_agent_url = _get_config("DD_TRACE_AGENT_URL")
+
+        self._stats_agent_hostname = _get_config(["DD_AGENT_HOST", "DD_DOGSTATSD_HOST"])
+        self._stats_agent_port = _get_config("DD_DOGSTATSD_PORT")
+        self._stats_agent_url = _get_config("DD_DOGSTATSD_URL")
+        self._agent_timeout_seconds = _get_config("DD_TRACE_AGENT_TIMEOUT_SECONDS", DEFAULT_TIMEOUT, float)
+
+        self._span_traceback_max_size = _get_config("DD_TRACE_SPAN_TRACEBACK_MAX_SIZE", 30, int)
+
+        # Master switch for turning on and off trace search by default
+        # this weird invocation of getenv is meant to read the DD_ANALYTICS_ENABLED
+        # legacy environment variable. It should be removed in the future
+        self._analytics_enabled = _get_config(["DD_TRACE_ANALYTICS_ENABLED", "DD_ANALYTICS_ENABLED"], False, asbool)
+        if self._analytics_enabled:
+            deprecate(
+                "Datadog App Analytics is deprecated and will be removed in a future version. "
+                "App Analytics can be enabled via DD_TRACE_ANALYTICS_ENABLED and DD_ANALYTICS_ENABLED "
+                "environment variables and ddtrace.config.analytics_enabled configuration. "
+                "These configurations will also be removed.",
+                category=DDTraceDeprecationWarning,
+            )
+        self._client_ip_header = _get_config("DD_TRACE_CLIENT_IP_HEADER")
+        self._retrieve_client_ip = _get_config("DD_TRACE_CLIENT_IP_ENABLED", False, asbool)
+
+        self._propagation_http_baggage_enabled = _get_config("DD_TRACE_PROPAGATION_HTTP_BAGGAGE_ENABLED", False, asbool)
+
+        self.env = _get_config("DD_ENV", self.tags.get("env"))
+        self.service = _get_config("DD_SERVICE", self.tags.get("service", None))
+
+        self._inferred_base_service = detect_service(sys.argv)
+
+        if self.service is None and in_gcp_function():
+            self.service = _get_config(["K_SERVICE", "FUNCTION_NAME"], DEFAULT_SPAN_SERVICE_NAME)
+        if self.service is None and in_azure_function():
+            self.service = _get_config("WEBSITE_SITE_NAME", DEFAULT_SPAN_SERVICE_NAME)
+        if self.service is None and DEFAULT_SPAN_SERVICE_NAME:
+            self.service = _get_config("DD_SERVICE", DEFAULT_SPAN_SERVICE_NAME)
+
+        self._extra_services = set()
+        self._extra_services_queue = None if in_aws_lambda() or not self._remote_config_enabled else File_Queue()
+        self.version = _get_config("DD_VERSION", self.tags.get("version"))
+        self._http_server = self._HTTPServerConfig()
+
+        self._unparsed_service_mapping = _get_config("DD_SERVICE_MAPPING", "")
+        self.service_mapping = parse_tags_str(self._unparsed_service_mapping)
+
+        # The service tag corresponds to span.service and should not be
+        # included in the global tags.
+        if self.service and "service" in self.tags:
+            del self.tags["service"]
+
+        # The version tag should not be included on all spans.
+        if self.version and "version" in self.tags:
+            del self.tags["version"]
+
+        self._report_hostname = _get_config("DD_TRACE_REPORT_HOSTNAME", False, asbool)
+
+        self._health_metrics_enabled = _get_config("DD_TRACE_HEALTH_METRICS_ENABLED", False, asbool)
+
+        self._telemetry_enabled = _get_config("DD_INSTRUMENTATION_TELEMETRY_ENABLED", True, asbool)
+        self._telemetry_heartbeat_interval = _get_config("DD_TELEMETRY_HEARTBEAT_INTERVAL", 60, float)
+        self._telemetry_dependency_collection = _get_config("DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED", True, asbool)
+
+        self._runtime_metrics_enabled = _get_config("DD_RUNTIME_METRICS_ENABLED", False, asbool)
+
+        self._128_bit_trace_id_enabled = _get_config("DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED", True, asbool)
+
+        self._128_bit_trace_id_logging_enabled = _get_config("DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED", False, asbool)
+        if self._128_bit_trace_id_logging_enabled:
+            deprecate(
+                "Using DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED is deprecated.",
+                message="Log injection format is now configured automatically.",
+                removal_version="3.0.0",
+                category=DDTraceDeprecationWarning,
+            )
+
+        self._sampling_rules = _get_config("DD_SPAN_SAMPLING_RULES")
+        self._sampling_rules_file = _get_config("DD_SPAN_SAMPLING_RULES_FILE")
+
+        # Propagation styles
+        # DD_TRACE_PROPAGATION_STYLE_EXTRACT and DD_TRACE_PROPAGATION_STYLE_INJECT
+        #  take precedence over DD_TRACE_PROPAGATION_STYLE
+        # if DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT is set to ignore
+        # we set DD_TRACE_PROPAGATION_STYLE_EXTRACT to [_PROPAGATION_STYLE_NONE] since no extraction will heeded
+        self._propagation_behavior_extract = _get_config(
+            ["DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT"], _PROPAGATION_BEHAVIOR_DEFAULT, self._lower
+        )
+        if self._propagation_behavior_extract != _PROPAGATION_BEHAVIOR_IGNORE:
+            self._propagation_style_extract = _parse_propagation_styles(
+                _get_config(
+                    ["DD_TRACE_PROPAGATION_STYLE_EXTRACT", "DD_TRACE_PROPAGATION_STYLE"], _PROPAGATION_STYLE_DEFAULT
+                )
+            )
+        else:
+            log.debug(
+                """DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT is set to ignore,
+                setting DD_TRACE_PROPAGATION_STYLE_EXTRACT to empty list"""
+            )
+            self._propagation_style_extract = [_PROPAGATION_STYLE_NONE]
+        self._propagation_style_inject = _parse_propagation_styles(
+            _get_config(["DD_TRACE_PROPAGATION_STYLE_INJECT", "DD_TRACE_PROPAGATION_STYLE"], _PROPAGATION_STYLE_DEFAULT)
+        )
+
+        self._propagation_extract_first = _get_config("DD_TRACE_PROPAGATION_EXTRACT_FIRST", False, asbool)
+
+        # Datadog tracer tags propagation
+        x_datadog_tags_max_length = _get_config("DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH", 512, int)
+        if x_datadog_tags_max_length < 0:
+            log.warning(
+                (
+                    "Invalid value %r provided for DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH, "
+                    "only non-negative values allowed"
+                ),
+                x_datadog_tags_max_length,
+            )
+            x_datadog_tags_max_length = 0
+        self._x_datadog_tags_max_length = x_datadog_tags_max_length
+        self._x_datadog_tags_enabled = x_datadog_tags_max_length > 0
+
+        # Raise certain errors only if in testing raise mode to prevent crashing in production with non-critical errors
+        self._raise = _get_config("DD_TESTING_RAISE", False, asbool)
+
+        trace_compute_stats_default = in_gcp_function() or in_azure_function()
+        self._trace_compute_stats = _get_config(
+            ["DD_TRACE_COMPUTE_STATS", "DD_TRACE_STATS_COMPUTATION_ENABLED"], trace_compute_stats_default, asbool
+        )
+        self._data_streams_enabled = _get_config("DD_DATA_STREAMS_ENABLED", False, asbool)
+
+        legacy_client_tag_enabled = _get_config("DD_HTTP_CLIENT_TAG_QUERY_STRING")
+        if legacy_client_tag_enabled is None:
+            self._http_client_tag_query_string = _get_config("DD_TRACE_HTTP_CLIENT_TAG_QUERY_STRING", "true")
+        else:
+            deprecate(
+                "DD_HTTP_CLIENT_TAG_QUERY_STRING is deprecated",
+                message="Please use DD_TRACE_HTTP_CLIENT_TAG_QUERY_STRING instead.",
+                removal_version="3.0.0",
+                category=DDTraceDeprecationWarning,
+            )
+            self._http_client_tag_query_string = legacy_client_tag_enabled.lower()
+
+        dd_trace_obfuscation_query_string_regexp = _get_config(
+            "DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP", DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP_DEFAULT
+        )
+        self._global_query_string_obfuscation_disabled = dd_trace_obfuscation_query_string_regexp == ""
+        self._obfuscation_query_string_pattern = None
+        self._http_tag_query_string = True  # Default behaviour of query string tagging in http.url
+        try:
+            self._obfuscation_query_string_pattern = re.compile(
+                dd_trace_obfuscation_query_string_regexp.encode("ascii")
+            )
+        except Exception:
+            log.warning("Invalid obfuscation pattern, disabling query string tracing", exc_info=True)
+            self._http_tag_query_string = False  # Disable query string tagging if malformed obfuscation pattern
+
+        self._ci_visibility_agentless_enabled = _get_config("DD_CIVISIBILITY_AGENTLESS_ENABLED", False, asbool)
+        self._ci_visibility_agentless_url = _get_config("DD_CIVISIBILITY_AGENTLESS_URL", "")
+        self._ci_visibility_intelligent_testrunner_enabled = _get_config("DD_CIVISIBILITY_ITR_ENABLED", True, asbool)
+        self._ci_visibility_log_level = _get_config("DD_CIVISIBILITY_LOG_LEVEL", "info")
+        self._test_session_name = _get_config("DD_TEST_SESSION_NAME")
+        self._test_visibility_early_flake_detection_enabled = _get_config(
+            "DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED", True, asbool
+        )
+        self._otel_enabled = _get_config("DD_TRACE_OTEL_ENABLED", False, asbool)
+        if self._otel_enabled:
+            # Replaces the default otel api runtime context with DDRuntimeContext
+            # https://github.com/open-telemetry/opentelemetry-python/blob/v1.16.0/opentelemetry-api/src/opentelemetry/context/__init__.py#L53
+            os.environ["OTEL_PYTHON_CONTEXT"] = "ddcontextvars_context"
+        self._subscriptions = []  # type: List[Tuple[List[str], Callable[[Config, List[str]], None]]]
+        self._span_aggregator_rlock = _get_config("DD_TRACE_SPAN_AGGREGATOR_RLOCK", True, asbool)
+        if self._span_aggregator_rlock is False:
+            deprecate(
+                "DD_TRACE_SPAN_AGGREGATOR_RLOCK is deprecated",
+                message="Soon the ddtrace library will only support using threading.Rlock to "
+                "aggregate and encode span data. If you need to disable the re-entrant lock and "
+                "revert to using threading.Lock, please contact Datadog support.",
+                removal_version="3.0.0",
+            )
+
+        self._trace_methods = _get_config("DD_TRACE_METHODS")
+
+        self._telemetry_install_id = _get_config("DD_INSTRUMENTATION_INSTALL_ID")
+        self._telemetry_install_type = _get_config("DD_INSTRUMENTATION_INSTALL_TYPE")
+        self._telemetry_install_time = _get_config("DD_INSTRUMENTATION_INSTALL_TYPE")
+
+        self._dd_api_key = _get_config("DD_API_KEY")
+        self._dd_site = _get_config("DD_SITE", "datadoghq.com")
+
+        self._llmobs_enabled = _get_config("DD_LLMOBS_ENABLED", False, asbool)
+        self._llmobs_sample_rate = _get_config("DD_LLMOBS_SAMPLE_RATE", 1.0, float)
+        self._llmobs_ml_app = _get_config("DD_LLMOBS_ML_APP")
+        self._llmobs_agentless_enabled = _get_config("DD_LLMOBS_AGENTLESS_ENABLED", False, asbool)
+
+        self._inject_force = _get_config("DD_INJECT_FORCE", False, asbool)
+        self._lib_was_injected = False
+        self._inject_was_attempted = _get_config("_DD_INJECT_WAS_ATTEMPTED", False, asbool)
+
+    def __getattr__(self, name) -> Any:
+        if name in self._DEPRECATED_ATTRS:
+            new_name, env_var = self._DEPRECATED_ATTRS[name]
+            deprecate(
+                f"ddtrace.config.{name} is deprecated",
+                message=f"Use the environment variable {env_var} instead. "
+                "This variable must be set before importing ddtrace.",
+                removal_version="3.0.0",
+                category=DDTraceDeprecationWarning,
+            )
+            if name == new_name:
+                raise RuntimeError(
+                    f"Circular mapping detected: deprecated attribute {name} "
+                    f"in {self._DEPRECATED_ATTRS} maps to a deprecated attribute {new_name}"
+                )
+            return getattr(self, new_name)
+
+        if name in self._config:
+            return self._config[name].value()
+
+        if name not in self._integration_configs:
+            self._integration_configs[name] = IntegrationConfig(self, name)
+
+        return self._integration_configs[name]
+
+    def _add_extra_service(self, service_name: str) -> None:
+        if self._extra_services_queue is None:
+            return
+        if service_name != self.service:
+            self._extra_services_queue.put(service_name)
+
+    def _get_extra_services(self):
+        # type: () -> set[str]
+        if self._extra_services_queue is None:
+            return set()
+        self._extra_services.update(self._extra_services_queue.get_all())
+        while len(self._extra_services) > 64:
+            self._extra_services.pop()
+        return self._extra_services
+
+    def get_from(self, obj):
+        deprecate(
+            "ddtrace.config.get_from is deprecated",
+            message="Use the `config` attribute directly.",
+        )
+        self._get_from(obj)
+
+    def _get_from(self, obj):
+        """Retrieves the configuration for the given object.
+        Any object that has an attached `Pin` must have a configuration
+        and if a wrong object is given, an empty `dict` is returned
+        for safety reasons.
+        """
+        pin = Pin.get_from(obj)
+        if pin is None:
+            log.debug("No configuration found for %s", obj)
+            return {}
+
+        return pin._config
+
+    def _add(self, integration, settings, merge=True):
+        """Internal API that registers an integration with given default
+        settings.
+
+        :param str integration: The integration name (i.e. `requests`)
+        :param dict settings: A dictionary that contains integration settings;
+            to preserve immutability of these values, the dictionary is copied
+            since it contains integration defaults.
+        :param bool merge: Whether to merge any existing settings with those provided,
+            or if we should overwrite the settings with those provided;
+            Note: when merging existing settings take precedence.
+        """
+        # DEV: Use `getattr()` to call our `__getattr__` helper
+        existing = getattr(self, integration)
+        settings = deepcopy(settings)
+
+        if merge:
+            # DEV: This may appear backwards keeping `existing` as the "source" and `settings` as
+            #   the "destination", but we do not want to let `_add(..., merge=True)` overwrite any
+            #   existing settings
+            #
+            # >>> config.requests['split_by_domain'] = True
+            # >>> config._add('requests', dict(split_by_domain=False))
+            # >>> config.requests['split_by_domain']
+            # True
+            self._integration_configs[integration] = IntegrationConfig(
+                self, integration, _deepmerge(existing, settings)
+            )
+        else:
+            self._integration_configs[integration] = IntegrationConfig(self, integration, settings)
+
+    def trace_headers(self, whitelist):
+        """
+        Registers a set of headers to be traced at global level or integration level.
+        :param whitelist: the case-insensitive list of traced headers
+        :type whitelist: list of str or str
+        :return: self
+        :rtype: HttpConfig
+        """
+        deprecate(
+            "ddtrace.config.trace_headers is deprecated",
+            message="Use the environment variable DD_TRACE_HEADER_TAGS instead.",
+            removal_version="3.0.0",
+        )
+        self._http.trace_headers(whitelist)
+        return self
+
+    def header_is_traced(self, header_name):
+        # type: (str) -> bool
+        """
+        Returns whether or not the current header should be traced.
+        :param header_name: the header name
+        :type header_name: str
+        :rtype: bool
+        """
+        deprecate(
+            "ddtrace.config.header_is_traced is deprecated",
+            removal_version="3.0.0",
+        )
+        return self._http.header_is_traced(header_name)
+
+    @cachedmethod()
+    def _header_tag_name(self, header_name):
+        # type: (str) -> Optional[str]
+        return self._http._header_tag_name(header_name)
+
+    def _get_service(self, default=None):
+        """
+        Returns the globally configured service or the default if none is configured.
+
+        :param default: the default service to use if none is configured or
+            found.
+        :type default: str
+        :rtype: str|None
+        """
+
+        # We check if self.service != _inferred_base_service since config.service
+        # defaults to _inferred_base_service when no DD_SERVICE is set. In this case, we want to not
+        # use the inferred base service value, and instead use the default if included. If we
+        # didn't do this, we would have a massive breaking change from adding inferred_base_service,
+        # which would be replacing any integration defaults since service is no longer None.
+        if self.service and self.service == self._inferred_base_service:
+            return default if default is not None else self.service
+
+        # TODO: This method can be replaced with `config.service`.
+        return self.service if self.service is not None else default
+
+    def __repr__(self):
+        cls = self.__class__
+        integrations = ", ".join(self._integration_config.keys())
+        return "{}.{}({})".format(cls.__module__, cls.__name__, integrations)
+
+    def _subscribe(self, items, handler):
+        # type: (List[str], Callable[[Config, List[str]], None]) -> None
+        self._subscriptions.append((items, handler))
+
+    def _notify_subscribers(self, changed_items):
+        # type: (List[str]) -> None
+        for sub_items, sub_handler in self._subscriptions:
+            sub_updated_items = [i for i in changed_items if i in sub_items]
+            if sub_updated_items:
+                sub_handler(self, sub_updated_items)
+
+    def __setattr__(self, key, value):
+        # type: (str, Any) -> None
+        if key in ("_config", "_from_endpoint"):
+            return super(self.__class__, self).__setattr__(key, value)
+        elif key in self._config:
+            self._set_config_items([(key, value, "code")])
+            return None
+        else:
+            if key in self._DEPRECATED_ATTRS:
+                # replace deprecated attribute name with the new name
+                new_key, env_var = self._DEPRECATED_ATTRS[key]
+                deprecate(
+                    f"ddtrace.config.{key} is deprecated",
+                    message=f"Use the environment variable {env_var} instead. "
+                    "This variable must be set before importing ddtrace.",
+                    removal_version="3.0.0",
+                    category=DDTraceDeprecationWarning,
+                )
+                key = new_key
+            return super(self.__class__, self).__setattr__(key, value)
+
+    def _set_config_items(self, items):
+        # type: (List[Tuple[str, Any, _ConfigSource]]) -> None
+        item_names = []
+        for key, value, origin in items:
+            item_names.append(key)
+            item = self._config[key]
+            item.set_value_source(value, origin)
+            if self._telemetry_enabled:
+                telemetry_writer.add_configuration(item._name, item.value(), item.source())
+        self._notify_subscribers(item_names)
+
+    def _reset(self):
+        # type: () -> None
+        self._config = _default_config()
+
+    def _get_source(self, item):
+        # type: (str) -> str
+        return self._config[item].source()
+
+    def _remoteconfigPubSub(self):
+        from ddtrace.internal.remoteconfig._connectors import PublisherSubscriberConnector
+        from ddtrace.internal.remoteconfig._publishers import RemoteConfigPublisher
+        from ddtrace.internal.remoteconfig._pubsub import PubSub
+        from ddtrace.internal.remoteconfig._pubsub import RemoteConfigSubscriber
+
+        class _GlobalConfigPubSub(PubSub):
+            __publisher_class__ = RemoteConfigPublisher
+            __subscriber_class__ = RemoteConfigSubscriber
+            __shared_data__ = PublisherSubscriberConnector()
+
+            def __init__(self, callback):
+                self._publisher = self.__publisher_class__(self.__shared_data__, None)
+                self._subscriber = self.__subscriber_class__(self.__shared_data__, callback, "GlobalConfig")
+
+        return _GlobalConfigPubSub
+
+    def _handle_remoteconfig(self, data, test_tracer=None):
+        # type: (Any, Any) -> None
+        if not isinstance(data, dict) or (isinstance(data, dict) and "config" not in data):
+            log.warning("unexpected RC payload %r", data)
+            return
+        if len(data["config"]) == 0:
+            log.warning("unexpected number of RC payloads %r", data)
+            return
+
+        # Check if 'lib_config' is a key in the dictionary since other items can be sent in the payload
+        config = None
+        for config_item in data["config"]:
+            if isinstance(config_item, Dict):
+                if "lib_config" in config_item:
+                    config = config_item
+                    break
+
+        # If no data is submitted then the RC config has been deleted. Revert the settings.
+        base_rc_config = {n: None for n in self._config}
+
+        if config and "lib_config" in config:
+            lib_config = config["lib_config"]
+            if "tracing_sampling_rate" in lib_config:
+                base_rc_config["_trace_sample_rate"] = lib_config["tracing_sampling_rate"]
+
+            if "tracing_sampling_rules" in lib_config:
+                trace_sampling_rules = lib_config["tracing_sampling_rules"]
+                if trace_sampling_rules:
+                    # returns None if no rules
+                    trace_sampling_rules = self._convert_rc_trace_sampling_rules(trace_sampling_rules)
+                    if trace_sampling_rules:
+                        base_rc_config["_trace_sampling_rules"] = trace_sampling_rules
+
+            if "log_injection_enabled" in lib_config:
+                base_rc_config["_logs_injection"] = lib_config["log_injection_enabled"]
+
+            if "tracing_tags" in lib_config:
+                tags = lib_config["tracing_tags"]
+                if tags:
+                    tags = self._format_tags(lib_config["tracing_tags"])
+                base_rc_config["tags"] = tags
+
+            if "tracing_enabled" in lib_config and lib_config["tracing_enabled"] is not None:
+                base_rc_config["_tracing_enabled"] = asbool(lib_config["tracing_enabled"])  # type: ignore[assignment]
+
+            if "tracing_header_tags" in lib_config:
+                tags = lib_config["tracing_header_tags"]
+                if tags:
+                    tags = self._format_tags(lib_config["tracing_header_tags"])
+                base_rc_config["_trace_http_header_tags"] = tags
+        self._set_config_items([(k, v, "remote_config") for k, v in base_rc_config.items()])
+        # called unconditionally to handle the case where header tags have been unset
+        self._handle_remoteconfig_header_tags(base_rc_config)
+
+    def _handle_remoteconfig_header_tags(self, base_rc_config):
+        """Implements precedence order between remoteconfig header tags from code, env, and RC"""
+        header_tags_conf = self._config["_trace_http_header_tags"]
+        env_headers = header_tags_conf._env_value or {}
+        code_headers = header_tags_conf._code_value or {}
+        non_rc_header_tags = {**code_headers, **env_headers}
+        selected_header_tags = base_rc_config.get("_trace_http_header_tags") or non_rc_header_tags
+        self._http = HttpConfig(header_tags=selected_header_tags)
+
+    def _format_tags(self, tags: List[Union[str, Dict]]) -> Dict[str, str]:
+        if not tags:
+            return {}
+        if isinstance(tags[0], Dict):
+            pairs = [(item["header"], item["tag_name"]) for item in tags]  # type: ignore[index]
+        else:
+            pairs = [t.split(":") for t in tags]  # type: ignore[union-attr,misc]
+        return {k: v for k, v in pairs}
+
+    def enable_remote_configuration(self):
+        deprecate(
+            "ddtrace.config.enable_remote_configuration(...) is deprecated",
+            message="Use DD_TRACE_REMOTE_CONFIG_ENABLED instead.",
+            version="3.0.0",
+        )
+        self._enable_remote_configuration()
+
+    def _enable_remote_configuration(self):
+        # type: () -> None
+        """Enable fetching configuration from Datadog."""
+        from ddtrace.internal.flare.flare import Flare
+        from ddtrace.internal.flare.handler import _handle_tracer_flare
+        from ddtrace.internal.flare.handler import _tracerFlarePubSub
+        from ddtrace.internal.remoteconfig.worker import remoteconfig_poller
+
+        remoteconfig_pubsub = self._remoteconfigPubSub()(self._handle_remoteconfig)
+        flare = Flare(trace_agent_url=self._trace_agent_url, api_key=self._dd_api_key, ddconfig=self.__dict__)
+        tracerflare_pubsub = _tracerFlarePubSub()(_handle_tracer_flare, flare)
+        remoteconfig_poller.register("APM_TRACING", remoteconfig_pubsub)
+        remoteconfig_poller.register("AGENT_CONFIG", tracerflare_pubsub)
+        remoteconfig_poller.register("AGENT_TASK", tracerflare_pubsub)
+
+    def _remove_invalid_rules(self, rc_rules: List) -> List:
+        """Remove invalid sampling rules from the given list"""
+        # loop through list of dictionaries, if a dictionary doesn't have certain attributes, remove it
+        for rule in rc_rules:
+            if (
+                ("service" not in rule and "name" not in rule and "resource" not in rule and "tags" not in rule)
+                or "sample_rate" not in rule
+                or "provenance" not in rule
+            ):
+                log.debug("Invalid sampling rule from remoteconfig found, rule will be removed: %s", rule)
+                rc_rules.remove(rule)
+
+        return rc_rules
+
+    def _tags_to_dict(self, tags: List[Dict]):
+        """
+        Converts a list of tag dictionaries to a single dictionary.
+        """
+        if isinstance(tags, list):
+            return {tag["key"]: tag["value_glob"] for tag in tags}
+        return tags
+
+    def convert_rc_trace_sampling_rules(self, rc_rules: List[Dict[str, Any]]) -> Optional[str]:
+        deprecate(
+            "ddtrace.config.convert_rc_trace_sampling_rules(...) is deprecated",
+            message="Use DD_REMOTE_CONFIGURATION_ENABLED instead.",
+            version="3.0.0",
+        )
+        return self._convert_rc_trace_sampling_rules(rc_rules)
+
+    def _convert_rc_trace_sampling_rules(self, rc_rules: List[Dict[str, Any]]) -> Optional[str]:
+        """Example of an incoming rule:
+        [
+          {
+            "service": "my-service",
+            "name": "web.request",
+            "resource": "*",
+            "provenance": "customer",
+            "sample_rate": 1.0,
+            "tags": [
+              {
+                "key": "care_about",
+                "value_glob": "yes"
+              },
+              {
+                "key": "region",
+                "value_glob": "us-*"
+              }
+            ]
+          }
+        ]
+
+                Example of a converted rule:
+                '[{"sample_rate":1.0,"service":"my-service","resource":"*","name":"web.request","tags":{"care_about":"yes","region":"us-*"},provenance":"customer"}]'
+        """
+        rc_rules = self._remove_invalid_rules(rc_rules)
+        for rule in rc_rules:
+            tags = rule.get("tags")
+            if tags:
+                rule["tags"] = self._tags_to_dict(tags)
+        if rc_rules:
+            return json.dumps(rc_rules)
+        else:
+            return None
+
+    def _lower(self, value):
+        return value.lower()
diff --git a/ddtrace/settings/config.py b/ddtrace/settings/config.py
index 536ea0131bc..00c0ee9917c 100644
--- a/ddtrace/settings/config.py
+++ b/ddtrace/settings/config.py
@@ -1,999 +1,11 @@
-from copy import deepcopy
-import json
-import os
-import re
-import sys
-from typing import Any  # noqa:F401
-from typing import Callable  # noqa:F401
-from typing import Dict  # noqa:F401
-from typing import List  # noqa:F401
-from typing import Optional  # noqa:F401
-from typing import Tuple  # noqa:F401
-from typing import Union  # noqa:F401
-
-from ddtrace.internal._file_queue import File_Queue
-from ddtrace.internal.serverless import in_azure_function
-from ddtrace.internal.serverless import in_gcp_function
-from ddtrace.internal.telemetry import telemetry_writer
-from ddtrace.internal.utils.cache import cachedmethod
 from ddtrace.internal.utils.deprecations import DDTraceDeprecationWarning
+from ddtrace.settings._config import *  # noqa: F403
 from ddtrace.vendor.debtcollector import deprecate
 
-from .._trace.pin import Pin
-from ..internal import gitmetadata
-from ..internal.constants import _PROPAGATION_BEHAVIOR_DEFAULT
-from ..internal.constants import _PROPAGATION_BEHAVIOR_IGNORE
-from ..internal.constants import _PROPAGATION_STYLE_DEFAULT
-from ..internal.constants import _PROPAGATION_STYLE_NONE
-from ..internal.constants import DEFAULT_BUFFER_SIZE
-from ..internal.constants import DEFAULT_MAX_PAYLOAD_SIZE
-from ..internal.constants import DEFAULT_PROCESSING_INTERVAL
-from ..internal.constants import DEFAULT_REUSE_CONNECTIONS
-from ..internal.constants import DEFAULT_SAMPLING_RATE_LIMIT
-from ..internal.constants import DEFAULT_TIMEOUT
-from ..internal.constants import PROPAGATION_STYLE_ALL
-from ..internal.constants import PROPAGATION_STYLE_B3_SINGLE
-from ..internal.logger import get_logger
-from ..internal.schema import DEFAULT_SPAN_SERVICE_NAME
-from ..internal.serverless import in_aws_lambda
-from ..internal.utils.formats import asbool
-from ..internal.utils.formats import parse_tags_str
-from ._core import get_config as _get_config
-from ._inferred_base_service import detect_service
-from ._otel_remapper import otel_remapping as _otel_remapping
-from .endpoint_config import fetch_config_from_endpoint
-from .http import HttpConfig
-from .integration import IntegrationConfig
-
-
-if sys.version_info >= (3, 8):
-    from typing import Literal  # noqa:F401
-else:
-    from typing_extensions import Literal
-
-
-log = get_logger(__name__)
 
-ENDPOINT_FETCHED_CONFIG = fetch_config_from_endpoint()
-
-DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP_DEFAULT = (
-    r"(?ix)"
-    r"(?:"  # JSON-ish leading quote
-    r'(?:"|%22)?'
-    r")"
-    r"(?:"  # common keys"
-    r"(?:old[-_]?|new[-_]?)?p(?:ass)?w(?:or)?d(?:1|2)?"  # pw, password variants
-    r"|pass(?:[-_]?phrase)?"  # pass, passphrase variants
-    r"|secret"
-    r"|(?:"  # key, key_id variants
-    r"api[-_]?"
-    r"|private[-_]?"
-    r"|public[-_]?"
-    r"|access[-_]?"
-    r"|secret[-_]?"
-    r"|app(?:lica"
-    r"tion)?[-_]?"
-    r")key(?:[-_]?id)?"
-    r"|token"
-    r"|consumer[-_]?(?:id|key|secret)"
-    r"|sign(?:ed|ature)?"
-    r"|auth(?:entication|orization)?"
-    r")"
-    r"(?:"
-    # '=' query string separator, plus value til next '&' separator
-    r"(?:\s|%20)*(?:=|%3D)[^&]+"
-    # JSON-ish '": "somevalue"', key being handled with case above, without the opening '"'
-    r'|(?:"|%22)'  # closing '"' at end of key
-    r"(?:\s|%20)*(?::|%3A)(?:\s|%20)*"  # ':' key-value separator, with surrounding spaces
-    r'(?:"|%22)'  # opening '"' at start of value
-    r'(?:%2[^2]|%[^2]|[^"%])+'  # value
-    r'(?:"|%22)'  # closing '"' at end of value
-    r")"
-    r"|(?:"  # other common secret values
-    r" bearer(?:\s|%20)+[a-z0-9._\-]+"
-    r"|token(?::|%3A)[a-z0-9]{13}"
-    r"|gh[opsu]_[0-9a-zA-Z]{36}"
-    r"|ey[I-L](?:[\w=-]|%3D)+\.ey[I-L](?:[\w=-]|%3D)+(?:\.(?:[\w.+/=-]|%3D|%2F|%2B)+)?"
-    r"|-{5}BEGIN(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY-{5}[^\-]+-{5}END"
-    r"(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY(?:-{5})?(?:\n|%0A)?"
-    r"|(?:ssh-(?:rsa|dss)|ecdsa-[a-z0-9]+-[a-z0-9]+)(?:\s|%20|%09)+(?:[a-z0-9/.+]"
-    r"|%2F|%5C|%2B){100,}(?:=|%3D)*(?:(?:\s|%20|%09)+[a-z0-9._-]+)?"
-    r")"
+deprecate(
+    "The ddtrace.settings.config module is deprecated",
+    message="Access the global configuration using ``ddtrace.config``.",
+    category=DDTraceDeprecationWarning,
+    removal_version="3.0.0",
 )
-
-
-def _parse_propagation_styles(styles_str):
-    # type: (str) -> Optional[List[str]]
-    """Helper to parse http propagation extract/inject styles via env variables.
-
-    The expected format is::
-
-        <style>[,<style>...]
-
-
-    The allowed values are:
-
-    - "datadog"
-    - "b3multi"
-    - "b3" (formerly 'b3 single header')
-    - "b3 single header (deprecated for 'b3')"
-    - "tracecontext"
-    - "baggage"
-    - "none"
-
-
-    The default value is ``"datadog,tracecontext,baggage"``.
-
-
-    Examples::
-
-        # Extract and inject b3 headers:
-        DD_TRACE_PROPAGATION_STYLE="b3multi"
-
-        # Disable header propagation:
-        DD_TRACE_PROPAGATION_STYLE="none"
-
-        # Extract trace context from "x-datadog-*" or "x-b3-*" headers from upstream headers
-        DD_TRACE_PROPAGATION_STYLE_EXTRACT="datadog,b3multi"
-
-        # Inject the "b3: *" header into downstream requests headers
-        DD_TRACE_PROPAGATION_STYLE_INJECT="b3"
-    """
-    styles = []
-    for style in styles_str.split(","):
-        style = style.strip().lower()
-        if style == "b3 single header":
-            deprecate(
-                'Using DD_TRACE_PROPAGATION_STYLE="b3 single header" is deprecated',
-                message="Please use 'DD_TRACE_PROPAGATION_STYLE=\"b3\"' instead",
-                removal_version="3.0.0",
-                category=DDTraceDeprecationWarning,
-            )
-            style = PROPAGATION_STYLE_B3_SINGLE
-        # None has no propagator so we pull it out
-        if not style or style == _PROPAGATION_STYLE_NONE:
-            continue
-        if style not in PROPAGATION_STYLE_ALL:
-            log.warning("Unknown DD_TRACE_PROPAGATION_STYLE: {!r}, allowed values are %r", style, PROPAGATION_STYLE_ALL)
-            continue
-        styles.append(style)
-    return styles
-
-
-# Borrowed from: https://stackoverflow.com/questions/20656135/python-deep-merge-dictionary-data#20666342
-def _deepmerge(source, destination):
-    """
-    Merge the first provided ``dict`` into the second.
-
-    :param dict source: The ``dict`` to merge into ``destination``
-    :param dict destination: The ``dict`` that should get updated
-    :rtype: dict
-    :returns: ``destination`` modified
-    """
-    for key, value in source.items():
-        if isinstance(value, dict):
-            # get node or create one
-            node = destination.setdefault(key, {})
-            _deepmerge(value, node)
-        else:
-            destination[key] = value
-
-    return destination
-
-
-def get_error_ranges(error_range_str):
-    # type: (str) -> List[Tuple[int, int]]
-    error_ranges = []
-    error_range_str = error_range_str.strip()
-    error_ranges_str = error_range_str.split(",")
-    for error_range in error_ranges_str:
-        values = error_range.split("-")
-        try:
-            # Note: mypy does not like variable type changing
-            values = [int(v) for v in values]  # type: ignore[misc]
-        except ValueError:
-            log.exception("Error status codes was not a number %s", values)
-            continue
-        error_range = (min(values), max(values))  # type: ignore[assignment]
-        error_ranges.append(error_range)
-    return error_ranges  # type: ignore[return-value]
-
-
-_ConfigSource = Literal["default", "env_var", "code", "remote_config"]
-_JSONType = Union[None, int, float, str, bool, List["_JSONType"], Dict[str, "_JSONType"]]
-
-
-class _ConfigItem:
-    """Configuration item that tracks the value of a setting, and where it came from."""
-
-    def __init__(self, default, envs):
-        # type: (Union[_JSONType, Callable[[], _JSONType]], List[Tuple[str, Callable[[str], Any]]]) -> None
-        # _ConfigItem._name is only used in __repr__ and instrumentation telemetry
-        self._name = envs[0][0]
-        self._env_value: _JSONType = None
-        self._code_value: _JSONType = None
-        self._rc_value: _JSONType = None
-        if callable(default):
-            self._default_value = default()
-        else:
-            self._default_value = default
-        self._envs = envs
-        for env_var, parser in envs:
-            if env_var in os.environ:
-                self._env_value = parser(os.environ[env_var])
-                break
-        telemetry_writer.add_configuration(self._name, self.value(), self.source())
-
-    def set_value_source(self, value: Any, source: _ConfigSource) -> None:
-        if source == "code":
-            self._code_value = value
-        elif source == "remote_config":
-            self._rc_value = value
-        else:
-            log.warning("Invalid source: %s", source)
-
-    def set_code(self, value: _JSONType) -> None:
-        self._code_value = value
-
-    def unset_rc(self) -> None:
-        self._rc_value = None
-
-    def value(self) -> _JSONType:
-        if self._rc_value is not None:
-            return self._rc_value
-        if self._code_value is not None:
-            return self._code_value
-        if self._env_value is not None:
-            return self._env_value
-        return self._default_value
-
-    def source(self) -> _ConfigSource:
-        if self._rc_value is not None:
-            return "remote_config"
-        if self._code_value is not None:
-            return "code"
-        if self._env_value is not None:
-            return "env_var"
-        return "default"
-
-    def __repr__(self):
-        return "<{} name={} default={} env_value={} user_value={} remote_config_value={}>".format(
-            self.__class__.__name__,
-            self._name,
-            self._default_value,
-            self._env_value,
-            self._code_value,
-            self._rc_value,
-        )
-
-
-def _parse_global_tags(s):
-    # cleanup DD_TAGS, because values will be inserted back in the optimal way (via _dd.git.* tags)
-    return gitmetadata.clean_tags(parse_tags_str(s))
-
-
-def _default_config() -> Dict[str, _ConfigItem]:
-    return {
-        "_trace_sample_rate": _ConfigItem(
-            default=1.0,
-            envs=[("DD_TRACE_SAMPLE_RATE", float)],
-        ),
-        "_trace_sampling_rules": _ConfigItem(
-            default=lambda: "",
-            envs=[("DD_TRACE_SAMPLING_RULES", str)],
-        ),
-        "_logs_injection": _ConfigItem(
-            default=False,
-            envs=[("DD_LOGS_INJECTION", asbool)],
-        ),
-        "_trace_http_header_tags": _ConfigItem(
-            default=lambda: {},
-            envs=[("DD_TRACE_HEADER_TAGS", parse_tags_str)],
-        ),
-        "tags": _ConfigItem(
-            default=lambda: {},
-            envs=[("DD_TAGS", _parse_global_tags)],
-        ),
-        "_tracing_enabled": _ConfigItem(
-            default=True,
-            envs=[("DD_TRACE_ENABLED", asbool)],
-        ),
-        "_profiling_enabled": _ConfigItem(
-            default=False,
-            envs=[("DD_PROFILING_ENABLED", asbool)],
-        ),
-        "_asm_enabled": _ConfigItem(
-            default=False,
-            envs=[("DD_APPSEC_ENABLED", asbool)],
-        ),
-        "_sca_enabled": _ConfigItem(
-            default=None,
-            envs=[("DD_APPSEC_SCA_ENABLED", asbool)],
-        ),
-        "_dsm_enabled": _ConfigItem(
-            default=False,
-            envs=[("DD_DATA_STREAMS_ENABLED", asbool)],
-        ),
-    }
-
-
-class Config(object):
-    """Configuration object that exposes an API to set and retrieve
-    global settings for each integration. All integrations must use
-    this instance to register their defaults, so that they're public
-    available and can be updated by users.
-    """
-
-    # Maps deprecated configuration attributes to their corresponding environment variable and
-    # internalized attribute name
-    _DEPRECATED_ATTRS = {
-        "http_tag_query_string": ("_http_tag_query_string", "DD_TRACE_HTTP_CLIENT_TAG_QUERY_STRING"),
-        "trace_http_header_tags": ("_trace_http_header_tags", "DD_TRACE_HEADER_TAGS"),
-        "report_hostname": ("_report_hostname", "DD_TRACE_REPORT_HOSTNAME"),
-        "health_metrics_enabled": ("_health_metrics_enabled", "DD_TRACE_HEALTH_METRICS_ENABLED"),
-        "analytics_enabled": ("_analytics_enabled", "DD_TRACE_ANALYTICS_ENABLED"),
-        "client_ip_header": ("_client_ip_header", "DD_TRACE_CLIENT_IP_HEADER"),
-        "retrieve_client_ip": ("_retrieve_client_ip", "DD_TRACE_CLIENT_IP_ENABLED"),
-        "propagation_http_baggage_enabled": (
-            "_propagation_http_baggage_enabled",
-            "DD_TRACE_PROPAGATION_HTTP_BAGGAGE_ENABLED",
-        ),
-        "global_query_string_obfuscation_disabled": (
-            "_global_query_string_obfuscation_disabled",
-            'DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP=""',
-        ),
-        "trace_methods": ("_trace_methods", "DD_TRACE_METHODS"),
-        "ci_visibility_log_level": ("_ci_visibility_log_level", "DD_CIVISIBILITY_LOG_LEVEL"),
-        "test_session_name": ("_test_session_name", "DD_TEST_SESSION_NAME"),
-        "logs_injection": ("_logs_injection", "DD_LOGS_INJECTION"),
-    }
-
-    class _HTTPServerConfig(object):
-        _error_statuses = _get_config("DD_TRACE_HTTP_SERVER_ERROR_STATUSES", "500-599")  # type: str
-        _error_ranges = get_error_ranges(_error_statuses)  # type: List[Tuple[int, int]]
-
-        @property
-        def error_statuses(self):
-            # type: () -> str
-            return self._error_statuses
-
-        @error_statuses.setter
-        def error_statuses(self, value):
-            # type: (str) -> None
-            self._error_statuses = value
-            self._error_ranges = get_error_ranges(value)
-            # Mypy can't catch cached method's invalidate()
-            self.is_error_code.invalidate()  # type: ignore[attr-defined]
-
-        @property
-        def error_ranges(self):
-            # type: () -> List[Tuple[int, int]]
-            return self._error_ranges
-
-        @cachedmethod()
-        def is_error_code(self, status_code):
-            # type: (int) -> bool
-            """Returns a boolean representing whether or not a status code is an error code.
-            Error status codes by default are 500-599.
-            You may also enable custom error codes::
-
-                from ddtrace import config
-                config.http_server.error_statuses = '401-404,419'
-
-            Ranges and singular error codes are permitted and can be separated using commas.
-            """
-            for error_range in self.error_ranges:
-                if error_range[0] <= status_code <= error_range[1]:
-                    return True
-            return False
-
-    def __init__(self):
-        # Must map Otel configurations to Datadog configurations before creating the config object.
-        _otel_remapping()
-        # Must come before _integration_configs due to __setattr__
-        self._from_endpoint = ENDPOINT_FETCHED_CONFIG
-        self._config = _default_config()
-
-        sample_rate = os.getenv("DD_TRACE_SAMPLE_RATE")
-        if sample_rate is not None:
-            deprecate(
-                "DD_TRACE_SAMPLE_RATE is deprecated",
-                message="Please use DD_TRACE_SAMPLING_RULES instead.",
-                removal_version="3.0.0",
-            )
-
-        # Use a dict as underlying storing mechanism for integration configs
-        self._integration_configs = {}
-
-        self._debug_mode = _get_config("DD_TRACE_DEBUG", False, asbool)
-        self._startup_logs_enabled = _get_config("DD_TRACE_STARTUP_LOGS", False, asbool)
-
-        rate_limit = os.getenv("DD_TRACE_RATE_LIMIT")
-        if rate_limit is not None and self._trace_sampling_rules in ("", "[]"):
-            # This warning will be logged when DD_TRACE_SAMPLE_RATE is set. This is intentional.
-            # Even though DD_TRACE_SAMPLE_RATE is treated as a global trace sampling rule, this configuration
-            # is deprecated. We should always encourage users to set DD_TRACE_SAMPLING_RULES instead.
-            log.warning(
-                "DD_TRACE_RATE_LIMIT is set to %s and DD_TRACE_SAMPLING_RULES is not set. "
-                "Tracer rate limiting is only applied to spans that match tracer sampling rules. "
-                "All other spans will be rate limited by the Datadog Agent via DD_APM_MAX_TPS.",
-                rate_limit,
-            )
-        self._trace_rate_limit = _get_config("DD_TRACE_RATE_LIMIT", DEFAULT_SAMPLING_RATE_LIMIT, int)
-        self._partial_flush_enabled = _get_config("DD_TRACE_PARTIAL_FLUSH_ENABLED", True, asbool)
-        self._partial_flush_min_spans = _get_config("DD_TRACE_PARTIAL_FLUSH_MIN_SPANS", 300, int)
-
-        self.http = HttpConfig(header_tags=self._trace_http_header_tags)
-        self._remote_config_enabled = _get_config("DD_REMOTE_CONFIGURATION_ENABLED", True, asbool)
-        self._remote_config_poll_interval = _get_config(
-            ["DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS", "DD_REMOTECONFIG_POLL_SECONDS"], 5.0, float
-        )
-        self._trace_api = _get_config("DD_TRACE_API_VERSION")
-        if self._trace_api == "v0.3":
-            deprecate(
-                "DD_TRACE_API_VERSION=v0.3 is deprecated",
-                message="Traces will be submitted to the v0.4/traces agent endpoint instead.",
-                removal_version="3.0.0",
-                category=DDTraceDeprecationWarning,
-            )
-            self._trace_api = "v0.4"
-        self._trace_writer_buffer_size = _get_config("DD_TRACE_WRITER_BUFFER_SIZE_BYTES", DEFAULT_BUFFER_SIZE, int)
-        self._trace_writer_payload_size = _get_config(
-            "DD_TRACE_WRITER_MAX_PAYLOAD_SIZE_BYTES", DEFAULT_MAX_PAYLOAD_SIZE, int
-        )
-        self._trace_writer_interval_seconds = _get_config(
-            "DD_TRACE_WRITER_INTERVAL_SECONDS", DEFAULT_PROCESSING_INTERVAL, float
-        )
-        self._trace_writer_connection_reuse = _get_config(
-            "DD_TRACE_WRITER_REUSE_CONNECTIONS", DEFAULT_REUSE_CONNECTIONS, asbool
-        )
-        self._trace_writer_log_err_payload = _get_config("_DD_TRACE_WRITER_LOG_ERROR_PAYLOADS", False, asbool)
-
-        self._trace_agent_hostname = _get_config(["DD_AGENT_HOST", "DD_TRACE_AGENT_HOSTNAME"])
-        self._trace_agent_port = _get_config(["DD_AGENT_PORT", "DD_TRACE_AGENT_PORT"])
-        self._trace_agent_url = _get_config("DD_TRACE_AGENT_URL")
-
-        self._stats_agent_hostname = _get_config(["DD_AGENT_HOST", "DD_DOGSTATSD_HOST"])
-        self._stats_agent_port = _get_config("DD_DOGSTATSD_PORT")
-        self._stats_agent_url = _get_config("DD_DOGSTATSD_URL")
-        self._agent_timeout_seconds = _get_config("DD_TRACE_AGENT_TIMEOUT_SECONDS", DEFAULT_TIMEOUT, float)
-
-        self._span_traceback_max_size = _get_config("DD_TRACE_SPAN_TRACEBACK_MAX_SIZE", 30, int)
-
-        # Master switch for turning on and off trace search by default
-        # this weird invocation of getenv is meant to read the DD_ANALYTICS_ENABLED
-        # legacy environment variable. It should be removed in the future
-        self._analytics_enabled = _get_config(["DD_TRACE_ANALYTICS_ENABLED", "DD_ANALYTICS_ENABLED"], False, asbool)
-        if self._analytics_enabled:
-            deprecate(
-                "Datadog App Analytics is deprecated and will be removed in a future version. "
-                "App Analytics can be enabled via DD_TRACE_ANALYTICS_ENABLED and DD_ANALYTICS_ENABLED "
-                "environment variables and ddtrace.config.analytics_enabled configuration. "
-                "These configurations will also be removed.",
-                category=DDTraceDeprecationWarning,
-            )
-        self._client_ip_header = _get_config("DD_TRACE_CLIENT_IP_HEADER")
-        self._retrieve_client_ip = _get_config("DD_TRACE_CLIENT_IP_ENABLED", False, asbool)
-
-        self._propagation_http_baggage_enabled = _get_config("DD_TRACE_PROPAGATION_HTTP_BAGGAGE_ENABLED", False, asbool)
-
-        self.env = _get_config("DD_ENV", self.tags.get("env"))
-        self.service = _get_config("DD_SERVICE", self.tags.get("service", None))
-
-        self._inferred_base_service = detect_service(sys.argv)
-
-        if self.service is None and in_gcp_function():
-            self.service = _get_config(["K_SERVICE", "FUNCTION_NAME"], DEFAULT_SPAN_SERVICE_NAME)
-        if self.service is None and in_azure_function():
-            self.service = _get_config("WEBSITE_SITE_NAME", DEFAULT_SPAN_SERVICE_NAME)
-        if self.service is None and DEFAULT_SPAN_SERVICE_NAME:
-            self.service = _get_config("DD_SERVICE", DEFAULT_SPAN_SERVICE_NAME)
-
-        self._extra_services = set()
-        self._extra_services_queue = None if in_aws_lambda() or not self._remote_config_enabled else File_Queue()
-        self.version = _get_config("DD_VERSION", self.tags.get("version"))
-        self.http_server = self._HTTPServerConfig()
-
-        self._unparsed_service_mapping = _get_config("DD_SERVICE_MAPPING", "")
-        self.service_mapping = parse_tags_str(self._unparsed_service_mapping)
-
-        # The service tag corresponds to span.service and should not be
-        # included in the global tags.
-        if self.service and "service" in self.tags:
-            del self.tags["service"]
-
-        # The version tag should not be included on all spans.
-        if self.version and "version" in self.tags:
-            del self.tags["version"]
-
-        self._report_hostname = _get_config("DD_TRACE_REPORT_HOSTNAME", False, asbool)
-
-        self._health_metrics_enabled = _get_config("DD_TRACE_HEALTH_METRICS_ENABLED", False, asbool)
-
-        self._telemetry_enabled = _get_config("DD_INSTRUMENTATION_TELEMETRY_ENABLED", True, asbool)
-        self._telemetry_heartbeat_interval = _get_config("DD_TELEMETRY_HEARTBEAT_INTERVAL", 60, float)
-        self._telemetry_dependency_collection = _get_config("DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED", True, asbool)
-
-        self._runtime_metrics_enabled = _get_config("DD_RUNTIME_METRICS_ENABLED", False, asbool)
-
-        self._128_bit_trace_id_enabled = _get_config("DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED", True, asbool)
-
-        self._128_bit_trace_id_logging_enabled = _get_config("DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED", False, asbool)
-        if self._128_bit_trace_id_logging_enabled:
-            deprecate(
-                "Using DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED is deprecated.",
-                message="Log injection format is now configured automatically.",
-                removal_version="3.0.0",
-                category=DDTraceDeprecationWarning,
-            )
-
-        self._sampling_rules = _get_config("DD_SPAN_SAMPLING_RULES")
-        self._sampling_rules_file = _get_config("DD_SPAN_SAMPLING_RULES_FILE")
-
-        # Propagation styles
-        # DD_TRACE_PROPAGATION_STYLE_EXTRACT and DD_TRACE_PROPAGATION_STYLE_INJECT
-        #  take precedence over DD_TRACE_PROPAGATION_STYLE
-        # if DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT is set to ignore
-        # we set DD_TRACE_PROPAGATION_STYLE_EXTRACT to [_PROPAGATION_STYLE_NONE] since no extraction will heeded
-        self._propagation_behavior_extract = _get_config(
-            ["DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT"], _PROPAGATION_BEHAVIOR_DEFAULT, self._lower
-        )
-        if self._propagation_behavior_extract != _PROPAGATION_BEHAVIOR_IGNORE:
-            self._propagation_style_extract = _parse_propagation_styles(
-                _get_config(
-                    ["DD_TRACE_PROPAGATION_STYLE_EXTRACT", "DD_TRACE_PROPAGATION_STYLE"], _PROPAGATION_STYLE_DEFAULT
-                )
-            )
-        else:
-            log.debug(
-                """DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT is set to ignore,
-                setting DD_TRACE_PROPAGATION_STYLE_EXTRACT to empty list"""
-            )
-            self._propagation_style_extract = [_PROPAGATION_STYLE_NONE]
-        self._propagation_style_inject = _parse_propagation_styles(
-            _get_config(["DD_TRACE_PROPAGATION_STYLE_INJECT", "DD_TRACE_PROPAGATION_STYLE"], _PROPAGATION_STYLE_DEFAULT)
-        )
-
-        self._propagation_extract_first = _get_config("DD_TRACE_PROPAGATION_EXTRACT_FIRST", False, asbool)
-
-        # Datadog tracer tags propagation
-        x_datadog_tags_max_length = _get_config("DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH", 512, int)
-        if x_datadog_tags_max_length < 0:
-            log.warning(
-                (
-                    "Invalid value %r provided for DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH, "
-                    "only non-negative values allowed"
-                ),
-                x_datadog_tags_max_length,
-            )
-            x_datadog_tags_max_length = 0
-        self._x_datadog_tags_max_length = x_datadog_tags_max_length
-        self._x_datadog_tags_enabled = x_datadog_tags_max_length > 0
-
-        # Raise certain errors only if in testing raise mode to prevent crashing in production with non-critical errors
-        self._raise = _get_config("DD_TESTING_RAISE", False, asbool)
-
-        trace_compute_stats_default = in_gcp_function() or in_azure_function()
-        self._trace_compute_stats = _get_config(
-            ["DD_TRACE_COMPUTE_STATS", "DD_TRACE_STATS_COMPUTATION_ENABLED"], trace_compute_stats_default, asbool
-        )
-        self._data_streams_enabled = _get_config("DD_DATA_STREAMS_ENABLED", False, asbool)
-
-        legacy_client_tag_enabled = _get_config("DD_HTTP_CLIENT_TAG_QUERY_STRING")
-        if legacy_client_tag_enabled is None:
-            self._http_client_tag_query_string = _get_config("DD_TRACE_HTTP_CLIENT_TAG_QUERY_STRING", "true")
-        else:
-            deprecate(
-                "DD_HTTP_CLIENT_TAG_QUERY_STRING is deprecated",
-                message="Please use DD_TRACE_HTTP_CLIENT_TAG_QUERY_STRING instead.",
-                removal_version="3.0.0",
-                category=DDTraceDeprecationWarning,
-            )
-            self._http_client_tag_query_string = legacy_client_tag_enabled.lower()
-
-        dd_trace_obfuscation_query_string_regexp = _get_config(
-            "DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP", DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP_DEFAULT
-        )
-        self._global_query_string_obfuscation_disabled = dd_trace_obfuscation_query_string_regexp == ""
-        self._obfuscation_query_string_pattern = None
-        self._http_tag_query_string = True  # Default behaviour of query string tagging in http.url
-        try:
-            self._obfuscation_query_string_pattern = re.compile(
-                dd_trace_obfuscation_query_string_regexp.encode("ascii")
-            )
-        except Exception:
-            log.warning("Invalid obfuscation pattern, disabling query string tracing", exc_info=True)
-            self._http_tag_query_string = False  # Disable query string tagging if malformed obfuscation pattern
-
-        self._ci_visibility_agentless_enabled = _get_config("DD_CIVISIBILITY_AGENTLESS_ENABLED", False, asbool)
-        self._ci_visibility_agentless_url = _get_config("DD_CIVISIBILITY_AGENTLESS_URL", "")
-        self._ci_visibility_intelligent_testrunner_enabled = _get_config("DD_CIVISIBILITY_ITR_ENABLED", True, asbool)
-        self._ci_visibility_log_level = _get_config("DD_CIVISIBILITY_LOG_LEVEL", "info")
-        self._test_session_name = _get_config("DD_TEST_SESSION_NAME")
-        self._test_visibility_early_flake_detection_enabled = _get_config(
-            "DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED", True, asbool
-        )
-        self._otel_enabled = _get_config("DD_TRACE_OTEL_ENABLED", False, asbool)
-        if self._otel_enabled:
-            # Replaces the default otel api runtime context with DDRuntimeContext
-            # https://github.com/open-telemetry/opentelemetry-python/blob/v1.16.0/opentelemetry-api/src/opentelemetry/context/__init__.py#L53
-            os.environ["OTEL_PYTHON_CONTEXT"] = "ddcontextvars_context"
-        self._subscriptions = []  # type: List[Tuple[List[str], Callable[[Config, List[str]], None]]]
-        self._span_aggregator_rlock = _get_config("DD_TRACE_SPAN_AGGREGATOR_RLOCK", True, asbool)
-        if self._span_aggregator_rlock is False:
-            deprecate(
-                "DD_TRACE_SPAN_AGGREGATOR_RLOCK is deprecated",
-                message="Soon the ddtrace library will only support using threading.Rlock to "
-                "aggregate and encode span data. If you need to disable the re-entrant lock and "
-                "revert to using threading.Lock, please contact Datadog support.",
-                removal_version="3.0.0",
-            )
-
-        self._trace_methods = _get_config("DD_TRACE_METHODS")
-
-        self._telemetry_install_id = _get_config("DD_INSTRUMENTATION_INSTALL_ID")
-        self._telemetry_install_type = _get_config("DD_INSTRUMENTATION_INSTALL_TYPE")
-        self._telemetry_install_time = _get_config("DD_INSTRUMENTATION_INSTALL_TYPE")
-
-        self._dd_api_key = _get_config("DD_API_KEY")
-        self._dd_site = _get_config("DD_SITE", "datadoghq.com")
-
-        self._llmobs_enabled = _get_config("DD_LLMOBS_ENABLED", False, asbool)
-        self._llmobs_sample_rate = _get_config("DD_LLMOBS_SAMPLE_RATE", 1.0, float)
-        self._llmobs_ml_app = _get_config("DD_LLMOBS_ML_APP")
-        self._llmobs_agentless_enabled = _get_config("DD_LLMOBS_AGENTLESS_ENABLED", False, asbool)
-
-        self._inject_force = _get_config("DD_INJECT_FORCE", False, asbool)
-        self._lib_was_injected = False
-        self._inject_was_attempted = _get_config("_DD_INJECT_WAS_ATTEMPTED", False, asbool)
-
-    def __getattr__(self, name) -> Any:
-        if name in self._DEPRECATED_ATTRS:
-            new_name, env_var = self._DEPRECATED_ATTRS[name]
-            deprecate(
-                f"ddtrace.config.{name} is deprecated",
-                message=f"Use the environment variable {env_var} instead. "
-                "This variable must be set before importing ddtrace.",
-                removal_version="3.0.0",
-                category=DDTraceDeprecationWarning,
-            )
-            if name == new_name:
-                raise RuntimeError(
-                    f"Circular mapping detected: deprecated attribute {name} "
-                    f"in {self._DEPRECATED_ATTRS} maps to a deprecated attribute {new_name}"
-                )
-            return getattr(self, new_name)
-
-        if name in self._config:
-            return self._config[name].value()
-
-        if name not in self._integration_configs:
-            self._integration_configs[name] = IntegrationConfig(self, name)
-
-        return self._integration_configs[name]
-
-    def _add_extra_service(self, service_name: str) -> None:
-        if self._extra_services_queue is None:
-            return
-        if service_name != self.service:
-            self._extra_services_queue.put(service_name)
-
-    def _get_extra_services(self):
-        # type: () -> set[str]
-        if self._extra_services_queue is None:
-            return set()
-        self._extra_services.update(self._extra_services_queue.get_all())
-        while len(self._extra_services) > 64:
-            self._extra_services.pop()
-        return self._extra_services
-
-    def get_from(self, obj):
-        """Retrieves the configuration for the given object.
-        Any object that has an attached `Pin` must have a configuration
-        and if a wrong object is given, an empty `dict` is returned
-        for safety reasons.
-        """
-        pin = Pin.get_from(obj)
-        if pin is None:
-            log.debug("No configuration found for %s", obj)
-            return {}
-
-        return pin._config
-
-    def _add(self, integration, settings, merge=True):
-        """Internal API that registers an integration with given default
-        settings.
-
-        :param str integration: The integration name (i.e. `requests`)
-        :param dict settings: A dictionary that contains integration settings;
-            to preserve immutability of these values, the dictionary is copied
-            since it contains integration defaults.
-        :param bool merge: Whether to merge any existing settings with those provided,
-            or if we should overwrite the settings with those provided;
-            Note: when merging existing settings take precedence.
-        """
-        # DEV: Use `getattr()` to call our `__getattr__` helper
-        existing = getattr(self, integration)
-        settings = deepcopy(settings)
-
-        if merge:
-            # DEV: This may appear backwards keeping `existing` as the "source" and `settings` as
-            #   the "destination", but we do not want to let `_add(..., merge=True)` overwrite any
-            #   existing settings
-            #
-            # >>> config.requests['split_by_domain'] = True
-            # >>> config._add('requests', dict(split_by_domain=False))
-            # >>> config.requests['split_by_domain']
-            # True
-            self._integration_configs[integration] = IntegrationConfig(
-                self, integration, _deepmerge(existing, settings)
-            )
-        else:
-            self._integration_configs[integration] = IntegrationConfig(self, integration, settings)
-
-    def trace_headers(self, whitelist):
-        """
-        Registers a set of headers to be traced at global level or integration level.
-        :param whitelist: the case-insensitive list of traced headers
-        :type whitelist: list of str or str
-        :return: self
-        :rtype: HttpConfig
-        """
-        self.http.trace_headers(whitelist)
-        return self
-
-    def header_is_traced(self, header_name):
-        # type: (str) -> bool
-        """
-        Returns whether or not the current header should be traced.
-        :param header_name: the header name
-        :type header_name: str
-        :rtype: bool
-        """
-        return self.http.header_is_traced(header_name)
-
-    @cachedmethod()
-    def _header_tag_name(self, header_name):
-        # type: (str) -> Optional[str]
-        return self.http._header_tag_name(header_name)
-
-    def _get_service(self, default=None):
-        """
-        Returns the globally configured service or the default if none is configured.
-
-        :param default: the default service to use if none is configured or
-            found.
-        :type default: str
-        :rtype: str|None
-        """
-
-        # We check if self.service != _inferred_base_service since config.service
-        # defaults to _inferred_base_service when no DD_SERVICE is set. In this case, we want to not
-        # use the inferred base service value, and instead use the default if included. If we
-        # didn't do this, we would have a massive breaking change from adding inferred_base_service,
-        # which would be replacing any integration defaults since service is no longer None.
-        if self.service and self.service == self._inferred_base_service:
-            return default if default is not None else self.service
-
-        # TODO: This method can be replaced with `config.service`.
-        return self.service if self.service is not None else default
-
-    def __repr__(self):
-        cls = self.__class__
-        integrations = ", ".join(self._integration_config.keys())
-        return "{}.{}({})".format(cls.__module__, cls.__name__, integrations)
-
-    def _subscribe(self, items, handler):
-        # type: (List[str], Callable[[Config, List[str]], None]) -> None
-        self._subscriptions.append((items, handler))
-
-    def _notify_subscribers(self, changed_items):
-        # type: (List[str]) -> None
-        for sub_items, sub_handler in self._subscriptions:
-            sub_updated_items = [i for i in changed_items if i in sub_items]
-            if sub_updated_items:
-                sub_handler(self, sub_updated_items)
-
-    def __setattr__(self, key, value):
-        # type: (str, Any) -> None
-        if key in ("_config", "_from_endpoint"):
-            return super(self.__class__, self).__setattr__(key, value)
-        elif key in self._config:
-            self._set_config_items([(key, value, "code")])
-            return None
-        else:
-            if key in self._DEPRECATED_ATTRS:
-                # replace deprecated attribute name with the new name
-                new_key, env_var = self._DEPRECATED_ATTRS[key]
-                deprecate(
-                    f"ddtrace.config.{key} is deprecated",
-                    message=f"Use the environment variable {env_var} instead. "
-                    "This variable must be set before importing ddtrace.",
-                    removal_version="3.0.0",
-                    category=DDTraceDeprecationWarning,
-                )
-                key = new_key
-            return super(self.__class__, self).__setattr__(key, value)
-
-    def _set_config_items(self, items):
-        # type: (List[Tuple[str, Any, _ConfigSource]]) -> None
-        item_names = []
-        for key, value, origin in items:
-            item_names.append(key)
-            item = self._config[key]
-            item.set_value_source(value, origin)
-            if self._telemetry_enabled:
-                telemetry_writer.add_configuration(item._name, item.value(), item.source())
-        self._notify_subscribers(item_names)
-
-    def _reset(self):
-        # type: () -> None
-        self._config = _default_config()
-
-    def _get_source(self, item):
-        # type: (str) -> str
-        return self._config[item].source()
-
-    def _remoteconfigPubSub(self):
-        from ddtrace.internal.remoteconfig._connectors import PublisherSubscriberConnector
-        from ddtrace.internal.remoteconfig._publishers import RemoteConfigPublisher
-        from ddtrace.internal.remoteconfig._pubsub import PubSub
-        from ddtrace.internal.remoteconfig._pubsub import RemoteConfigSubscriber
-
-        class _GlobalConfigPubSub(PubSub):
-            __publisher_class__ = RemoteConfigPublisher
-            __subscriber_class__ = RemoteConfigSubscriber
-            __shared_data__ = PublisherSubscriberConnector()
-
-            def __init__(self, callback):
-                self._publisher = self.__publisher_class__(self.__shared_data__, None)
-                self._subscriber = self.__subscriber_class__(self.__shared_data__, callback, "GlobalConfig")
-
-        return _GlobalConfigPubSub
-
-    def _handle_remoteconfig(self, data, test_tracer=None):
-        # type: (Any, Any) -> None
-        if not isinstance(data, dict) or (isinstance(data, dict) and "config" not in data):
-            log.warning("unexpected RC payload %r", data)
-            return
-        if len(data["config"]) == 0:
-            log.warning("unexpected number of RC payloads %r", data)
-            return
-
-        # Check if 'lib_config' is a key in the dictionary since other items can be sent in the payload
-        config = None
-        for config_item in data["config"]:
-            if isinstance(config_item, Dict):
-                if "lib_config" in config_item:
-                    config = config_item
-                    break
-
-        # If no data is submitted then the RC config has been deleted. Revert the settings.
-        base_rc_config = {n: None for n in self._config}
-
-        if config and "lib_config" in config:
-            lib_config = config["lib_config"]
-            if "tracing_sampling_rate" in lib_config:
-                base_rc_config["_trace_sample_rate"] = lib_config["tracing_sampling_rate"]
-
-            if "tracing_sampling_rules" in lib_config:
-                trace_sampling_rules = lib_config["tracing_sampling_rules"]
-                if trace_sampling_rules:
-                    # returns None if no rules
-                    trace_sampling_rules = self.convert_rc_trace_sampling_rules(trace_sampling_rules)
-                    if trace_sampling_rules:
-                        base_rc_config["_trace_sampling_rules"] = trace_sampling_rules
-
-            if "log_injection_enabled" in lib_config:
-                base_rc_config["_logs_injection"] = lib_config["log_injection_enabled"]
-
-            if "tracing_tags" in lib_config:
-                tags = lib_config["tracing_tags"]
-                if tags:
-                    tags = self._format_tags(lib_config["tracing_tags"])
-                base_rc_config["tags"] = tags
-
-            if "tracing_enabled" in lib_config and lib_config["tracing_enabled"] is not None:
-                base_rc_config["_tracing_enabled"] = asbool(lib_config["tracing_enabled"])  # type: ignore[assignment]
-
-            if "tracing_header_tags" in lib_config:
-                tags = lib_config["tracing_header_tags"]
-                if tags:
-                    tags = self._format_tags(lib_config["tracing_header_tags"])
-                base_rc_config["_trace_http_header_tags"] = tags
-        self._set_config_items([(k, v, "remote_config") for k, v in base_rc_config.items()])
-        # called unconditionally to handle the case where header tags have been unset
-        self._handle_remoteconfig_header_tags(base_rc_config)
-
-    def _handle_remoteconfig_header_tags(self, base_rc_config):
-        """Implements precedence order between remoteconfig header tags from code, env, and RC"""
-        header_tags_conf = self._config["_trace_http_header_tags"]
-        env_headers = header_tags_conf._env_value or {}
-        code_headers = header_tags_conf._code_value or {}
-        non_rc_header_tags = {**code_headers, **env_headers}
-        selected_header_tags = base_rc_config.get("_trace_http_header_tags") or non_rc_header_tags
-        self.http = HttpConfig(header_tags=selected_header_tags)
-
-    def _format_tags(self, tags: List[Union[str, Dict]]) -> Dict[str, str]:
-        if not tags:
-            return {}
-        if isinstance(tags[0], Dict):
-            pairs = [(item["header"], item["tag_name"]) for item in tags]  # type: ignore[index]
-        else:
-            pairs = [t.split(":") for t in tags]  # type: ignore[union-attr,misc]
-        return {k: v for k, v in pairs}
-
-    def enable_remote_configuration(self):
-        # type: () -> None
-        """Enable fetching configuration from Datadog."""
-        from ddtrace.internal.flare.flare import Flare
-        from ddtrace.internal.flare.handler import _handle_tracer_flare
-        from ddtrace.internal.flare.handler import _tracerFlarePubSub
-        from ddtrace.internal.remoteconfig.worker import remoteconfig_poller
-
-        remoteconfig_pubsub = self._remoteconfigPubSub()(self._handle_remoteconfig)
-        flare = Flare(trace_agent_url=self._trace_agent_url, api_key=self._dd_api_key, ddconfig=self.__dict__)
-        tracerflare_pubsub = _tracerFlarePubSub()(_handle_tracer_flare, flare)
-        remoteconfig_poller.register("APM_TRACING", remoteconfig_pubsub)
-        remoteconfig_poller.register("AGENT_CONFIG", tracerflare_pubsub)
-        remoteconfig_poller.register("AGENT_TASK", tracerflare_pubsub)
-
-    def _remove_invalid_rules(self, rc_rules: List) -> List:
-        """Remove invalid sampling rules from the given list"""
-        # loop through list of dictionaries, if a dictionary doesn't have certain attributes, remove it
-        for rule in rc_rules:
-            if (
-                ("service" not in rule and "name" not in rule and "resource" not in rule and "tags" not in rule)
-                or "sample_rate" not in rule
-                or "provenance" not in rule
-            ):
-                log.debug("Invalid sampling rule from remoteconfig found, rule will be removed: %s", rule)
-                rc_rules.remove(rule)
-
-        return rc_rules
-
-    def _tags_to_dict(self, tags: List[Dict]):
-        """
-        Converts a list of tag dictionaries to a single dictionary.
-        """
-        if isinstance(tags, list):
-            return {tag["key"]: tag["value_glob"] for tag in tags}
-        return tags
-
-    def convert_rc_trace_sampling_rules(self, rc_rules: List[Dict[str, Any]]) -> Optional[str]:
-        """Example of an incoming rule:
-        [
-          {
-            "service": "my-service",
-            "name": "web.request",
-            "resource": "*",
-            "provenance": "customer",
-            "sample_rate": 1.0,
-            "tags": [
-              {
-                "key": "care_about",
-                "value_glob": "yes"
-              },
-              {
-                "key": "region",
-                "value_glob": "us-*"
-              }
-            ]
-          }
-        ]
-
-                Example of a converted rule:
-                '[{"sample_rate":1.0,"service":"my-service","resource":"*","name":"web.request","tags":{"care_about":"yes","region":"us-*"},provenance":"customer"}]'
-        """
-        rc_rules = self._remove_invalid_rules(rc_rules)
-        for rule in rc_rules:
-            tags = rule.get("tags")
-            if tags:
-                rule["tags"] = self._tags_to_dict(tags)
-        if rc_rules:
-            return json.dumps(rc_rules)
-        else:
-            return None
-
-    def _lower(self, value):
-        return value.lower()
diff --git a/ddtrace/settings/dynamic_instrumentation.py b/ddtrace/settings/dynamic_instrumentation.py
index 27008bec692..5f46e06896f 100644
--- a/ddtrace/settings/dynamic_instrumentation.py
+++ b/ddtrace/settings/dynamic_instrumentation.py
@@ -7,7 +7,7 @@
 from ddtrace.internal.agent import get_trace_url
 from ddtrace.internal.constants import DEFAULT_SERVICE_NAME
 from ddtrace.internal.utils.config import get_application_name
-from ddtrace.settings import _config as ddconfig
+from ddtrace.settings import _global_config as ddconfig
 from ddtrace.settings._core import report_telemetry as _report_telemetry
 from ddtrace.version import get_version
 
diff --git a/ddtrace/settings/integration.py b/ddtrace/settings/integration.py
index ad901baf219..354e99f7625 100644
--- a/ddtrace/settings/integration.py
+++ b/ddtrace/settings/integration.py
@@ -103,7 +103,7 @@ def get_http_tag_query_string(self, value):
     def trace_query_string(self):
         if self.http.trace_query_string is not None:
             return self.http.trace_query_string
-        return self.global_config.http.trace_query_string
+        return self.global_config._http.trace_query_string
 
     @property
     def is_header_tracing_configured(self):
@@ -113,7 +113,7 @@ def is_header_tracing_configured(self):
         Will return true if traced headers are configured for this integration
         or if they are configured globally.
         """
-        return self.http.is_header_tracing_configured or self.global_config.http.is_header_tracing_configured
+        return self.http.is_header_tracing_configured or self.global_config._http.is_header_tracing_configured
 
     def header_is_traced(self, header_name):
         # type: (str) -> bool
diff --git a/docs/advanced_usage.rst b/docs/advanced_usage.rst
index c1c41df00c0..05879acac37 100644
--- a/docs/advanced_usage.rst
+++ b/docs/advanced_usage.rst
@@ -396,7 +396,7 @@ Examples::
     from ddtrace import config
 
     # Global config
-    config.http.trace_query_string = True
+    # Set DD_TRACE_HTTP_CLIENT_TAG_QUERY_STRING environment variable to true/false
 
     # Integration level config, e.g. 'falcon'
     config.falcon.http.trace_query_string = True
@@ -471,14 +471,9 @@ structure like in the following example::
 Custom Error Codes
 ^^^^^^^^^^^^^^^^^^
 It is possible to have a custom mapping of which HTTP status codes are considered errors.
-By default, 500-599 status codes are considered errors.
-Configuration is provided both at the global level.
+By default, 500-599 status codes are considered errors. The default value can be overridden 
+by setting the ``DD_TRACE_HTTP_SERVER_ERROR_STATUSES`` environment variable.
 
-Examples::
-
-    from ddtrace import config
-
-    config.http_server.error_statuses = '500-599'
 
 Certain status codes can be excluded by providing a list of ranges. Valid options:
     - ``400-400``
diff --git a/releasenotes/notes/munir-deprecate-rc-http-configs-206f6c60ff383c05.yaml b/releasenotes/notes/munir-deprecate-rc-http-configs-206f6c60ff383c05.yaml
new file mode 100644
index 00000000000..1732431383d
--- /dev/null
+++ b/releasenotes/notes/munir-deprecate-rc-http-configs-206f6c60ff383c05.yaml
@@ -0,0 +1,11 @@
+---
+deprecations:
+  - |
+    tracing: Internalizes the ``ddtrace.settings.config`` module and deprecates the following ``ddtrace.config`` attributes:
+    - http, use ``DD_TRACE_HEADER_TAGS`` environment variable instead.
+    - http_server, use ``DD_TRACE_HTTP_SERVER_ERROR_STATUSES`` environment variable instead.
+    - trace_headers, this attribute is internal to the tracer.
+    - header_is_traced, this attribute is internal to the tracer.
+    - convert_rc_trace_sampling_rules, this attribute is internal to the tracer.
+    - enable_remote_configuration, use ``DD_REMOTE_CONFIGURATION_ENABLED`` environment variable instead.
+    - get_from, use ``ddtrace.trace.Pin`` to set instance level configurations.
diff --git a/tests/ci_visibility/test_ci_visibility.py b/tests/ci_visibility/test_ci_visibility.py
index 9eee9eb43da..525d9b014fa 100644
--- a/tests/ci_visibility/test_ci_visibility.py
+++ b/tests/ci_visibility/test_ci_visibility.py
@@ -684,7 +684,7 @@ def test_civisibilitywriter_evp_proxy_url(self):
             )
         ), mock.patch(
             "ddtrace.internal.agent.get_trace_url", return_value="http://evpproxy.bar:1234"
-        ), mock.patch("ddtrace.settings.config.Config", _get_default_civisibility_ddconfig()), mock.patch(
+        ), mock.patch("ddtrace.settings._config.Config", _get_default_civisibility_ddconfig()), mock.patch(
             "ddtrace.tracer", ddtrace.Tracer()
         ), mock.patch(
             "ddtrace.internal.ci_visibility.recorder.CIVisibility._agent_evp_proxy_is_available", return_value=True
diff --git a/tests/contrib/httplib/test_httplib_distributed.py b/tests/contrib/httplib/test_httplib_distributed.py
index 40e5e891662..706921388bc 100644
--- a/tests/contrib/httplib/test_httplib_distributed.py
+++ b/tests/contrib/httplib/test_httplib_distributed.py
@@ -71,14 +71,14 @@ def test_propagation_disabled(self):
 
     def test_propagation_connection_true(self):
         conn = self.get_http_connection(SOCKET)
-        cfg = config.get_from(conn)
+        cfg = config._get_from(conn)
         cfg["distributed_tracing"] = True
         self.request(conn=conn)
         self.check_enabled()
 
     def test_propagation_connection_false(self):
         conn = self.get_http_connection(SOCKET)
-        cfg = config.get_from(conn)
+        cfg = config._get_from(conn)
         cfg["distributed_tracing"] = False
         self.request(conn=conn)
         self.check_disabled()
diff --git a/tests/contrib/jinja2/test_jinja2.py b/tests/contrib/jinja2/test_jinja2.py
index 64002fd6555..ce91c7e5ed0 100644
--- a/tests/contrib/jinja2/test_jinja2.py
+++ b/tests/contrib/jinja2/test_jinja2.py
@@ -136,7 +136,7 @@ def test_service_name(self):
         loader = jinja2.loaders.FileSystemLoader(TMPL_DIR)
         env = jinja2.Environment(loader=loader)
 
-        cfg = config.get_from(env)
+        cfg = config._get_from(env)
         cfg["service_name"] = "renderer"
 
         t = env.get_template("template.html")
diff --git a/tests/contrib/requests/test_requests.py b/tests/contrib/requests/test_requests.py
index 2a892a218f7..bab742a6cd8 100644
--- a/tests/contrib/requests/test_requests.py
+++ b/tests/contrib/requests/test_requests.py
@@ -281,7 +281,7 @@ def test_default_service_name(self):
 
     def test_user_set_service_name(self):
         # ensure a service name set by the user has precedence
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["service_name"] = "clients"
         out = self.session.get(URL_200)
         assert out.status_code == 200
@@ -292,7 +292,7 @@ def test_user_set_service_name(self):
 
     def test_user_set_service(self):
         # ensure a service name set by the user has precedence
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["service"] = "clients"
         out = self.session.get(URL_200)
         assert out.status_code == 200
@@ -333,7 +333,7 @@ def test_parent_without_service_name(self):
     def test_user_service_name_precedence(self):
         # ensure the user service name takes precedence over
         # the parent Span
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["service_name"] = "clients"
         with self.tracer.trace("parent.span", service="web"):
             out = self.session.get(URL_200)
@@ -349,7 +349,7 @@ def test_user_service_name_precedence(self):
     def test_split_by_domain_with_ampersat(self):
         # Regression test for: https://github.com/DataDog/dd-trace-py/issues/4062
         # ensure a service name is generated by the domain name
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["split_by_domain"] = True
         # domain name should take precedence over monkey_service
         cfg["service_name"] = "monkey_service"
@@ -368,7 +368,7 @@ def test_split_by_domain_with_ampersat(self):
     def test_split_by_domain(self):
         # ensure a service name is generated by the domain name
         # of the ongoing call
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["split_by_domain"] = True
         out = self.session.get(URL_200)
         assert out.status_code == 200
@@ -383,7 +383,7 @@ def test_split_by_domain(self):
 
     def test_split_by_domain_precedence(self):
         # ensure the split by domain has precedence all the time
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["split_by_domain"] = True
         cfg["service_name"] = "intake"
         out = self.session.get(URL_200)
@@ -400,7 +400,7 @@ def test_split_by_domain_precedence(self):
     def test_split_by_domain_wrong(self):
         # ensure the split by domain doesn't crash in case of a wrong URL;
         # in that case, no spans are created
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["split_by_domain"] = True
         with pytest.raises((MissingSchema, InvalidURL)):
             self.session.get("http:/some>thing")
@@ -411,7 +411,7 @@ def test_split_by_domain_wrong(self):
 
     def test_split_by_domain_remove_auth_in_url(self):
         # ensure that auth details are stripped from URL
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["split_by_domain"] = True
         out = self.session.get(f"http://user:pass@{HOST_AND_PORT}")
         assert out.status_code == 200
@@ -425,7 +425,7 @@ def test_split_by_domain_remove_auth_in_url(self):
 
     def test_split_by_domain_includes_port(self):
         # ensure that port is included if present in URL
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["split_by_domain"] = True
         out = self.session.get(f"http://{HOST_AND_PORT}")
         assert out.status_code == 200
@@ -439,7 +439,7 @@ def test_split_by_domain_includes_port(self):
 
     def test_split_by_domain_includes_port_path(self):
         # ensure that port is included if present in URL but not path
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["split_by_domain"] = True
         out = self.session.get(f"http://{HOST_AND_PORT}/anything/v1/foo")
         assert out.status_code == 200
@@ -458,7 +458,7 @@ def test_global_config_service_env_precedence(self):
         spans = self.pop_spans()
         assert spans[0].service == "override"
 
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["service"] = "override2"
         out = self.session.get(URL_200)
         assert out.status_code == 200
diff --git a/tests/contrib/requests/test_requests_distributed.py b/tests/contrib/requests/test_requests_distributed.py
index b3974700f87..51ce0a500a9 100644
--- a/tests/contrib/requests/test_requests_distributed.py
+++ b/tests/contrib/requests/test_requests_distributed.py
@@ -77,7 +77,7 @@ def matcher(request):
 
     def test_propagation_true(self):
         # ensure distributed tracing can be enabled manually
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["distributed_tracing"] = True
         adapter = Adapter()
         self.session.mount("mock", adapter)
@@ -101,7 +101,7 @@ def matcher(request):
 
     def test_propagation_false(self):
         # ensure distributed tracing can be disabled manually
-        cfg = config.get_from(self.session)
+        cfg = config._get_from(self.session)
         cfg["distributed_tracing"] = False
         adapter = Adapter()
         self.session.mount("mock", adapter)
@@ -121,7 +121,7 @@ def test_propagation_apm_opt_out_true(self):
         with self.override_global_config(dict(_appsec_standalone_enabled=True, _asm_enabled=True)):
             assert asm_config._apm_opt_out
             self.tracer.enabled = False
-            cfg = config.get_from(self.session)
+            cfg = config._get_from(self.session)
             cfg["distributed_tracing"] = True
             adapter = Adapter()
             self.session.mount("mock", adapter)
@@ -149,7 +149,7 @@ def test_propagation_apm_opt_out_false(self):
             assert not asm_config._apm_opt_out
             self.tracer.enabled = False
 
-            cfg = config.get_from(self.session)
+            cfg = config._get_from(self.session)
             cfg["distributed_tracing"] = True
             adapter = Adapter()
             self.session.mount("mock", adapter)
diff --git a/tests/contrib/tornado/test_tornado_web.py b/tests/contrib/tornado/test_tornado_web.py
index 2a22651cdf1..554d3edbf8c 100644
--- a/tests/contrib/tornado/test_tornado_web.py
+++ b/tests/contrib/tornado/test_tornado_web.py
@@ -212,13 +212,13 @@ def test_http_exception_500_handler(self):
     def test_http_exception_500_handler_ignored_exception(self):
         # it should trace a handler that raises a Tornado HTTPError
         # The exception should NOT be set on the span
-        prev_error_statuses = config.http_server.error_statuses
+        prev_error_statuses = config._http_server.error_statuses
         try:
-            config.http_server.error_statuses = "501-599"
+            config._http_server.error_statuses = "501-599"
             response = self.fetch("/http_exception_500/")
             assert 500 == response.code
         finally:
-            config.http_server.error_statuses = prev_error_statuses
+            config._http_server.error_statuses = prev_error_statuses
 
         traces = self.pop_traces()
         assert 1 == len(traces)
diff --git a/tests/contrib/vertica/test_vertica.py b/tests/contrib/vertica/test_vertica.py
index 196e1621ee5..d3fb9709bea 100644
--- a/tests/contrib/vertica/test_vertica.py
+++ b/tests/contrib/vertica/test_vertica.py
@@ -9,7 +9,7 @@
 from ddtrace.contrib.internal.vertica.patch import patch
 from ddtrace.contrib.internal.vertica.patch import unpatch
 from ddtrace.internal.schema import DEFAULT_SPAN_SERVICE_NAME
-from ddtrace.settings.config import _deepmerge
+from ddtrace.settings._config import _deepmerge
 from ddtrace.trace import Pin
 from tests.contrib.config import VERTICA_CONFIG
 from tests.opentracer.utils import init_tracer
diff --git a/tests/internal/remoteconfig/test_remoteconfig.py b/tests/internal/remoteconfig/test_remoteconfig.py
index 5bf87179025..a53db57adb8 100644
--- a/tests/internal/remoteconfig/test_remoteconfig.py
+++ b/tests/internal/remoteconfig/test_remoteconfig.py
@@ -583,7 +583,7 @@ def test_rc_default_products_registered():
     ],
 )
 def test_trace_sampling_rules_conversion(rc_rules, expected_config_rules, expected_sampling_rules):
-    trace_sampling_rules = config.convert_rc_trace_sampling_rules(rc_rules)
+    trace_sampling_rules = config._convert_rc_trace_sampling_rules(rc_rules)
 
     assert trace_sampling_rules == expected_config_rules
     if trace_sampling_rules is not None:
diff --git a/tests/internal/test_settings.py b/tests/internal/test_settings.py
index 9010e5f044a..14f52092f4d 100644
--- a/tests/internal/test_settings.py
+++ b/tests/internal/test_settings.py
@@ -589,7 +589,7 @@ def test_remoteconfig_header_tags(run_python_code_in_subprocess):
 assert span.get_tag("header_tag_420") is None
 assert span.get_tag("env_set_tag_name") == "helloworld"
 
-config.http._reset()
+config._http._reset()
 config._header_tag_name.invalidate()
 config._handle_remoteconfig(_base_rc_config({"tracing_header_tags":
     [{"header": "X-Header-Tag-420", "tag_name":"header_tag_420"}]}))
@@ -601,7 +601,7 @@ def test_remoteconfig_header_tags(run_python_code_in_subprocess):
 assert span2.get_tag("header_tag_420") == "foobarbanana", span2._meta
 assert span2.get_tag("env_set_tag_name") is None
 
-config.http._reset()
+config._http._reset()
 config._header_tag_name.invalidate()
 config._handle_remoteconfig(_base_rc_config({}))
 
@@ -634,14 +634,13 @@ def test_config_public_properties_and_methods():
             public_attrs.add(key)
 
     assert public_attrs == {
-        "trace_headers",
         "service",
         "service_mapping",
         "env",
         "tags",
         "version",
-        "http",
-        "http_server",
+        # Attributes below are deprecated and will be removed in v3.0
+        "trace_headers",
         "header_is_traced",
         "convert_rc_trace_sampling_rules",
         "enable_remote_configuration",
diff --git a/tests/telemetry/test_writer.py b/tests/telemetry/test_writer.py
index 228b6fd4ea1..52d0f763df9 100644
--- a/tests/telemetry/test_writer.py
+++ b/tests/telemetry/test_writer.py
@@ -15,8 +15,8 @@
 from ddtrace.internal.telemetry.data import get_host_info
 from ddtrace.internal.telemetry.writer import get_runtime_id
 from ddtrace.internal.utils.version import _pep440_to_semver
-from ddtrace.settings import _config as config
-from ddtrace.settings.config import DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP_DEFAULT
+from ddtrace.settings import _global_config as config
+from ddtrace.settings._config import DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP_DEFAULT
 from tests.conftest import DEFAULT_DDTRACE_SUBPROCESS_TEST_SERVICE_NAME
 from tests.utils import override_global_config
 
diff --git a/tests/tracer/test_env_vars.py b/tests/tracer/test_env_vars.py
index fb5f5ada055..16b92cc49f2 100644
--- a/tests/tracer/test_env_vars.py
+++ b/tests/tracer/test_env_vars.py
@@ -50,7 +50,7 @@ def test_obfuscation_querystring_pattern_env_var(
             "-c",
             (
                 """import re;from ddtrace import config;
-from ddtrace.settings.config import DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP_DEFAULT;
+from ddtrace.settings._config import DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP_DEFAULT;
 assert config._obfuscation_query_string_pattern == %s;
 assert config._global_query_string_obfuscation_disabled == %s;
 assert config._http_tag_query_string == %s
diff --git a/tests/tracer/test_global_config.py b/tests/tracer/test_global_config.py
index a83b8352074..6c557bc8de6 100644
--- a/tests/tracer/test_global_config.py
+++ b/tests/tracer/test_global_config.py
@@ -6,7 +6,7 @@
 
 from ddtrace import config as global_config
 from ddtrace.settings import Config
-from ddtrace.settings.config import _parse_propagation_styles
+from ddtrace.settings._config import _parse_propagation_styles
 
 from ..utils import DummyTracer
 from ..utils import override_env
diff --git a/tests/tracer/test_instance_config.py b/tests/tracer/test_instance_config.py
index 457bf53a408..130e46350ae 100644
--- a/tests/tracer/test_instance_config.py
+++ b/tests/tracer/test_instance_config.py
@@ -22,47 +22,47 @@ class Klass(object):
 
     def test_configuration_get_from(self):
         # ensure a dictionary is returned
-        cfg = config.get_from(self.Klass)
+        cfg = config._get_from(self.Klass)
         assert isinstance(cfg, dict)
 
     def test_configuration_get_from_twice(self):
         # ensure the configuration is the same if `get_from` is used
         # in the same instance
         instance = self.Klass()
-        cfg1 = config.get_from(instance)
-        cfg2 = config.get_from(instance)
+        cfg1 = config._get_from(instance)
+        cfg2 = config._get_from(instance)
         assert cfg1 is cfg2
 
     def test_configuration_set(self):
         # ensure the configuration can be updated in the Pin
         instance = self.Klass()
-        cfg = config.get_from(instance)
+        cfg = config._get_from(instance)
         cfg["distributed_tracing"] = True
-        assert config.get_from(instance)["distributed_tracing"] is True
+        assert config._get_from(instance)["distributed_tracing"] is True
 
     def test_global_configuration_inheritance(self):
         # ensure global configuration is inherited when it's set
-        cfg = config.get_from(self.Klass)
+        cfg = config._get_from(self.Klass)
         cfg["distributed_tracing"] = True
         instance = self.Klass()
-        assert config.get_from(instance)["distributed_tracing"] is True
+        assert config._get_from(instance)["distributed_tracing"] is True
 
     def test_configuration_override_instance(self):
         # ensure instance configuration doesn't override global settings
-        global_cfg = config.get_from(self.Klass)
+        global_cfg = config._get_from(self.Klass)
         global_cfg["distributed_tracing"] = True
         instance = self.Klass()
-        cfg = config.get_from(instance)
+        cfg = config._get_from(instance)
         cfg["distributed_tracing"] = False
-        assert config.get_from(self.Klass)["distributed_tracing"] is True
-        assert config.get_from(instance)["distributed_tracing"] is False
+        assert config._get_from(self.Klass)["distributed_tracing"] is True
+        assert config._get_from(instance)["distributed_tracing"] is False
 
     def test_service_name_for_pin(self):
         # ensure for backward compatibility that changing the service
         # name via the Pin object also updates integration config
         Pin(service="intake").onto(self.Klass)
         instance = self.Klass()
-        cfg = config.get_from(instance)
+        cfg = config._get_from(instance)
         assert cfg["service_name"] == "intake"
 
     def test_service_attribute_priority(self):
@@ -73,7 +73,7 @@ def test_service_attribute_priority(self):
         }
         Pin(service="service", _config=global_config).onto(self.Klass)
         instance = self.Klass()
-        cfg = config.get_from(instance)
+        cfg = config._get_from(instance)
         assert cfg["service_name"] == "service"
 
     def test_configuration_copy(self):
@@ -83,7 +83,7 @@ def test_configuration_copy(self):
         }
         Pin(service="service", _config=global_config).onto(self.Klass)
         instance = self.Klass()
-        cfg = config.get_from(instance)
+        cfg = config._get_from(instance)
         cfg["service_name"] = "metrics"
         assert global_config["service_name"] == "service"
 
@@ -98,7 +98,7 @@ def test_configuration_copy_upside_down(self):
         global_config["service_name"] = "metrics"
         # use the Pin via `get_from`
         instance = self.Klass()
-        cfg = config.get_from(instance)
+        cfg = config._get_from(instance)
         # it should have users updated value
         assert cfg["service_name"] == "metrics"
 
diff --git a/tests/tracer/test_settings.py b/tests/tracer/test_settings.py
index c78302712e7..ac94404200a 100644
--- a/tests/tracer/test_settings.py
+++ b/tests/tracer/test_settings.py
@@ -33,15 +33,15 @@ def test_http_config(self):
         config = Config()
         config._add("django", dict())
         assert config.django.trace_query_string is None
-        config.http.trace_query_string = True
-        assert config.http.trace_query_string is True
+        config._http.trace_query_string = True
+        assert config._http.trace_query_string is True
         assert config.django.trace_query_string is True
 
         # Integration usage
         config = Config()
         config._add("django", dict())
         config.django.http.trace_query_string = True
-        assert config.http.trace_query_string is None
+        assert config._http.trace_query_string is None
         assert config.django.trace_query_string is True
         assert config.django.http.trace_query_string is True
 
@@ -183,7 +183,7 @@ def test_config_is_header_tracing_configured(global_headers, int_headers, expect
         integration_config.http.trace_headers(int_headers)
 
     assert (
-        config.http.is_header_tracing_configured,
+        config._http.is_header_tracing_configured,
         integration_config.http.is_header_tracing_configured,
         integration_config.is_header_tracing_configured,
     ) == expected
@@ -193,7 +193,7 @@ def test_environment_header_tags():
     with override_env(dict(DD_TRACE_HEADER_TAGS="Host:http.host,User-agent:http.user_agent")):
         config = Config()
 
-    assert config.http.is_header_tracing_configured
+    assert config._http.is_header_tracing_configured
     assert config._header_tag_name("Host") == "http.host"
     assert config._header_tag_name("User-agent") == "http.user_agent"
     # Case insensitive
diff --git a/tests/tracer/test_trace_utils.py b/tests/tracer/test_trace_utils.py
index 38ba097f308..9e05cd9f40d 100644
--- a/tests/tracer/test_trace_utils.py
+++ b/tests/tracer/test_trace_utils.py
@@ -483,7 +483,7 @@ def test_set_http_meta(
             assert core.get_item("http.request.path_params", span=span) == path_params
 
 
-@mock.patch("ddtrace.settings.config.log")
+@mock.patch("ddtrace.settings._config.log")
 @pytest.mark.parametrize(
     "error_codes,status_code,error,log_call",
     [
@@ -499,7 +499,7 @@ def test_set_http_meta(
     ],
 )
 def test_set_http_meta_custom_errors(mock_log, span, int_config, error_codes, status_code, error, log_call):
-    config.http_server.error_statuses = error_codes
+    config._http_server.error_statuses = error_codes
     trace_utils.set_http_meta(span, int_config, status_code=status_code)
     assert span.error == error
     if log_call: