We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Flask support doesn't call store_request_headers
Flask integration doesn't store request/response headers on the span. Other integrations such as Falcon do.

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `ddtrace/contrib/flask/middleware.py`
Content:
```
1 from ... import compat
2 from ...ext import SpanTypes, http, errors
3 from ...internal.logger import get_logger
4 from ...propagation.http import HTTPPropagator
5 from ...utils.deprecation import deprecated
6 
7 import flask.templating
8 from flask import g, request, signals
9 
10 
11 log = get_logger(__name__)
12 
13 
14 SPAN_NAME = 'flask.request'
15 
16 
17 class TraceMiddleware(object):
18 
19     @deprecated(message='Use patching instead (see the docs).', version='1.0.0')
20     def __init__(self, app, tracer, service='flask', use_signals=True, distributed_tracing=False):
21         self.app = app
22         log.debug('flask: initializing trace middleware')
23 
24         # Attach settings to the inner application middleware. This is required if double
25         # instrumentation happens (i.e. `ddtrace-run` with `TraceMiddleware`). In that
26         # case, `ddtrace-run` instruments the application, but then users code is unable
27         # to update settings such as `distributed_tracing` flag. This step can be removed
28         # when the `Config` object is used
29         self.app._tracer = tracer
30         self.app._service = service
31         self.app._use_distributed_tracing = distributed_tracing
32         self.use_signals = use_signals
33 
34         # safe-guard to avoid double instrumentation
35         if getattr(app, '__dd_instrumentation', False):
36             return
37         setattr(app, '__dd_instrumentation', True)
38 
39         # Install hooks which time requests.
40         self.app.before_request(self._before_request)
41         self.app.after_request(self._after_request)
42         self.app.teardown_request(self._teardown_request)
43 
44         # Add exception handling signals. This will annotate exceptions that
45         # are caught and handled in custom user code.
46         # See https://github.com/DataDog/dd-trace-py/issues/390
47         if use_signals and not signals.signals_available:
48             log.debug(_blinker_not_installed_msg)
49         self.use_signals = use_signals and signals.signals_available
50         timing_signals = {
51             'got_request_exception': self._request_exception,
52         }
53         self._receivers = []
54         if self.use_signals and _signals_exist(timing_signals):
55             self._connect(timing_signals)
56 
57         _patch_render(tracer)
58 
59     def _connect(self, signal_to_handler):
60         connected = True
61         for name, handler in signal_to_handler.items():
62             s = getattr(signals, name, None)
63             if not s:
64                 connected = False
65                 log.warning('trying to instrument missing signal %s', name)
66                 continue
67             # we should connect to the signal without using weak references
68             # otherwise they will be garbage collected and our handlers
69             # will be disconnected after the first call; for more details check:
70             # https://github.com/jek/blinker/blob/207446f2d97/blinker/base.py#L106-L108
71             s.connect(handler, sender=self.app, weak=False)
72             self._receivers.append(handler)
73         return connected
74 
75     def _before_request(self):
76         """ Starts tracing the current request and stores it in the global
77             request object.
78         """
79         self._start_span()
80 
81     def _after_request(self, response):
82         """ Runs after the server can process a response. """
83         try:
84             self._process_response(response)
85         except Exception:
86             log.debug('flask: error tracing response', exc_info=True)
87         return response
88 
89     def _teardown_request(self, exception):
90         """ Runs at the end of a request. If there's an unhandled exception, it
91             will be passed in.
92         """
93         # when we teardown the span, ensure we have a clean slate.
94         span = getattr(g, 'flask_datadog_span', None)
95         setattr(g, 'flask_datadog_span', None)
96         if not span:
97             return
98 
99         try:
100             self._finish_span(span, exception=exception)
101         except Exception:
102             log.debug('flask: error finishing span', exc_info=True)
103 
104     def _start_span(self):
105         if self.app._use_distributed_tracing:
106             propagator = HTTPPropagator()
107             context = propagator.extract(request.headers)
108             # Only need to active the new context if something was propagated
109             if context.trace_id:
110                 self.app._tracer.context_provider.activate(context)
111         try:
112             g.flask_datadog_span = self.app._tracer.trace(
113                 SPAN_NAME,
114                 service=self.app._service,
115                 span_type=SpanTypes.WEB,
116             )
117         except Exception:
118             log.debug('flask: error tracing request', exc_info=True)
119 
120     def _process_response(self, response):
121         span = getattr(g, 'flask_datadog_span', None)
122         if not (span and span.sampled):
123             return
124 
125         code = response.status_code if response else ''
126         span.set_tag(http.STATUS_CODE, code)
127 
128     def _request_exception(self, *args, **kwargs):
129         exception = kwargs.get('exception', None)
130         span = getattr(g, 'flask_datadog_span', None)
131         if span and exception:
132             _set_error_on_span(span, exception)
133 
134     def _finish_span(self, span, exception=None):
135         if not span or not span.sampled:
136             return
137 
138         code = span.get_tag(http.STATUS_CODE) or 0
139         try:
140             code = int(code)
141         except Exception:
142             code = 0
143 
144         if exception:
145             # if the request has already had a code set, don't override it.
146             code = code or 500
147             _set_error_on_span(span, exception)
148 
149         # the endpoint that matched the request is None if an exception
150         # happened so we fallback to a common resource
151         span.error = 0 if code < 500 else 1
152 
153         # the request isn't guaranteed to exist here, so only use it carefully.
154         method = ''
155         endpoint = ''
156         url = ''
157         if request:
158             method = request.method
159             endpoint = request.endpoint or code
160             url = request.base_url or ''
161 
162         # Let users specify their own resource in middleware if they so desire.
163         # See case https://github.com/DataDog/dd-trace-py/issues/353
164         if span.resource == SPAN_NAME:
165             resource = endpoint or code
166             span.resource = compat.to_unicode(resource).lower()
167 
168         span.set_tag(http.URL, compat.to_unicode(url))
169         span.set_tag(http.STATUS_CODE, code)
170         span.set_tag(http.METHOD, method)
171         span.finish()
172 
173 
174 def _set_error_on_span(span, exception):
175     # The 3 next lines might not be strictly required, since `set_traceback`
176     # also get the exception from the sys.exc_info (and fill the error meta).
177     # Since we aren't sure it always work/for insuring no BC break, keep
178     # these lines which get overridden anyway.
179     span.set_tag(errors.ERROR_TYPE, type(exception))
180     span.set_tag(errors.ERROR_MSG, exception)
181     # The provided `exception` object doesn't have a stack trace attached,
182     # so attach the stack trace with `set_traceback`.
183     span.set_traceback()
184 
185 
186 def _patch_render(tracer):
187     """ patch flask's render template methods with the given tracer. """
188     # fall back to patching  global method
189     _render = flask.templating._render
190 
191     # If the method has already been patched and we're patching again then
192     # we have to patch again with the new tracer reference.
193     if hasattr(_render, "__dd_orig"):
194         _render = getattr(_render, "__dd_orig")
195 
196     def _traced_render(template, context, app):
197         with tracer.trace('flask.template', span_type=SpanTypes.TEMPLATE) as span:
198             span.set_tag('flask.template', template.name or 'string')
199             return _render(template, context, app)
200 
201     setattr(_traced_render, "__dd_orig", _render)
202     flask.templating._render = _traced_render
203 
204 
205 def _signals_exist(names):
206     """ Return true if all of the given signals exist in this version of flask.
207     """
208     return all(getattr(signals, n, False) for n in names)
209 
210 
211 _blinker_not_installed_msg = (
212     'please install blinker to use flask signals. '
213     'http://flask.pocoo.org/docs/0.11/signals/'
214 )
215
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/ddtrace/contrib/flask/middleware.py b/ddtrace/contrib/flask/middleware.py
--- a/ddtrace/contrib/flask/middleware.py
+++ b/ddtrace/contrib/flask/middleware.py
@@ -3,6 +3,8 @@
 from ...internal.logger import get_logger
 from ...propagation.http import HTTPPropagator
 from ...utils.deprecation import deprecated
+from ddtrace.http import store_request_headers
+from ddtrace import config
 
 import flask.templating
 from flask import g, request, signals
@@ -155,6 +157,7 @@
         endpoint = ''
         url = ''
         if request:
+            store_request_headers(request.headers, span, config.flask)
             method = request.method
             endpoint = request.endpoint or code
             url = request.base_url or ''

{"golden_diff": "diff --git a/ddtrace/contrib/flask/middleware.py b/ddtrace/contrib/flask/middleware.py\n--- a/ddtrace/contrib/flask/middleware.py\n+++ b/ddtrace/contrib/flask/middleware.py\n@@ -3,6 +3,8 @@\n from ...internal.logger import get_logger\n from ...propagation.http import HTTPPropagator\n from ...utils.deprecation import deprecated\n+from ddtrace.http import store_request_headers\n+from ddtrace import config\n \n import flask.templating\n from flask import g, request, signals\n@@ -155,6 +157,7 @@\n         endpoint = ''\n         url = ''\n         if request:\n+            store_request_headers(request.headers, span, config.flask)\n             method = request.method\n             endpoint = request.endpoint or code\n             url = request.base_url or ''\n", "issue": "Flask support doesn't call store_request_headers\nFlask integration doesn't store request/response headers on the span. Other integrations such as Falcon do.\n", "before_files": [{"content": "from ... import compat\nfrom ...ext import SpanTypes, http, errors\nfrom ...internal.logger import get_logger\nfrom ...propagation.http import HTTPPropagator\nfrom ...utils.deprecation import deprecated\n\nimport flask.templating\nfrom flask import g, request, signals\n\n\nlog = get_logger(__name__)\n\n\nSPAN_NAME = 'flask.request'\n\n\nclass TraceMiddleware(object):\n\n    @deprecated(message='Use patching instead (see the docs).', version='1.0.0')\n    def __init__(self, app, tracer, service='flask', use_signals=True, distributed_tracing=False):\n        self.app = app\n        log.debug('flask: initializing trace middleware')\n\n        # Attach settings to the inner application middleware. This is required if double\n        # instrumentation happens (i.e. `ddtrace-run` with `TraceMiddleware`). In that\n        # case, `ddtrace-run` instruments the application, but then users code is unable\n        # to update settings such as `distributed_tracing` flag. This step can be removed\n        # when the `Config` object is used\n        self.app._tracer = tracer\n        self.app._service = service\n        self.app._use_distributed_tracing = distributed_tracing\n        self.use_signals = use_signals\n\n        # safe-guard to avoid double instrumentation\n        if getattr(app, '__dd_instrumentation', False):\n            return\n        setattr(app, '__dd_instrumentation', True)\n\n        # Install hooks which time requests.\n        self.app.before_request(self._before_request)\n        self.app.after_request(self._after_request)\n        self.app.teardown_request(self._teardown_request)\n\n        # Add exception handling signals. This will annotate exceptions that\n        # are caught and handled in custom user code.\n        # See https://github.com/DataDog/dd-trace-py/issues/390\n        if use_signals and not signals.signals_available:\n            log.debug(_blinker_not_installed_msg)\n        self.use_signals = use_signals and signals.signals_available\n        timing_signals = {\n            'got_request_exception': self._request_exception,\n        }\n        self._receivers = []\n        if self.use_signals and _signals_exist(timing_signals):\n            self._connect(timing_signals)\n\n        _patch_render(tracer)\n\n    def _connect(self, signal_to_handler):\n        connected = True\n        for name, handler in signal_to_handler.items():\n            s = getattr(signals, name, None)\n            if not s:\n                connected = False\n                log.warning('trying to instrument missing signal %s', name)\n                continue\n            # we should connect to the signal without using weak references\n            # otherwise they will be garbage collected and our handlers\n            # will be disconnected after the first call; for more details check:\n            # https://github.com/jek/blinker/blob/207446f2d97/blinker/base.py#L106-L108\n            s.connect(handler, sender=self.app, weak=False)\n            self._receivers.append(handler)\n        return connected\n\n    def _before_request(self):\n        \"\"\" Starts tracing the current request and stores it in the global\n            request object.\n        \"\"\"\n        self._start_span()\n\n    def _after_request(self, response):\n        \"\"\" Runs after the server can process a response. \"\"\"\n        try:\n            self._process_response(response)\n        except Exception:\n            log.debug('flask: error tracing response', exc_info=True)\n        return response\n\n    def _teardown_request(self, exception):\n        \"\"\" Runs at the end of a request. If there's an unhandled exception, it\n            will be passed in.\n        \"\"\"\n        # when we teardown the span, ensure we have a clean slate.\n        span = getattr(g, 'flask_datadog_span', None)\n        setattr(g, 'flask_datadog_span', None)\n        if not span:\n            return\n\n        try:\n            self._finish_span(span, exception=exception)\n        except Exception:\n            log.debug('flask: error finishing span', exc_info=True)\n\n    def _start_span(self):\n        if self.app._use_distributed_tracing:\n            propagator = HTTPPropagator()\n            context = propagator.extract(request.headers)\n            # Only need to active the new context if something was propagated\n            if context.trace_id:\n                self.app._tracer.context_provider.activate(context)\n        try:\n            g.flask_datadog_span = self.app._tracer.trace(\n                SPAN_NAME,\n                service=self.app._service,\n                span_type=SpanTypes.WEB,\n            )\n        except Exception:\n            log.debug('flask: error tracing request', exc_info=True)\n\n    def _process_response(self, response):\n        span = getattr(g, 'flask_datadog_span', None)\n        if not (span and span.sampled):\n            return\n\n        code = response.status_code if response else ''\n        span.set_tag(http.STATUS_CODE, code)\n\n    def _request_exception(self, *args, **kwargs):\n        exception = kwargs.get('exception', None)\n        span = getattr(g, 'flask_datadog_span', None)\n        if span and exception:\n            _set_error_on_span(span, exception)\n\n    def _finish_span(self, span, exception=None):\n        if not span or not span.sampled:\n            return\n\n        code = span.get_tag(http.STATUS_CODE) or 0\n        try:\n            code = int(code)\n        except Exception:\n            code = 0\n\n        if exception:\n            # if the request has already had a code set, don't override it.\n            code = code or 500\n            _set_error_on_span(span, exception)\n\n        # the endpoint that matched the request is None if an exception\n        # happened so we fallback to a common resource\n        span.error = 0 if code < 500 else 1\n\n        # the request isn't guaranteed to exist here, so only use it carefully.\n        method = ''\n        endpoint = ''\n        url = ''\n        if request:\n            method = request.method\n            endpoint = request.endpoint or code\n            url = request.base_url or ''\n\n        # Let users specify their own resource in middleware if they so desire.\n        # See case https://github.com/DataDog/dd-trace-py/issues/353\n        if span.resource == SPAN_NAME:\n            resource = endpoint or code\n            span.resource = compat.to_unicode(resource).lower()\n\n        span.set_tag(http.URL, compat.to_unicode(url))\n        span.set_tag(http.STATUS_CODE, code)\n        span.set_tag(http.METHOD, method)\n        span.finish()\n\n\ndef _set_error_on_span(span, exception):\n    # The 3 next lines might not be strictly required, since `set_traceback`\n    # also get the exception from the sys.exc_info (and fill the error meta).\n    # Since we aren't sure it always work/for insuring no BC break, keep\n    # these lines which get overridden anyway.\n    span.set_tag(errors.ERROR_TYPE, type(exception))\n    span.set_tag(errors.ERROR_MSG, exception)\n    # The provided `exception` object doesn't have a stack trace attached,\n    # so attach the stack trace with `set_traceback`.\n    span.set_traceback()\n\n\ndef _patch_render(tracer):\n    \"\"\" patch flask's render template methods with the given tracer. \"\"\"\n    # fall back to patching  global method\n    _render = flask.templating._render\n\n    # If the method has already been patched and we're patching again then\n    # we have to patch again with the new tracer reference.\n    if hasattr(_render, \"__dd_orig\"):\n        _render = getattr(_render, \"__dd_orig\")\n\n    def _traced_render(template, context, app):\n        with tracer.trace('flask.template', span_type=SpanTypes.TEMPLATE) as span:\n            span.set_tag('flask.template', template.name or 'string')\n            return _render(template, context, app)\n\n    setattr(_traced_render, \"__dd_orig\", _render)\n    flask.templating._render = _traced_render\n\n\ndef _signals_exist(names):\n    \"\"\" Return true if all of the given signals exist in this version of flask.\n    \"\"\"\n    return all(getattr(signals, n, False) for n in names)\n\n\n_blinker_not_installed_msg = (\n    'please install blinker to use flask signals. '\n    'http://flask.pocoo.org/docs/0.11/signals/'\n)\n", "path": "ddtrace/contrib/flask/middleware.py"}], "after_files": [{"content": "from ... import compat\nfrom ...ext import SpanTypes, http, errors\nfrom ...internal.logger import get_logger\nfrom ...propagation.http import HTTPPropagator\nfrom ...utils.deprecation import deprecated\nfrom ddtrace.http import store_request_headers\nfrom ddtrace import config\n\nimport flask.templating\nfrom flask import g, request, signals\n\n\nlog = get_logger(__name__)\n\n\nSPAN_NAME = 'flask.request'\n\n\nclass TraceMiddleware(object):\n\n    @deprecated(message='Use patching instead (see the docs).', version='1.0.0')\n    def __init__(self, app, tracer, service='flask', use_signals=True, distributed_tracing=False):\n        self.app = app\n        log.debug('flask: initializing trace middleware')\n\n        # Attach settings to the inner application middleware. This is required if double\n        # instrumentation happens (i.e. `ddtrace-run` with `TraceMiddleware`). In that\n        # case, `ddtrace-run` instruments the application, but then users code is unable\n        # to update settings such as `distributed_tracing` flag. This step can be removed\n        # when the `Config` object is used\n        self.app._tracer = tracer\n        self.app._service = service\n        self.app._use_distributed_tracing = distributed_tracing\n        self.use_signals = use_signals\n\n        # safe-guard to avoid double instrumentation\n        if getattr(app, '__dd_instrumentation', False):\n            return\n        setattr(app, '__dd_instrumentation', True)\n\n        # Install hooks which time requests.\n        self.app.before_request(self._before_request)\n        self.app.after_request(self._after_request)\n        self.app.teardown_request(self._teardown_request)\n\n        # Add exception handling signals. This will annotate exceptions that\n        # are caught and handled in custom user code.\n        # See https://github.com/DataDog/dd-trace-py/issues/390\n        if use_signals and not signals.signals_available:\n            log.debug(_blinker_not_installed_msg)\n        self.use_signals = use_signals and signals.signals_available\n        timing_signals = {\n            'got_request_exception': self._request_exception,\n        }\n        self._receivers = []\n        if self.use_signals and _signals_exist(timing_signals):\n            self._connect(timing_signals)\n\n        _patch_render(tracer)\n\n    def _connect(self, signal_to_handler):\n        connected = True\n        for name, handler in signal_to_handler.items():\n            s = getattr(signals, name, None)\n            if not s:\n                connected = False\n                log.warning('trying to instrument missing signal %s', name)\n                continue\n            # we should connect to the signal without using weak references\n            # otherwise they will be garbage collected and our handlers\n            # will be disconnected after the first call; for more details check:\n            # https://github.com/jek/blinker/blob/207446f2d97/blinker/base.py#L106-L108\n            s.connect(handler, sender=self.app, weak=False)\n            self._receivers.append(handler)\n        return connected\n\n    def _before_request(self):\n        \"\"\" Starts tracing the current request and stores it in the global\n            request object.\n        \"\"\"\n        self._start_span()\n\n    def _after_request(self, response):\n        \"\"\" Runs after the server can process a response. \"\"\"\n        try:\n            self._process_response(response)\n        except Exception:\n            log.debug('flask: error tracing response', exc_info=True)\n        return response\n\n    def _teardown_request(self, exception):\n        \"\"\" Runs at the end of a request. If there's an unhandled exception, it\n            will be passed in.\n        \"\"\"\n        # when we teardown the span, ensure we have a clean slate.\n        span = getattr(g, 'flask_datadog_span', None)\n        setattr(g, 'flask_datadog_span', None)\n        if not span:\n            return\n\n        try:\n            self._finish_span(span, exception=exception)\n        except Exception:\n            log.debug('flask: error finishing span', exc_info=True)\n\n    def _start_span(self):\n        if self.app._use_distributed_tracing:\n            propagator = HTTPPropagator()\n            context = propagator.extract(request.headers)\n            # Only need to active the new context if something was propagated\n            if context.trace_id:\n                self.app._tracer.context_provider.activate(context)\n        try:\n            g.flask_datadog_span = self.app._tracer.trace(\n                SPAN_NAME,\n                service=self.app._service,\n                span_type=SpanTypes.WEB,\n            )\n        except Exception:\n            log.debug('flask: error tracing request', exc_info=True)\n\n    def _process_response(self, response):\n        span = getattr(g, 'flask_datadog_span', None)\n        if not (span and span.sampled):\n            return\n\n        code = response.status_code if response else ''\n        span.set_tag(http.STATUS_CODE, code)\n\n    def _request_exception(self, *args, **kwargs):\n        exception = kwargs.get('exception', None)\n        span = getattr(g, 'flask_datadog_span', None)\n        if span and exception:\n            _set_error_on_span(span, exception)\n\n    def _finish_span(self, span, exception=None):\n        if not span or not span.sampled:\n            return\n\n        code = span.get_tag(http.STATUS_CODE) or 0\n        try:\n            code = int(code)\n        except Exception:\n            code = 0\n\n        if exception:\n            # if the request has already had a code set, don't override it.\n            code = code or 500\n            _set_error_on_span(span, exception)\n\n        # the endpoint that matched the request is None if an exception\n        # happened so we fallback to a common resource\n        span.error = 0 if code < 500 else 1\n\n        # the request isn't guaranteed to exist here, so only use it carefully.\n        method = ''\n        endpoint = ''\n        url = ''\n        if request:\n            store_request_headers(request.headers, span, config.flask)\n            method = request.method\n            endpoint = request.endpoint or code\n            url = request.base_url or ''\n\n        # Let users specify their own resource in middleware if they so desire.\n        # See case https://github.com/DataDog/dd-trace-py/issues/353\n        if span.resource == SPAN_NAME:\n            resource = endpoint or code\n            span.resource = compat.to_unicode(resource).lower()\n\n        span.set_tag(http.URL, compat.to_unicode(url))\n        span.set_tag(http.STATUS_CODE, code)\n        span.set_tag(http.METHOD, method)\n        span.finish()\n\n\ndef _set_error_on_span(span, exception):\n    # The 3 next lines might not be strictly required, since `set_traceback`\n    # also get the exception from the sys.exc_info (and fill the error meta).\n    # Since we aren't sure it always work/for insuring no BC break, keep\n    # these lines which get overridden anyway.\n    span.set_tag(errors.ERROR_TYPE, type(exception))\n    span.set_tag(errors.ERROR_MSG, exception)\n    # The provided `exception` object doesn't have a stack trace attached,\n    # so attach the stack trace with `set_traceback`.\n    span.set_traceback()\n\n\ndef _patch_render(tracer):\n    \"\"\" patch flask's render template methods with the given tracer. \"\"\"\n    # fall back to patching  global method\n    _render = flask.templating._render\n\n    # If the method has already been patched and we're patching again then\n    # we have to patch again with the new tracer reference.\n    if hasattr(_render, \"__dd_orig\"):\n        _render = getattr(_render, \"__dd_orig\")\n\n    def _traced_render(template, context, app):\n        with tracer.trace('flask.template', span_type=SpanTypes.TEMPLATE) as span:\n            span.set_tag('flask.template', template.name or 'string')\n            return _render(template, context, app)\n\n    setattr(_traced_render, \"__dd_orig\", _render)\n    flask.templating._render = _traced_render\n\n\ndef _signals_exist(names):\n    \"\"\" Return true if all of the given signals exist in this version of flask.\n    \"\"\"\n    return all(getattr(signals, n, False) for n in names)\n\n\n_blinker_not_installed_msg = (\n    'please install blinker to use flask signals. '\n    'http://flask.pocoo.org/docs/0.11/signals/'\n)\n", "path": "ddtrace/contrib/flask/middleware.py"}]}