7 "golang.org/x/time/rate"
9 stdopentracing "github.com/opentracing/opentracing-go"
10 "github.com/sony/gobreaker"
12 "github.com/go-kit/kit/circuitbreaker"
13 "github.com/go-kit/kit/endpoint"
14 "github.com/go-kit/kit/log"
15 "github.com/go-kit/kit/metrics"
16 "github.com/go-kit/kit/ratelimit"
17 "github.com/go-kit/kit/tracing/opentracing"
19 "github.com/go-kit/kit/examples/addsvc/pkg/addservice"
22 // Set collects all of the endpoints that compose an add service. It's meant to
23 // be used as a helper struct, to collect all of the endpoints into a single
26 SumEndpoint endpoint.Endpoint
27 ConcatEndpoint endpoint.Endpoint
30 // New returns a Set that wraps the provided server, and wires in all of the
31 // expected endpoint middlewares via the various parameters.
32 func New(svc addservice.Service, logger log.Logger, duration metrics.Histogram, trace stdopentracing.Tracer) Set {
33 var sumEndpoint endpoint.Endpoint
35 sumEndpoint = MakeSumEndpoint(svc)
36 sumEndpoint = ratelimit.NewErroringLimiter(rate.NewLimiter(rate.Every(time.Second), 1))(sumEndpoint)
37 sumEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{}))(sumEndpoint)
38 sumEndpoint = opentracing.TraceServer(trace, "Sum")(sumEndpoint)
39 sumEndpoint = LoggingMiddleware(log.With(logger, "method", "Sum"))(sumEndpoint)
40 sumEndpoint = InstrumentingMiddleware(duration.With("method", "Sum"))(sumEndpoint)
42 var concatEndpoint endpoint.Endpoint
44 concatEndpoint = MakeConcatEndpoint(svc)
45 concatEndpoint = ratelimit.NewErroringLimiter(rate.NewLimiter(rate.Every(time.Second), 100))(concatEndpoint)
46 concatEndpoint = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{}))(concatEndpoint)
47 concatEndpoint = opentracing.TraceServer(trace, "Concat")(concatEndpoint)
48 concatEndpoint = LoggingMiddleware(log.With(logger, "method", "Concat"))(concatEndpoint)
49 concatEndpoint = InstrumentingMiddleware(duration.With("method", "Concat"))(concatEndpoint)
52 SumEndpoint: sumEndpoint,
53 ConcatEndpoint: concatEndpoint,
57 // Sum implements the service interface, so Set may be used as a service.
58 // This is primarily useful in the context of a client library.
59 func (s Set) Sum(ctx context.Context, a, b int) (int, error) {
60 resp, err := s.SumEndpoint(ctx, SumRequest{A: a, B: b})
64 response := resp.(SumResponse)
65 return response.V, response.Err
68 // Concat implements the service interface, so Set may be used as a
69 // service. This is primarily useful in the context of a client library.
70 func (s Set) Concat(ctx context.Context, a, b string) (string, error) {
71 resp, err := s.ConcatEndpoint(ctx, ConcatRequest{A: a, B: b})
75 response := resp.(ConcatResponse)
76 return response.V, response.Err
79 // MakeSumEndpoint constructs a Sum endpoint wrapping the service.
80 func MakeSumEndpoint(s addservice.Service) endpoint.Endpoint {
81 return func(ctx context.Context, request interface{}) (response interface{}, err error) {
82 req := request.(SumRequest)
83 v, err := s.Sum(ctx, req.A, req.B)
84 return SumResponse{V: v, Err: err}, nil
88 // MakeConcatEndpoint constructs a Concat endpoint wrapping the service.
89 func MakeConcatEndpoint(s addservice.Service) endpoint.Endpoint {
90 return func(ctx context.Context, request interface{}) (response interface{}, err error) {
91 req := request.(ConcatRequest)
92 v, err := s.Concat(ctx, req.A, req.B)
93 return ConcatResponse{V: v, Err: err}, nil
97 // Failer is an interface that should be implemented by response types.
98 // Response encoders can check if responses are Failer, and if so if they've
99 // failed, and if so encode them using a separate write path based on the error.
100 type Failer interface {
104 // SumRequest collects the request parameters for the Sum method.
105 type SumRequest struct {
109 // SumResponse collects the response values for the Sum method.
110 type SumResponse struct {
112 Err error `json:"-"` // should be intercepted by Failed/errorEncoder
115 // Failed implements Failer.
116 func (r SumResponse) Failed() error { return r.Err }
118 // ConcatRequest collects the request parameters for the Concat method.
119 type ConcatRequest struct {
123 // ConcatResponse collects the response values for the Concat method.
124 type ConcatResponse struct {
129 // Failed implements Failer.
130 func (r ConcatResponse) Failed() error { return r.Err }