// 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
}