// MakeHTTPHandler mounts the endpoints into a REST-y HTTP handler. func MakeHTTPHandler(ctx context.Context, e Endpoints, imagePath string, logger log.Logger) http.Handler { r := mux.NewRouter().StrictSlash(false) options := []httptransport.ServerOption{ httptransport.ServerErrorLogger(logger), httptransport.ServerErrorEncoder(encodeError), } // GET /catalogue List // GET /catalogue/size Count // GET /catalogue/{id} Get // GET /tags Tags // GET /health Health Check r.Methods("GET").Path("/catalogue").Handler(httptransport.NewServer( ctx, e.ListEndpoint, decodeListRequest, encodeListResponse, options..., )) r.Methods("GET").Path("/catalogue/size").Handler(httptransport.NewServer( ctx, e.CountEndpoint, decodeCountRequest, encodeResponse, options..., )) r.Methods("GET").Path("/catalogue/{id}").Handler(httptransport.NewServer( ctx, e.GetEndpoint, decodeGetRequest, encodeGetResponse, // special case, this one can have an error options..., )) r.Methods("GET").Path("/tags").Handler(httptransport.NewServer( ctx, e.TagsEndpoint, decodeTagsRequest, encodeResponse, options..., )) r.Methods("GET").PathPrefix("/catalogue/images/").Handler(http.StripPrefix( "/catalogue/images/", http.FileServer(http.Dir(imagePath)), )) r.Methods("GET").PathPrefix("/health").Handler(httptransport.NewServer( ctx, e.HealthEndpoint, decodeHealthRequest, encodeHealthResponse, options..., )) r.Handle("/metrics", promhttp.Handler()) return r }
func createHealthCheckRouter(logger kitlog.Logger, ctx context.Context, healthCheckEndpoint endpoint.HealthCheckServicer) *mux.Router { router := mux.NewRouter() router.Handle("/healthcheck", kithttp.NewServer( ctx, healthCheckEndpoint.Run, func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil }, encodeHealthCheckHTTPResponse, kithttp.ServerErrorLogger(logger), )).Methods(getHTTPMethod) return router }
func createApplicationRouter(logger kitlog.Logger, ctx context.Context, c *config.Configuration, sensorReadingsServicer endpoint.SensorReadingsServicer) *mux.Router { router := mux.NewRouter() router.Handle("/api/v1/sensor_readings", kithttp.NewServer( ctx, endpoint.VerifyAPIKey(c.APITokens)(sensorReadingsServicer.HandleMeasurementMessage), decodeSensorReadingsHTTPRequest, encodeSensorReadingsHTTPResponse, kithttp.ServerErrorEncoder(errorEncoder), kithttp.ServerErrorLogger(logger), )).Methods(postHTTPMethod) return router }
// MakeHandler returns a handler for the tracking service. func MakeHandler(ctx context.Context, ts Service, logger kitlog.Logger) http.Handler { r := mux.NewRouter() opts := []kithttp.ServerOption{ kithttp.ServerErrorLogger(logger), kithttp.ServerErrorEncoder(encodeError), } trackCargoHandler := kithttp.NewServer( ctx, makeTrackCargoEndpoint(ts), decodeTrackCargoRequest, encodeResponse, opts..., ) r.Handle("/tracking/v1/cargos/{id}", trackCargoHandler).Methods("GET") return r }
// MakeHandler returns a handler for the handling service. func MakeHandler(ctx context.Context, hs Service, logger kitlog.Logger) http.Handler { r := mux.NewRouter() opts := []kithttp.ServerOption{ kithttp.ServerErrorLogger(logger), kithttp.ServerErrorEncoder(encodeError), } registerIncidentHandler := kithttp.NewServer( ctx, makeRegisterIncidentEndpoint(hs), decodeRegisterIncidentRequest, encodeResponse, opts..., ) r.Handle("/handling/v1/incidents", registerIncidentHandler).Methods("POST") return r }
// MakeHTTPHandler returns a handler that makes a set of endpoints available // on predefined paths. func MakeHTTPHandler(ctx context.Context, endpoints Endpoints, tracer stdopentracing.Tracer, logger log.Logger) http.Handler { options := []httptransport.ServerOption{ httptransport.ServerErrorEncoder(errorEncoder), httptransport.ServerErrorLogger(logger), } m := http.NewServeMux() m.Handle("/sum", httptransport.NewServer( ctx, endpoints.SumEndpoint, DecodeHTTPSumRequest, EncodeHTTPGenericResponse, append(options, httptransport.ServerBefore(opentracing.FromHTTPRequest(tracer, "Sum", logger)))..., )) m.Handle("/concat", httptransport.NewServer( ctx, endpoints.ConcatEndpoint, DecodeHTTPConcatRequest, EncodeHTTPGenericResponse, append(options, httptransport.ServerBefore(opentracing.FromHTTPRequest(tracer, "Concat", logger)))..., )) return m }
// MakeHTTPHandler mounts the endpoints into a REST-y HTTP handler. func MakeHTTPHandler(ctx context.Context, e Endpoints, logger log.Logger) http.Handler { r := mux.NewRouter().StrictSlash(false) options := []httptransport.ServerOption{ httptransport.ServerErrorLogger(logger), httptransport.ServerErrorEncoder(encodeError), } // GET /login Login // GET /register Register // GET /health Health Check r.Methods("GET").Path("/login").Handler(httptransport.NewServer( ctx, e.LoginEndpoint, decodeLoginRequest, encodeResponse, options..., )) r.Methods("POST").Path("/register").Handler(httptransport.NewServer( ctx, e.RegisterEndpoint, decodeRegisterRequest, encodeResponse, options..., )) r.Methods("GET").PathPrefix("/customers").Handler(httptransport.NewServer( ctx, e.UserGetEndpoint, decodeGetRequest, encodeResponse, options..., )) r.Methods("GET").PathPrefix("/cards").Handler(httptransport.NewServer( ctx, e.CardGetEndpoint, decodeGetRequest, encodeResponse, options..., )) r.Methods("GET").PathPrefix("/addresses").Handler(httptransport.NewServer( ctx, e.AddressGetEndpoint, decodeGetRequest, encodeResponse, options..., )) r.Methods("POST").Path("/customers").Handler(httptransport.NewServer( ctx, e.UserPostEndpoint, decodeUserRequest, encodeResponse, options..., )) r.Methods("POST").Path("/addresses").Handler(httptransport.NewServer( ctx, e.AddressPostEndpoint, decodeAddressRequest, encodeResponse, options..., )) r.Methods("POST").Path("/cards").Handler(httptransport.NewServer( ctx, e.CardPostEndpoint, decodeCardRequest, encodeResponse, options..., )) r.Methods("DELETE").PathPrefix("/").Handler(httptransport.NewServer( ctx, e.DeleteEndpoint, decodeDeleteRequest, encodeResponse, options..., )) r.Methods("GET").PathPrefix("/health").Handler(httptransport.NewServer( ctx, e.HealthEndpoint, decodeHealthRequest, encodeHealthResponse, options..., )) r.Handle("/metrics", promhttp.Handler()) return r }
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) }
// MakeHTTPHandler mounts all of the service endpoints into an http.Handler. // Useful in a restsvc server. func MakeHTTPHandler(ctx context.Context, s Service, logger log.Logger) http.Handler { r := mux.NewRouter() e := MakeServerEndpoints(s) options := []httptransport.ServerOption{ httptransport.ServerErrorLogger(logger), httptransport.ServerErrorEncoder(encodeError), } // POST /configs/ adds another config // GET /configs/:id retrieves the given config by id // PUT /configs/:id post updated config information about the config // PATCH /configs/:id partial updated config information // DELETE /configs/:id remove the given config // GET /configs/:id/channels/ retrieve channels associated with the config // GET /configs/:id/channels/:channelID retrieve a particular config channel // POST /configs/:id/channels/ add a new channel // DELETE /configs/:id/channels/:channelID remove an channel r.Methods("POST").Path("/api/configs/").Handler(httptransport.NewServer( ctx, e.PostConfigEndpoint, decodePostConfigRequest, encodeResponse, options..., )) r.Methods("GET").Path("/api/configs/{id}").Handler(httptransport.NewServer( ctx, e.GetConfigEndpoint, decodeGetConfigRequest, encodeResponse, options..., )) r.Methods("PUT").Path("/api/configs/{id}").Handler(httptransport.NewServer( ctx, e.PutConfigEndpoint, decodePutConfigRequest, encodeResponse, options..., )) r.Methods("PATCH").Path("/api/configs/{id}").Handler(httptransport.NewServer( ctx, e.PatchConfigEndpoint, decodePatchConfigRequest, encodeResponse, options..., )) r.Methods("DELETE").Path("/api/configs/{id}").Handler(httptransport.NewServer( ctx, e.DeleteConfigEndpoint, decodeDeleteConfigRequest, encodeResponse, options..., )) r.Methods("GET").Path("/api/configs/{id}/channels/").Handler(httptransport.NewServer( ctx, e.GetChannelsEndpoint, decodeGetChannelsRequest, encodeResponse, options..., )) r.Methods("GET").Path("/api/configs/{id}/channels/{channelID}").Handler(httptransport.NewServer( ctx, e.GetChannelEndpoint, decodeGetChannelRequest, encodeResponse, options..., )) r.Methods("POST").Path("/api/configs/{id}/channels/").Handler(httptransport.NewServer( ctx, e.PostChannelEndpoint, decodePostChannelRequest, encodeResponse, options..., )) r.Methods("DELETE").Path("/api/configs/{id}/channels/{channelID}").Handler(httptransport.NewServer( ctx, e.DeleteChannelEndpoint, decodeDeleteChannelRequest, encodeResponse, options..., )) // Convenience routes to help consumers nesting limitations r.Methods("GET").Path("/api/channels/{channelID}/notes/").Handler(httptransport.NewServer( ctx, e.GetNotesEndpoint, decodeGetNotesRequest, encodeResponse, options..., )) r.Methods("GET").Path("/api/channels/{channelID}").Handler(httptransport.NewServer( ctx, e.GetChannelEndpoint, decodeGetChannelRequest, encodeResponse, options..., )) return r }
func main() { 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") ) 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"}), )) } // Business domain var svc server.InfoService { svc = pureInfoService{} 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") mux = http.NewServeMux() hello, host endpoint.Endpoint ) hello = makeHelloEndpoint(svc) mux.Handle("/hello", httptransport.NewServer( root, hello, server.DecodeHelloRequest, server.EncodeHelloResponse, httptransport.ServerErrorLogger(transportLogger), )) host = makeHostEndpoint(svc) mux.Handle("/host", httptransport.NewServer( root, host, server.DecodeHostRequest, server.EncodeHostResponse, httptransport.ServerErrorLogger(transportLogger), )) _ = transportLogger.Log("addr", *httpAddr) errc <- http.ListenAndServe(*httpAddr, mux) }() _ = logger.Log("fatal", <-errc) }
func makeHandler(ctx context.Context, s ProfileService, logger kitlog.Logger) stdhttp.Handler { e := makeEndpoints(s) r := mux.NewRouter() commonOptions := []kithttp.ServerOption{ kithttp.ServerErrorLogger(logger), kithttp.ServerErrorEncoder(encodeError), } // POST /profiles adds another profile // GET /profiles/:id retrieves the given profile by id // PUT /profiles/:id post updated profile information about the profile // PATCH /profiles/:id partial updated profile information // DELETE /profiles/:id remove the given profile // GET /profiles/:id/addresses retrieve addresses associated with the profile // GET /profiles/:id/addresses/:addressID retrieve a particular profile address // POST /profiles/:id/addresses add a new address // DELETE /profiles/:id/addresses/:addressID remove an address r.Methods("POST").Path("/profiles/").Handler(kithttp.NewServer( ctx, e.postProfileEndpoint, decodePostProfileRequest, encodeResponse, commonOptions..., )) r.Methods("GET").Path("/profiles/{id}").Handler(kithttp.NewServer( ctx, e.getProfileEndpoint, decodeGetProfileRequest, encodeResponse, commonOptions..., )) r.Methods("PUT").Path("/profiles/{id}").Handler(kithttp.NewServer( ctx, e.putProfileEndpoint, decodePutProfileRequest, encodeResponse, commonOptions..., )) r.Methods("PATCH").Path("/profiles/{id}").Handler(kithttp.NewServer( ctx, e.patchProfileEndpoint, decodePatchProfileRequest, encodeResponse, commonOptions..., )) r.Methods("DELETE").Path("/profiles/{id}").Handler(kithttp.NewServer( ctx, e.deleteProfileEndpoint, decodeDeleteProfileRequest, encodeResponse, commonOptions..., )) r.Methods("GET").Path("/profiles/{id}/addresses/").Handler(kithttp.NewServer( ctx, e.getAddressesEndpoint, decodeGetAddressesRequest, encodeResponse, commonOptions..., )) r.Methods("GET").Path("/profiles/{id}/addresses/{addressID}").Handler(kithttp.NewServer( ctx, e.getAddressEndpoint, decodeGetAddressRequest, encodeResponse, commonOptions..., )) r.Methods("POST").Path("/profiles/{id}/addresses/").Handler(kithttp.NewServer( ctx, e.postAddressEndpoint, decodePostAddressRequest, encodeResponse, commonOptions..., )) r.Methods("DELETE").Path("/profiles/{id}/addresses/{addressID}").Handler(kithttp.NewServer( ctx, e.deleteAddressEndpoint, decodeDeleteAddressRequest, encodeResponse, commonOptions..., )) return r }
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) }
// MakeHandler returns a handler for the booking service. func MakeHandler(ctx context.Context, bs Service, logger kitlog.Logger) http.Handler { opts := []kithttp.ServerOption{ kithttp.ServerErrorLogger(logger), kithttp.ServerErrorEncoder(encodeError), } bookCargoHandler := kithttp.NewServer( ctx, makeBookCargoEndpoint(bs), decodeBookCargoRequest, encodeResponse, opts..., ) loadCargoHandler := kithttp.NewServer( ctx, makeLoadCargoEndpoint(bs), decodeLoadCargoRequest, encodeResponse, opts..., ) requestRoutesHandler := kithttp.NewServer( ctx, makeRequestRoutesEndpoint(bs), decodeRequestRoutesRequest, encodeResponse, opts..., ) assignToRouteHandler := kithttp.NewServer( ctx, makeAssignToRouteEndpoint(bs), decodeAssignToRouteRequest, encodeResponse, opts..., ) changeDestinationHandler := kithttp.NewServer( ctx, makeChangeDestinationEndpoint(bs), decodeChangeDestinationRequest, encodeResponse, opts..., ) listCargosHandler := kithttp.NewServer( ctx, makeListCargosEndpoint(bs), decodeListCargosRequest, encodeResponse, opts..., ) listLocationsHandler := kithttp.NewServer( ctx, makeListLocationsEndpoint(bs), decodeListLocationsRequest, encodeResponse, opts..., ) r := mux.NewRouter() r.Handle("/booking/v1/cargos", bookCargoHandler).Methods("POST") r.Handle("/booking/v1/cargos", listCargosHandler).Methods("GET") r.Handle("/booking/v1/cargos/{id}", loadCargoHandler).Methods("GET") r.Handle("/booking/v1/cargos/{id}/request_routes", requestRoutesHandler).Methods("GET") r.Handle("/booking/v1/cargos/{id}/assign_to_route", assignToRouteHandler).Methods("POST") r.Handle("/booking/v1/cargos/{id}/change_destination", changeDestinationHandler).Methods("POST") r.Handle("/booking/v1/locations", listLocationsHandler).Methods("GET") r.Handle("/booking/v1/docs", http.StripPrefix("/booking/v1/docs", http.FileServer(http.Dir("booking/docs")))) return r }
func main() { flag.Parse() // 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 ( requestCount metrics.Counter requestLatency metrics.TimeHistogram ) { fieldKeys := []string{"method", "error"} requestCount = kitprometheus.NewCounter(stdprometheus.CounterOpts{ Namespace: "gmuch", Subsystem: "api", Name: "request_count", Help: "Number of requests received.", }, fieldKeys) requestLatency = metrics.NewTimeHistogram(time.Nanosecond, metrics.NewMultiHistogram( expvar.NewHistogram("request_duration_ns", 0, 5e9, 1, 50, 95, 99), kitprometheus.NewSummary(stdprometheus.SummaryOpts{ Namespace: "gmuch", Subsystem: "api", Name: "duration_ns", Help: "Request duration in nanoseconds.", }, fieldKeys), )) } // Business domain var g server.GmuchService { g = gmuch.New(*dbPath, logger) g = server.LoggingMiddleware(logger)(g) g = server.InstrumentingMiddleware(requestCount, requestLatency)(g) } // 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() { transportLogger := log.NewContext(logger).With("transport", "HTTP/JSON") mux := http.NewServeMux() mux.Handle("/query", httptransport.NewServer( root, shttp.EndpointenizeQuery(g), shttp.DecodeQueryRequest, shttp.EncodeQueryResponse, httptransport.ServerErrorLogger(transportLogger), )) mux.Handle("/thread", httptransport.NewServer( root, shttp.EndpointenizeThread(g), shttp.DecodeThreadRequest, shttp.EncodeThreadResponse, 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 sgrpc.RegisterGmuchServer(s, sgrpc.Binding{g}) _ = transportLogger.Log("addr", *grpcAddr) errc <- s.Serve(ln) }() _ = logger.Log("fatal", <-errc) }
// MakeHTTPHandler mounts all of the service endpoints into an http.Handler. // Useful in a profilesvc server. func MakeHTTPHandler(ctx context.Context, s Service, logger log.Logger) http.Handler { r := mux.NewRouter() e := MakeServerEndpoints(s) options := []httptransport.ServerOption{ httptransport.ServerErrorLogger(logger), httptransport.ServerErrorEncoder(encodeError), } // POST /profiles/ adds another profile // GET /profiles/:id retrieves the given profile by id // PUT /profiles/:id post updated profile information about the profile // PATCH /profiles/:id partial updated profile information // DELETE /profiles/:id remove the given profile // GET /profiles/:id/addresses/ retrieve addresses associated with the profile // GET /profiles/:id/addresses/:addressID retrieve a particular profile address // POST /profiles/:id/addresses/ add a new address // DELETE /profiles/:id/addresses/:addressID remove an address r.Methods("POST").Path("/profiles/").Handler(httptransport.NewServer( ctx, e.PostProfileEndpoint, decodePostProfileRequest, encodeResponse, options..., )) r.Methods("GET").Path("/profiles/{id}").Handler(httptransport.NewServer( ctx, e.GetProfileEndpoint, decodeGetProfileRequest, encodeResponse, options..., )) r.Methods("PUT").Path("/profiles/{id}").Handler(httptransport.NewServer( ctx, e.PutProfileEndpoint, decodePutProfileRequest, encodeResponse, options..., )) r.Methods("PATCH").Path("/profiles/{id}").Handler(httptransport.NewServer( ctx, e.PatchProfileEndpoint, decodePatchProfileRequest, encodeResponse, options..., )) r.Methods("DELETE").Path("/profiles/{id}").Handler(httptransport.NewServer( ctx, e.DeleteProfileEndpoint, decodeDeleteProfileRequest, encodeResponse, options..., )) r.Methods("GET").Path("/profiles/{id}/addresses/").Handler(httptransport.NewServer( ctx, e.GetAddressesEndpoint, decodeGetAddressesRequest, encodeResponse, options..., )) r.Methods("GET").Path("/profiles/{id}/addresses/{addressID}").Handler(httptransport.NewServer( ctx, e.GetAddressEndpoint, decodeGetAddressRequest, encodeResponse, options..., )) r.Methods("POST").Path("/profiles/{id}/addresses/").Handler(httptransport.NewServer( ctx, e.PostAddressEndpoint, decodePostAddressRequest, encodeResponse, options..., )) r.Methods("DELETE").Path("/profiles/{id}/addresses/{addressID}").Handler(httptransport.NewServer( ctx, e.DeleteAddressEndpoint, decodeDeleteAddressRequest, encodeResponse, options..., )) return r }