def __init__(self, address: Optional[str] = None, tracer: Optional[Tracer] = None): """Connects to Dapr Runtime and initialize gRPC client stub. Args: address (str, optional): Dapr Runtime gRPC endpoint address. """ if not address: address = f"{settings.DAPR_RUNTIME_HOST}:{settings.DAPR_GRPC_PORT}" self._address = address self._channel = grpc.insecure_channel(address) # type: ignore if settings.DAPR_API_TOKEN: api_token_interceptor = DaprClientInterceptor([ ('dapr-api-token', settings.DAPR_API_TOKEN), ]) self._channel = grpc.intercept_channel( # type: ignore self._channel, api_token_interceptor) if tracer: self._channel = grpc.intercept_channel( # type: ignore self._channel, client_interceptor.OpenCensusClientInterceptor(tracer=tracer)) self._stub = api_service_v1.DaprStub(self._channel)
def test__intercept_call_metadata_list(self): tracer = mock.Mock() tracer.span_context = mock.Mock() test_header = 'test header' mock_propagator = mock.Mock() mock_propagator.to_header.return_value = test_header interceptor = client_interceptor.OpenCensusClientInterceptor( tracer=tracer, host_port='test') interceptor._propagator = mock_propagator mock_client_call_details = mock.Mock() mock_client_call_details.metadata = [ ('test_key', 'test_value'), ] mock_client_call_details.method = '/hello' client_call_details, request_iterator, current_span =\ interceptor._intercept_call( mock_client_call_details, mock.Mock(), 'unary_unary') expected_metadata = [ ('test_key', 'test_value'), ('grpc-trace-bin', test_header), ] self.assertEqual(expected_metadata, client_call_details.metadata)
def _unary_helper(self): continuation = mock.Mock() mock_response = mock.Mock() continuation.return_value = mock_response interceptor = client_interceptor.OpenCensusClientInterceptor() interceptor._intercept_call = mock.Mock( return_value=(None, iter([mock.Mock()]), None)) return interceptor, continuation, mock_response
def test_constructor_default(self): from opencensus.trace.propagation import binary_format interceptor = client_interceptor.OpenCensusClientInterceptor() self.assertIsNone(interceptor._tracer) self.assertIsNone(interceptor.host_port) self.assertTrue( isinstance(interceptor._propagator, binary_format.BinaryFormatPropagator))
def test__start_client_span(self): tracer = mock.Mock() interceptor = client_interceptor.OpenCensusClientInterceptor( tracer=tracer, host_port='test') mock_client_call_details = mock.Mock() mock_client_call_details.method = '/hello' interceptor._start_client_span(mock_client_call_details) self.assertTrue(tracer.start_span.called) self.assertTrue(tracer.add_attribute_to_current_span.called)
def main(): exporter = stackdriver_exporter.StackdriverExporter() tracer = Tracer(exporter=exporter) tracer_interceptor = client_interceptor.OpenCensusClientInterceptor( tracer, host_port=HOST_PORT) channel = grpc.insecure_channel(HOST_PORT) channel = grpc.intercept_channel(channel, tracer_interceptor) stub = hello_world_pb2_grpc.GreeterStub(channel) response = stub.SayHello(hello_world_pb2.HelloRequest(name='you')) print("Message received: " + response.message)
def _stream_helper(self): continuation = mock.Mock() mock_response = iter([mock.Mock()]) continuation.return_value = mock_response mock_tracer = mock.Mock() interceptor = client_interceptor.OpenCensusClientInterceptor( tracer=mock_tracer) interceptor._intercept_call = mock.Mock( return_value=(None, iter([mock.Mock()]), mock.Mock())) return interceptor, continuation, mock_tracer
def _get_grpc_stub(stub_cls, host_port): stub = _stub_cache.get((stub_cls, host_port)) if stub is not None: return stub channel = grpc.insecure_channel(host_port) tracer_interceptor = client_interceptor.OpenCensusClientInterceptor( host_port=HELLO_WORLD_HOST_PORT) channel = grpc.intercept_channel(channel, tracer_interceptor) stub = stub_cls(channel) _stub_cache[(stub_cls, host_port)] = stub return stub
def test__callback_no_exception(self): current_span = mock.Mock() tracer = MockTracer(current_span) interceptor = client_interceptor.OpenCensusClientInterceptor( tracer=tracer, host_port='test') current_span.attributes = {} callback = interceptor._callback(current_span) response = mock.Mock() response.exception.return_value = None callback(response) expected_attributes = {'error.message': None} self.assertEqual(current_span.attributes, expected_attributes)
def test__end_span_between_context(self): from opencensus.trace import execution_context current_span = mock.Mock() tracer = mock.Mock() interceptor = client_interceptor.OpenCensusClientInterceptor( tracer=tracer, host_port='test') interceptor._end_span_between_context(current_span) span_in_context = execution_context.get_current_span() self.assertEqual(span_in_context, current_span) self.assertTrue(tracer.end_span.called)
def test_constructor_explicit(self): from opencensus.trace.propagation import binary_format tracer = mock.Mock() host_port = 'localhost:50051' interceptor = client_interceptor.OpenCensusClientInterceptor( tracer=tracer, host_port=host_port) self.assertEqual(interceptor._tracer, tracer) self.assertEqual(interceptor.host_port, host_port) self.assertTrue( isinstance(interceptor._propagator, binary_format.BinaryFormatPropagator))
def get_channel(target: str, is_secure: bool = True) -> grpc.Channel: interceptors = [ GrpcClientInterceptor(), client_interceptor.OpenCensusClientInterceptor(host_port=target), ] if is_secure: with open(os.path.join(root_directory, "mygrpc/keys/cert.pem"), "rb") as f: trusted_certs = f.read() credentials = grpc.ssl_channel_credentials( root_certificates=trusted_certs) options = (("grpc.ssl_target_name_override", "grpc.seekplum.top"), ) secure_channel = grpc.secure_channel(target=target, credentials=credentials, options=options) return grpc.intercept_channel(secure_channel, *interceptors) return grpc.intercept_channel(grpc.insecure_channel(target), *interceptors)
def test__intercept_call_noop_tracer(self): tracer = NoopTracer() test_header = 'test header' mock_propagator = mock.Mock() mock_propagator.to_header.return_value = test_header interceptor = client_interceptor.OpenCensusClientInterceptor( tracer=tracer, host_port='test') interceptor._propagator = mock_propagator mock_client_call_details = mock.Mock() mock_client_call_details.metadata = None mock_client_call_details.method = '/hello' client_call_details, request_iterator, current_span =\ interceptor._intercept_call( mock_client_call_details, mock.Mock(), 'unary_unary') expected_metadata = (('grpc-trace-bin', test_header), ) self.assertEqual(expected_metadata, client_call_details.metadata)
def process_grpc(self, instance, incentive, spec): logger = self.get_logger() if self.runner is None: tracer_interceptor = client_interceptor.OpenCensusClientInterceptor( get_current_tracer(), host_port=settings.CODEBOX_BROKER_GRPC) channel = grpc.insecure_channel(settings.CODEBOX_BROKER_GRPC) channel = grpc.intercept_channel(channel, tracer_interceptor) self.runner = broker_pb2_grpc.ScriptRunnerStub(channel) socket = incentive.socket entrypoint = socket.get_local_path(incentive.codebox.path) # Add environment environment_hash = '' environment_url = '' if socket.environment_id: environment = Cached(SocketEnvironment, kwargs={'pk': socket.environment_id}).get() if not environment.is_ready: self.block_run('Environment is not yet ready.', incentive, instance, spec, status=Trace.STATUS_CHOICES.FAILURE) return environment_hash = environment.get_hash() environment_url = environment.get_url() req = broker_pb2.SimpleRunRequest( meta={ 'files': socket.get_files(), 'environment_url': environment_url, 'trace': json.dumps(spec['trace']).encode(), 'trace_id': spec['trace']['id'], }, lb_meta={ 'concurrency_key': str(instance.pk), 'concurrency_limit': spec['run']['concurrency_limit'], }, script_meta={ 'runtime': spec['run']['runtime_name'], 'source_hash': socket.get_hash(), 'user_id': str(instance.pk), 'environment': environment_hash, 'options': { 'entrypoint': entrypoint, 'output_limit': settings.CODEBOX_RESULT_SIZE_LIMIT, 'timeout': int(spec['run']['timeout'] * 1000), 'async': spec['run']['async'], 'mcpu': spec['run']['mcpu'], 'args': spec['run']['additional_args'].encode(), 'config': spec['run']['config'].encode(), 'meta': spec['run']['meta'].encode(), }, }, ) # Retry grpc Run if needed. for i in range(self.grpc_run_retries + 1): try: response = self.runner.SimpleRun(req, timeout=GRPC_RUN_TIMEOUT) for _ in response: # Drain response so it is processed and not queued pass return except Exception: if i + 1 > self.grpc_run_retries: raise logger.warning("gRPC run failed, retrying (try #%d out of %d)", i + 1, self.grpc_run_retries, exc_info=1) time.sleep(1)
# Setup Zipkin exporter try: zipkin_service_addr = os.environ.get("ZIPKIN_SERVICE_ADDR", '') if zipkin_service_addr == "": logger.info( "Skipping Zipkin traces initialization. Set environment variable ZIPKIN_SERVICE_ADDR=<host>:<port> to enable." ) raise KeyError() host, port = zipkin_service_addr.split(":") ze = ZipkinExporter(service_name="recommendationservice-client", host_name=host, port=port, endpoint='/api/v2/spans') sampler = AlwaysOnSampler() tracer = Tracer(exporter=ze, sampler=sampler) tracer_interceptor = client_interceptor.OpenCensusClientInterceptor( sampler, ze) logger.info("Zipkin traces enabled, sending to " + zipkin_service_addr) except KeyError: tracer_interceptor = client_interceptor.OpenCensusClientInterceptor() if __name__ == "__main__": # get port if len(sys.argv) > 1: port = sys.argv[1] else: port = "8080" # set up server stub channel = grpc.insecure_channel('localhost:' + port) # channel = grpc.intercept_channel(channel, tracer_interceptor) stub = demo_pb2_grpc.RecommendationServiceStub(channel)
logger = getJSONLogger('recommendationservice-server') if __name__ == "__main__": # get port if len(sys.argv) > 1: port = sys.argv[1] else: port = "8080" try: exporter = NewRelicTraceExporter( insert_key=os.environ["NEW_RELIC_API_KEY"], host=urlparse(os.environ["NEW_RELIC_TRACE_URL"]).hostname, service_name="recommendationservice") tracer = Tracer(exporter=exporter) tracer_interceptor = client_interceptor.OpenCensusClientInterceptor( tracer, host_port='localhost:' + port) except: tracer_interceptor = client_interceptor.OpenCensusClientInterceptor() # set up server stub channel = grpc.insecure_channel('localhost:' + port) channel = grpc.intercept_channel(channel, tracer_interceptor) stub = demo_pb2_grpc.RecommendationServiceStub(channel) # form request request = demo_pb2.ListRecommendationsRequest(user_id="test", product_ids=["test"]) # make call to server response = stub.ListRecommendations(request) logger.info(response)
from logger import getJSONLogger logger = getJSONLogger('emailservice-client') from opencensus_ext_newrelic import NewRelicTraceExporter from opencensus.ext.grpc import client_interceptor from opencensus.trace import samplers try: sampler = samplers.AlwaysOnSampler() exporter = NewRelicTraceExporter( insert_key=os.environ["NEW_RELIC_API_KEY"], host=urlparse(os.environ["NEW_RELIC_TRACE_URL"]).hostname, service_name="emailservice") tracer = Tracer(exporter=exporter) tracer_interceptor = client_interceptor.OpenCensusClientInterceptor( tracer, host_port='0.0.0.0:8080') except: tracer_interceptor = client_interceptor.OpenCensusClientInterceptor() def send_confirmation_email(email, order): channel = grpc.insecure_channel('0.0.0.0:8080') channel = grpc.intercept_channel(channel, tracer_interceptor) stub = demo_pb2_grpc.EmailServiceStub(channel) try: response = stub.SendOrderConfirmation( demo_pb2.SendOrderConfirmationRequest(email=email, order=order)) logger.info('Request sent.') except grpc.RpcError as err: logger.error(err.details()) logger.error('{}, {}'.format(err.code().name, err.code().value))
def _intercepted_channel(self, tracer=None): return grpc.intercept_channel( self._channel, client_interceptor.OpenCensusClientInterceptor(tracer=tracer))