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():
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 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, consul=False, tracer=None):
self.interceptor = None
# Init tracing if enabled
if tracer:
logging.info('gRPC channel tracing enabled')
self.interceptor = open_tracing_client_interceptor(tracer)
# not auto filled in, call refresh() or refresh_all()
self.uri = Box()
self.channel = Box()
if consul:
self.consul = True
logging.info('Using Consul to resolve backends.')
else:
for service, stub in services.items():
self.uri[service] = '{}:{}'.format(FLAGS.monolithic_host,
FLAGS.monolithic_port)
self.channel[service] = self._get_channel(service, stub)
def setUp(self):
self._tracer = Tracer()
self._service = Service([open_tracing_client_interceptor(self._tracer)],
[open_tracing_server_interceptor(self._tracer)],
ExceptionErroringHandler())
def setUp(self):
self._tracer = Tracer()
self._service = Service([open_tracing_client_interceptor(self._tracer)],
[open_tracing_server_interceptor(self._tracer)])
config={ # usually read from some yaml config
'sampler': {
'type': 'const', # 全部
'param': 1, # 1开启全部采样 0 关闭全部采样
},
'local_agent': {
'reporting_host': '127.0.0.1',
'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=(
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)
