def serve():
config = Config(
config={
"sampler": {
"type": "const",
"param": 1
},
"logging": True
},
service_name="chat-server",
)
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_server_interceptor(tracer,
log_payloads=True)
redis_opentracing.init_tracing(tracer_interceptor)
redis_client = Redis()
kafka_producer = KafkaProducer(
bootstrap_servers="127.0.0.1:9092",
value_serializer=lambda v: json.dumps(v).encode("utf-8"),
)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
chat_pb2_grpc.add_ChatServicer_to_server(
ChatServicer(tracer, redis_client, kafka_producer), server)
server.add_insecure_port("[::]:50051")
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
def serve():
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-server')
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_server_interceptor(
tracer, log_payloads=args.log_payloads)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
command_line_pb2.add_CommandLineServicer_to_server(CommandLine(), server)
server.add_insecure_port('[::]:50051')
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
time.sleep(2)
tracer.close()
time.sleep(2)
def grpc_prediction_server():
if args.tracing:
from grpc_opentracing import open_tracing_server_interceptor
logger.info("Adding tracer")
tracer = setup_tracing(args.interface_name)
interceptor = open_tracing_server_interceptor(tracer)
else:
interceptor = None
server = seldon_microservice.get_grpc_server(
user_object,
seldon_metrics,
annotations=annotations,
trace_interceptor=interceptor,
)
try:
user_object.load()
except (NotImplementedError, AttributeError):
pass
server.add_insecure_port(f"0.0.0.0:{grpc_port}")
server.start()
logger.info("GRPC microservice Running on port %i", grpc_port)
while True:
time.sleep(1000)
def _run_grpc_server(bind_address):
"""Start a server in a subprocess."""
logger.info(f"Starting new GRPC server with {args.grpc_threads}.")
if args.tracing:
from grpc_opentracing import open_tracing_server_interceptor
logger.info("Adding tracer")
tracer = setup_tracing(args.interface_name)
interceptor = open_tracing_server_interceptor(tracer)
else:
interceptor = None
server = seldon_microservice.get_grpc_server(
user_object,
seldon_metrics,
annotations=annotations,
trace_interceptor=interceptor,
num_threads=args.grpc_threads,
)
try:
user_object.load()
except (NotImplementedError, AttributeError):
pass
server.add_insecure_port(bind_address)
server.start()
_wait_forever(server)
def serve():
"""Read in key and cert and start's serving the server."""
Configuration.tracer = init_jaeger_tracer("stub_api")
# read in key and certificate
with open("certs/tls.key", "rb") as f:
private_key = f.read()
with open("certs/tls.crt", "rb") as f:
certificate_chain = f.read()
# create server credentials
server_credentials = grpc.ssl_server_credentials(
((private_key, certificate_chain), ))
tracer_interceptor = open_tracing_server_interceptor(Configuration.tracer)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
stub_pb2_grpc.add_StubServicer_to_server(
StubServicer(Configuration.tracer), server)
server.add_secure_port(f"[::]:{Configuration.GRPC_PORT}",
server_credentials)
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
Configuration.tracer.close()
def new_tracer(cls,
tracer_type,
tracer_config,
span_decorator=None,
**kwargs):
if not tracer_type:
return Tracer()
config = tracer_config.TRACING_CONFIG
service_name = tracer_config.TRACING_SERVICE_NAME
validate = tracer_config.TRACING_VALIDATE
# if not tracer_type:
# tracer_type = 'jaeger'
# config = tracer_config.DEFAULT_TRACING_CONFIG
if tracer_type.lower() == 'jaeger':
config = Config(config=config,
service_name=service_name,
validate=validate)
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_server_interceptor(
tracer,
log_payloads=tracer_config.TRACING_LOG_PAYLOAD,
span_decorator=span_decorator)
return Tracer(tracer, tracer_interceptor, intercept_server)
assert False, 'Unsupported tracer type: {}'.format(tracer_type)
def intercept_server(server):
"""Attaches gRPC opentracing interceptor to a server.
Args:
server: gRPC server to intercept
Returns:
server
"""
return _InterceptorServer(
server,
open_tracing_server_interceptor(global_tracer(), log_payloads=True))
def serve():
config = get_config('account-server')
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_server_interceptor(tracer,
log_payloads=True)
server = grpc.server(ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
add_AccountServicer_to_server(Account(), server)
server.add_insecure_port('[::]:50051')
server.start()
wait_for_termination()
server.stop(0)
tracer.close()
def serve():
grpc_server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
tracer_interceptor = open_tracing_server_interceptor(tracer)
grpc_server = intercept_server(grpc_server, tracer_interceptor)
hello_pb2_grpc.add_HelloServerServicer_to_server(Greeter(), grpc_server)
grpc_server.add_insecure_port('[::]:50051')
grpc_server.start()
# grpc_server.wait_for_termination()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
grpc_server.stop(0)
tracer.close()
def Create(cls, plugin_config, **kwargs):
tracing_config = plugin_config.TRACING_CONFIG
span_decorator = kwargs.pop('span_decorator', None)
service_name = plugin_config.TRACING_SERVICE_NAME
validate = plugin_config.TRACING_VALIDATE
config = Config(config=tracing_config,
service_name=service_name,
validate=validate)
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_server_interceptor(
tracer,
log_payloads=plugin_config.TRACING_LOG_PAYLOAD,
span_decorator=span_decorator)
return Tracer(tracer, tracer_interceptor, intercept_server)
def grpc_prediction_server():
if args.tracing:
from grpc_opentracing import open_tracing_server_interceptor
logger.info("Adding tracer")
interceptor = open_tracing_server_interceptor(tracer)
else:
interceptor = None
server = seldon_microservice.get_grpc_server(
user_object, debug=DEBUG, annotations=annotations, trace_interceptor=interceptor)
server.add_insecure_port("0.0.0.0:{}".format(port))
server.start()
logger.info("GRPC microservice Running on port %i",port)
while True:
time.sleep(1000)
def serve():
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-server')
tracer = config.initialize_tracer()
span_decorator = None
if args.include_grpc_tags:
span_decorator = StoreSpanDecorator()
tracer_interceptor = open_tracing_server_interceptor(
tracer, log_payloads=args.log_payloads, span_decorator=span_decorator)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
store_pb2.add_StoreServicer_to_server(Store(), server)
server.add_insecure_port('[::]:50051')
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
time.sleep(2)
tracer.close()
time.sleep(2)
def serve(self):
config = Config(
config={ # usually read from some yaml config
'sampler': {
'type': 'const', # 全部
'param': 1, # 1 开启全部采样 0 表示关闭全部采样
},
'local_agent': {
'reporting_host': '192.168.0.14',
'reporting_port': '6831',
},
'logging': True,
},
service_name='order-srv',
validate=True,
)
tracer = config.initialize_tracer()
self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=40))
tracing_interceptor = open_tracing_server_interceptor(tracer)
self.server = intercept_server(self.server, tracing_interceptor)
order_pb2_grpc.add_OrderServicer_to_server(OrderService(), self.server)
health_servicer = health.HealthServicer()
health_pb2_grpc.add_HealthServicer_to_server(health_servicer,
self.server)
self.server.add_insecure_port(f'[::]:{self.SERVICE_PORT}')
signal.signal(signal.SIGINT, self.onExit)
signal.signal(signal.SIGTERM, self.onExit)
logger.info("Start Order Service at {}:{}".format(
self.SERVICE_HOST, self.SERVICE_PORT))
self.server.start()
self.register()
#监听超时订单消息
consumer = PushConsumer("mxshop_order")
consumer.set_name_server_address(
f"{settings.RocketMQ_HOST}:{settings.RocketMQ_PORT}")
consumer.subscribe("order_timeout", order_timeout)
consumer.start()
self.server.wait_for_termination()
consumer.shutdown()
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_server_interceptor(self._tracer)])
def intercept_grpc_server(server, tracer):
tracer_interceptor = open_tracing_server_interceptor(tracer)
new_server = intercept_server(server, tracer_interceptor)
return new_server
def _enable_trace(self, server, tracer):
from grpc_opentracing import open_tracing_server_interceptor
from grpc_opentracing.grpcext import intercept_server
tracer_interceptor = open_tracing_server_interceptor(tracer)
return intercept_server(server, tracer_interceptor)
