func (s *ThriftServer) Start() (err error) { processor := wire.NewBarProcessor(s.Handler) var transport t_thrift.TServerTransport if transport, err = t_thrift.NewTServerSocket(s.options.Bind); err != nil { return } protoFactory := t_thrift.NewTBinaryProtocolFactoryDefault() transportFactory := t_thrift.NewTBufferedTransportFactory( s.BufferSize) s.TServer = t_thrift.NewTSimpleServer4(processor, transport, transportFactory, protoFactory) logx.Debugf("thrift listening at %s", s.options.Info.RPCEndpoints[0]) errChan := make(chan error, 1) go func() { errChan <- s.TServer.Serve() }() defer s.TServer.Stop() defer s.cancel() select { case <-s.ctx.Done(): return case err = <-errChan: return } return }
// Serve requests func (s *TServer) Serve() error { var transport thrift.TServerTransport transport, err := thrift.NewTServerSocket(s.Bind) if err != nil { return err } s.server = thrift.NewTSimpleServer4(s.GetProcessor(), transport, s.TransportFactory, s.ProtoFactory) logx.Infof("serving %s", s) return s.server.Serve() }
func NewTRpcServer(listen string, handler thrift.TProcessor, prot thrift.TProtocolFactory) (*TRpcServer, error) { transport, err := thrift.NewTServerSocket(listen) if err != nil { return nil, err } server := thrift.NewTSimpleServer4( handler, transport, thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()), prot, ) return &TRpcServer{server, transport}, nil }
func main() { transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() serverTransport, err := thrift.NewTServerSocket(NetworkAddr) if err != nil { fmt.Println("new socket fail") } handler := &BsServiceImpl{} processor := bs.NewBSServiceProcessor(handler) server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory) fmt.Println("server start") server.Serve() }
func (s *TServer) Start(transportFactory thrift.TTransportFactory) (err error) { if s.Port, err = fixtures.GetOpenPort(); err != nil { return } protoFactory := thrift.NewTBinaryProtocolFactoryDefault() processor := srv.NewTSrvProcessor(&service{}) var transport thrift.TServerTransport if transport, err = thrift.NewTServerSocket(fmt.Sprintf(":%d", s.Port)); err != nil { return } s.Server = thrift.NewTSimpleServer4(processor, transport, transportFactory, protoFactory) go s.Server.Serve() time.Sleep(time.Millisecond * 100) return }
func newScribeServer(t *testing.T) *scribeServer { protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) var port int var transport *thrift.TServerSocket var err error for i := 0; i < 10; i++ { port = 10000 + rand.Intn(10000) transport, err = thrift.NewTServerSocket(fmt.Sprintf(":%d", port)) if err != nil { t.Logf("port %d: %v", port, err) continue } break } if err != nil { t.Fatal(err) } handler := newScribeHandler(t) server := thrift.NewTSimpleServer4( scribe.NewScribeProcessor(handler), transport, transportFactory, protocolFactory, ) go server.Serve() deadline := time.Now().Add(time.Second) for !canConnect(port) { if time.Now().After(deadline) { t.Fatal("server never started") } time.Sleep(time.Millisecond) } return &scribeServer{ transport: transport, address: fmt.Sprintf("127.0.0.1:%d", port), handler: handler, } }
func main() { // Flag domain. Note that gRPC transitively registers flags via its import // of glog. So, we define a new flag set, to keep those domains distinct. fs := flag.NewFlagSet("", flag.ExitOnError) var ( debugAddr = fs.String("debug.addr", ":8000", "Address for HTTP debug/instrumentation server") httpAddr = fs.String("http.addr", ":8001", "Address for HTTP (JSON) server") grpcAddr = fs.String("grpc.addr", ":8002", "Address for gRPC server") netrpcAddr = fs.String("netrpc.addr", ":8003", "Address for net/rpc server") thriftAddr = fs.String("thrift.addr", ":8004", "Address for Thrift server") thriftProtocol = fs.String("thrift.protocol", "binary", "binary, compact, json, simplejson") thriftBufferSize = fs.Int("thrift.buffer.size", 0, "0 for unbuffered") thriftFramed = fs.Bool("thrift.framed", false, "true to enable framing") zipkinHostPort = fs.String("zipkin.host.port", "my.service.domain:12345", "Zipkin host:port") zipkinServiceName = fs.String("zipkin.service.name", "addsvc", "Zipkin service name") zipkinCollectorAddr = fs.String("zipkin.collector.addr", "", "Zipkin Scribe collector address (empty will log spans)") zipkinCollectorTimeout = fs.Duration("zipkin.collector.timeout", time.Second, "Zipkin collector timeout") zipkinCollectorBatchSize = fs.Int("zipkin.collector.batch.size", 100, "Zipkin collector batch size") zipkinCollectorBatchInterval = fs.Duration("zipkin.collector.batch.interval", time.Second, "Zipkin collector batch interval") ) flag.Usage = fs.Usage // only show our flags if err := fs.Parse(os.Args[1:]); err != nil { fmt.Fprintf(os.Stderr, "%v", err) os.Exit(1) } // package log var logger log.Logger { logger = log.NewLogfmtLogger(os.Stderr) logger = log.NewContext(logger).With("ts", log.DefaultTimestampUTC).With("caller", log.DefaultCaller) stdlog.SetFlags(0) // flags are handled by Go kit's logger stdlog.SetOutput(log.NewStdlibAdapter(logger)) // redirect anything using stdlib log to us } // package metrics var requestDuration metrics.TimeHistogram { requestDuration = metrics.NewTimeHistogram(time.Nanosecond, metrics.NewMultiHistogram( expvar.NewHistogram("request_duration_ns", 0, 5e9, 1, 50, 95, 99), prometheus.NewSummary(stdprometheus.SummaryOpts{ Namespace: "myorg", Subsystem: "addsvc", Name: "duration_ns", Help: "Request duration in nanoseconds.", }, []string{"method"}), )) } // package tracing var collector zipkin.Collector { zipkinLogger := log.NewContext(logger).With("component", "zipkin") collector = loggingCollector{zipkinLogger} // TODO(pb) if *zipkinCollectorAddr != "" { var err error if collector, err = zipkin.NewScribeCollector( *zipkinCollectorAddr, *zipkinCollectorTimeout, zipkin.ScribeBatchSize(*zipkinCollectorBatchSize), zipkin.ScribeBatchInterval(*zipkinCollectorBatchInterval), zipkin.ScribeLogger(zipkinLogger), ); err != nil { zipkinLogger.Log("err", err) os.Exit(1) } } } // Business domain var svc server.AddService { svc = pureAddService{} svc = loggingMiddleware{svc, logger} svc = instrumentingMiddleware{svc, requestDuration} } // Mechanical stuff rand.Seed(time.Now().UnixNano()) root := context.Background() errc := make(chan error) go func() { errc <- interrupt() }() // Debug/instrumentation go func() { transportLogger := log.NewContext(logger).With("transport", "debug") transportLogger.Log("addr", *debugAddr) errc <- http.ListenAndServe(*debugAddr, nil) // DefaultServeMux }() // Transport: HTTP/JSON go func() { var ( transportLogger = log.NewContext(logger).With("transport", "HTTP/JSON") tracingLogger = log.NewContext(transportLogger).With("component", "tracing") newSumSpan = zipkin.MakeNewSpanFunc(*zipkinHostPort, *zipkinServiceName, "sum") newConcatSpan = zipkin.MakeNewSpanFunc(*zipkinHostPort, *zipkinServiceName, "concat") traceSum = zipkin.ToContext(newSumSpan, tracingLogger) traceConcat = zipkin.ToContext(newConcatSpan, tracingLogger) mux = http.NewServeMux() sum, concat endpoint.Endpoint ) sum = makeSumEndpoint(svc) sum = zipkin.AnnotateServer(newSumSpan, collector)(sum) mux.Handle("/sum", httptransport.NewServer( root, sum, server.DecodeSumRequest, server.EncodeSumResponse, httptransport.ServerBefore(traceSum), httptransport.ServerErrorLogger(transportLogger), )) concat = makeConcatEndpoint(svc) concat = zipkin.AnnotateServer(newConcatSpan, collector)(concat) mux.Handle("/concat", httptransport.NewServer( root, concat, server.DecodeConcatRequest, server.EncodeConcatResponse, httptransport.ServerBefore(traceConcat), httptransport.ServerErrorLogger(transportLogger), )) transportLogger.Log("addr", *httpAddr) errc <- http.ListenAndServe(*httpAddr, mux) }() // Transport: gRPC go func() { transportLogger := log.NewContext(logger).With("transport", "gRPC") ln, err := net.Listen("tcp", *grpcAddr) if err != nil { errc <- err return } s := grpc.NewServer() // uses its own, internal context pb.RegisterAddServer(s, grpcBinding{svc}) transportLogger.Log("addr", *grpcAddr) errc <- s.Serve(ln) }() // Transport: net/rpc go func() { transportLogger := log.NewContext(logger).With("transport", "net/rpc") s := rpc.NewServer() if err := s.RegisterName("addsvc", netrpcBinding{svc}); err != nil { errc <- err return } s.HandleHTTP(rpc.DefaultRPCPath, rpc.DefaultDebugPath) transportLogger.Log("addr", *netrpcAddr) errc <- http.ListenAndServe(*netrpcAddr, s) }() // Transport: Thrift go func() { var protocolFactory thrift.TProtocolFactory switch *thriftProtocol { case "binary": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() default: errc <- fmt.Errorf("invalid Thrift protocol %q", *thriftProtocol) return } var transportFactory thrift.TTransportFactory if *thriftBufferSize > 0 { transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize) } else { transportFactory = thrift.NewTTransportFactory() } if *thriftFramed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } transport, err := thrift.NewTServerSocket(*thriftAddr) if err != nil { errc <- err return } transportLogger := log.NewContext(logger).With("transport", "net/rpc") transportLogger.Log("addr", *thriftAddr) errc <- thrift.NewTSimpleServer4( thriftadd.NewAddServiceProcessor(thriftBinding{svc}), transport, transportFactory, protocolFactory, ).Serve() }() logger.Log("fatal", <-errc) }
func main() { // Flag domain. Note that gRPC transitively registers flags via its import // of glog. So, we define a new flag set, to keep those domains distinct. fs := flag.NewFlagSet("", flag.ExitOnError) var ( debugAddr = fs.String("debug.addr", ":8000", "Address for HTTP debug/instrumentation server") httpAddr = fs.String("http.addr", ":8001", "Address for HTTP (JSON) server") grpcAddr = fs.String("grpc.addr", ":8002", "Address for gRPC server") netrpcAddr = fs.String("netrpc.addr", ":8003", "Address for net/rpc server") thriftAddr = fs.String("thrift.addr", ":8004", "Address for Thrift server") thriftProtocol = fs.String("thrift.protocol", "binary", "binary, compact, json, simplejson") thriftBufferSize = fs.Int("thrift.buffer.size", 0, "0 for unbuffered") thriftFramed = fs.Bool("thrift.framed", false, "true to enable framing") proxyHTTPAddr = fs.String("proxy.http.url", "", "if set, proxy requests over HTTP to this addsvc") zipkinServiceName = fs.String("zipkin.service.name", "addsvc", "Zipkin service name") zipkinCollectorAddr = fs.String("zipkin.collector.addr", "", "Zipkin Scribe collector address (empty will log spans)") zipkinCollectorTimeout = fs.Duration("zipkin.collector.timeout", time.Second, "Zipkin collector timeout") zipkinCollectorBatchSize = fs.Int("zipkin.collector.batch.size", 100, "Zipkin collector batch size") zipkinCollectorBatchInterval = fs.Duration("zipkin.collector.batch.interval", time.Second, "Zipkin collector batch interval") ) flag.Usage = fs.Usage // only show our flags fs.Parse(os.Args[1:]) // `package log` domain var logger kitlog.Logger logger = kitlog.NewLogfmtLogger(os.Stderr) logger = kitlog.With(logger, "ts", kitlog.DefaultTimestampUTC) stdlog.SetOutput(kitlog.NewStdlibAdapter(logger)) // redirect stdlib logging to us stdlog.SetFlags(0) // flags are handled in our logger // `package metrics` domain requests := metrics.NewMultiCounter( expvar.NewCounter("requests"), statsd.NewCounter(ioutil.Discard, "requests_total", time.Second), prometheus.NewCounter(stdprometheus.CounterOpts{ Namespace: "addsvc", Subsystem: "add", Name: "requests_total", Help: "Total number of received requests.", }, []string{}), ) duration := metrics.NewTimeHistogram(time.Nanosecond, metrics.NewMultiHistogram( expvar.NewHistogram("duration_nanoseconds_total", 0, 1e9, 3, 50, 95, 99), statsd.NewHistogram(ioutil.Discard, "duration_nanoseconds_total", time.Second), prometheus.NewSummary(stdprometheus.SummaryOpts{ Namespace: "addsvc", Subsystem: "add", Name: "duration_nanoseconds_total", Help: "Total nanoseconds spend serving requests.", }, []string{}), )) // `package tracing` domain zipkinHostPort := "localhost:1234" // TODO Zipkin makes overly simple assumptions about services var zipkinCollector zipkin.Collector = loggingCollector{logger} if *zipkinCollectorAddr != "" { var err error if zipkinCollector, err = zipkin.NewScribeCollector( *zipkinCollectorAddr, *zipkinCollectorTimeout, *zipkinCollectorBatchSize, *zipkinCollectorBatchInterval, ); err != nil { logger.Log("err", err) os.Exit(1) } } zipkinMethodName := "add" zipkinSpanFunc := zipkin.MakeNewSpanFunc(zipkinHostPort, *zipkinServiceName, zipkinMethodName) zipkin.Log.Swap(logger) // log diagnostic/error details // Our business and operational domain var a Add = pureAdd if *proxyHTTPAddr != "" { var e endpoint.Endpoint e = httpclient.NewClient("GET", *proxyHTTPAddr, zipkin.ToRequest(zipkinSpanFunc)) e = zipkin.AnnotateClient(zipkinSpanFunc, zipkinCollector)(e) a = proxyAdd(e, logger) } a = logging(logger)(a) a = instrument(requests, duration)(a) // Server domain var e endpoint.Endpoint e = makeEndpoint(a) e = zipkin.AnnotateServer(zipkinSpanFunc, zipkinCollector)(e) // Mechanical stuff rand.Seed(time.Now().UnixNano()) root := context.Background() errc := make(chan error) go func() { errc <- interrupt() }() // Transport: HTTP (debug/instrumentation) go func() { logger.Log("addr", *debugAddr, "transport", "debug") errc <- http.ListenAndServe(*debugAddr, nil) }() // Transport: HTTP (JSON) go func() { ctx, cancel := context.WithCancel(root) defer cancel() before := []httptransport.BeforeFunc{zipkin.ToContext(zipkinSpanFunc)} after := []httptransport.AfterFunc{} handler := makeHTTPBinding(ctx, e, before, after) logger.Log("addr", *httpAddr, "transport", "HTTP/JSON") errc <- http.ListenAndServe(*httpAddr, handler) }() // Transport: gRPC go func() { ln, err := net.Listen("tcp", *grpcAddr) if err != nil { errc <- err return } s := grpc.NewServer() // uses its own context? pb.RegisterAddServer(s, grpcBinding{e}) logger.Log("addr", *grpcAddr, "transport", "gRPC") errc <- s.Serve(ln) }() // Transport: net/rpc go func() { ctx, cancel := context.WithCancel(root) defer cancel() s := rpc.NewServer() s.RegisterName("addsvc", NetrpcBinding{ctx, e}) s.HandleHTTP(rpc.DefaultRPCPath, rpc.DefaultDebugPath) logger.Log("addr", *netrpcAddr, "transport", "net/rpc") errc <- http.ListenAndServe(*netrpcAddr, s) }() // Transport: Thrift go func() { ctx, cancel := context.WithCancel(root) defer cancel() var protocolFactory thrift.TProtocolFactory switch *thriftProtocol { case "binary": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() default: errc <- fmt.Errorf("invalid Thrift protocol %q", *thriftProtocol) return } var transportFactory thrift.TTransportFactory if *thriftBufferSize > 0 { transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize) } else { transportFactory = thrift.NewTTransportFactory() } if *thriftFramed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } transport, err := thrift.NewTServerSocket(*thriftAddr) if err != nil { errc <- err return } logger.Log("addr", *thriftAddr, "transport", "Thrift") errc <- thrift.NewTSimpleServer4( thriftadd.NewAddServiceProcessor(thriftBinding{ctx, e}), transport, transportFactory, protocolFactory, ).Serve() }() logger.Log("fatal", <-errc) }
func main() { // Flag domain. Note that gRPC transitively registers flags via its import // of glog. So, we define a new flag set, to keep those domains distinct. fs := flag.NewFlagSet("", flag.ExitOnError) var ( debugAddr = fs.String("debug.addr", ":8000", "Address for HTTP debug/instrumentation server") httpAddr = fs.String("http.addr", ":8001", "Address for HTTP (JSON) server") grpcAddr = fs.String("grpc.addr", ":8002", "Address for gRPC server") netrpcAddr = fs.String("netrpc.addr", ":8003", "Address for net/rpc server") thriftAddr = fs.String("thrift.addr", ":8004", "Address for Thrift server") thriftProtocol = fs.String("thrift.protocol", "binary", "binary, compact, json, simplejson") thriftBufferSize = fs.Int("thrift.buffer.size", 0, "0 for unbuffered") thriftFramed = fs.Bool("thrift.framed", false, "true to enable framing") // Supported OpenTracing backends zipkinAddr = fs.String("zipkin.kafka.addr", "", "Enable Zipkin tracing via a Kafka server host:port") appdashAddr = fs.String("appdash.addr", "", "Enable Appdash tracing via an Appdash server host:port") lightstepAccessToken = fs.String("lightstep.token", "", "Enable LightStep tracing via a LightStep access token") ) flag.Usage = fs.Usage // only show our flags if err := fs.Parse(os.Args[1:]); err != nil { fmt.Fprintf(os.Stderr, "%v", err) os.Exit(1) } // package log var logger log.Logger { logger = log.NewLogfmtLogger(os.Stderr) logger = log.NewContext(logger).With("ts", log.DefaultTimestampUTC).With("caller", log.DefaultCaller) stdlog.SetFlags(0) // flags are handled by Go kit's logger stdlog.SetOutput(log.NewStdlibAdapter(logger)) // redirect anything using stdlib log to us } // package metrics var requestDuration metrics.TimeHistogram { requestDuration = metrics.NewTimeHistogram(time.Nanosecond, metrics.NewMultiHistogram( "request_duration_ns", expvar.NewHistogram("request_duration_ns", 0, 5e9, 1, 50, 95, 99), prometheus.NewSummary(stdprometheus.SummaryOpts{ Namespace: "myorg", Subsystem: "addsvc", Name: "duration_ns", Help: "Request duration in nanoseconds.", }, []string{"method"}), )) } // Set up OpenTracing var tracer opentracing.Tracer { switch { case *appdashAddr != "" && *lightstepAccessToken == "" && *zipkinAddr == "": tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr)) case *appdashAddr == "" && *lightstepAccessToken != "" && *zipkinAddr == "": tracer = lightstep.NewTracer(lightstep.Options{ AccessToken: *lightstepAccessToken, }) defer lightstep.FlushLightStepTracer(tracer) case *appdashAddr == "" && *lightstepAccessToken == "" && *zipkinAddr != "": collector, err := zipkin.NewKafkaCollector( strings.Split(*zipkinAddr, ","), zipkin.KafkaLogger(logger), ) if err != nil { logger.Log("err", "unable to create collector", "fatal", err) os.Exit(1) } tracer, err = zipkin.NewTracer( zipkin.NewRecorder(collector, false, "localhost:80", "addsvc"), ) if err != nil { logger.Log("err", "unable to create zipkin tracer", "fatal", err) os.Exit(1) } case *appdashAddr == "" && *lightstepAccessToken == "" && *zipkinAddr == "": tracer = opentracing.GlobalTracer() // no-op default: logger.Log("fatal", "specify a single -appdash.addr, -lightstep.access.token or -zipkin.kafka.addr") os.Exit(1) } } // Business domain var svc server.AddService { svc = pureAddService{} svc = loggingMiddleware{svc, logger} svc = instrumentingMiddleware{svc, requestDuration} } // Mechanical stuff rand.Seed(time.Now().UnixNano()) root := context.Background() errc := make(chan error) go func() { errc <- interrupt() }() // Debug/instrumentation go func() { transportLogger := log.NewContext(logger).With("transport", "debug") transportLogger.Log("addr", *debugAddr) errc <- http.ListenAndServe(*debugAddr, nil) // DefaultServeMux }() // Transport: HTTP/JSON go func() { var ( transportLogger = log.NewContext(logger).With("transport", "HTTP/JSON") tracingLogger = log.NewContext(transportLogger).With("component", "tracing") mux = http.NewServeMux() sum, concat endpoint.Endpoint ) sum = makeSumEndpoint(svc) sum = kitot.TraceServer(tracer, "sum")(sum) mux.Handle("/sum", httptransport.NewServer( root, sum, server.DecodeSumRequest, server.EncodeSumResponse, httptransport.ServerErrorLogger(transportLogger), httptransport.ServerBefore(kitot.FromHTTPRequest(tracer, "sum", tracingLogger)), )) concat = makeConcatEndpoint(svc) concat = kitot.TraceServer(tracer, "concat")(concat) mux.Handle("/concat", httptransport.NewServer( root, concat, server.DecodeConcatRequest, server.EncodeConcatResponse, httptransport.ServerErrorLogger(transportLogger), httptransport.ServerBefore(kitot.FromHTTPRequest(tracer, "concat", tracingLogger)), )) transportLogger.Log("addr", *httpAddr) errc <- http.ListenAndServe(*httpAddr, mux) }() // Transport: gRPC go func() { transportLogger := log.NewContext(logger).With("transport", "gRPC") tracingLogger := log.NewContext(transportLogger).With("component", "tracing") ln, err := net.Listen("tcp", *grpcAddr) if err != nil { errc <- err return } s := grpc.NewServer() // uses its own, internal context pb.RegisterAddServer(s, newGRPCBinding(root, tracer, svc, tracingLogger)) transportLogger.Log("addr", *grpcAddr) errc <- s.Serve(ln) }() // Transport: net/rpc go func() { transportLogger := log.NewContext(logger).With("transport", "net/rpc") s := rpc.NewServer() if err := s.RegisterName("addsvc", netrpcBinding{svc}); err != nil { errc <- err return } s.HandleHTTP(rpc.DefaultRPCPath, rpc.DefaultDebugPath) transportLogger.Log("addr", *netrpcAddr) errc <- http.ListenAndServe(*netrpcAddr, s) }() // Transport: Thrift go func() { var protocolFactory thrift.TProtocolFactory switch *thriftProtocol { case "binary": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() default: errc <- fmt.Errorf("invalid Thrift protocol %q", *thriftProtocol) return } var transportFactory thrift.TTransportFactory if *thriftBufferSize > 0 { transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize) } else { transportFactory = thrift.NewTTransportFactory() } if *thriftFramed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } transport, err := thrift.NewTServerSocket(*thriftAddr) if err != nil { errc <- err return } transportLogger := log.NewContext(logger).With("transport", "thrift") transportLogger.Log("addr", *thriftAddr) errc <- thrift.NewTSimpleServer4( thriftadd.NewAddServiceProcessor(thriftBinding{svc}), transport, transportFactory, protocolFactory, ).Serve() }() logger.Log("fatal", <-errc) }
func main() { var ( debugAddr = flag.String("debug.addr", ":8080", "Debug and metrics listen address") httpAddr = flag.String("http.addr", ":8081", "HTTP listen address") grpcAddr = flag.String("grpc.addr", ":8082", "gRPC (HTTP) listen address") thriftAddr = flag.String("thrift.addr", ":8083", "Thrift listen address") thriftProtocol = flag.String("thrift.protocol", "binary", "binary, compact, json, simplejson") thriftBufferSize = flag.Int("thrift.buffer.size", 0, "0 for unbuffered") thriftFramed = flag.Bool("thrift.framed", false, "true to enable framing") zipkinAddr = flag.String("zipkin.addr", "", "Enable Zipkin tracing via a Kafka server host:port") appdashAddr = flag.String("appdash.addr", "", "Enable Appdash tracing via an Appdash server host:port") lightstepToken = flag.String("lightstep.token", "", "Enable LightStep tracing via a LightStep access token") ) flag.Parse() // Logging domain. var logger log.Logger { logger = log.NewLogfmtLogger(os.Stdout) logger = log.NewContext(logger).With("ts", log.DefaultTimestampUTC) logger = log.NewContext(logger).With("caller", log.DefaultCaller) } logger.Log("msg", "hello") defer logger.Log("msg", "goodbye") // Metrics domain. var ints, chars metrics.Counter { // Business level metrics. ints = prometheus.NewCounter(stdprometheus.CounterOpts{ Namespace: "addsvc", Name: "integers_summed", Help: "Total count of integers summed via the Sum method.", }, []string{}) chars = prometheus.NewCounter(stdprometheus.CounterOpts{ Namespace: "addsvc", Name: "characters_concatenated", Help: "Total count of characters concatenated via the Concat method.", }, []string{}) } var duration metrics.TimeHistogram { // Transport level metrics. duration = metrics.NewTimeHistogram(time.Nanosecond, prometheus.NewSummary(stdprometheus.SummaryOpts{ Namespace: "addsvc", Name: "request_duration_ns", Help: "Request duration in nanoseconds.", }, []string{"method", "success"})) } // Tracing domain. var tracer stdopentracing.Tracer { if *zipkinAddr != "" { logger := log.NewContext(logger).With("tracer", "Zipkin") logger.Log("addr", *zipkinAddr) collector, err := zipkin.NewKafkaCollector( strings.Split(*zipkinAddr, ","), zipkin.KafkaLogger(logger), ) if err != nil { logger.Log("err", err) os.Exit(1) } tracer, err = zipkin.NewTracer( zipkin.NewRecorder(collector, false, "localhost:80", "addsvc"), ) if err != nil { logger.Log("err", err) os.Exit(1) } } else if *appdashAddr != "" { logger := log.NewContext(logger).With("tracer", "Appdash") logger.Log("addr", *appdashAddr) tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr)) } else if *lightstepToken != "" { logger := log.NewContext(logger).With("tracer", "LightStep") logger.Log() // probably don't want to print out the token :) tracer = lightstep.NewTracer(lightstep.Options{ AccessToken: *lightstepToken, }) defer lightstep.FlushLightStepTracer(tracer) } else { logger := log.NewContext(logger).With("tracer", "none") logger.Log() tracer = stdopentracing.GlobalTracer() // no-op } } // Business domain. var service addsvc.Service { service = addsvc.NewBasicService() service = addsvc.ServiceLoggingMiddleware(logger)(service) service = addsvc.ServiceInstrumentingMiddleware(ints, chars)(service) } // Endpoint domain. var sumEndpoint endpoint.Endpoint { sumDuration := duration.With(metrics.Field{Key: "method", Value: "Sum"}) sumLogger := log.NewContext(logger).With("method", "Sum") sumEndpoint = addsvc.MakeSumEndpoint(service) sumEndpoint = opentracing.TraceServer(tracer, "Sum")(sumEndpoint) sumEndpoint = addsvc.EndpointInstrumentingMiddleware(sumDuration)(sumEndpoint) sumEndpoint = addsvc.EndpointLoggingMiddleware(sumLogger)(sumEndpoint) } var concatEndpoint endpoint.Endpoint { concatDuration := duration.With(metrics.Field{Key: "method", Value: "Concat"}) concatLogger := log.NewContext(logger).With("method", "Concat") concatEndpoint = addsvc.MakeConcatEndpoint(service) concatEndpoint = opentracing.TraceServer(tracer, "Concat")(concatEndpoint) concatEndpoint = addsvc.EndpointInstrumentingMiddleware(concatDuration)(concatEndpoint) concatEndpoint = addsvc.EndpointLoggingMiddleware(concatLogger)(concatEndpoint) } endpoints := addsvc.Endpoints{ SumEndpoint: sumEndpoint, ConcatEndpoint: concatEndpoint, } // Mechanical domain. errc := make(chan error) ctx := context.Background() // Interrupt handler. go func() { c := make(chan os.Signal, 1) signal.Notify(c, syscall.SIGINT, syscall.SIGTERM) errc <- fmt.Errorf("%s", <-c) }() // Debug listener. go func() { logger := log.NewContext(logger).With("transport", "debug") m := http.NewServeMux() m.Handle("/debug/pprof/", http.HandlerFunc(pprof.Index)) m.Handle("/debug/pprof/cmdline", http.HandlerFunc(pprof.Cmdline)) m.Handle("/debug/pprof/profile", http.HandlerFunc(pprof.Profile)) m.Handle("/debug/pprof/symbol", http.HandlerFunc(pprof.Symbol)) m.Handle("/debug/pprof/trace", http.HandlerFunc(pprof.Trace)) m.Handle("/metrics", stdprometheus.Handler()) logger.Log("addr", *debugAddr) errc <- http.ListenAndServe(*debugAddr, m) }() // HTTP transport. go func() { logger := log.NewContext(logger).With("transport", "HTTP") h := addsvc.MakeHTTPHandler(ctx, endpoints, tracer, logger) logger.Log("addr", *httpAddr) errc <- http.ListenAndServe(*httpAddr, h) }() // gRPC transport. go func() { logger := log.NewContext(logger).With("transport", "gRPC") ln, err := net.Listen("tcp", *grpcAddr) if err != nil { errc <- err return } srv := addsvc.MakeGRPCServer(ctx, endpoints, tracer, logger) s := grpc.NewServer() pb.RegisterAddServer(s, srv) logger.Log("addr", *grpcAddr) errc <- s.Serve(ln) }() // Thrift transport. go func() { logger := log.NewContext(logger).With("transport", "Thrift") var protocolFactory thrift.TProtocolFactory switch *thriftProtocol { case "binary": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() default: errc <- fmt.Errorf("invalid Thrift protocol %q", *thriftProtocol) return } var transportFactory thrift.TTransportFactory if *thriftBufferSize > 0 { transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize) } else { transportFactory = thrift.NewTTransportFactory() } if *thriftFramed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } transport, err := thrift.NewTServerSocket(*thriftAddr) if err != nil { errc <- err return } logger.Log("addr", *thriftAddr) errc <- thrift.NewTSimpleServer4( thriftadd.NewAddServiceProcessor(addsvc.MakeThriftHandler(ctx, endpoints)), transport, transportFactory, protocolFactory, ).Serve() }() // Run! logger.Log("exit", <-errc) }