def test_create_headers_for_new_span(mock_create_http_headers): tracer = MockTracer() context_stack = Stack() zipkin.create_http_headers_for_new_span(context_stack, tracer) assert mock_create_http_headers.call_count == 1 assert mock_create_http_headers.call_args == mock.call(context_stack, tracer, True,)
def invoke_service(request): headers = {} headers.update(create_http_headers_for_new_span()) nextend_response = requests.get( 'http://localhost:9002/apib', headers=headers, ) headers = {} headers.update(create_http_headers_for_new_span()) nextend_response = requests.get( 'http://localhost:9003/api', headers=headers, ) return Response(nextend_response.text)
def do_stuff(): # time.sleep(2) headers = create_http_headers_for_new_span() r = requests.get('http://www.baidu.com', headers=headers) log.info(r) log.info(r.content) return 'OK'
def get_playlist_songs_info(id): """ Retrieves all playlist songs' information""" logging.debug("{aggregator_controller} BEGIN function get_playlist_songs_info()") if id is '': return RESP.response_400(message='A given parameter is empty') base_url = PLAYLISTS_MS + '/playlists/songs' url = '/'.join((base_url, str(id))) # Checks if song exists by sending a request into the Songs Microservice headers = {'Content-Type': 'application/json', 'Authorization': request.headers['Authorization']} headers.update(create_http_headers_for_new_span()) with zipkin_span(service_name='aggregator_ms', span_name='get_playlists_songs') as zipkin_context: r = requests.get(url, headers=headers) zipkin_context.update_binary_annotations({'http.method': 'GET', 'http.url': url, 'http.status_code': r.status_code}) if r.status_code == 400: return RESP.response_400() if r.status_code == 404: return RESP.response_404(message='Playlist not found!') if r.status_code == 500: return RESP.response_500(message='Playlists_MS is down!') response_data = json.loads(r.text) song_ids = [] for dictionary in response_data: song_ids.append(dictionary['song_id']) return RESP.response_200(message="Playlist Songs Info Retrieved Successfully")
def with_headers(self, call_name, *args, **kwargs): kwargs.setdefault('_request_options', {}) headers = kwargs['_request_options'].setdefault('headers', {}) headers.update( create_http_headers_for_new_span( context_stack=self._context_stack)) return getattr(self.resource, call_name)(*args, **kwargs)
def do_stuff2(): time.sleep(2) headers = create_http_headers_for_new_span() print('do_stuff') print(headers) requests.get('http://localhost:7003/service1/', headers=headers) # print(res.text) return 'OK'
def call_backend(request): headers = {} headers.update(create_http_headers_for_new_span()) backend_response = requests.get( url='http://localhost:9000/api', headers=headers, ) return Response(backend_response.text)
def do_stuff(): logger.debug("") time.sleep(5) logger.debug("") headers = create_http_headers_for_new_span() logger.debug("") requests.get('http://localhost:6000/service1/', headers=headers) logger.debug("") return 'OK'
def add_2_numbers_and_square_it(num1, num2): output = {"sum_of_numbers": 0} sum_of_2_numbers = num1 + num2 headers_new = create_http_headers_for_new_span() response_square = requests.post( SQUARE_URL, json={"num": sum_of_2_numbers}, headers=headers_new) if response_square.ok: resp_sq_json = response_square.json() output["sum_of_numbers"] = resp_sq_json['square_of_number'] return output
def _call_traced(self: MethodProxy, *args, **kwargs): span = zipkin.zipkin_client_span(self.service_name, self.method_name, transport_handler=transport_handler) start_span(span) self.worker_ctx.data.update(zipkin.create_http_headers_for_new_span()) try: reply = _call(self, *args, **kwargs) except: stop_span(span) raise return TracedRpcReply(reply.reply_event, span)
def do_stuff(): time.sleep(2) headers = create_http_headers_for_new_span() print('do_stuff') print(headers) res = requests.get('http://192.168.10.104:5000/api/fortunes', headers=headers) # res = requests.get('http://192.168.10.104:17401/values/1', headers=headers) # requests.post('http://localhost:9000/', headers=headers) # requests.get('http://localhost:6000/service1/', headers=headers) # print(res.text) return 'OK'
def test_create_headers_for_new_span_returns_header_if_active_request( gen_mock, get_mock): get_mock.return_value = mock.Mock( trace_id='27133d482ba4f605', span_id='37133d482ba4f605', is_sampled=True) gen_mock.return_value = '17133d482ba4f605' expected = { 'X-B3-TraceId': '27133d482ba4f605', 'X-B3-SpanId': '17133d482ba4f605', 'X-B3-ParentSpanId': '37133d482ba4f605', 'X-B3-Flags': '0', 'X-B3-Sampled': '1', } assert expected == zipkin.create_http_headers_for_new_span()
def hello(): with zipkin_span( service_name='hello_world_service', span_name='hello', transport_handler=http_transport, port=6000, sample_rate=100, # Value between 0.0 and 100.0 ): zipkin_headers = create_http_headers_for_new_span() print zipkin_headers time.sleep(0.2) requests.get('http://localhost:6001', headers=zipkin_headers) time.sleep(0.3) return "Hello World!\n", 200
def test_create_headers_for_new_span_custom_tracer(gen_mock): tracer = MockTracer() tracer.push_zipkin_attrs( mock.Mock( trace_id='27133d482ba4f605', span_id='37133d482ba4f605', is_sampled=True, )) gen_mock.return_value = '17133d482ba4f605' expected = { 'X-B3-TraceId': '27133d482ba4f605', 'X-B3-SpanId': '17133d482ba4f605', 'X-B3-ParentSpanId': '37133d482ba4f605', 'X-B3-Flags': '0', 'X-B3-Sampled': '1', } assert expected == zipkin.create_http_headers_for_new_span(tracer=tracer, )
def get_song(id): """ Retrives a song given an id""" headers = {'Content-Type': 'application/json', 'Authorization': request.headers['Authorization']} headers.update(create_http_headers_for_new_span()) param = {'id': id} with zipkin_span(service_name='aggregator_ms', span_name='get_song') as zipkin_context: r = requests.get(SONGS_MS + '/songs', params=param, headers=headers) zipkin_context.update_binary_annotations({'http.method': 'GET', 'http.url': SONGS_MS + '/songs', 'http.status_code': r.status_code}) if r.status_code == 404: return RESP.response_404(message='Song not found!') if r.status_code == 500: return RESP.response_500(message='Songs_MS is down!') return json.loads(r.text)
def urlopen(self, method, url, *args, **kw): if parsed_host and self.host == parsed_host.hostname: # Don't trace zipkin calls return func(self, method, url, **kw) attrs = { zipkin_core.HTTP_HOST: self.host, zipkin_core.HTTP_METHOD: method, zipkin_core.HTTP_PATH: url, } with zipkin_span(service_name=self.host, span_name=self._absolute_url(url), binary_annotations=attrs) as span: headers = kw['headers'] or {} headers.update(create_http_headers_for_new_span()) if 'headers' in kw: del kw['headers'] try: out = func(self, method, url, *args, headers=headers, **kw) if hasattr(out.connection, 'sock') and out.connection.sock and hasattr( out.connection.sock, 'getpeername'): peer = out.connection.sock.getpeername() span.add_sa_binary_annotation(peer[1], self.host, peer[0]) else: span.add_sa_binary_annotation(self.port, self.host) except: # always add sa_binary even in case of error # but if we do it before firing urlopen, then we ended up with two annotations span.add_sa_binary_annotation(self.port, self.host) raise span.update_binary_annotations({ zipkin_core.HTTP_STATUS_CODE: out.status, 'http.retries': out.retries, }) return out
async def call_service_d(tracer, span): # to call next service, generate a span context using create_http_headers_for_new_span() span_headers = create_http_headers_for_new_span(tracer=tracer) # trace_id, span_id, parent_id et.al all the same zipkin_attrs = ZipkinAttrs( trace_id=span_headers.get('X-B3-TraceId'), span_id=span_headers.get('X-B3-SpanId'), parent_span_id=span_headers.get('X-B3-ParentSpanId'), flags=span_headers.get('X-B3-Flags'), is_sampled=span_headers.get('X-B3-Sampled')) # generate CLIENT span with tracer.zipkin_span( service_name=SERVICE_NAME, span_name='/services/d', kind=Kind.CLIENT, transport_handler=HttpTransport(), zipkin_attrs=zipkin_attrs, ) as client_span_d: res_body = None res_code = '500' req = tornado.httpclient.HTTPRequest( url='http://localhost:9001/services/d', method='GET', headers=span_headers) try: res = await AsyncHTTPClient().fetch(req) res_code = res.code res_body = res.body.decode().strip() except Exception as e: return "Error: %s" % e else: pass finally: client_span_d.update_binary_annotations({"result": str(res_code)}) span.update_binary_annotations({"result": str(res_code)}) return res_body
def create_token(body): logging.debug("{authentication_controller} BEGIN function create_token()") if body['email'] is '' or body['password'] is '': return RESP.response_400(message='A given parameter is empty!') payload = {'email': body['email'], 'password': body['password']} logging.debug("{authentication_controller} %s", USERS_MS) with zipkin_span(service_name='authentication_ms', span_name='create_token') as zipkin_context: headers = {} headers.update(create_http_headers_for_new_span()) r = requests.post(USERS_MS + '/login', json=payload, headers=headers) zipkin_context.update_binary_annotations({ 'http.method': 'POST', 'http.url': USERS_MS + '/login', 'http.status_code': r.status_code }) if r.status_code == requests.codes.ok: token_info = { 'id': json.loads(r.content).get('id'), 'name': json.loads(r.content).get('name'), 'email': json.loads(r.content).get('email') } token = jwt.encode(token_info, TOKEN_SECRET, algorithm=ALGORITHM) return RESP.response_200(message={'token': token.decode('utf-8')}) if r.status_code == 500: return RESP.response_500(message='Users_MS is down!') return RESP.response_400(message='Credentials are incorrect!')
def sample_child_span(dummy_request): return create_http_headers_for_new_span()
def create_http_headers_for_new_span(self): if self._disable: return dict() return zipkin.create_http_headers_for_new_span()
def cart_service_do_stuff(): time.sleep(5) headers = create_http_headers_for_new_span() requests.get('http://www.kubernetes/cart', headers=headers) return 'OK'
def test_create_headers_for_new_span_empty_if_no_active_request(): with mock.patch.object(get_default_tracer(), 'get_zipkin_attrs') as mock_ctx: mock_ctx.return_value = None assert {} == zipkin.create_http_headers_for_new_span()
def test_create_headers_for_new_span_empty_if_no_active_request( mock_context_stack, ): mock_context_stack.get.return_value = None assert {} == zipkin.create_http_headers_for_new_span()
def with_headers(self, call_name, *args, **kwargs): kwargs.setdefault("_request_options", {}) headers = kwargs["_request_options"].setdefault("headers", {}) headers.update(create_http_headers_for_new_span()) return getattr(self.resource, call_name)(*args, **kwargs)
def test_create_headers_for_new_span_empty_if_no_active_request(get_mock): get_mock.return_value = None assert {} == zipkin.create_http_headers_for_new_span()
def create_http_headers_for_new_span(self): return zipkin.create_http_headers_for_new_span()