[core] Update config to allow configuration before patching (#650)

* Add ddtrace.utils.merge.deepmerge helper function

* [core] Update config to allow configuration before patching

Previously if we tried to set a config setting before the contrib module was imported
we would receive an error that the integration key did not exist.

With this new approach we are allowing any integration setting to be configured by
the user, whenever they want and then when we call `config._add()` in the contrib
module, we will merge the settings with any existing settings, keeping those that
already exist.

We have also added a Config.__repr__

* [tests] Fix spelling mistakes in global config test docstrings

Author: brettlangdon

ddtrace/settings.py

@@ -3,6 +3,7 @@
 from copy import deepcopy
 
 from .pin import Pin
+from .utils.merge import deepmerge
 
 
 log = logging.getLogger(__name__)
@@ -26,12 +27,9 @@ def __init__(self):
         self._config = {}
 
     def __getattr__(self, name):
-        try:
-            return self._config[name]
-        except KeyError as e:
-            raise ConfigException(
-                'Integration "{}" is not registered in this configuration'.format(e.message)
-            )
+        if name not in self._config:
+            self._config[name] = dict()
+        return self._config[name]
 
     def get_from(self, obj):
         """Retrieves the configuration for the given object.
@@ -46,14 +44,36 @@ def get_from(self, obj):
 
         return pin._config
 
-    def _add(self, integration, settings):
+    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)
 
-        self._config[integration] = 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._config[integration] = deepmerge(existing, settings)
+        else:
+            self._config[integration] = settings
+
+    def __repr__(self):
+        cls = self.__class__
+        integrations = ', '.join(self._config.keys())
+        return '{}.{}({})'.format(cls.__module__, cls.__name__, integrations)

ddtrace/utils/merge.py

@@ -0,0 +1,19 @@
+# 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

tests/test_global_config.py

@@ -48,3 +48,45 @@ def test_missing_integration(self):
     def test_global_configuration(self):
         # ensure a global configuration is available in the `ddtrace` module
         ok_(isinstance(global_config, Config))
+
+    def test_settings_merge(self):
+        """
+        When calling `config._add()`
+            when existing settings exist
+                we do not overwrite the existing settings
+        """
+        self.config.requests['split_by_domain'] = True
+        self.config._add('requests', dict(split_by_domain=False))
+        eq_(self.config.requests['split_by_domain'], True)
+
+    def test_settings_overwrite(self):
+        """
+        When calling `config._add(..., merge=False)`
+            when existing settings exist
+                we overwrite the existing settings
+        """
+        self.config.requests['split_by_domain'] = True
+        self.config._add('requests', dict(split_by_domain=False), merge=False)
+        eq_(self.config.requests['split_by_domain'], False)
+
+    def test_settings_merge_deep(self):
+        """
+        When calling `config._add()`
+            when existing "deep" settings exist
+                we do not overwrite the existing settings
+        """
+        self.config.requests['a'] = dict(
+            b=dict(
+                c=True,
+            ),
+        )
+        self.config._add('requests', dict(
+            a=dict(
+                b=dict(
+                    c=False,
+                    d=True,
+                ),
+            ),
+        ))
+        eq_(self.config.requests['a']['b']['c'], True)
+        eq_(self.config.requests['a']['b']['d'], True)