def run():
parser = argparse.ArgumentParser()
parser.add_argument(
'--log_payloads',
action='store_true',
help='log request/response objects to open-tracing spans')
parser.add_argument('--include_grpc_tags',
action='store_true',
help='set gRPC-specific tags on spans')
args = parser.parse_args()
config = Config(config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
},
service_name='store-client')
tracer = config.initialize_tracer()
span_decorator = None
if args.include_grpc_tags:
span_decorator = StoreSpanDecorator()
tracer_interceptor = open_tracing_client_interceptor(
tracer, log_payloads=args.log_payloads, span_decorator=span_decorator)
channel = grpc.insecure_channel('localhost:50051')
channel = intercept_channel(channel, tracer_interceptor)
stub = store_pb2.StoreStub(channel)
read_and_execute(CommandExecuter(stub))
time.sleep(2)
tracer.close()
time.sleep(2)
def _serving_service(self):
"""
Creates or returns the gRPC Feast Serving Service Stub. If both `opentracing`
and `grpcio-opentracing` are installed, an opentracing interceptor will be
instantiated based on the global tracer.
Returns: ServingServiceStub
"""
if not self._serving_service_stub:
channel = create_grpc_channel(
url=self._config.get(opt.SERVING_URL),
enable_ssl=self._config.getboolean(opt.SERVING_ENABLE_SSL),
enable_auth=self._config.getboolean(opt.ENABLE_AUTH),
ssl_server_cert_path=self._config.get(
opt.SERVING_SERVER_SSL_CERT),
auth_metadata_plugin=self._auth_metadata,
timeout=self._config.getint(opt.GRPC_CONNECTION_TIMEOUT),
)
try:
import opentracing
from grpc_opentracing import open_tracing_client_interceptor
from grpc_opentracing.grpcext import intercept_channel
interceptor = open_tracing_client_interceptor(
opentracing.global_tracer())
channel = intercept_channel(channel, interceptor)
except ImportError:
pass
self._serving_service_stub = ServingServiceStub(channel)
return self._serving_service_stub
def get_channel(host, port, enable_tracing=False):
channel = grpc.insecure_channel(f'{host}:{port}')
if enable_tracing:
tracer_interceptor = open_tracing_client_interceptor(
opentracing.global_tracer())
channel = intercept_channel(channel, tracer_interceptor)
return channel
def run():
config = Config(
config={
"sampler": {
"type": "const",
"param": 1
},
"logging": True
},
service_name="chat-client",
)
tracer = config.initialize_tracer()
active_span_source = FixedActiveSpanSource()
tracer_interceptor = open_tracing_client_interceptor(
tracer, active_span_source=active_span_source, log_payloads=True)
channel = grpc.insecure_channel("localhost:50051")
channel = intercept_channel(channel, tracer_interceptor)
stub = chat_pb2_grpc.ChatStub(channel)
response = list_messages(tracer, active_span_source, stub)
pprint(MessageToDict(response))
time.sleep(2)
tracer.close()
time.sleep(2)
def run():
parser = argparse.ArgumentParser()
parser.add_argument(
'--log_payloads',
action='store_true',
help='log request/response objects to open-tracing spans')
args = parser.parse_args()
config = Config(
config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
},
service_name='trivial-client')
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_client_interceptor(
tracer, log_payloads=args.log_payloads)
channel = grpc.insecure_channel('localhost:50051')
channel = intercept_channel(channel, tracer_interceptor)
stub = command_line_pb2.CommandLineStub(channel)
response = stub.Echo(command_line_pb2.CommandRequest(text='Hello, hello'))
print(response.text)
time.sleep(2)
tracer.close()
time.sleep(2)
def run():
parser = argparse.ArgumentParser()
parser.add_argument(
'--log_payloads',
action='store_true',
help='log request/response objects to open-tracing spans')
args = parser.parse_args()
config = Config(config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
},
service_name='trivial-client')
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_client_interceptor(
tracer, log_payloads=args.log_payloads)
channel = grpc.insecure_channel('localhost:50051')
channel = intercept_channel(channel, tracer_interceptor)
stub = command_line_pb2.CommandLineStub(channel)
response = stub.Echo(command_line_pb2.CommandRequest(text='Hello, hello'))
print(response.text)
time.sleep(2)
tracer.close()
time.sleep(2)
def run():
parser = argparse.ArgumentParser()
parser.add_argument(
'--log_payloads',
action='store_true',
help='log request/response objects to open-tracing spans')
args = parser.parse_args()
config = Config(config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
},
service_name='integration-client')
tracer = config.initialize_tracer()
active_span_source = FixedActiveSpanSource()
tracer_interceptor = open_tracing_client_interceptor(
tracer,
active_span_source=active_span_source,
log_payloads=args.log_payloads)
channel = grpc.insecure_channel('localhost:50051')
channel = intercept_channel(channel, tracer_interceptor)
stub = command_line_pb2.CommandLineStub(channel)
echo(tracer, active_span_source, stub)
time.sleep(2)
tracer.close()
time.sleep(2)
def run():
parser = argparse.ArgumentParser()
parser.add_argument(
'--log_payloads',
action='store_true',
help='log request/response objects to open-tracing spans')
args = parser.parse_args()
config = Config(
config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
},
service_name='integration-client')
tracer = config.initialize_tracer()
active_span_source = FixedActiveSpanSource()
tracer_interceptor = open_tracing_client_interceptor(
tracer,
active_span_source=active_span_source,
log_payloads=args.log_payloads)
channel = grpc.insecure_channel('localhost:50051')
channel = intercept_channel(channel, tracer_interceptor)
stub = command_line_pb2.CommandLineStub(channel)
echo(tracer, active_span_source, stub)
time.sleep(2)
tracer.close()
time.sleep(2)
def wrap_grpc_client_channel(channel):
"""Wraps a GRPC channel with tracing, given a global tracer has been registered"""
if not opentracing.is_global_tracer_registered():
raise Exception(
"Global tracer has not been registered. Disable tracing or "
"register a global tracer")
interceptor = open_tracing_client_interceptor(
opentracing.global_tracer(),
active_span_source=RequestContextSpanSource())
return intercept_channel(channel, interceptor)
def __init__(self,
client_interceptors,
server_interceptors,
handler=Handler()):
self.handler = handler
self._server_pool = logging_pool.pool(2)
self._server = grpcext.intercept_server(grpc.server(self._server_pool),
*server_interceptors)
port = self._server.add_insecure_port('[::]:0')
self._server.add_generic_rpc_handlers(
(_GenericHandler(self.handler), ))
self._server.start()
self.channel = grpcext.intercept_channel(
grpc.insecure_channel('localhost:%d' % port), *client_interceptors)
'reporting_port': '6831',
},
'logging': True,
},
service_name='your-app-name-grpc',
validate=True,
)
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_client_interceptor(tracer)
default_interceptor = DefaultInterceptors()
# 测试 SayHello , :8001
with grpc.insecure_channel("localhost:50051") as channel:
try:
old_intercept_channel = grpc.intercept_channel(channel, default_interceptor)
trace_intercept_channel = intercept_channel(old_intercept_channel, tracer_interceptor)
client = hello_pb2_grpc.HelloServerStub(trace_intercept_channel)
request = hello_pb2.HelloRequest()
request.username = "******"
response, call = client.SayHello.with_call(
request=request,
metadata=(
('initial-metadata-1', 'The value should be str'),
('binary-metadata-bin',
b'With -bin surffix, the value can be bytes'),
('accesstoken', 'gRPC Python is great'),
), timeout=3)
from grpc import insecure_channel
from opentracing import global_tracer
from grpc_opentracing.grpcext import intercept_channel
from grpc_opentracing import open_tracing_client_interceptor
from utils import get_config
# from github_pb2 import Request
from github_pb2_grpc import GistStub
config = get_config('gist-client')
tracer = global_tracer()
tracer_interceptor = open_tracing_client_interceptor(tracer, log_payloads=True)
channel = insecure_channel('gist:50054')
channel = intercept_channel(channel, tracer_interceptor)
gist_stub = GistStub(channel)
# response = gist_stub.GetPublicGist(Request(request_id='foo'))
# print("Greeter client received: " + response.msg)
def _get_channel(self, service, stub):
channel = grpc.insecure_channel(self.uri[service])
if self.interceptor:
logging.info(f'Tracing channel for {service}')
channel = intercept_channel(channel, self.interceptor)
return stub(channel)