format

Author: matthewgrossman

instrumentation/opentelemetry-instrumentation-flask/src/opentelemetry/instrumentation/flask/__init__.py

@@ -305,8 +305,8 @@ def _wrapped_app(wrapped_app_environ, start_response):
         wrapped_app_environ[_ENVIRON_STARTTIME_KEY] = time_ns()
         start = default_timer()
         attributes = otel_wsgi.collect_request_attributes(wrapped_app_environ)
-        active_requests_count_attrs = (
-            otel_wsgi._parse_active_request_count_attrs(attributes)
+        active_requests_count_attrs = otel_wsgi._parse_active_request_count_attrs(
+            attributes
         )
         duration_attrs = otel_wsgi._parse_duration_attrs(attributes)
         active_requests_counter.add(1, active_requests_count_attrs)
@@ -326,20 +326,15 @@ def _start_response(status, response_headers, *args, **kwargs):
                     )
 
                 if span:
-                    otel_wsgi.add_response_attributes(
-                        span, status, response_headers
-                    )
+                    otel_wsgi.add_response_attributes(span, status, response_headers)
                     status_code = otel_wsgi._parse_status_code(status)
                     if status_code is not None:
-                        duration_attrs[
-                            SpanAttributes.HTTP_STATUS_CODE
-                        ] = status_code
-                    if (
-                        span.is_recording()
-                        and span.kind == trace.SpanKind.SERVER
-                    ):
-                        custom_attributes = otel_wsgi.collect_custom_response_headers_attributes(
-                            response_headers
+                        duration_attrs[SpanAttributes.HTTP_STATUS_CODE] = status_code
+                    if span.is_recording() and span.kind == trace.SpanKind.SERVER:
+                        custom_attributes = (
+                            otel_wsgi.collect_custom_response_headers_attributes(
+                                response_headers
+                            )
                         )
                         if len(custom_attributes) > 0:
                             span.set_attributes(custom_attributes)
@@ -387,22 +382,16 @@ def _before_request():
             request_hook(span, flask_request_environ)
 
         if span.is_recording():
-            attributes = otel_wsgi.collect_request_attributes(
-                flask_request_environ
-            )
+            attributes = otel_wsgi.collect_request_attributes(flask_request_environ)
             if flask.request.url_rule:
                 # For 404 that result from no route found, etc, we
                 # don't have a url_rule.
-                attributes[
-                    SpanAttributes.HTTP_ROUTE
-                ] = flask.request.url_rule.rule
+                attributes[SpanAttributes.HTTP_ROUTE] = flask.request.url_rule.rule
             for key, value in attributes.items():
                 span.set_attribute(key, value)
             if span.is_recording() and span.kind == trace.SpanKind.SERVER:
-                custom_attributes = (
-                    otel_wsgi.collect_custom_request_headers_attributes(
-                        flask_request_environ
-                    )
+                custom_attributes = otel_wsgi.collect_custom_request_headers_attributes(
+                    flask_request_environ
                 )
                 if len(custom_attributes) > 0:
                     span.set_attributes(custom_attributes)
@@ -422,10 +411,7 @@ def _before_request():
             if flask and flask.request:
                 if commenter_options.get("framework", True):
                     flask_info["framework"] = f"flask:{flask.__version__}"
-                if (
-                    commenter_options.get("controller", True)
-                    and flask.request.endpoint
-                ):
+                if commenter_options.get("controller", True) and flask.request.endpoint:
                     flask_info["controller"] = flask.request.endpoint
                 if (
                     commenter_options.get("route", True)
@@ -451,9 +437,7 @@ def _teardown_request(exc):
 
         activation = flask.request.environ.get(_ENVIRON_ACTIVATION_KEY)
 
-        original_reqctx_ref = flask.request.environ.get(
-            _ENVIRON_REQCTX_REF_KEY
-        )
+        original_reqctx_ref = flask.request.environ.get(_ENVIRON_REQCTX_REF_KEY)
         current_reqctx_ref = _request_ctx_ref()
         if not activation or original_reqctx_ref != current_reqctx_ref:
             # This request didn't start a span, maybe because it was created in
@@ -470,9 +454,7 @@ def _teardown_request(exc):
         if exc is None:
             activation.__exit__(None, None, None)
         else:
-            activation.__exit__(
-                type(exc), exc, getattr(exc, "__traceback__", None)
-            )
+            activation.__exit__(type(exc), exc, getattr(exc, "__traceback__", None))
 
         if flask.request.environ.get(_ENVIRON_TOKEN, None):
             context.detach(flask.request.environ.get(_ENVIRON_TOKEN))
@@ -495,9 +477,7 @@ def __init__(self, *args, **kwargs):
         self._original_wsgi_app = self.wsgi_app
         self._is_instrumented_by_opentelemetry = True
 
-        meter = get_meter(
-            __name__, __version__, _InstrumentedFlask._meter_provider
-        )
+        meter = get_meter(__name__, __version__, _InstrumentedFlask._meter_provider)
         duration_histogram = meter.create_histogram(
             name=MetricInstruments.HTTP_SERVER_DURATION,
             unit="ms",
@@ -623,9 +603,7 @@ def instrument_app(
                 tracer,
                 excluded_urls=excluded_urls,
                 enable_commenter=enable_commenter,
-                commenter_options=commenter_options
-                if commenter_options
-                else {},
+                commenter_options=commenter_options if commenter_options else {},
             )
             app._before_request = _before_request
             app.before_request(_before_request)
@@ -653,6 +631,5 @@ def uninstrument_app(app):
             app._is_instrumented_by_opentelemetry = False
         else:
             _logger.warning(
-                "Attempting to uninstrument Flask "
-                "app while already uninstrumented"
+                "Attempting to uninstrument Flask " "app while already uninstrumented"
             )

instrumentation/opentelemetry-instrumentation-flask/tests/base_test.py

@@ -77,9 +77,7 @@ def _custom_response_headers():
         resp = flask.Response("test response")
         resp.headers["content-type"] = "text/plain; charset=utf-8"
         resp.headers["content-length"] = "13"
-        resp.headers[
-            "my-custom-header"
-        ] = "my-custom-value-1,my-custom-header-2"
+        resp.headers["my-custom-header"] = "my-custom-value-1,my-custom-header-2"
         resp.headers[
             "my-custom-regex-header-1"
         ] = "my-custom-regex-value-1,my-custom-regex-value-2"
@@ -104,9 +102,7 @@ def excluded2_endpoint():
         self.app.route("/excluded/<int:helloid>")(self._hello_endpoint)
         self.app.route("/excluded")(excluded_endpoint)
         self.app.route("/excluded2")(excluded2_endpoint)
-        self.app.route("/test_custom_response_headers")(
-            self._custom_response_headers
-        )
+        self.app.route("/test_custom_response_headers")(self._custom_response_headers)
 
         # pylint: disable=attribute-defined-outside-init
         self.client = Client(self.app, Response)