Enable distributed tracing by default (#818)

brettlangdon · web-flow · commit be743b9c58ba · 2019-02-13T12:24:20.000-05:00
* [flask] enable distributed tracing by default

* [aiohttp] Enable distributed tracing by default

* [bottle] Enable distributed tracing by default

* [falcon] Enable distributed tracing by default

* [molten] Ennable distributed tracing by default

* [pylons] Enable distributed tracing by default

* [pyramid] enable distributed tracing by default

* [requests] Enable distributed tracing by default

* [tornado] Enable distributed tracing by default

* Update distributed tracing documentation

* update docs
diff --git a/ddtrace/contrib/aiohttp/__init__.py b/ddtrace/contrib/aiohttp/__init__.py
@@ -20,16 +20,16 @@
 Integration settings are attached to your application under the ``datadog_trace``
 namespace. You can read or update them as follows::
 
-    # activates distributed tracing for all received requests
-    app['datadog_trace']['distributed_tracing_enabled'] = True
+    # disables distributed tracing for all received requests
+    app['datadog_trace']['distributed_tracing_enabled'] = False
 
 Available settings are:
 
 * ``tracer`` (default: ``ddtrace.tracer``): set the default tracer instance that is used to
   trace `aiohttp` internals. By default the `ddtrace` tracer is used.
 * ``service`` (default: ``aiohttp-web``): set the service name used by the tracer. Usually
   this configuration must be updated with a meaningful name.
-* ``distributed_tracing_enabled`` (default: ``False``): enable distributed tracing during
+* ``distributed_tracing_enabled`` (default: ``True``): enable distributed tracing during
   the middleware execution, so that a new span is created with the given ``trace_id`` and
   ``parent_id`` injected via request headers.
 
diff --git a/ddtrace/contrib/aiohttp/middlewares.py b/ddtrace/contrib/aiohttp/middlewares.py
@@ -117,7 +117,7 @@ def trace_app(app, tracer, service='aiohttp-web'):
     app[CONFIG_KEY] = {
         'tracer': tracer,
         'service': service,
-        'distributed_tracing_enabled': False,
+        'distributed_tracing_enabled': True,
     }
 
     # the tracer must work with asynchronous Context propagation
diff --git a/ddtrace/contrib/bottle/__init__.py b/ddtrace/contrib/bottle/__init__.py
@@ -9,10 +9,6 @@
     app = bottle.Bottle()
     plugin = TracePlugin(service="my-web-app")
     app.install(plugin)
-
-To enable distributed tracing::
-
-    plugin = TracePlugin(service="my-web-app", distributed_tracing=True)
 """
 
 from ...utils.importlib import require_modules
diff --git a/ddtrace/contrib/bottle/trace.py b/ddtrace/contrib/bottle/trace.py
@@ -17,7 +17,7 @@ class TracePlugin(object):
     name = 'trace'
     api = 2
 
-    def __init__(self, service='bottle', tracer=None, distributed_tracing=None):
+    def __init__(self, service='bottle', tracer=None, distributed_tracing=True):
         self.service = service
         self.tracer = tracer or ddtrace.tracer
         self.distributed_tracing = distributed_tracing
diff --git a/ddtrace/contrib/falcon/__init__.py b/ddtrace/contrib/falcon/__init__.py
@@ -5,7 +5,7 @@
     from ddtrace import tracer
     from ddtrace.contrib.falcon import TraceMiddleware
 
-    mw = TraceMiddleware(tracer, 'my-falcon-app', distributed_tracing=True)
+    mw = TraceMiddleware(tracer, 'my-falcon-app')
     falcon.API(middleware=[mw])
 
 You can also use the autopatching functionality::
@@ -17,8 +17,8 @@
 
     app = falcon.API()
 
-To enable distributed tracing when using autopatching, set the
-``DATADOG_FALCON_DISTRIBUTED_TRACING`` environment variable to ``True``.
+To disable distributed tracing when using autopatching, set the
+``DATADOG_FALCON_DISTRIBUTED_TRACING`` environment variable to ``False``.
 
 **Supported span hooks**
 
diff --git a/ddtrace/contrib/falcon/middleware.py b/ddtrace/contrib/falcon/middleware.py
@@ -11,7 +11,7 @@
 
 class TraceMiddleware(object):
 
-    def __init__(self, tracer, service="falcon", distributed_tracing=False):
+    def __init__(self, tracer, service="falcon", distributed_tracing=True):
         # store tracing references
         self.tracer = tracer
         self.service = service
@@ -23,7 +23,9 @@ def process_request(self, req, resp):
             headers = dict((k.lower(), v) for k, v in iteritems(req.headers))
             propagator = HTTPPropagator()
             context = propagator.extract(headers)
-            self.tracer.context_provider.activate(context)
+            # Only activate the new context if there was a trace id extracted
+            if context.trace_id:
+                self.tracer.context_provider.activate(context)
 
         span = self.tracer.trace(
             "falcon.request",
diff --git a/ddtrace/contrib/falcon/patch.py b/ddtrace/contrib/falcon/patch.py
@@ -5,7 +5,7 @@
 from ddtrace import tracer
 
 from .middleware import TraceMiddleware
-from ...utils.formats import asbool
+from ...utils.formats import asbool, get_env
 
 
 def patch():
@@ -23,8 +23,7 @@ def patch():
 def traced_init(wrapped, instance, args, kwargs):
     mw = kwargs.pop('middleware', [])
     service = os.environ.get('DATADOG_SERVICE_NAME') or 'falcon'
-    distributed_tracing = asbool(os.environ.get(
-        'DATADOG_FALCON_DISTRIBUTED_TRACING')) or False
+    distributed_tracing = asbool(get_env('falcon', 'distributed_tracing', True))
 
     mw.insert(0, TraceMiddleware(tracer, service, distributed_tracing))
     kwargs['middleware'] = mw
diff --git a/ddtrace/contrib/flask/__init__.py b/ddtrace/contrib/flask/__init__.py
@@ -35,7 +35,7 @@ def index():
 
    Whether to parse distributed tracing headers from requests received by your Flask app.
 
-   Default: ``False``
+   Default: ``True``
 
 .. py:data:: ddtrace.config.flask['service_name']
 
diff --git a/ddtrace/contrib/flask/patch.py b/ddtrace/contrib/flask/patch.py
@@ -31,7 +31,7 @@
     app_type=AppTypes.web,
 
     collect_view_args=True,
-    distributed_tracing_enabled=False,
+    distributed_tracing_enabled=True,
     template_default_name='<memory>',
     trace_signals=True,
 
diff --git a/ddtrace/contrib/molten/__init__.py b/ddtrace/contrib/molten/__init__.py
@@ -13,8 +13,23 @@ def hello(name: str, age: int) -> str:
 
     ddtrace-run python app.py
 
-To enable distributed tracing when using autopatching, set the
-``DD_MOLTEN_DISTRIBUTED_TRACING`` environment variable to ``True``.
+
+Configuration
+~~~~~~~~~~~~~
+
+.. py:data:: ddtrace.config.molten['distributed_tracing']
+
+   Whether to parse distributed tracing headers from requests received by your Molten app.
+
+   Default: ``True``
+
+.. py:data:: ddtrace.config.molten['service_name']
+
+   The service name reported for your Molten app.
+
+   Can also be configured via the ``DD_MOLTEN_SERVICE_NAME`` environment variable.
+
+   Default: ``'molten'``
 """
 from ...utils.importlib import require_modules
 
diff --git a/ddtrace/contrib/molten/patch.py b/ddtrace/contrib/molten/patch.py
@@ -19,7 +19,7 @@
     service_name=get_env('molten', 'service_name', 'molten'),
     app='molten',
     app_type=AppTypes.web,
-    distributed_tracing=asbool(get_env('molten', 'distributed_tracing', False)),
+    distributed_tracing=asbool(get_env('molten', 'distributed_tracing', True)),
 ))
 
 
@@ -75,7 +75,7 @@ def patch_app_call(wrapped, instance, args, kwargs):
     resource = func_name(wrapped)
 
     # Configure distributed tracing
-    if config.molten.get('distributed_tracing', False):
+    if config.molten.get('distributed_tracing', True):
         propagator = HTTPPropagator()
         # request.headers is type Iterable[Tuple[str, str]]
         context = propagator.extract(dict(request.headers))
diff --git a/ddtrace/contrib/pylons/__init__.py b/ddtrace/contrib/pylons/__init__.py
@@ -12,10 +12,7 @@
 
     traced_app = PylonsTraceMiddleware(app, tracer, service='my-pylons-app')
 
-Then you can define your routes and views as usual. To enable distributed tracing,
-set the following keyword argument::
-
-    traced_app = PylonsTraceMiddleware(app, tracer, service='my-pylons-app', distributed_tracing=True)
+Then you can define your routes and views as usual.
 """
 
 from ...utils.importlib import require_modules
diff --git a/ddtrace/contrib/pylons/middleware.py b/ddtrace/contrib/pylons/middleware.py
@@ -19,7 +19,7 @@
 
 class PylonsTraceMiddleware(object):
 
-    def __init__(self, app, tracer, service='pylons', distributed_tracing=False):
+    def __init__(self, app, tracer, service='pylons', distributed_tracing=True):
         self.app = app
         self._service = service
         self._distributed_tracing = distributed_tracing
diff --git a/ddtrace/contrib/pylons/patch.py b/ddtrace/contrib/pylons/patch.py
@@ -5,6 +5,7 @@
 from ddtrace import tracer, Pin
 
 from .middleware import PylonsTraceMiddleware
+from ...utils.formats import asbool, get_env
 from ...utils.wrappers import unwrap as _u
 
 
@@ -31,7 +32,7 @@ def traced_init(wrapped, instance, args, kwargs):
 
     # set tracing options and create the TraceMiddleware
     service = os.environ.get('DATADOG_SERVICE_NAME', 'pylons')
-    distributed_tracing = os.environ.get('DATADOG_PYLONS_DISTRIBUTED_TRACING', False)
+    distributed_tracing = asbool(get_env('pylons', 'distributed_tracing', True))
     Pin(service=service, tracer=tracer).onto(instance)
     traced_app = PylonsTraceMiddleware(instance, tracer, service=service, distributed_tracing=distributed_tracing)
 
diff --git a/ddtrace/contrib/pyramid/__init__.py b/ddtrace/contrib/pyramid/__init__.py
@@ -19,7 +19,7 @@
 
 * ``datadog_trace_service``: change the `pyramid` service name
 * ``datadog_trace_enabled``: sets if the Tracer is enabled or not
-* ``datadog_distributed_tracing``: set it to ``True`` to enable Distributed Tracing
+* ``datadog_distributed_tracing``: set it to ``False`` to disable Distributed Tracing
 
 If you use the ``pyramid.tweens`` settings value to set the tweens for your
 application, you need to add ``ddtrace.contrib.pyramid:trace_tween_factory``
diff --git a/ddtrace/contrib/pyramid/patch.py b/ddtrace/contrib/pyramid/patch.py
@@ -2,7 +2,7 @@
 
 from .trace import trace_pyramid, DD_TWEEN_NAME
 from .constants import SETTINGS_SERVICE, SETTINGS_DISTRIBUTED_TRACING
-from ...utils.formats import asbool
+from ...utils.formats import asbool, get_env
 
 import pyramid.config
 from pyramid.path import caller_package
@@ -27,16 +27,19 @@ def patch():
 def traced_init(wrapped, instance, args, kwargs):
     settings = kwargs.pop('settings', {})
     service = os.environ.get('DATADOG_SERVICE_NAME') or 'pyramid'
-    distributed_tracing = asbool(os.environ.get('DATADOG_PYRAMID_DISTRIBUTED_TRACING')) or False
+    distributed_tracing = asbool(get_env('pyramid', 'distributed_tracing', True))
     trace_settings = {
         SETTINGS_SERVICE: service,
         SETTINGS_DISTRIBUTED_TRACING: distributed_tracing,
     }
-    settings.update(trace_settings)
+    # Update over top of the defaults
+    # DEV: If we did `settings.update(trace_settings)` then we would only ever
+    #      have the default values.
+    trace_settings.update(settings)
     # If the tweens are explicitly set with 'pyramid.tweens', we need to
     # explicitly set our tween too since `add_tween` will be ignored.
-    insert_tween_if_needed(settings)
-    kwargs['settings'] = settings
+    insert_tween_if_needed(trace_settings)
+    kwargs['settings'] = trace_settings
 
     # `caller_package` works by walking a fixed amount of frames up the stack
     # to find the calling package. So if we let the original `__init__`
diff --git a/ddtrace/contrib/pyramid/trace.py b/ddtrace/contrib/pyramid/trace.py
@@ -60,7 +60,7 @@ def trace_tween_factory(handler, registry):
     service = settings.get(SETTINGS_SERVICE) or 'pyramid'
     tracer = settings.get(SETTINGS_TRACER) or ddtrace.tracer
     enabled = asbool(settings.get(SETTINGS_TRACE_ENABLED, tracer.enabled))
-    distributed_tracing = asbool(settings.get(SETTINGS_DISTRIBUTED_TRACING, False))
+    distributed_tracing = asbool(settings.get(SETTINGS_DISTRIBUTED_TRACING, True))
 
     if enabled:
         # make a request tracing function
diff --git a/ddtrace/contrib/requests/__init__.py b/ddtrace/contrib/requests/__init__.py
@@ -21,10 +21,10 @@
 
     from ddtrace import config
 
-    # enable distributed tracing globally
-    config.requests['distributed_tracing'] = True
+    # disable distributed tracing globally
+    config.requests['distributed_tracing'] = False
 
-    # change the service name only for this session
+    # change the service name/distributed tracing only for this session
     session = Session()
     cfg = config.get_from(session)
     cfg['service_name'] = 'auth-api'
diff --git a/ddtrace/contrib/requests/patch.py b/ddtrace/contrib/requests/patch.py
@@ -15,7 +15,7 @@
 # requests default settings
 config._add('requests', {
     'service_name': get_env('requests', 'service_name', DEFAULT_SERVICE),
-    'distributed_tracing': asbool(get_env('requests', 'distributed_tracing', False)),
+    'distributed_tracing': asbool(get_env('requests', 'distributed_tracing', True)),
     'split_by_domain': asbool(get_env('requests', 'split_by_domain', False)),
 })
 
diff --git a/ddtrace/contrib/tornado/__init__.py b/ddtrace/contrib/tornado/__init__.py
@@ -54,7 +54,7 @@ def notify(self):
         'datadog_trace': {
             'default_service': 'my-tornado-app',
             'tags': {'env': 'production'},
-            'distributed_tracing': True,
+            'distributed_tracing': False,
             'settings': {
                 'FILTERS':  [
                     FilterRequestsOnUrl(r'http://test\.example\.com'),
@@ -74,7 +74,7 @@ def notify(self):
 * ``tags`` (default: `{}`): set global tags that should be applied to all spans.
 * ``enabled`` (default: `True`): define if the tracer is enabled or not. If set to `false`, the
   code is still instrumented but no spans are sent to the APM agent.
-* ``distributed_tracing`` (default: `False`): enable distributed tracing if this is called
+* ``distributed_tracing`` (default: `True`): enable distributed tracing if this is called
   remotely from an instrumented application.
   We suggest to enable it only for internal services where headers are under your control.
 * ``agent_hostname`` (default: `localhost`): define the hostname of the APM agent.
diff --git a/ddtrace/contrib/tornado/application.py b/ddtrace/contrib/tornado/application.py
@@ -18,7 +18,7 @@ def tracer_config(__init__, app, args, kwargs):
     settings = {
         'tracer': ddtrace.tracer,
         'default_service': 'tornado-web',
-        'distributed_tracing': False,
+        'distributed_tracing': True,
     }
 
     # update defaults with users settings
diff --git a/docs/advanced_usage.rst b/docs/advanced_usage.rst
@@ -27,31 +27,31 @@ To trace requests across hosts, the spans on the secondary hosts must be linked
 Web Frameworks
 ^^^^^^^^^^^^^^
 
-Some web framework integrations support distributed tracing out of the box, you just have to enable it.
-For that, refer to the configuration of the given integration.
+Some web framework integrations support distributed tracing out of the box.
+
 Supported web frameworks:
 
 
 +-------------------+-----------------+
 | Framework/Library |  Enabled        |
 +===================+=================+
-| :ref:`aiohttp`    | False           |
+| :ref:`aiohttp`    | True            |
 +-------------------+-----------------+
-| :ref:`bottle`     | False           |
+| :ref:`bottle`     | True            |
 +-------------------+-----------------+
-| :ref:`django`     | False           |
+| :ref:`django`     | True            |
 +-------------------+-----------------+
-| :ref:`falcon`     | False           |
+| :ref:`falcon`     | True            |
 +-------------------+-----------------+
-| :ref:`flask`      | False           |
+| :ref:`flask`      | True            |
 +-------------------+-----------------+
-| :ref:`pylons`     | False           |
+| :ref:`pylons`     | True            |
 +-------------------+-----------------+
-| :ref:`pyramid`    | False           |
+| :ref:`pyramid`    | True            |
 +-------------------+-----------------+
-| :ref:`requests`   | False           |
+| :ref:`requests`   | True            |
 +-------------------+-----------------+
-| :ref:`tornado`    | False           |
+| :ref:`tornado`    | True            |
 +-------------------+-----------------+
 
 
diff --git a/tests/contrib/aiohttp/test_middleware.py b/tests/contrib/aiohttp/test_middleware.py
@@ -205,8 +205,7 @@ def test_wrapped_coroutine(self):
     @unittest_run_loop
     @asyncio.coroutine
     def test_distributed_tracing(self):
-        # activate distributed tracing
-        self.app['datadog_trace']['distributed_tracing_enabled'] = True
+        # distributed tracing is enabled by default
         tracing_headers = {
             'x-datadog-trace-id': '100',
             'x-datadog-parent-id': '42',
@@ -231,8 +230,6 @@ def test_distributed_tracing(self):
     def test_distributed_tracing_with_sampling_true(self):
         self.tracer.priority_sampler = RateSampler(0.1)
 
-        # activate distributed tracing
-        self.app['datadog_trace']['distributed_tracing_enabled'] = True
         tracing_headers = {
             'x-datadog-trace-id': '100',
             'x-datadog-parent-id': '42',
@@ -258,8 +255,6 @@ def test_distributed_tracing_with_sampling_true(self):
     def test_distributed_tracing_with_sampling_false(self):
         self.tracer.priority_sampler = RateSampler(0.9)
 
-        # activate distributed tracing
-        self.app['datadog_trace']['distributed_tracing_enabled'] = True
         tracing_headers = {
             'x-datadog-trace-id': '100',
             'x-datadog-parent-id': '42',
@@ -282,8 +277,9 @@ def test_distributed_tracing_with_sampling_false(self):
 
     @unittest_run_loop
     @asyncio.coroutine
-    def test_distributed_tracing_disabled_default(self):
+    def test_distributed_tracing_disabled(self):
         # pass headers for distributed tracing
+        self.app['datadog_trace']['distributed_tracing_enabled'] = False
         tracing_headers = {
             'x-datadog-trace-id': '100',
             'x-datadog-parent-id': '42',
@@ -308,7 +304,6 @@ def test_distributed_tracing_sub_span(self):
         self.tracer.priority_sampler = RateSampler(1.0)
 
         # activate distributed tracing
-        self.app['datadog_trace']['distributed_tracing_enabled'] = True
         tracing_headers = {
             'x-datadog-trace-id': '100',
             'x-datadog-parent-id': '42',
diff --git a/tests/contrib/bottle/test_distributed.py b/tests/contrib/bottle/test_distributed.py
diff --git a/tests/contrib/falcon/app/app.py b/tests/contrib/falcon/app/app.py
diff --git a/tests/contrib/falcon/test_distributed_tracing.py b/tests/contrib/falcon/test_distributed_tracing.py
diff --git a/tests/contrib/flask/test_request.py b/tests/contrib/flask/test_request.py
diff --git a/tests/contrib/molten/test_molten.py b/tests/contrib/molten/test_molten.py
diff --git a/tests/contrib/pylons/test_pylons.py b/tests/contrib/pylons/test_pylons.py
diff --git a/tests/contrib/pyramid/test_pyramid.py b/tests/contrib/pyramid/test_pyramid.py
diff --git a/tests/contrib/requests/test_requests_distributed.py b/tests/contrib/requests/test_requests_distributed.py
diff --git a/tests/contrib/tornado/test_tornado_web.py b/tests/contrib/tornado/test_tornado_web.py

Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ def trace_app(app, tracer, service='aiohttp-web'):`
`117`	`117`	`app[CONFIG_KEY] = {`
`118`	`118`	`'tracer': tracer,`
`119`	`119`	`'service': service,`
`120`		`- 'distributed_tracing_enabled': False,`
	`120`	`+ 'distributed_tracing_enabled': True,`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`# the tracer must work with asynchronous Context propagation`