flake-cache: test the tracer with a wrong client connection

Author: Emanuele Palazzetti

tests/contrib/flask_cache/test.py

@@ -3,11 +3,16 @@
 
 from nose.tools import eq_, ok_
 
+# project
+from ddtrace.ext import net
 from ddtrace.tracer import Tracer
 from ddtrace.contrib.flask_cache import get_traced_cache
+from ddtrace.contrib.flask_cache.tracers import TYPE, CACHE_BACKEND
 
+# 3rd party
 from flask import Flask
 
+# testing
 from ...test_tracer import DummyWriter
 
 
@@ -241,3 +246,45 @@ def test_simple_cache_set_many(self):
         eq_(span.meta["flask_cache.backend"], "simple")
         ok_("first_complex_op" in span.meta["flask_cache.key"])
         ok_("second_complex_op" in span.meta["flask_cache.key"])
+
+    def test_default_span_tags(self):
+        # create the TracedCache instance for a Flask app
+        tracer = Tracer()
+        Cache = get_traced_cache(tracer, service=self.SERVICE)
+        app = Flask(__name__)
+        cache = Cache(app, config={"CACHE_TYPE": "simple"})
+        # test tags and attributes
+        with cache._TracedCache__trace("flask_cache.cmd") as span:
+            eq_(span.service, cache._datadog_service)
+            eq_(span.span_type, TYPE)
+            eq_(span.meta[CACHE_BACKEND], "simple")
+            ok_(net.TARGET_HOST not in span.meta)
+            ok_(net.TARGET_PORT not in span.meta)
+
+    def test_default_span_tags_for_redis(self):
+        # create the TracedCache instance for a Flask app
+        tracer = Tracer()
+        Cache = get_traced_cache(tracer, service=self.SERVICE)
+        app = Flask(__name__)
+        cache = Cache(app, config={"CACHE_TYPE": "redis"})
+        # test tags and attributes
+        with cache._TracedCache__trace("flask_cache.cmd") as span:
+            eq_(span.service, cache._datadog_service)
+            eq_(span.span_type, TYPE)
+            eq_(span.meta[CACHE_BACKEND], "redis")
+            eq_(span.meta[net.TARGET_HOST], 'localhost')
+            eq_(span.meta[net.TARGET_PORT], '6379')
+
+    def test_default_span_tags_memcached(self):
+        # create the TracedCache instance for a Flask app
+        tracer = Tracer()
+        Cache = get_traced_cache(tracer, service=self.SERVICE)
+        app = Flask(__name__)
+        cache = Cache(app, config={"CACHE_TYPE": "memcached"})
+        # test tags and attributes
+        with cache._TracedCache__trace("flask_cache.cmd") as span:
+            eq_(span.service, cache._datadog_service)
+            eq_(span.span_type, TYPE)
+            eq_(span.meta[CACHE_BACKEND], "memcached")
+            eq_(span.meta[net.TARGET_HOST], "127.0.0.1")
+            eq_(span.meta[net.TARGET_PORT], "11211")

tests/contrib/flask_cache/test_utils.py

@@ -59,48 +59,6 @@ def test_extract_memcached_multiple_connection_metadata(self):
         }
         eq_(meta, expected_meta)
 
-    def test_default_span_tags(self):
-        # create the TracedCache instance for a Flask app
-        tracer = Tracer()
-        Cache = get_traced_cache(tracer, service=self.SERVICE)
-        app = Flask(__name__)
-        cache = Cache(app, config={"CACHE_TYPE": "simple"})
-        # test tags and attributes
-        with cache._TracedCache__trace("flask_cache.cmd") as span:
-            eq_(span.service, cache._datadog_service)
-            eq_(span.span_type, TYPE)
-            eq_(span.meta[CACHE_BACKEND], "simple")
-            ok_(net.TARGET_HOST not in span.meta)
-            ok_(net.TARGET_PORT not in span.meta)
-
-    def test_default_span_tags_for_redis(self):
-        # create the TracedCache instance for a Flask app
-        tracer = Tracer()
-        Cache = get_traced_cache(tracer, service=self.SERVICE)
-        app = Flask(__name__)
-        cache = Cache(app, config={"CACHE_TYPE": "redis"})
-        # test tags and attributes
-        with cache._TracedCache__trace("flask_cache.cmd") as span:
-            eq_(span.service, cache._datadog_service)
-            eq_(span.span_type, TYPE)
-            eq_(span.meta[CACHE_BACKEND], "redis")
-            eq_(span.meta[net.TARGET_HOST], 'localhost')
-            eq_(span.meta[net.TARGET_PORT], '6379')
-
-    def test_default_span_tags_memcached(self):
-        # create the TracedCache instance for a Flask app
-        tracer = Tracer()
-        Cache = get_traced_cache(tracer, service=self.SERVICE)
-        app = Flask(__name__)
-        cache = Cache(app, config={"CACHE_TYPE": "memcached"})
-        # test tags and attributes
-        with cache._TracedCache__trace("flask_cache.cmd") as span:
-            eq_(span.service, cache._datadog_service)
-            eq_(span.span_type, TYPE)
-            eq_(span.meta[CACHE_BACKEND], "memcached")
-            eq_(span.meta[net.TARGET_HOST], "127.0.0.1")
-            eq_(span.meta[net.TARGET_PORT], "11211")
-
     def test_resource_from_cache_with_prefix(self):
         # create the TracedCache instance for a Flask app
         tracer = Tracer()

tests/contrib/flask_cache/test_wrapper_safety.py

@@ -7,9 +7,11 @@
 from ddtrace.ext import net
 from ddtrace.tracer import Tracer
 from ddtrace.contrib.flask_cache import get_traced_cache
+from ddtrace.contrib.flask_cache.tracers import TYPE, CACHE_BACKEND
 
 # 3rd party
 from flask import Flask
+from redis.exceptions import ConnectionError
 
 # testing
 from ...test_tracer import DummyWriter
@@ -157,3 +159,70 @@ def test_cache_set_many_without_arguments(self):
         eq_(span.name, "flask_cache.cmd")
         eq_(span.span_type, "cache")
         eq_(span.error, 1)
+
+    def test_redis_cache_tracing_with_a_wrong_connection(self):
+        # initialize the dummy writer
+        writer = DummyWriter()
+        tracer = Tracer()
+        tracer.writer = writer
+
+        # create the TracedCache instance for a Flask app
+        Cache = get_traced_cache(tracer, service=self.SERVICE)
+        app = Flask(__name__)
+        config = {
+            "CACHE_TYPE": "redis",
+            "CACHE_REDIS_PORT": 22230,
+        }
+        cache = Cache(app, config=config)
+
+        # use a wrong redis connection
+        with assert_raises(ConnectionError) as ex:
+            cache.get(u"á_complex_operation")
+
+        # ensure that the error is not caused by our tracer
+        ok_("localhost:22230. Connection refused." in ex.exception.args[0])
+        spans = writer.pop()
+        # an error trace must be sent
+        eq_(len(spans), 1)
+        span = spans[0]
+        eq_(span.service, self.SERVICE)
+        eq_(span.resource, "get")
+        eq_(span.name, "flask_cache.cmd")
+        eq_(span.span_type, "cache")
+        eq_(span.meta[CACHE_BACKEND], "redis")
+        eq_(span.meta[net.TARGET_HOST], 'localhost')
+        eq_(span.meta[net.TARGET_PORT], '22230')
+        eq_(span.error, 1)
+
+    def test_memcached_cache_tracing_with_a_wrong_connection(self):
+        # initialize the dummy writer
+        writer = DummyWriter()
+        tracer = Tracer()
+        tracer.writer = writer
+
+        # create the TracedCache instance for a Flask app
+        Cache = get_traced_cache(tracer, service=self.SERVICE)
+        app = Flask(__name__)
+        config = {
+            "CACHE_TYPE": "memcached",
+            "CACHE_MEMCACHED_SERVERS": ['localhost:22230'],
+        }
+        cache = Cache(app, config=config)
+
+        # use a wrong memcached connection
+        # unfortunately, the library doesn't raise an error
+        cache.get(u"á_complex_operation")
+
+        # ensure that the error is not caused by our tracer
+        spans = writer.pop()
+        # an error trace must be sent
+        eq_(len(spans), 1)
+        span = spans[0]
+        eq_(span.service, self.SERVICE)
+        eq_(span.resource, "get")
+        eq_(span.name, "flask_cache.cmd")
+        eq_(span.span_type, "cache")
+        eq_(span.meta[CACHE_BACKEND], "memcached")
+        eq_(span.meta[net.TARGET_HOST], 'localhost')
+        eq_(span.meta[net.TARGET_PORT], '22230')
+        eq_(span.error, 0)