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