Updates to support OpenTracing v2.0 (#74)

* Updates to support OpenTracing v2.0

* Fixed test requirements for travis

* Moar test dependencies

* Tested in clean/empty python install

* Remove debug remnant

* Don't call finish() on scoped spans

* Update suds instrumentation to use OT 2.0

* Update OT dependencies to GA

* Use OT 2.0 everywhere

* Update examples

Author: pglombardo

example/opentracing_vanilla.py

@@ -3,31 +3,23 @@
 
 import opentracing
 
-import instana
-
 # Loop continuously with a 2 second sleep to generate traces
 while True:
-    entry_span = opentracing.tracer.start_span('universe')
-
-    entry_span.set_tag('http.method', 'GET')
-    entry_span.set_tag('http.url', '/users')
-    entry_span.set_tag('span.kind', 'entry')
-
-    intermediate_span = opentracing.tracer.start_span('nebula', child_of=entry_span)
-    intermediate_span.finish()
-
-    db_span = opentracing.tracer.start_span('black-hole', child_of=entry_span)
-    db_span.set_tag('db.instance', 'users')
-    db_span.set_tag('db.statement', 'SELECT * FROM user_table')
-    db_span.set_tag('db.type', 'mysql')
-    db_span.set_tag('db.user', 'mysql_login')
-    db_span.set_tag('span.kind', 'exit')
-    db_span.finish()
-
-    intermediate_span = opentracing.tracer.start_span('space-dust', child_of=entry_span)
-    intermediate_span.log_kv({'message': 'All seems ok'})
-    intermediate_span.finish()
-
-    entry_span.set_tag('http.status_code', 200)
-    entry_span.finish()
-    time.sleep(2)
+    with opentracing.tracer.start_active_span('universe') as escope:
+        escope.span.set_tag('http.method', 'GET')
+        escope.span.set_tag('http.url', '/users')
+        escope.span.set_tag('span.kind', 'entry')
+
+        with opentracing.tracer.start_active_span('black-hole', child_of=escope.span) as dbscope:
+            dbscope.span.set_tag('db.instance', 'users')
+            dbscope.span.set_tag('db.statement', 'SELECT * FROM user_table')
+            time.sleep(.1)
+            dbscope.span.set_tag('db.type', 'mysql')
+            dbscope.span.set_tag('db.user', 'mysql_login')
+            dbscope.span.set_tag('span.kind', 'exit')
+
+        with opentracing.tracer.start_active_span('space-dust', child_of=escope.span) as iscope:
+            iscope.span.log_kv({'message': 'All seems ok'})
+
+        escope.span.set_tag('http.status_code', 200)
+        time.sleep(.2)

example/simple.py

@@ -16,28 +16,24 @@ def main(argv):
 
 
 def simple():
-    parent_span = ot.tracer.start_span(operation_name="asteroid")
-    parent_span.set_tag(ext.COMPONENT, "Python simple example app")
-    parent_span.set_tag(ext.SPAN_KIND, ext.SPAN_KIND_RPC_SERVER)
-    parent_span.set_tag(ext.PEER_HOSTNAME, "localhost")
-    parent_span.set_tag(ext.HTTP_URL, "/python/simple/one")
-    parent_span.set_tag(ext.HTTP_METHOD, "GET")
-    parent_span.set_tag(ext.HTTP_STATUS_CODE, 200)
-    parent_span.log_kv({"foo": "bar"})
-
-    child_span = ot.tracer.start_span(operation_name="spacedust", child_of=parent_span)
-    child_span.set_tag(ext.SPAN_KIND, ext.SPAN_KIND_RPC_CLIENT)
-    child_span.set_tag(ext.PEER_HOSTNAME, "localhost")
-    child_span.set_tag(ext.HTTP_URL, "/python/simple/two")
-    child_span.set_tag(ext.HTTP_METHOD, "POST")
-    child_span.set_tag(ext.HTTP_STATUS_CODE, 204)
-    child_span.set_baggage_item("someBaggage", "someValue")
-
-    time.sleep(.1)
-    child_span.finish()
-
-    time.sleep(.2)
-    parent_span.finish()
+    with ot.tracer.start_active_span('asteroid') as pscope:
+        pscope.span.set_tag(ext.COMPONENT, "Python simple example app")
+        pscope.span.set_tag(ext.SPAN_KIND, ext.SPAN_KIND_RPC_SERVER)
+        pscope.span.set_tag(ext.PEER_HOSTNAME, "localhost")
+        pscope.span.set_tag(ext.HTTP_URL, "/python/simple/one")
+        pscope.span.set_tag(ext.HTTP_METHOD, "GET")
+        pscope.span.set_tag(ext.HTTP_STATUS_CODE, 200)
+        pscope.span.log_kv({"foo": "bar"})
+        time.sleep(.2)
+
+        with ot.tracer.start_active_span('spacedust', child_of=pscope.span) as cscope:
+            cscope.span.set_tag(ext.SPAN_KIND, ext.SPAN_KIND_RPC_CLIENT)
+            cscope.span.set_tag(ext.PEER_HOSTNAME, "localhost")
+            cscope.span.set_tag(ext.HTTP_URL, "/python/simple/two")
+            cscope.span.set_tag(ext.HTTP_METHOD, "POST")
+            cscope.span.set_tag(ext.HTTP_STATUS_CODE, 204)
+            cscope.span.set_baggage_item("someBaggage", "someValue")
+            time.sleep(.1)
 
 
 if __name__ == "__main__":

instana/helpers.py

@@ -33,10 +33,10 @@ def eum_snippet(trace_id=None, eum_api_key=None, meta={}):
         ids = {}
         ids['meta_kvs'] = ''
 
-        current_ctx = internal_tracer.current_context()
+        parent_span = internal_tracer.active_span
 
-        if trace_id or current_ctx:
-            ids['trace_id'] = trace_id or current_ctx.trace_id
+        if trace_id or parent_span:
+            ids['trace_id'] = trace_id or parent_span.trace_id
         else:
             # No trace_id passed in and tracer doesn't show an active span so
             # return nothing, nada & zip.
@@ -78,10 +78,9 @@ def eum_test_snippet(trace_id=None, eum_api_key=None, meta={}):
         ids = {}
         ids['meta_kvs'] = ''
 
-        current_ctx = internal_tracer.current_context()
-
-        if trace_id or current_ctx:
-            ids['trace_id'] = trace_id or current_ctx.trace_id
+        parent_span = internal_tracer.active_span
+        if trace_id or parent_span:
+            ids['trace_id'] = trace_id or parent_span.trace_id
         else:
             # No trace_id passed in and tracer doesn't show an active span so
             # return nothing, nada & zip.

instana/instrumentation/pep0249.py

@@ -32,73 +32,61 @@ def _collect_kvs(self, span, sql):
             return span
 
     def execute(self, sql, params=None):
-        try:
-            span = None
-            context = internal_tracer.current_context()
+        parent_span = internal_tracer.active_span
 
-            # If we're not tracing, just return
-            if context is None:
-                return self.__wrapped__.execute(sql, params)
+        # If we're not tracing, just return
+        if parent_span is None:
+            return self.__wrapped__.execute(sql, params)
 
-            span = internal_tracer.start_span(self._module_name, child_of=context)
-            span = self._collect_kvs(span, sql)
+        with internal_tracer.start_active_span(self._module_name, child_of=parent_span) as scope:
+            try:
+                self._collect_kvs(scope.span, sql)
 
-            result = self.__wrapped__.execute(sql, params)
-        except Exception as e:
-            if span:
-                span.log_exception(e)
-            raise
-        else:
-            return result
-        finally:
-            if span:
-                span.finish()
+                result = self.__wrapped__.execute(sql, params)
+            except Exception as e:
+                if scope.span:
+                    scope.span.log_exception(e)
+                raise
+            else:
+                return result
 
     def executemany(self, sql, seq_of_parameters):
-        try:
-            span = None
-            context = internal_tracer.current_context()
+        parent_span = internal_tracer.active_span
 
-            # If we're not tracing, just return
-            if context is None:
-                return self.__wrapped__.executemany(sql, seq_of_parameters)
+        # If we're not tracing, just return
+        if parent_span is None:
+            return self.__wrapped__.executemany(sql, seq_of_parameters)
 
-            span = internal_tracer.start_span(self._module_name, child_of=context)
-            span = self._collect_kvs(span, sql)
+        with internal_tracer.start_active_span(self._module_name, child_of=parent_span) as scope:
+            try:
+                self._collect_kvs(scope.span, sql)
 
-            result = self.__wrapped__.executemany(sql, seq_of_parameters)
-        except Exception as e:
-            if span:
-                span.log_exception(e)
-            raise
-        else:
-            return result
-        finally:
-            if span:
-                span.finish()
+                result = self.__wrapped__.executemany(sql, seq_of_parameters)
+            except Exception as e:
+                if scope.span:
+                    scope.span.log_exception(e)
+                raise
+            else:
+                return result
 
     def callproc(self, proc_name, params):
-        try:
-            span = None
-            context = internal_tracer.current_context()
-
-            # If we're not tracing, just return
-            if context is None:
-                return self.__wrapped__.execute(proc_name, params)
-
-            span = internal_tracer.start_span(self._module_name, child_of=context)
-            span = self._collect_kvs(span, proc_name)
-
-            result = self.__wrapped__.callproc(proc_name, params)
-        except Exception as e:
-            if span:
-                span.log_exception(e)
-            raise
-        else:
-            return result
-        finally:
-            if span:
-                span.finish()
+        parent_span = internal_tracer.active_span
+
+        # If we're not tracing, just return
+        if parent_span is None:
+            return self.__wrapped__.execute(proc_name, params)
+
+        with internal_tracer.start_active_span(self._module_name, child_of=parent_span) as scope:
+            try:
+                self._collect_kvs(scope.span, proc_name)
+
+                result = self.__wrapped__.callproc(proc_name, params)
+            except Exception as e:
+                if scope.span:
+                    scope.span.log_exception(e)
+                raise
+            else:
+                return result
 
 
 class ConnectionWrapper(wrapt.ObjectProxy):

instana/instrumentation/sudsjurko.py

@@ -6,8 +6,8 @@
 import opentracing.ext.tags as ext
 import wrapt
 
-from ..tracer import internal_tracer
 from ..log import logger
+from ..tracer import internal_tracer
 
 try:
     import suds # noqa
@@ -19,32 +19,29 @@
 
     @wrapt.patch_function_wrapper('suds.client', class_method)
     def send_with_instana(wrapped, instance, args, kwargs):
-        context = internal_tracer.current_context()
+        parent_span = internal_tracer.active_span
 
         # If we're not tracing, just return
-        if context is None:
+        if parent_span is None:
             return wrapped(*args, **kwargs)
 
-        try:
-            span = internal_tracer.start_span("soap", child_of=context)
-            span.set_tag('soap.action', instance.method.name)
-            span.set_tag(ext.HTTP_URL, instance.method.location)
-            span.set_tag(ext.HTTP_METHOD, 'POST')
-
-            internal_tracer.inject(span.context, opentracing.Format.HTTP_HEADERS,
-                                           instance.options.headers)
-
-            rv = wrapped(*args, **kwargs)
-
-        except Exception as e:
-            span.log_exception(e)
-            span.set_tag(ext.HTTP_STATUS_CODE, 500)
-            raise
-        else:
-            span.set_tag(ext.HTTP_STATUS_CODE, 200)
-            return rv
-        finally:
-            span.finish()
+        with internal_tracer.start_active_span("soap", child_of=parent_span) as scope:
+            try:
+                scope.span.set_tag('soap.action', instance.method.name)
+                scope.span.set_tag(ext.HTTP_URL, instance.method.location)
+                scope.span.set_tag(ext.HTTP_METHOD, 'POST')
+
+                internal_tracer.inject(scope.span.context, opentracing.Format.HTTP_HEADERS, instance.options.headers)
+
+                rv = wrapped(*args, **kwargs)
+
+            except Exception as e:
+                scope.span.log_exception(e)
+                scope.span.set_tag(ext.HTTP_STATUS_CODE, 500)
+                raise
+            else:
+                scope.span.set_tag(ext.HTTP_STATUS_CODE, 200)
+                return rv
 
     logger.debug("Instrumenting suds-jurko")
 except ImportError:

instana/instrumentation/urllib3.py

@@ -1,11 +1,12 @@
 from __future__ import absolute_import
 
+import instana
 import opentracing
 import opentracing.ext.tags as ext
 import wrapt
 
-from ..tracer import internal_tracer
 from ..log import logger
+from ..tracer import internal_tracer
 
 try:
     import urllib3 # noqa
@@ -37,40 +38,36 @@ def collect(instance, args, kwargs):
 
     @wrapt.patch_function_wrapper('urllib3', 'HTTPConnectionPool.urlopen')
     def urlopen_with_instana(wrapped, instance, args, kwargs):
-        context = internal_tracer.current_context()
+        parent_span = internal_tracer.active_span
 
         # If we're not tracing, just return
-        if context is None:
+        if parent_span is None:
             return wrapped(*args, **kwargs)
 
-        try:
-            span = internal_tracer.start_span("urllib3", child_of=context)
-
-            kvs = collect(instance, args, kwargs)
-            if 'url' in kvs:
-                span.set_tag(ext.HTTP_URL, kvs['url'])
-            if 'method' in kvs:
-                span.set_tag(ext.HTTP_METHOD, kvs['method'])
+        with internal_tracer.start_active_span("urllib3", child_of=parent_span) as scope:
+            try:
+                kvs = collect(instance, args, kwargs)
+                if 'url' in kvs:
+                    scope.span.set_tag(ext.HTTP_URL, kvs['url'])
+                if 'method' in kvs:
+                    scope.span.set_tag(ext.HTTP_METHOD, kvs['method'])
 
-            internal_tracer.inject(span.context, opentracing.Format.HTTP_HEADERS, kwargs["headers"])
-            rv = wrapped(*args, **kwargs)
+                internal_tracer.inject(scope.span.context, opentracing.Format.HTTP_HEADERS, kwargs["headers"])
+                rv = wrapped(*args, **kwargs)
 
-            span.set_tag(ext.HTTP_STATUS_CODE, rv.status)
-            if 500 <= rv.status <= 599:
-                span.set_tag("error", True)
-                ec = span.tags.get('ec', 0)
-                span.set_tag("ec", ec+1)
+                scope.span.set_tag(ext.HTTP_STATUS_CODE, rv.status)
+                if 500 <= rv.status <= 599:
+                    scope.span.set_tag("error", True)
+                    ec = scope.span.tags.get('ec', 0)
+                    scope.span.set_tag("ec", ec+1)
 
-        except Exception as e:
-            span.log_kv({'message': e})
-            span.set_tag("error", True)
-            ec = span.tags.get('ec', 0)
-            span.set_tag("ec", ec+1)
-            span.finish()
-            raise
-        else:
-            span.finish()
-            return rv
+                return rv
+            except Exception as e:
+                scope.span.log_kv({'message': e})
+                scope.span.set_tag("error", True)
+                ec = scope.span.tags.get('ec', 0)
+                scope.span.set_tag("ec", ec+1)
+                raise
 
     logger.debug("Instrumenting urllib3")
 except ImportError:

instana/span.py

@@ -4,15 +4,6 @@
 
 class InstanaSpan(BasicSpan):
     def finish(self, finish_time=None):
-        if self.parent_id is None:
-            self.tracer.cur_ctx = None
-        else:
-            # Set tracer context to the parent span
-            pctx = SpanContext(span_id=self.parent_id,
-                               trace_id=self.context.trace_id,
-                               baggage={},
-                               sampled=True)
-            self.tracer.cur_ctx = pctx
         super(InstanaSpan, self).finish(finish_time)
 
     def log_exception(self, e):