Merge pull request #91 from DataDog/matt/services

Matt/services

Author: clutchski

ddtrace/api.py

@@ -23,14 +23,21 @@ def send_traces(self, traces):
         self.send_spans(spans)
 
     def send_spans(self, spans):
+        if not spans:
+            return
         start = time.time()
         data = ddtrace.encoding.encode_spans(spans)
         self._send_span_data(data)
         log.debug("reported %d spans in %.5fs", len(spans), time.time() - start)
 
     def send_services(self, services):
+        if not services:
+            return
         log.debug("Reporting %d services", len(services))
-        data = ddtrace.encoding.encode_services(services)
+        s = {}
+        for service in services:
+            s.update(service)
+        data = ddtrace.encoding.encode_services(s)
         self._put("/services", data, self.headers)
 
     def _send_span_data(self, data):

ddtrace/tracer.py

@@ -46,6 +46,10 @@ def __init__(self):
         # in production.
         self.debug_logging = False
 
+        # a buffer for service info so we dont' perpetually send the same
+        # things.
+        self._services = {}
+
     def configure(self, enabled=None, hostname=None, port=None, sampler=None):
         """Configure an existing Tracer the easy way.
 
@@ -169,20 +173,28 @@ def set_service_info(self, service, app, app_type):
         :param str app: the off the shelf name of the application (e.g. rails, postgres, custom-app)
         :param str app_type: the type of the application (e.g. db, web)
         """
-
-        services = {
-            service : {
-                "app" : app,
-                "app_type": app_type,
-            }
-        }
-
-        if self.debug_logging:
-            log.debug("set_service_info: service:%s app:%s type:%s",
-                service, app, app_type)
-
-        if self.enabled and self.writer:
-            self.writer.write(services=services)
+        try:
+            # don't bother sending the same services over and over.
+            info = (service, app, app_type)
+            if self._services.get(service, None) == info:
+                return
+            self._services[service] = info
+
+            if self.debug_logging:
+                log.debug("set_service_info: service:%s app:%s type:%s", service, app, app_type)
+
+            # If we had changes, send them to the writer.
+            if self.enabled and self.writer:
+
+                # translate to the form the server understands.
+                services = {}
+                for service, app, app_type in self._services.values():
+                    services[service] = {"app" : app, "app_type" : app_type}
+
+                # queue them for writes.
+                self.writer.write(services=services)
+        except Exception:
+            log.exception("error setting service info")
 
     def wrap(self, name=None, service=None, resource=None, span_type=None):
         """A decorator used to trace an entire function.

tests/test_compat.py

@@ -12,48 +12,49 @@
 #   results for each Python version rather than writing a generic "works for both" test suite
 if PY2:
     class TestCompatPY2(object):
+
         def test_to_unicode_string(self):
-            """ Calling `compat.to_unicode` on a non-unicode string """
+            # Calling `compat.to_unicode` on a non-unicode string
             res = to_unicode('test')
             eq_(type(res), unicode)
             eq_(res, 'test')
 
         def test_to_unicode_unicode_encoded(self):
-            """ Calling `compat.to_unicode` on a unicode encoded string """
+            # Calling `compat.to_unicode` on a unicode encoded string
             res = to_unicode('\xc3\xbf')
             eq_(type(res), unicode)
             eq_(res, u'ÿ')
 
         def test_to_unicode_unicode_double_decode(self):
-            """ Calling `compat.to_unicode` on a unicode decoded string """
+            # Calling `compat.to_unicode` on a unicode decoded string
             # This represents the double-decode issue, which can cause a `UnicodeEncodeError`
             #   `'\xc3\xbf'.decode('utf-8').decode('utf-8')`
             res = to_unicode('\xc3\xbf'.decode('utf-8'))
             eq_(type(res), unicode)
             eq_(res, u'ÿ')
 
         def test_to_unicode_unicode_string(self):
-            """ Calling `compat.to_unicode` on a unicode string """
+            # Calling `compat.to_unicode` on a unicode string
             res = to_unicode(u'ÿ')
             eq_(type(res), unicode)
             eq_(res, u'ÿ')
 
         def test_to_unicode_bytearray(self):
-            """ Calling `compat.to_unicode` with a `bytearray` containing unicode """
+            # Calling `compat.to_unicode` with a `bytearray` containing unicode
             res = to_unicode(bytearray('\xc3\xbf'))
             eq_(type(res), unicode)
             eq_(res, u'ÿ')
 
         def test_to_unicode_bytearray_double_decode(self):
-            """ Calling `compat.to_unicode` with an already decoded `bytearray` """
+            #  Calling `compat.to_unicode` with an already decoded `bytearray`
             # This represents the double-decode issue, which can cause a `UnicodeEncodeError`
             #   `bytearray('\xc3\xbf').decode('utf-8').decode('utf-8')`
             res = to_unicode(bytearray('\xc3\xbf').decode('utf-8'))
             eq_(type(res), unicode)
             eq_(res, u'ÿ')
 
         def test_to_unicode_non_string(self):
-            """ Calling `compat.to_unicode` on non-string types """
+            #  Calling `compat.to_unicode` on non-string types
             eq_(to_unicode(1), u'1')
             eq_(to_unicode(True), u'True')
             eq_(to_unicode(None), u'None')
@@ -62,31 +63,31 @@ def test_to_unicode_non_string(self):
 else:
     class TestCompatPY3(object):
         def test_to_unicode_string(self):
-            """ Calling `compat.to_unicode` on a non-unicode string """
+            # Calling `compat.to_unicode` on a non-unicode string
             res = to_unicode('test')
             eq_(type(res), str)
             eq_(res, 'test')
 
         def test_to_unicode_unicode_encoded(self):
-            """ Calling `compat.to_unicode` on a unicode encoded string """
+            # Calling `compat.to_unicode` on a unicode encoded string
             res = to_unicode('\xff')
             eq_(type(res), str)
             eq_(res, 'ÿ')
 
         def test_to_unicode_unicode_string(self):
-            """ Calling `compat.to_unicode` on a unicode string """
+            # Calling `compat.to_unicode` on a unicode string
             res = to_unicode('ÿ')
             eq_(type(res), str)
             eq_(res, 'ÿ')
 
         def test_to_unicode_bytearray(self):
-            """ Calling `compat.to_unicode` with a `bytearray` containing unicode """
+            # Calling `compat.to_unicode` with a `bytearray` containing unicode """
             res = to_unicode(bytearray('\xff', 'utf-8'))
             eq_(type(res), str)
             eq_(res, 'ÿ')
 
         def test_to_unicode_non_string(self):
-            """ Calling `compat.to_unicode` on non-string types """
+            # Calling `compat.to_unicode` on non-string types
             eq_(to_unicode(1), '1')
             eq_(to_unicode(True), 'True')
             eq_(to_unicode(None), 'None')

tests/test_sampler.py

@@ -117,7 +117,7 @@ def test_concurrency(self):
         tracer = Tracer()
         tracer.writer = writer
 
-        total_time = 10
+        total_time = 3
         concurrency = 100
         end_time = time.time() + total_time
 

tox.ini

@@ -21,6 +21,7 @@ envlist =
     {py27,py34}-pymongo{30,31,32,33}-mongoengine
     {py27,py34}-requests{208,209,210,211}
     {py27,py34}-sqlalchemy{10,11}-psycopg2
+    {py27,py34}-redis
     {py27,py34}-all
 
 [testenv]
@@ -103,6 +104,7 @@ commands =
     {py27,py34}-pymongo{30,31,32,33}: nosetests {posargs} tests/contrib/pymongo/
     {py27,py34}-mongoengine: nosetests {posargs} tests/contrib/mongoengine
     {py27,py34}-psycopg2: nosetests {posargs} tests/contrib/psycopg
+    {py27,py34}-redis: nosetests {posargs} tests/contrib/redis
     {py27,py34}-requests{200,208,209,210,211}: nosetests {posargs} tests/contrib/requests
     {py27,py34}-sqlalchemy{10,11}: nosetests {posargs} tests/contrib/sqlalchemy