Initial code import.

Author: carlosalberto

.gitignore

@@ -0,0 +1,8 @@
+*.pyc
+dist
+bin
+eggs
+lib
+*.egg-info
+build
+env/

README.rst

@@ -0,0 +1,28 @@
+##################
+Django Opentracing
+##################
+
+This package enables distributed tracing in Pyramid projects via `The OpenTracing Project`_. Once a production system contends with real concurrency or splits into many services, crucial (and formerly easy) tasks become difficult: user-facing latency optimization, root-cause analysis of backend errors, communication about distinct pieces of a now-distributed system, etc. Distributed tracing follows a request on its journey from inception to completion from mobile/browser all the way to the microservices.
+
+Setting up Tracing
+==================
+
+In order to implement tracing in your system (for all the requests), add the following lines of code to your site's Configuration section to enable the tracing tweed:
+
+.. code-block:: python
+
+    # OpenTracing settings
+
+    # if not included, defaults to False
+    config.add_attributes(opentracing_trace_all=True)
+
+    # defaults to []
+    # only valid if 'opentracing_trace_all' == True
+    config.add_attributes(opentracing_trace_attributes=['host', 'method', ...])
+
+    # can be any valid underlying OpenTracing tracer implementation
+    config.add_attributes(opentracing_base_tracer=...)
+
+    # enable the tween
+    config.include('pyramid_opentracing')
+

example/simple.py

@@ -0,0 +1,47 @@
+from wsgiref.simple_server import make_server
+from pyramid.config import Configurator
+from pyramid.view import view_config
+
+import opentracing
+from pyramid_opentracing import PyramidTracer
+
+# Pass a specific Tracer instance to PyramidTracer()
+tracer = PyramidTracer(opentracing.Tracer())
+
+@view_config(route_name='root', renderer='json')
+def server_index(request):
+    return { 'message': 'Hello world!' }
+
+@tracer.trace('method')
+@view_config(route_name='simple', renderer='json')
+def server_simple(request):
+    return { 'message': 'This is a simple traced request.' }
+
+@tracer.trace()
+@view_config(route_name='log', renderer='json')
+def server_log(request):
+    if tracer.get_span(request) is not None:
+        span.log_event('Hello, World!')
+    return { 'message': 'Something was logged' }
+
+@tracer.trace()
+@view_config(route_name='childspan', renderer='json')
+def server_child_span(request):
+    if tracer.get_span(request) is not None:
+        child_span = tracer._tracer.start_span('child_span', child_of=span.context)
+        child_span.finish()
+    return { 'message': 'A child span was created' }
+
+
+if __name__ == '__main__':
+    config = Configurator()
+    config.add_route('root', '/')
+    config.add_route('simple', '/simple')
+    config.add_route('log', '/log')
+    config.add_route('childspan', '/childspan')
+    config.scan()
+
+    app = config.make_wsgi_app()
+    server = make_server('127.0.0.1', 8080, app)
+    server.serve_forever()
+

example/tween.py

@@ -0,0 +1,40 @@
+from wsgiref.simple_server import make_server
+from pyramid.config import Configurator
+from pyramid.view import view_config
+
+import opentracing
+from pyramid_opentracing import PyramidTracer
+
+# Pass a specific Tracer instance
+base_tracer = opentracing.Tracer()
+
+@view_config(route_name='root', renderer='json')
+def server_index(request):
+    return { 'message': 'Hello world!' }
+
+@view_config(route_name='simple', renderer='json')
+def server_simple(request):
+    return { 'message': 'This is a simple traced request.' }
+
+@view_config(route_name='log', renderer='json')
+def server_log(request):
+    return { 'message': 'Something was logged' }
+
+
+if __name__ == '__main__':
+    config = Configurator()
+    config.add_route('root', '')
+    config.add_route('simple', '/simple')
+    config.add_route('log', '/log')
+    config.scan()
+
+    # Tween setup
+    config.add_settings(opentracing_traced_attributes=['host', 'method'])
+    config.add_settings(opentracing_traced_all=True)
+    config.add_settings(opentracing_base_tracer=base_tracer)
+    config.include('pyramid_opentracing')
+
+    app = config.make_wsgi_app()
+    server = make_server('127.0.0.1', 8080, app)
+    server.serve_forever()
+

pyramid_opentracing/__init__.py

@@ -0,0 +1,2 @@
+from .tracer import PyramidTracer
+from .tween_factory import includeme, opentracing_tween_factory

pyramid_opentracing/tests.py

@@ -0,0 +1,140 @@
+import unittest
+from pyramid import testing
+import opentracing
+
+from tracer import PyramidTracer
+from tween_factory import includeme, opentracing_tween_factory
+
+class TestPyramidTracer(unittest.TestCase):
+    def test_ctor_default(self):
+        tracer = PyramidTracer(DummyTracer())
+        self.assertIsNotNone(tracer._tracer, '#A0')
+        self.assertFalse(tracer._trace_all, '#A1')
+        self.assertEqual({}, tracer._current_spans, '#A2')
+
+    def test_ctor(self):
+        tracer = PyramidTracer(DummyTracer(), trace_all=True)
+        self.assertTrue(tracer._trace_all, '#A0')
+
+        tracer = PyramidTracer(DummyTracer(), trace_all=False)
+        self.assertFalse(tracer._trace_all, '#B0')
+
+    def test_get_span_none(self):
+        tracer = PyramidTracer(DummyTracer())
+        self.assertIsNone(tracer.get_span(DummyRequest()), '#A0')
+
+    def test_get_span(self):
+        tracer = PyramidTracer(DummyTracer())
+        req = DummyRequest()
+        tracer._apply_tracing(req, [])
+        self.assertIsNotNone(tracer.get_span(req), '#B0')
+        self.assertIsNone(tracer.get_span(DummyRequest()), '#B1')
+        self.assertEqual(1, len(tracer._current_spans), '#B2')
+
+    def test_apply_tracing_invalid(self):
+        tracer = PyramidTracer(DummyTracer(opentracing.InvalidCarrierException()))
+        tracer._apply_tracing(DummyRequest(), [])
+
+    def test_apply_tracing_corrupted(self):
+        tracer = PyramidTracer(DummyTracer(opentracing.SpanContextCorruptedException()))
+        tracer._apply_tracing(DummyRequest(), [])
+
+    def test_apply_tracing_operation(self):
+        tracer = PyramidTracer(DummyTracer(opentracing.SpanContextCorruptedException()))
+        span = tracer._apply_tracing(DummyRequest(), [])
+        self.assertEqual('/', span.operation_name)
+
+    def test_apply_tracing_attrs(self):
+        tracer = PyramidTracer(DummyTracer())
+        req = DummyRequest()
+
+        span = tracer._apply_tracing(req, [])
+        self.assertEqual({}, span._tags, '#A0')
+
+        span = tracer._apply_tracing(req, ['dont', 'exist'])
+        self.assertEqual({}, span._tags, '#B0')
+
+        span = tracer._apply_tracing(req, ['host', 'path'])
+        self.assertEqual({'host': 'example.com:80', 'path': '/'}, span._tags, '#C0')
+
+    def test_finish_none(self):
+        tracer = PyramidTracer(DummyTracer())
+        tracer._finish_tracing(DummyRequest())
+
+    def test_finish(self):
+        tracer = PyramidTracer(DummyTracer())
+        req = DummyRequest()
+        span = tracer._apply_tracing(req, [])
+        tracer._finish_tracing(req)
+        self.assertTrue(span._is_finished)
+
+class TestTweenFactory(unittest.TestCase):
+
+    def setUp(self):
+        self.request = DummyRequest()
+        self.response = DummyResponse()
+        self.registry = DummyRegistry()
+
+    def test_it(self):
+        handler = lambda x: self.response
+        factory = opentracing_tween_factory(handler, self.registry)
+
+        res = factory(self.request)
+        self.assertIsNotNone(self.registry.settings.get('opentracing_tracer'))
+
+class TestIncludeme(unittest.TestCase):
+
+    def test_it(self):
+        config = DummyConfig()
+        includeme(config)
+        self.assertEqual([('pyramid_opentracing.opentracing_tween_factory', None, None)], config.tweens, '#A0')
+
+class DummyTracer(object):
+    def __init__(self, excToThrow=None):
+        super(DummyTracer, self).__init__()
+        self.excToThrow = excToThrow
+
+    def extract(self, f, headers):
+        if self.excToThrow:
+            raise self.excToThrow
+
+        return DummyContext()
+
+    def start_span(self, operation_name, child_of=None):
+        return DummySpan(operation_name, child_of=child_of)
+
+class DummyRegistry(object):
+    def __init__(self, settings={}):
+        self.settings = settings
+
+class DummyConfig(object):
+    def __init__(self):
+        self.tweens = []
+
+    def add_tween(self, x, under=None, over=None):
+        self.tweens.append((x, under, over))
+
+class DummyRequest(testing.DummyRequest):
+    def __init__(self, *args, **kwargs):
+        super(DummyRequest, self).__init__(*args, **kwargs)
+
+class DummyResponse(object):
+    def __init__(self, headers={}):
+        self.headers = headers
+
+class DummyContext(object):
+    pass
+
+class DummySpan(object):
+    def __init__(self, operation_name, child_of):
+        super(DummySpan, self).__init__()
+        self.operation_name = operation_name
+        self.child_of = child_of
+        self._tags = {}
+
+    def set_tag(self, name, value):
+        self._tags[name] = value
+
+    def finish(self):
+        self._is_finished = True
+

pyramid_opentracing/tracer.py

@@ -0,0 +1,75 @@
+import opentracing
+
+# Ported from the Django library:
+# https://github.com/opentracing-contrib/python-django
+class PyramidTracer(object):
+    '''
+    @param tracer the OpenTracing tracer to be used
+    to trace requests using this PyramidTracer
+    '''
+    def __init__(self, tracer, trace_all=False):
+        self._tracer = tracer
+        self._trace_all = trace_all
+        self._current_spans = {}
+
+    def get_span(self, request):
+        '''
+        @param request 
+        Returns the span tracing this request
+        '''
+        return self._current_spans.get(request, None)
+
+    def trace(self, *attributes):
+        '''
+        Function decorator that traces functions
+        '''
+        def decorator(view_func):
+            if self._trace_all:
+                return view_func
+
+            # otherwise, execute the decorator
+            def wrapper(request):
+                span = self._apply_tracing(request, list(attributes))
+                r = view_func(request)
+                self._finish_tracing(request)
+                return r
+
+            return wrapper
+        return decorator
+
+    def _apply_tracing(self, request, attributes):
+        '''
+        Helper function to avoid rewriting for middleware and decorator.
+        Returns a new span from the request with logged attributes and 
+        correct operation name from the view_func.
+        '''
+        headers = request.headers
+
+        # start new span from trace info
+        span = None
+        operation_name = request.path # (xxx) fix this thing
+        try:
+            span_ctx = self._tracer.extract(opentracing.Format.HTTP_HEADERS, headers)
+            span = self._tracer.start_span(operation_name=operation_name, child_of=span_ctx)
+        except (opentracing.InvalidCarrierException, opentracing.SpanContextCorruptedException) as e:
+            span = self._tracer.start_span(operation_name=operation_name)
+        if span is None:
+            span = self._tracer.start_span(operation_name=operation_name)
+
+        # add span to current spans 
+        self._current_spans[request] = span
+
+        # log any traced attributes
+        for attr in attributes:
+            if hasattr(request, attr):
+                payload = str(getattr(request, attr))
+                if payload:
+                    span.set_tag(attr, payload)
+        
+        return span
+
+    def _finish_tracing(self, request):
+        span = self._current_spans.pop(request, None)     
+        if span is not None:
+            span.finish()
+

pyramid_opentracing/tween_factory.py

@@ -0,0 +1,27 @@
+import opentracing
+
+from .tracer import PyramidTracer
+
+def opentracing_tween_factory(handler, registry):
+    base_tracer = registry.settings.get('opentracing_base_tracer', opentracing.Tracer())
+    traced_attrs = registry.settings.get('opentracing_traced_attributes', [])
+    trace_all = registry.settings.get('opentracing_trace_all', False)
+
+    tracer = PyramidTracer(base_tracer, trace_all)
+    registry.settings ['opentracing_tracer'] = tracer
+
+    def opentracing_tween(req):
+        if not trace_all:
+            return handler(req)
+
+        span = tracer._apply_tracing(req, traced_attrs)
+        res = handler(req)
+        tracer._finish_tracing(req)
+
+        return res
+
+    return opentracing_tween
+
+def includeme(config):
+    config.add_tween('pyramid_opentracing.opentracing_tween_factory')
+