Using InMemorySpanExporter for wsgi/flask tests

ext/opentelemetry-ext-flask/tests/test_flask_integration.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import unittest
-from unittest import mock
 
 from flask import Flask
 from werkzeug.test import Client
@@ -22,20 +21,14 @@
 import opentelemetry.ext.flask as otel_flask
 from opentelemetry import trace as trace_api
 from opentelemetry.ext.testutil.wsgitestutil import WsgiTestBase
+from opentelemetry.sdk.trace import MAX_NUM_ATTRIBUTES
+from opentelemetry.sdk.util import BoundedDict
 
 
 class TestFlaskIntegration(WsgiTestBase):
     def setUp(self):
         super().setUp()
 
-        self.span_attrs = {}
-
-        def setspanattr(key, value):
-            self.assertIsInstance(key, str)
-            self.span_attrs[key] = value
-
-        self.span.set_attribute = setspanattr
-
         self.app = Flask(__name__)
 
         def hello_endpoint(helloid):
@@ -49,15 +42,9 @@ def hello_endpoint(helloid):
         self.client = Client(self.app, BaseResponse)
 
     def test_simple(self):
-        resp = self.client.get("/hello/123")
-        self.assertEqual(200, resp.status_code)
-        self.assertEqual([b"Hello: 123"], list(resp.response))
-
-        self.start_span.assert_called_with(
-            "hello_endpoint",
-            trace_api.INVALID_SPAN_CONTEXT,
-            kind=trace_api.SpanKind.SERVER,
-            attributes={
+        expected_attrs = BoundedDict.from_map(
+            MAX_NUM_ATTRIBUTES,
+            {
                 "component": "http",
                 "http.method": "GET",
                 "http.server_name": "localhost",
@@ -67,27 +54,23 @@ def test_simple(self):
                 "http.target": "/hello/123",
                 "http.flavor": "1.1",
                 "http.route": "/hello/<int:helloid>",
+                "http.status_text": "OK",
+                "http.status_code": 200,
             },
-            start_time=mock.ANY,
-        )
-
-        # TODO: Change this test to use the SDK, as mocking becomes painful
-
-        self.assertEqual(
-            self.span_attrs,
-            {"http.status_code": 200, "http.status_text": "OK"},
         )
+        resp = self.client.get("/hello/123")
+        self.assertEqual(200, resp.status_code)
+        self.assertEqual([b"Hello: 123"], list(resp.response))
+        span_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(span_list), 1)
+        self.assertEqual(span_list[0].name, "hello_endpoint")
+        self.assertEqual(span_list[0].kind, trace_api.SpanKind.SERVER)
+        self.assertEqual(span_list[0].attributes, expected_attrs)
 
     def test_404(self):
-        resp = self.client.post("/bye")
-        self.assertEqual(404, resp.status_code)
-        resp.close()
-
-        self.start_span.assert_called_with(
-            "/bye",
-            trace_api.INVALID_SPAN_CONTEXT,
-            kind=trace_api.SpanKind.SERVER,
-            attributes={
+        expected_attrs = BoundedDict.from_map(
+            MAX_NUM_ATTRIBUTES,
+            {
                 "component": "http",
                 "http.method": "POST",
                 "http.server_name": "localhost",
@@ -96,29 +79,23 @@ def test_404(self):
                 "http.host": "localhost",
                 "http.target": "/bye",
                 "http.flavor": "1.1",
+                "http.status_text": "NOT FOUND",
+                "http.status_code": 404,
             },
-            start_time=mock.ANY,
-        )
-
-        # Nope, this uses Tracer.use_span(end_on_exit)
-        #  self.assertEqual(1, self.span.end.call_count)
-        # TODO: Change this test to use the SDK, as mocking becomes painful
-
-        self.assertEqual(
-            self.span_attrs,
-            {"http.status_code": 404, "http.status_text": "NOT FOUND"},
         )
-
-    def test_internal_error(self):
-        resp = self.client.get("/hello/500")
-        self.assertEqual(500, resp.status_code)
+        resp = self.client.post("/bye")
+        self.assertEqual(404, resp.status_code)
         resp.close()
+        span_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(span_list), 1)
+        self.assertEqual(span_list[0].name, "/bye")
+        self.assertEqual(span_list[0].kind, trace_api.SpanKind.SERVER)
+        self.assertEqual(span_list[0].attributes, expected_attrs)
 
-        self.start_span.assert_called_with(
-            "hello_endpoint",
-            trace_api.INVALID_SPAN_CONTEXT,
-            kind=trace_api.SpanKind.SERVER,
-            attributes={
+    def test_internal_error(self):
+        expected_attrs = BoundedDict.from_map(
+            MAX_NUM_ATTRIBUTES,
+            {
                 "component": "http",
                 "http.method": "GET",
                 "http.server_name": "localhost",
@@ -128,21 +105,18 @@ def test_internal_error(self):
                 "http.target": "/hello/500",
                 "http.flavor": "1.1",
                 "http.route": "/hello/<int:helloid>",
-            },
-            start_time=mock.ANY,
-        )
-
-        # Nope, this uses Tracer.use_span(end_on_exit)
-        #  self.assertEqual(1, self.span.end.call_count)
-        # TODO: Change this test to use the SDK, as mocking becomes painful
-
-        self.assertEqual(
-            self.span_attrs,
-            {
-                "http.status_code": 500,
                 "http.status_text": "INTERNAL SERVER ERROR",
+                "http.status_code": 500,
             },
         )
+        resp = self.client.get("/hello/500")
+        self.assertEqual(500, resp.status_code)
+        resp.close()
+        span_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(span_list), 1)
+        self.assertEqual(span_list[0].name, "hello_endpoint")
+        self.assertEqual(span_list[0].kind, trace_api.SpanKind.SERVER)
+        self.assertEqual(span_list[0].attributes, expected_attrs)
 
 
 if __name__ == "__main__":

ext/opentelemetry-ext-testutil/src/opentelemetry/ext/testutil/wsgitestutil.py

@@ -1,23 +1,26 @@
 import io
 import unittest
-import unittest.mock as mock
 import wsgiref.util as wsgiref_util
 
 from opentelemetry import trace as trace_api
+from opentelemetry.sdk.trace import Tracer, export
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import (
+    InMemorySpanExporter,
+)
 
 
 class WsgiTestBase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        trace_api.set_preferred_tracer_implementation(lambda T: Tracer())
+
     def setUp(self):
         tracer = trace_api.tracer()
-        self.span = mock.create_autospec(trace_api.Span, spec_set=True)
-        self.start_span_patcher = mock.patch.object(
-            tracer,
-            "start_span",
-            autospec=True,
-            spec_set=True,
-            return_value=self.span,
-        )
-        self.start_span = self.start_span_patcher.start()
+
+        self.memory_exporter = InMemorySpanExporter()
+        span_processor = export.SimpleExportSpanProcessor(self.memory_exporter)
+        tracer.add_span_processor(span_processor)
+
         self.write_buffer = io.BytesIO()
         self.write = self.write_buffer.write
 
@@ -28,9 +31,6 @@ def setUp(self):
         self.response_headers = None
         self.exc_info = None
 
-    def tearDown(self):
-        self.start_span_patcher.stop()
-
     def start_response(self, status, response_headers, exc_info=None):
         self.status = status
         self.response_headers = response_headers

ext/opentelemetry-ext-wsgi/tests/test_wsgi_middleware.py

@@ -21,6 +21,8 @@
 import opentelemetry.ext.wsgi as otel_wsgi
 from opentelemetry import trace as trace_api
 from opentelemetry.ext.testutil.wsgitestutil import WsgiTestBase
+from opentelemetry.sdk.trace import MAX_NUM_ATTRIBUTES
+from opentelemetry.sdk.util import BoundedDict
 
 
 class Response:
@@ -78,10 +80,8 @@ def validate_response(self, response, error=None):
         while True:
             try:
                 value = next(response)
-                self.assertEqual(0, self.span.end.call_count)
                 self.assertEqual(value, b"*")
             except StopIteration:
-                self.span.end.assert_called_once_with()
                 break
 
         self.assertEqual(self.status, "200 OK")
@@ -95,21 +95,27 @@ def validate_response(self, response, error=None):
         else:
             self.assertIsNone(self.exc_info)
 
-        # Verify that start_span has been called
-        self.start_span.assert_called_with(
-            "/",
-            trace_api.INVALID_SPAN_CONTEXT,
-            kind=trace_api.SpanKind.SERVER,
-            attributes={
-                "component": "http",
-                "http.method": "GET",
-                "http.server_name": "127.0.0.1",
-                "http.scheme": "http",
-                "host.port": 80,
-                "http.host": "127.0.0.1",
-                "http.flavor": "1.0",
-                "http.url": "http://127.0.0.1/",
-            },
+        span_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(span_list), 1)
+        self.assertEqual(span_list[0].name, "/")
+        self.assertEqual(span_list[0].kind, trace_api.SpanKind.SERVER)
+        self.assertEqual(
+            span_list[0].attributes,
+            BoundedDict.from_map(
+                MAX_NUM_ATTRIBUTES,
+                {
+                    "component": "http",
+                    "http.method": "GET",
+                    "http.server_name": "127.0.0.1",
+                    "http.scheme": "http",
+                    "host.port": 80,
+                    "http.host": "127.0.0.1",
+                    "http.flavor": "1.0",
+                    "http.url": "http://127.0.0.1/",
+                    "http.status_text": "OK",
+                    "http.status_code": 200,
+                },
+            ),
         )
 
     def test_basic_wsgi_call(self):

tox.ini

@@ -64,6 +64,7 @@ commands_pre =
   ext: pip install {toxinidir}/opentelemetry-api
   wsgi,flask: pip install {toxinidir}/ext/opentelemetry-ext-testutil
   wsgi,flask: pip install {toxinidir}/ext/opentelemetry-ext-wsgi
+  wsgi,flask: pip install {toxinidir}/opentelemetry-sdk
   flask: pip install {toxinidir}/ext/opentelemetry-ext-flask[test]
   pymongo: pip install {toxinidir}/ext/opentelemetry-ext-pymongo
   http-requests: pip install {toxinidir}/ext/opentelemetry-ext-http-requests