Django updates

django_opentracing/__init__.py

@@ -1,2 +1,2 @@
 from .middleware import OpenTracingMiddleware
-from .tracer import DjangoTracer
+from .tracer import DjangoTracer, get_current_span, get_tracer

django_opentracing/middleware.py

@@ -1,5 +1,10 @@
-from django.conf import settings 
+from __future__ import absolute_import
+import django
+from django.conf import settings
+from jaeger_client import Config
 import opentracing
+from .tracer import DjangoTracer
+
 try:
     # Django >= 1.10
     from django.utils.deprecation import MiddlewareMixin
@@ -10,29 +15,35 @@
 
 class OpenTracingMiddleware(MiddlewareMixin):
     '''
-    __init__() is only called once, no arguments, when the Web server responds to the first request
+    In Django <= 1.9 __init__() is only called once, no arguments, when the Web server responds to the first request
     '''
     def __init__(self, get_response=None):
-        '''
-        TODO: ANSWER Qs
-        - Is it better to place all tracing info in the settings file, or to require a tracing.py file with configurations?
-        - Also, better to have try/catch with empty tracer or just fail fast if there's no tracer specified
-        '''
-        if hasattr(settings, 'OPENTRACING_TRACER'):
-            self._tracer = settings.OPENTRACING_TRACER 
-        else:
-            self._tracer = opentracing.Tracer()
+        self._tracer = None
+        self.get_response = get_response
 
-    def process_view(self, request, view_func, view_args, view_kwargs):
-        # determine whether this middleware should be applied
-        # NOTE: if tracing is on but not tracing all requests, then the tracing occurs
-        # through decorator functions rather than middleware
-        if not self._tracer._trace_all:
-            return None
+        # in django 1.10, __init__ is called on server startup
+        if int(django.get_version().split('.')[1]) <= 9:
+            if self._tracer == None:
+                self._tracer = self.init_tracer()
+
+    '''
+    For Django >= 1.10, executed on every request
+    '''
+    def __call__(self, request):
+        if self._tracer == None:
+            self._tracer = self.init_tracer()
 
+        response = self.get_response(request)
+
+        return response
+
+    def init_tracer(self):
+        return DjangoTracer(Config(config=settings.OPENTRACING_TRACER_CONFIG, service_name=settings.SERVICE_NAME).initialize_tracer())
+
+    def process_view(self, request, view_func, view_args, view_kwargs):
         if hasattr(settings, 'OPENTRACING_TRACED_ATTRIBUTES'):
             traced_attributes = getattr(settings, 'OPENTRACING_TRACED_ATTRIBUTES')
-        else: 
+        else:
             traced_attributes = []
         self._tracer._apply_tracing(request, view_func, traced_attributes)
 

django_opentracing/tracer.py

@@ -1,12 +1,30 @@
+from builtins import object, str
 from django.conf import settings
 import opentracing
 
+django_tracer = None
+
+def get_tracer():
+    return opentracing.tracer
+
+def get_current_span(request):
+    # this lets django rest framework work seamlessly since they wrap the request
+    if hasattr(request, '_request'):
+        request = request._request
+    if django_tracer != None:
+        return django_tracer.get_span(request)
+    else:
+        return None
+
+
 class DjangoTracer(object):
     '''
     @param tracer the OpenTracing tracer to be used
     to trace requests using this DjangoTracer
     '''
     def __init__(self, tracer):
+        global django_tracer
+        django_tracer = self
         self._tracer = tracer
         self._current_spans = {}
         if not hasattr(settings, 'OPENTRACING_TRACE_ALL'):
@@ -16,9 +34,9 @@ def __init__(self, tracer):
         else:
             self._trace_all = True
 
-    def get_span(self, request): 
+    def get_span(self, request):
         '''
-        @param request 
+        @param request
         Returns the span tracing this request
         '''
         return self._current_spans.get(request, None)
@@ -53,11 +71,11 @@ def _apply_tracing(self, request, view_func, attributes):
         '''
         # strip headers for trace info
         headers = {}
-        for k,v in request.META.iteritems():
+        for k,v in list(request.META.items()):
             k = k.lower().replace('_','-')
             if k.startswith('http-'):
                 k = k[5:]
-            headers[k] = v              
+            headers[k] = v
 
         # start new span from trace info
         span = None
@@ -79,10 +97,9 @@ def _apply_tracing(self, request, view_func, attributes):
                 payload = str(getattr(request, attr))
                 if payload:
                     span.set_tag(attr, payload)
-
-        return span  
+        return span
 
     def _finish_tracing(self, request):
-        span = self._current_spans.pop(request, None)     
+        span = self._current_spans.pop(request, None)
         if span is not None:
-            span.finish()
+            span.finish()

example/client/views.py

@@ -1,9 +1,12 @@
+from future import standard_library
+standard_library.install_aliases()
+from builtins import str
 from django.conf import settings
 from django.http import HttpResponse
 from django.shortcuts import render
 
 import opentracing
-import urllib2
+import urllib.request, urllib.error, urllib.parse
 
 tracer = settings.OPENTRACING_TRACER
 
@@ -15,42 +18,42 @@ def client_index(request):
 @tracer.trace()
 def client_simple(request):
     url = "http://localhost:8000/server/simple"
-    new_request = urllib2.Request(url)
+    new_request = urllib.request.Request(url)
     current_span = tracer.get_span(request)
     inject_as_headers(tracer, current_span, new_request)
     try:
-        response = urllib2.urlopen(new_request)
+        response = urllib.request.urlopen(new_request)
         return HttpResponse("Made a simple request")
-    except urllib2.URLError as e:  
+    except urllib.error.URLError as e:  
         return HttpResponse("Error: " + str(e))
 
 @tracer.trace()
 def client_log(request):
     url = "http://localhost:8000/server/log"
-    new_request = urllib2.Request(url)
+    new_request = urllib.request.Request(url)
     current_span = tracer.get_span(request)
     inject_as_headers(tracer, current_span, new_request)
     try:
-        response = urllib2.urlopen(new_request)
+        response = urllib.request.urlopen(new_request)
         return HttpResponse("Sent a request to log")
-    except urllib2.URLError as e:  
+    except urllib.error.URLError as e:  
         return HttpResponse("Error: " + str(e))
 
 @tracer.trace()
 def client_child_span(request):
     url = "http://localhost:8000/server/childspan"
-    new_request = urllib2.Request(url)
+    new_request = urllib.request.Request(url)
     current_span = tracer.get_span(request)
     inject_as_headers(tracer, current_span, new_request)
     try:
-        response = urllib2.urlopen(new_request)
+        response = urllib.request.urlopen(new_request)
         return HttpResponse("Sent a request that should produce an additional child span")
-    except urllib2.URLError as e:  
+    except urllib.error.URLError as e:  
         return HttpResponse("Error: " + str(e))
 
 def inject_as_headers(tracer, span, request):
     text_carrier = {}
     tracer._tracer.inject(span.context, opentracing.Format.TEXT_MAP, text_carrier)
-    for k, v in text_carrier.iteritems():
+    for k, v in text_carrier.items():
         request.add_header(k,v)
 

tests/test_site/__init__.py

@@ -1 +1,2 @@
-import test_middleware
+from __future__ import absolute_import
+from . import test_middleware