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))
