def test_create_attrs_for_span(random_64bit_mock, random_128bit_mock): random_64bit_mock.return_value = '0000000000000042' expected_attrs = ZipkinAttrs( trace_id='0000000000000042', span_id='0000000000000042', parent_span_id=None, flags='0', is_sampled=True, ) assert expected_attrs == zipkin.create_attrs_for_span() # Test overrides expected_attrs = ZipkinAttrs( trace_id='0000000000000045', span_id='0000000000000046', parent_span_id=None, flags='0', is_sampled=False, ) assert expected_attrs == zipkin.create_attrs_for_span( sample_rate=0.0, trace_id='0000000000000045', span_id='0000000000000046', ) random_128bit_mock.return_value = '00000000000000420000000000000042' expected_attrs = ZipkinAttrs( trace_id='00000000000000420000000000000042', span_id='0000000000000042', parent_span_id=None, flags='0', is_sampled=True, ) assert expected_attrs == zipkin.create_attrs_for_span( use_128bit_trace_id=True, )
def test_get_current_context_non_root_existing( self, mock_create_attr, ): # Non root, zipkin_attrs in context stack. # Return existing zipkin_attrs with the current one as parent zipkin_attrs = ZipkinAttrs( trace_id=generate_random_64bit_string(), span_id=generate_random_64bit_string(), parent_span_id=generate_random_64bit_string(), flags=None, is_sampled=True, ) tracer = MockTracer() context = tracer.zipkin_span( service_name='test_service', span_name='test_span', ) tracer._context_stack.push(zipkin_attrs) _, current_attrs = context._get_current_context() assert mock_create_attr.call_count == 0 assert current_attrs == ZipkinAttrs( trace_id=zipkin_attrs.trace_id, span_id=mock.ANY, parent_span_id=zipkin_attrs.span_id, flags=zipkin_attrs.flags, is_sampled=zipkin_attrs.is_sampled, )
def create_zipkin_attr_from_dict(data): """ Create ZipkinAttrs object from a dict. """ if not data or 'trace_id' not in data: return ZipkinAttrs('', '', '', '0', False) return ZipkinAttrs( trace_id=data['trace_id'], span_id=generate_random_64bit_string(), parent_span_id=data['span_id'], flags=data['flags'], is_sampled=True, )
def test_service_span_that_is_independently_sampled(mock_logger): mock_transport_handler, mock_logs = mock_logger zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id='2', flags='0', is_sampled=False, ) with zipkin.zipkin_span( service_name='test_service_name', span_name='service_span', zipkin_attrs=zipkin_attrs, transport_handler=mock_transport_handler, port=45, sample_rate=100.0, binary_annotations={'some_key': 'some_value'}, ): pass span = _decode_binary_thrift_obj(mock_logs[0]) assert span.name == 'service_span' assert span.annotations[0].host.service_name == 'test_service_name' assert span.parent_id is None assert span.binary_annotations[0].key == 'some_key' assert span.binary_annotations[0].value == 'some_value' assert set([ann.value for ann in span.annotations]) == set(['ss', 'sr'])
def test_get_current_context_root_sample_rate_override_not_sampled( self, mock_create_attr, ): # Root span, with custom zipkin_attrs, not sampled and sample_rate zipkin_attrs = ZipkinAttrs( trace_id=generate_random_64bit_string(), span_id=generate_random_64bit_string(), parent_span_id=generate_random_64bit_string(), flags=None, is_sampled=False, ) context = zipkin.zipkin_span( service_name='test_service', span_name='test_span', transport_handler=MockTransportHandler(), zipkin_attrs=zipkin_attrs, sample_rate=100.0, ) report_root, _ = context._get_current_context() assert mock_create_attr.call_args == mock.call( sample_rate=100.0, trace_id=zipkin_attrs.trace_id, ) # It wasn't sampled before and now it is, so this is the trace root assert report_root is True
def test_update_binary_annotations(): zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id=None, flags='0', is_sampled=True, ) context = zipkin.zipkin_span( service_name='my_service', span_name='span_name', zipkin_attrs=zipkin_attrs, transport_handler=mock.Mock(), port=5, ) with context: assert 'test' not in context.logging_context.binary_annotations_dict context.update_binary_annotations({'test': 'hi'}) assert context.logging_context.binary_annotations_dict['test'] == 'hi' nested_context = zipkin.zipkin_span( service_name='my_service', span_name='nested_span', binary_annotations={'one': 'one'}, ) with nested_context: assert 'one' not in context.logging_context.binary_annotations_dict nested_context.update_binary_annotations({'two': 'two'}) assert 'two' in nested_context.binary_annotations assert 'two' not in context.logging_context.binary_annotations_dict
def test_span_context_sampled_no_handlers( zipkin_logger_mock, generate_string_mock, thread_local_mock, ): zipkin_attrs = ZipkinAttrs( trace_id='1111111111111111', span_id='2222222222222222', parent_span_id='3333333333333333', flags='flags', is_sampled=True, ) thread_local_mock.zipkin_attrs = [zipkin_attrs] zipkin_logger_mock.handlers = [] generate_string_mock.return_value = '1' context = zipkin.zipkin_span( service_name='my_service', port=5, transport_handler=mock.Mock(), sample_rate=0.0, ) with context: # Assert that the new ZipkinAttrs were saved new_zipkin_attrs = get_zipkin_attrs() assert new_zipkin_attrs.span_id == '1' # Outside of the context, things should be returned to normal assert get_zipkin_attrs() == zipkin_attrs
def test_zipkin_span_trace_with_0_sample_rate( logging_context_cls_mock, logger_handler_cls_mock, create_endpoint_mock, create_attrs_for_span_mock, push_zipkin_attrs_mock, pop_zipkin_attrs_mock, ): create_attrs_for_span_mock.return_value = ZipkinAttrs( trace_id=generate_random_64bit_string(), span_id=generate_random_64bit_string(), parent_span_id=None, flags='0', is_sampled=False, ) with zipkin.zipkin_span( service_name='some_service_name', span_name='span_name', transport_handler=mock.Mock(), sample_rate=0.0, ) as zipkin_context: assert zipkin_context.port == 0 pass create_attrs_for_span_mock.assert_called_once_with( sample_rate=0.0, use_128bit_trace_id=False, ) push_zipkin_attrs_mock.assert_called_once_with( create_attrs_for_span_mock.return_value) assert create_endpoint_mock.call_count == 0 assert logger_handler_cls_mock.call_count == 0 assert logging_context_cls_mock.call_count == 0 pop_zipkin_attrs_mock.assert_called_once_with()
def test_zipkin_span_trace_with_no_sampling( logging_context_cls_mock, create_endpoint_mock, create_attrs_for_span_mock, mock_context_stack, ): zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id=None, flags='0', is_sampled=False, ) with zipkin.zipkin_span( service_name='my_service', span_name='span_name', zipkin_attrs=zipkin_attrs, transport_handler=MockTransportHandler(), port=5, context_stack=mock_context_stack, span_storage=SpanStorage(), ): pass assert create_attrs_for_span_mock.call_count == 0 mock_context_stack.push.assert_called_once_with(zipkin_attrs, ) assert create_endpoint_mock.call_count == 0 assert logging_context_cls_mock.call_count == 0 mock_context_stack.pop.assert_called_once_with()
def trace(span_name, tracer, span_id=None, service_name=None): span_id = span_id or generate_random_64bit_string() service_name = service_name or settings.ZIPKIN_SERVICE_NAME if len(span_id) > 16: logger.warning('Span id %s for %s should be max 16 chars.' % (span_id, span_name)) trace_id = (tracer.get('trace_id') or generate_random_64bit_string()) parent_span_id = (tracer.get('span_id') or generate_random_64bit_string()) flags = tracer.get('flags') or '' is_sampled = (True if tracer.get('is_tracing') else False) transport_handler = import_string( getattr(settings, 'ZIPKIN_TRANSPORT_HANDLER', 'django_py_zipkin.transport.zipkin_transport')) span = zipkin_span(service_name=service_name, span_name=span_name, transport_handler=transport_handler, zipkin_attrs=ZipkinAttrs(trace_id=trace_id, span_id=span_id, parent_span_id=parent_span_id, flags=flags, is_sampled=is_sampled)) with span as zipkin_context: dict_context = {} yield dict_context zipkin_context.update_binary_annotations(dict_context)
def test_batch_sender_add_span_not_sampled_with_firehose( add_span_mock, flush_mock, time_mock): attr = ZipkinAttrs( trace_id='0000000000000001', span_id='0000000000000002', parent_span_id=None, flags=None, is_sampled=False, ) span_storage = SpanStorage() transport_handler = mock.Mock() firehose_handler = mock.Mock() context = logging_helper.ZipkinLoggingContext( zipkin_attrs=attr, endpoint=create_endpoint(80, 'test_server', '127.0.0.1'), span_name='span_name', transport_handler=transport_handler, report_root_timestamp=False, span_storage=span_storage, firehose_handler=firehose_handler, service_name='test_server', encoding=Encoding.V1_JSON, ) context.start_timestamp = 24 context.response_status_code = 200 context.binary_annotations_dict = {'k': 'v'} time_mock.return_value = 42 context.emit_spans() assert add_span_mock.call_count == 1 assert flush_mock.call_count == 1
def test_batch_sender_add_span_not_called_if_not_sampled( add_span_mock, flush_mock): attr = ZipkinAttrs( trace_id='0000000000000001', span_id='0000000000000002', parent_span_id=None, flags=None, is_sampled=False, ) span_storage = SpanStorage() transport_handler = mock.Mock() context = logging_helper.ZipkinLoggingContext( zipkin_attrs=attr, endpoint=create_endpoint(80, 'test_server', '127.0.0.1'), span_name='span_name', transport_handler=transport_handler, report_root_timestamp=False, span_storage=span_storage, service_name='test_server', encoding=Encoding.V1_JSON, ) context.emit_spans() assert add_span_mock.call_count == 0 assert flush_mock.call_count == 0
def test_service_exits_on_erroneous_span(log_mock): """Tests that for invalid zipkin_attrs exceptions are not thrown Services may not be handling them. Instead log an error """ mock_transport_handler, mock_logs = mock_logger() tracer = MockTracer() try: zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1, 1', # invalid span id parent_span_id='2', flags='0', is_sampled=True, ) with tracer.zipkin_span( service_name='test_service_name', span_name='service_span', zipkin_attrs=zipkin_attrs, transport_handler=mock_transport_handler, encoding=Encoding.V1_THRIFT, ): pass except Exception: pytest.fail('Exception not expected to be thrown!') finally: assert log_mock.call_count == 1 assert len(mock_logs) == 0 assert len(tracer.get_spans()) == 0
def test_batch_sender_add_span_not_sampled_with_firehose( add_span_mock, flush_mock, time_mock): attr = ZipkinAttrs( trace_id='0000000000000001', span_id='0000000000000002', parent_span_id=None, flags=None, is_sampled=False, ) log_handler = logging_helper.ZipkinLoggerHandler(attr) transport_handler = mock.Mock() firehose_handler = mock.Mock() context = logging_helper.ZipkinLoggingContext( zipkin_attrs=attr, thrift_endpoint='thrift_endpoint', log_handler=log_handler, span_name='span_name', transport_handler=transport_handler, report_root_timestamp=False, firehose_handler=firehose_handler, ) context.start_timestamp = 24 context.response_status_code = 200 context.binary_annotations_dict = {'k': 'v'} time_mock.return_value = 42 context.log_spans() assert add_span_mock.call_count == 1 assert flush_mock.call_count == 1
def test_service_span(mock_logger): mock_transport_handler, mock_logs = mock_logger zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id='2', flags='0', is_sampled=True, ) with zipkin.zipkin_span( service_name='test_service_name', span_name='service_span', zipkin_attrs=zipkin_attrs, transport_handler=mock_transport_handler, binary_annotations={'some_key': 'some_value'}, ): pass span = _decode_binary_thrift_obj(mock_logs[0]) assert span.name == 'service_span' assert span.trace_id == 0 assert span.id == 1 assert span.annotations[0].host.service_name == 'test_service_name' assert span.annotations[0].host.port == 0 assert span.parent_id == 2 assert span.binary_annotations[0].key == 'some_key' assert span.binary_annotations[0].value == 'some_value' assert set([ann.value for ann in span.annotations]) == set(['ss', 'sr'])
def test_service_span_report_timestamp_override( mock_logger, default_annotations, ): mock_transport_handler, mock_logs = mock_logger zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id='2', flags='0', is_sampled=True, ) with zipkin.zipkin_span( service_name='test_service_name', span_name='service_span', zipkin_attrs=zipkin_attrs, transport_handler=mock_transport_handler, binary_annotations={'some_key': 'some_value'}, add_logging_annotation=True, report_root_timestamp=True, ): pass span = _decode_binary_thrift_obj(mock_logs[0]) _verify_service_span(span, default_annotations) assert span.timestamp is not None assert span.duration is not None
def test_service_span_that_is_independently_sampled( mock_logger, default_annotations, ): mock_transport_handler, mock_logs = mock_logger zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id='2', flags='0', is_sampled=False, ) with zipkin.zipkin_span( service_name='test_service_name', span_name='service_span', zipkin_attrs=zipkin_attrs, transport_handler=mock_transport_handler, port=45, sample_rate=100.0, binary_annotations={'some_key': 'some_value'}, add_logging_annotation=True, ): pass span = _decode_binary_thrift_obj(mock_logs[0]) assert span.name == 'service_span' assert span.annotations[0].host.service_name == 'test_service_name' assert span.parent_id is None assert span.binary_annotations[0].key == 'some_key' assert span.binary_annotations[0].value == 'some_value' # Spans that are part of an unsampled trace which start their own sampling # should report timestamp/duration, as they're acting as root spans. assert span.timestamp is not None assert span.duration is not None assert set([ann.value for ann in span.annotations]) == default_annotations
def test_adding_error_annotation_on_exception( mock_update_binary_annotations, exception_message, expected_error_string, ): zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id=None, flags='0', is_sampled=True, ) context = zipkin.zipkin_span( service_name='my_service', span_name='span_name', zipkin_attrs=zipkin_attrs, transport_handler=MockTransportHandler(), port=5, ) with pytest.raises(ValueError): with context: raise ValueError(exception_message) assert mock_update_binary_annotations.call_count == 1 call_args, _ = mock_update_binary_annotations.call_args assert 'error' in call_args[1] assert expected_error_string == call_args[1]['error']
def bulk_record_workunits(self, engine_workunits): """A collection of workunits from v2 engine part""" for workunit in engine_workunits: start_timestamp = from_secs_and_nanos_to_float( workunit['start_secs'], workunit['start_nanos'] ) duration = from_secs_and_nanos_to_float( workunit['duration_secs'], workunit['duration_nanos'] ) local_tracer = get_default_tracer() span = local_tracer.zipkin_span( service_name=self.service_name_prefix.format("rule"), span_name=workunit['name'], duration=duration, ) span.start() span.zipkin_attrs = ZipkinAttrs( trace_id=self.trace_id, span_id=workunit['span_id'], # TODO change it when we properly pass parent_id to the v2 engine Nodes # TODO Pass parent_id with ExecutionRequest when v2 engine is called by a workunit # TODO pass parent_id when v2 engine Node is called by another v2 engine Node parent_span_id=workunit.get("parent_id", self.parent_id), flags='0', # flags: stores flags header. Currently unused is_sampled=True, ) span.start_timestamp = start_timestamp span.stop()
def test_service_span(encoding): """Tests that zipkin_attrs can be passed in""" mock_transport_handler, mock_logs = mock_logger() zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id='2', flags='0', is_sampled=True, ) with zipkin.zipkin_span( service_name='test_service_name', span_name='service_span', zipkin_attrs=zipkin_attrs, transport_handler=mock_transport_handler, encoding=encoding, ): pass span = json.loads(mock_logs[0])[0] assert span['name'] == 'service_span' assert span['traceId'] == '0' assert span['id'] == '1' assert span['parentId'] == '2' if encoding == Encoding.V1_JSON: # Spans continued on the server don't log timestamp/duration, as it's # assumed the client part of the pair will log them. assert 'timestamp' not in span assert 'duration' not in span elif encoding == Encoding.V2_JSON: assert span['shared'] is True
def test_zipkin_span_trace_with_no_sampling( logging_context_cls_mock, logger_handler_cls_mock, create_endpoint_mock, create_attrs_for_span_mock, push_zipkin_attrs_mock, pop_zipkin_attrs_mock, ): zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id=None, flags='0', is_sampled=False, ) with zipkin.zipkin_span( service_name='my_service', span_name='span_name', zipkin_attrs=zipkin_attrs, transport_handler=mock.Mock(), port=5, ): pass assert create_attrs_for_span_mock.call_count == 0 push_zipkin_attrs_mock.assert_called_once_with(zipkin_attrs) assert create_endpoint_mock.call_count == 0 assert logger_handler_cls_mock.call_count == 0 assert logging_context_cls_mock.call_count == 0 pop_zipkin_attrs_mock.assert_called_once_with()
def test_service_span_report_timestamp_override(): """Tests that timestamp and duration are set if report_root_timestamp=True""" mock_transport_handler, mock_logs = mock_logger() # We need to pass in zipkin_attrs so that py_zipkin doesn't think this is the # root span (ts and duration are always set for the root span) zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id='2', flags='0', is_sampled=True, ) with zipkin.zipkin_span( service_name='test_service_name', span_name='service_span', zipkin_attrs=zipkin_attrs, transport_handler=mock_transport_handler, report_root_timestamp=True, encoding=Encoding.V1_JSON, ): pass span = json.loads(mock_logs[0])[0] assert 'timestamp' in span assert 'duration' in span
def test_span_context( zipkin_logger_mock, generate_string_128bit_mock, generate_string_mock, thread_local_mock, span_func, expected_annotations, ): zipkin_attrs = ZipkinAttrs( trace_id='1111111111111111', span_id='2222222222222222', parent_span_id='3333333333333333', flags='flags', is_sampled=True, ) thread_local_mock.zipkin_attrs = [zipkin_attrs] logging_handler = ZipkinLoggerHandler(zipkin_attrs) assert logging_handler.parent_span_id is None assert logging_handler.client_spans == [] zipkin_logger_mock.handlers = [logging_handler] generate_string_mock.return_value = '1' context = span_func( service_name='svc', span_name='span', annotations={'something': 1}, binary_annotations={'foo': 'bar'}, ) with context: # Assert that the new ZipkinAttrs were saved new_zipkin_attrs = get_zipkin_attrs() assert new_zipkin_attrs.span_id == '1' # And that the logging handler has a parent_span_id assert logging_handler.parent_span_id == '1' # Outside of the context, things should be returned to normal, # except a new client span is saved in the handler assert logging_handler.parent_span_id is None assert get_zipkin_attrs() == zipkin_attrs client_span = logging_handler.client_spans.pop() assert logging_handler.client_spans == [] # These reserved annotations are based on timestamps so pop em. # This also acts as a check that they exist. for annotation in expected_annotations: client_span['annotations'].pop(annotation) expected_client_span = { 'span_name': 'span', 'service_name': 'svc', 'parent_span_id': None, 'span_id': '1', 'annotations': {'something': 1}, 'binary_annotations': {'foo': 'bar'}, 'sa_binary_annotations': [], } assert client_span == expected_client_span assert generate_string_128bit_mock.call_count == 0
def zipkin_span_params(self, span): span_params = self.log_span_params(span) timing = {'ss': span.start_time, 'sr': span.start_time + span.duration} annotations = annotation_list_builder(timing, self.endpoint) zipkin_attrs = ZipkinAttrs( trace_id=span_params['trace_id'], span_id=span_params['span_id'], parent_span_id=span_params['parent_span_id'], flags=span_params['flags'], is_sampled=span_params['is_sampled']) return { **span_params, 'zipkin_attrs': zipkin_attrs, 'annotations': annotations, 'binary_annotations': binary_annotation_list_builder( { **span.context.baggage, **span.tags }, self.endpoint), }
def test_init(self, mock_generate_kind): # Test that all arguments are correctly saved zipkin_attrs = ZipkinAttrs(None, None, None, None, None) transport = MockTransportHandler() firehose = MockTransportHandler() stack = Stack([]) span_storage = SpanStorage() tracer = MockTracer() context = tracer.zipkin_span( service_name="test_service", span_name="test_span", zipkin_attrs=zipkin_attrs, transport_handler=transport, max_span_batch_size=10, annotations={"test_annotation": 1}, binary_annotations={"status": "200"}, port=80, sample_rate=100.0, include=("cs", "cr"), add_logging_annotation=True, report_root_timestamp=True, use_128bit_trace_id=True, host="127.0.0.255", context_stack=stack, span_storage=span_storage, firehose_handler=firehose, kind=Kind.CLIENT, timestamp=1234, duration=10, encoding=Encoding.V2_JSON, ) assert context.service_name == "test_service" assert context.span_name == "test_span" assert context.zipkin_attrs_override == zipkin_attrs assert context.transport_handler == transport assert context.max_span_batch_size == 10 assert context.annotations == {"test_annotation": 1} assert context.binary_annotations == {"status": "200"} assert context.port == 80 assert context.sample_rate == 100.0 assert context.add_logging_annotation is True assert context.report_root_timestamp_override is True assert context.use_128bit_trace_id is True assert context.host == "127.0.0.255" assert context._context_stack == stack assert context._span_storage == span_storage assert context.firehose_handler == firehose assert mock_generate_kind.call_count == 1 assert mock_generate_kind.call_args == mock.call( context, Kind.CLIENT, ("cs", "cr"), ) assert context.timestamp == 1234 assert context.duration == 10 assert context.encoding == Encoding.V2_JSON assert context._tracer == tracer # Check for backward compatibility assert tracer.get_spans() == span_storage assert tracer.get_context() == stack
def test_batch_sender_add_span_not_sampled_with_firehose( add_span_mock, flush_mock, time_mock ): attr = ZipkinAttrs( trace_id="0000000000000001", span_id="0000000000000002", parent_span_id=None, flags=None, is_sampled=False, ) tracer = MockTracer() transport_handler = mock.Mock() firehose_handler = mock.Mock() context = logging_helper.ZipkinLoggingContext( zipkin_attrs=attr, endpoint=create_endpoint(80, "test_server", "127.0.0.1"), span_name="span_name", transport_handler=transport_handler, report_root_timestamp=False, get_tracer=lambda: tracer, firehose_handler=firehose_handler, service_name="test_server", encoding=Encoding.V1_JSON, ) context.start_timestamp = 24 context.response_status_code = 200 context.tags = {"k": "v"} time_mock.return_value = 42 context.emit_spans() assert add_span_mock.call_count == 1 assert flush_mock.call_count == 1
def test_get_current_context_root_sample_rate_override_sampled( self, mock_create_attr, ): # Root span, with custom zipkin_attrs, sampled # Just return the custom zipkin_attrs. zipkin_attrs = ZipkinAttrs( trace_id=generate_random_64bit_string(), span_id=generate_random_64bit_string(), parent_span_id=generate_random_64bit_string(), flags=None, is_sampled=True, ) context = zipkin.zipkin_span( service_name='test_service', span_name='test_span', transport_handler=MockTransportHandler(), zipkin_attrs=zipkin_attrs, sample_rate=100.0, ) report_root, current_attrs = context._get_current_context() assert mock_create_attr.call_count == 0 assert current_attrs == zipkin_attrs # The override was set and was already sampled, so this is probably # not the trace root. assert report_root is False
def construct_zipkin_attrs(data): parsed = json.loads(data) return ZipkinAttrs(trace_id=parsed.get('trace_id'), parent_span_id=parsed.get('parent_span_id'), span_id=generate_random_64bit_string(), is_sampled=parsed.get('is_sampled'), flags='0')
def dealsbyhotel(): with zipkin_span(service_name='hotels.com:dealsquery', zipkin_attrs=ZipkinAttrs( trace_id=request.headers['X-B3-TraceID'], span_id=request.headers['X-B3-SpanID'], parent_span_id=request.headers['X-B3-ParentSpanID'], flags='1', is_sampled=request.headers['X-B3-Sampled']), span_name='dealquery:dealsbyhotel', transport_handler=http_transport, port=PORT, sample_rate=ZIPKINSAMPLERATE): sessionid = request.args.get('sessionid') debugmessage('BEGIN DEALS SEARCH: SESSIONID', sessionid) status = setupsearchindex(sessionid) if (status == False): return jsonify({}) deals = getdeals(sessionid) hoteldict = defaultdict(defaultdict) for deal in deals: hoteldict[deal['hotelid']] = [] for deal in deals: hoteldict[deal['hotelid']].append(deal) debugmessage('END DEALS SEARCH: SESSIONID', sessionid) return jsonify(hoteldict)
def test_service_span(mock_logger, default_annotations): mock_transport_handler, mock_logs = mock_logger zipkin_attrs = ZipkinAttrs( trace_id='0', span_id='1', parent_span_id='2', flags='0', is_sampled=True, ) with zipkin.zipkin_span( service_name='test_service_name', span_name='service_span', zipkin_attrs=zipkin_attrs, transport_handler=mock_transport_handler, binary_annotations={'some_key': 'some_value'}, add_logging_annotation=True, ): pass span = _decode_binary_thrift_obj(mock_logs[0]) _verify_service_span(span, default_annotations) # Spans continued on the server don't log timestamp/duration, as it's # assumed the client part of the pair will log them. assert span.timestamp is None assert span.duration is None