def test_success_handler_ot(self):
"""OpenTracing version of test_success_handler."""
from opentracing.scope_managers.tornado import TornadoScopeManager
ot_tracer = init_tracer("tornado_svc",
self.tracer,
scope_manager=TornadoScopeManager())
with ot_tracer.start_active_span("tornado_op"):
response = self.fetch("/success/")
assert 200 == response.code
traces = self.pop_traces()
assert 1 == len(traces)
assert 2 == len(traces[0])
# dd_span will start and stop before the ot_span finishes
ot_span, dd_span = traces[0]
# confirm the parenting
assert ot_span.parent_id is None
assert dd_span.parent_id == ot_span.span_id
assert ot_span.name == "tornado_op"
assert ot_span.service == "tornado_svc"
assert_is_measured(dd_span)
assert "tornado-web" == dd_span.service
assert "tornado.request" == dd_span.name
assert "web" == dd_span.span_type
assert "tests.contrib.tornado.web.app.SuccessHandler" == dd_span.resource
assert "GET" == dd_span.get_tag("http.method")
assert_span_http_status_code(dd_span, 200)
assert self.get_url("/success/") == dd_span.get_tag(http.URL)
assert 0 == dd_span.error
def test_success_handler_ot(self):
"""OpenTracing version of test_success_handler."""
ot_tracer = init_tracer('tornado_svc',
self.tracer,
scope_manager=TornadoScopeManager())
with ot_tracer.start_active_span('tornado_op'):
response = self.fetch('/success/')
assert 200 == response.code
traces = self.tracer.writer.pop_traces()
assert 1 == len(traces)
assert 2 == len(traces[0])
# dd_span will start and stop before the ot_span finishes
ot_span, dd_span = traces[0]
# confirm the parenting
assert ot_span.parent_id is None
assert dd_span.parent_id == ot_span.span_id
assert ot_span.name == 'tornado_op'
assert ot_span.service == 'tornado_svc'
assert 'tornado-web' == dd_span.service
assert 'tornado.request' == dd_span.name
assert 'http' == dd_span.span_type
assert 'tests.contrib.tornado.web.app.SuccessHandler' == dd_span.resource
assert 'GET' == dd_span.get_tag('http.method')
assert '200' == dd_span.get_tag('http.status_code')
assert self.get_url('/success/') == dd_span.get_tag(http.URL)
assert 0 == dd_span.error
def test_success_handler_ot(self):
"""OpenTracing version of test_success_handler."""
ot_tracer = init_tracer('tornado_svc',
self.tracer,
scope_manager=TornadoScopeManager())
with ot_tracer.start_active_span('tornado_op'):
response = self.fetch('/success/')
eq_(200, response.code)
traces = self.tracer.writer.pop_traces()
eq_(1, len(traces))
eq_(2, len(traces[0]))
# dd_span will start and stop before the ot_span finishes
ot_span, dd_span = traces[0]
# confirm the parenting
eq_(ot_span.parent_id, None)
eq_(dd_span.parent_id, ot_span.span_id)
eq_(ot_span.name, 'tornado_op')
eq_(ot_span.service, 'tornado_svc')
eq_('tornado-web', dd_span.service)
eq_('tornado.request', dd_span.name)
eq_('http', dd_span.span_type)
eq_('tests.contrib.tornado.web.app.SuccessHandler', dd_span.resource)
eq_('GET', dd_span.get_tag('http.method'))
eq_('200', dd_span.get_tag('http.status_code'))
eq_('/success/', dd_span.get_tag('http.url'))
eq_(0, dd_span.error)
def get_app(self):
self.tracer = MockTracer(TornadoScopeManager())
return make_app(self.tracer,
trace_client=False,
traced_attributes=[
'version',
'protocol',
'doesnotexist',
])
def tracer():
tracer = Tracer(
service_name='test-tracer',
sampler=ConstSampler(True),
reporter=InMemoryReporter(),
scope_manager=TornadoScopeManager()
)
try:
yield tracer
finally:
tracer.close()
def tracer():
old_tracer = opentracing.tracer
t = BasicTracer(
recorder=InMemoryRecorder(),
scope_manager=TornadoScopeManager(),
)
t.register_required_propagators()
opentracing.tracer = t
try:
yield t
finally:
opentracing.tracer = old_tracer
def setUp(self):
self.tracer = MockTracer(TornadoScopeManager())
super(TestClient, self).setUp()
def setup_tornado_tracer():
global tornado_tracer
from opentracing.scope_managers.tornado import TornadoScopeManager
tornado_tracer = InstanaTracer(scope_manager=TornadoScopeManager(), recorder=span_recorder)
import opentracing
from opentracing.scope_managers.tornado import TornadoScopeManager
from opentracing_instrumentation.request_context import (
get_current_span,
span_in_stack_context,
RequestContext,
RequestContextManager,
)
from mock import patch
from tornado import gen
from tornado import stack_context
from tornado.testing import AsyncTestCase, gen_test
@patch('opentracing.tracer', new=opentracing.Tracer(TornadoScopeManager()))
class TornadoTraceContextTest(AsyncTestCase):
@gen_test
def test_http_fetch(self):
span1 = 'Bender is great!'
span2 = 'Fry is dumb!'
@gen.coroutine
def check(span_to_check):
assert get_current_span() == span_to_check
with self.assertRaises(Exception): # passing mismatching spans
yield run_coroutine_with_span(span1, check, span2)
@gen.coroutine
def nested(nested_span_to_check, span_to_check):
def setUp(self):
self.tracer = MockTracer(TornadoScopeManager())
self.queue = queues.Queue()
self.loop = ioloop.IOLoop.current()
self.server = Server(tracer=self.tracer, queue=self.queue)
def ot_tracer(ot_tracer_factory):
"""Fixture providing an opentracer configured for tornado usage."""
yield ot_tracer_factory("tornado_svc", {}, TornadoScopeManager())
def get_app(self):
self.tracer = MockTracer(TornadoScopeManager())
return make_app(tracer_callable=tracer_callable,
tracer_parameters={
'tracer': self.tracer,
})
def thread_safe_tracer():
old_tracer, dummy_tracer = _get_tracers(TornadoScopeManager())
try:
yield dummy_tracer
finally:
opentracing.tracer = old_tracer
"()": "app.logging.SpanLoggerFilter",
}
},
"root": {
"handlers": ["console"],
"level": "INFO",
},
"formatters": {
"simple": {
"format": "{asctime} {levelname} {event_id} {message}",
"style": "{",
},
},
"loggers": {
"github.Requester": {
"level": "INFO",
},
},
}
GITHUB_APP_ID = os.getenv("GITHUB_APP_ID")
tracer = BasicTracer(scope_manager=TornadoScopeManager())
tracer.register_required_propagators()
opentracing.set_global_tracer(tracer)
install_all_patches()
OPENTRACING_TRACING = django_opentracing.DjangoTracing(tracer)
OPENTRACING_TRACER_CALLABLE = "basictracer.tracer.BasicTracer"
OPENTRACING_TRACER_PARAMETERS = {}
from tornado.ioloop import IOLoop
from tornado.web import Application, RequestHandler
from tornado import gen
import opentracing
from opentracing.scope_managers.tornado import TornadoScopeManager
import tornado_opentracing
tornado_opentracing.init_tracing()
# Your OpenTracing-compatible tracer here.
tracer = opentracing.Tracer(scope_manager=TornadoScopeManager())
class MainHandler(RequestHandler):
def get(self):
self.write({'status': 'ok'})
class StoryHandler(RequestHandler):
@gen.coroutine
def get(self, story_id):
if int(story_id) == 0:
raise ValueError('invalid value passed')
tracer.active_span.set_tag('processed', True)
self.write({'status': 'fetched'})
def get_app(self):
self.tracer = MockTracer(TornadoScopeManager())
return make_app(tracer_callable='tests.test_tracing.tracer_callable',
tracer_parameters={'tracer': self.tracer})
import opentracing.ext.tags as ext_tags
from crossdock.thrift_gen.tracetest.ttypes import ObservedSpan, TraceResponse, Transport, \
JoinTraceRequest
from tchannel import TChannel, thrift
from crossdock.server.thriftrw_serializer import trace_response_to_thriftrw, \
join_trace_request_to_thriftrw
DefaultClientPortHTTP = 8080
DefaultServerPortHTTP = 8081
DefaultServerPortTChannel = 8082
tracer = Tracer(service_name='python',
reporter=NullReporter(),
sampler=ConstSampler(decision=True),
scope_manager=TornadoScopeManager())
opentracing.set_global_tracer(tracer)
idl_path = 'idl/thrift/crossdock/tracetest.thrift'
thrift_services = {}
def get_thrift_service(service_name):
if service_name in thrift_services:
return thrift_services[service_name]
thrift_service = thrift.load(path=idl_path, service=service_name)
thrift_services[service_name] = thrift_service
return thrift_service
def serve():
def get_app(self):
self.tracer = MockTracer(TornadoScopeManager())
return make_app(self.tracer, trace_all=False)
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from opentracing.mocktracer import MockTracer
from opentracing.scope_managers.tornado import TornadoScopeManager
from opentracing.scope_managers.tornado import tracer_stack_context
import tornado.gen
import tornado.web
import tornado.testing
import tornado_opentracing
tracing = tornado_opentracing.TornadoTracing(MockTracer(TornadoScopeManager()))
class MainHandler(tornado.web.RequestHandler):
def get(self):
# Not being traced.
assert tracing.get_span(self.request) is None
self.write('{}')
class DecoratedHandler(tornado.web.RequestHandler):
@tracing.trace('protocol', 'doesntexist')
def get(self):
assert tracing.get_span(self.request) is not None
self.write('{}')
def scope_manager(self):
return TornadoScopeManager()
def get_app(self):
self.tracer = MockTracer(TornadoScopeManager())
return make_app(self.tracer,
trace_all=False,
start_span_cb=self.start_span_cb)
def setUp(self):
self.tracer = MockTracer(TornadoScopeManager())
self.loop = ioloop.IOLoop.current()
import tornado.stack_context
import tornado.concurrent
from tornado import gen
from tornado.testing import AsyncTestCase, gen_test
from opentracing_instrumentation import traced_function
from opentracing_instrumentation import span_in_stack_context
patch_object = mock.patch.object
def extract_call_site_tag(span, *_, **kwargs):
if 'call_site_tag' in kwargs:
span.set_tag('call_site_tag', kwargs['call_site_tag'])
@mock.patch('opentracing.tracer', opentracing.Tracer(TornadoScopeManager()))
class TracedFuctionDecoratorTest(AsyncTestCase):
@gen_test
def test_no_arg_decorator(self):
class SomeClient(object):
@traced_function
@gen.coroutine
def func1(self, param1):
assert param1 == 123
raise tornado.gen.Return('oh yeah')
@traced_function
def func1_1(self, param1):
assert param1 == 123
return 'oh yeah' # not a co-routine
def setUp(self):
self.tracer = MockTracer(TornadoScopeManager())
self.loop = ioloop.IOLoop.current()
self.client = Client(RequestHandler(self.tracer), self.loop)
def get_app(self):
self.tracer = MockTracer(TornadoScopeManager())
return make_app() # no opentracing_tracing
