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)