// Execute execudes the commands with the given arguments and returns an error, // if any. func (c *SendCmd) Execute(args []string) error { var rc *appdash.RemoteCollector switch c.CollectorProto { case "tcp": rc = appdash.NewRemoteCollector(c.CollectorAddr) case "tls": rc = appdash.NewTLSRemoteCollector(c.CollectorAddr, &tls.Config{ServerName: c.ServerName}) default: return fmt.Errorf("unknown proto: %q", c.CollectorProto) } rc.Debug = c.Debug rcc := &appdash.ChunkedCollector{ Collector: rc, MinInterval: time.Second, } log.Println("Sending sample data...") if err := sampleData(rc); err != nil { return err } log.Println("Done sending sample data.") log.Println("Flushing chunked collector...") if err := rcc.Flush(); err != nil { return err } log.Println("Done flushing chunked collector.") return nil }
// Execute execudes the commands with the given arguments and returns an error, // if any. func (c *DemoCmd) Execute(args []string) error { // We create a new in-memory store. All information about traces will // eventually be stored here. store := appdash.NewMemoryStore() // Listen on any available TCP port locally. l, err := net.ListenTCP("tcp", &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0}) if err != nil { log.Fatal(err) } collectorPort := l.Addr().(*net.TCPAddr).Port log.Printf("Appdash collector listening on tcp:%d", collectorPort) // Start an Appdash collection server that will listen for spans and // annotations and add them to the local collector (stored in-memory). cs := appdash.NewServer(l, appdash.NewLocalCollector(store)) cs.Debug = c.Debug // Debug logging cs.Trace = c.Trace // Trace logging go cs.Start() // Print the URL at which the web UI will be running. appdashURLStr := "http://localhost" + c.AppdashHTTPAddr appdashURL, err := url.Parse(appdashURLStr) if err != nil { log.Fatalf("Error parsing http://localhost:%s: %s", c.AppdashHTTPAddr, err) } log.Printf("Appdash web UI running at %s", appdashURL) // Start the web UI in a separate goroutine. tapp := traceapp.New(nil) tapp.Store = store tapp.Queryer = store go func() { log.Fatal(http.ListenAndServe(c.AppdashHTTPAddr, tapp)) }() // Print the URL at which the demo app is running. demoURLStr := "http://localhost" + c.DemoHTTPAddr demoURL, err := url.Parse(demoURLStr) if err != nil { log.Fatalf("Error parsing http://localhost:%s: %s", c.DemoHTTPAddr, err) } log.Println() log.Printf("Appdash demo app running at %s", demoURL) // The Appdash collection server that our demo app will use is running // locally with our HTTP server in this case, so we set this up now. localCollector := appdash.NewRemoteCollector(fmt.Sprintf(":%d", collectorPort)) // Handle the root path of our app. http.Handle("/", &middlewareHandler{ middleware: httptrace.Middleware(localCollector, &httptrace.MiddlewareConfig{ RouteName: func(r *http.Request) string { return r.URL.Path }, SetContextSpan: requestSpans.setRequestSpan, }), next: &demoApp{collector: localCollector, baseURL: demoURL, appdashURL: appdashURL}, }) return http.ListenAndServe(c.DemoHTTPAddr, nil) }
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") grpcAddr = flag.String("grpc.addr", ":8082", "gRPC (HTTP) listen address") appdashAddr = flag.String("appdash.addr", "", "Enable Appdash tracing via an Appdash server host:port") ircNick = flag.String("irc.nick", "gogrpctest", "IRC nickname") ircSecret = flag.String("irc.secret", "", "IRC password") ircHost = flag.String("irc.addr", "irc.freenode.net:6667", "IRC host system") ) 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 cx, cxerr, joins metrics.Counter { // Business level metrics. cx = prometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "relay", Name: "connect_succeeded", Help: "Total count of connects via the Connect method.", }, []string{}) cxerr = prometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "relay", Name: "connect_failed", Help: "Total count of connect errors via the Connect method.", }, []string{}) joins = prometheus.NewCounterFrom(stdprometheus.CounterOpts{ Namespace: "relay", Name: "channels_joined", Help: "Total count of channels joined via the Join method.", }, []string{}) } var duration metrics.Histogram { // Transport level metrics. duration = prometheus.NewSummaryFrom(stdprometheus.SummaryOpts{ Namespace: "relay", Name: "request_duration_ns", Help: "Request duration in nanoseconds.", }, []string{"method", "success"}) } // Tracing domain. var tracer stdopentracing.Tracer { if *appdashAddr != "" { logger := log.NewContext(logger).With("tracer", "Appdash") logger.Log("addr", *appdashAddr) tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr)) } else { logger := log.NewContext(logger).With("tracer", "none") logger.Log() tracer = stdopentracing.GlobalTracer() // no-op } } // Business domain. var service relay.Service { service = relay.NewBasicService(*ircNick, *ircHost, *ircSecret) service = relay.ServiceLoggingMiddleware(logger)(service) service = relay.ServiceInstrumentingMiddleware(cx, cxerr, joins)(service) } // Endpoint domain. var connectEndpoint endpoint.Endpoint { connectDuration := duration.With("method", "Connect") connectLogger := log.NewContext(logger).With("method", "Connect") connectEndpoint = relay.MakeConnectEndpoint(service) connectEndpoint = opentracing.TraceServer(tracer, "Connect")(connectEndpoint) connectEndpoint = relay.EndpointInstrumentingMiddleware(connectDuration)(connectEndpoint) connectEndpoint = relay.EndpointLoggingMiddleware(connectLogger)(connectEndpoint) } var joinEndpoint endpoint.Endpoint { joinDuration := duration.With("method", "Join") joinLogger := log.NewContext(logger).With("method", "Join") joinEndpoint = relay.MakeJoinEndpoint(service) joinEndpoint = opentracing.TraceServer(tracer, "Join")(joinEndpoint) joinEndpoint = relay.EndpointInstrumentingMiddleware(joinDuration)(joinEndpoint) joinEndpoint = relay.EndpointLoggingMiddleware(joinLogger)(joinEndpoint) } endpoints := relay.Endpoints{ ConnectEndpoint: connectEndpoint, JoinEndpoint: joinEndpoint, } // 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) }() // gRPC transport. go func() { logger := log.NewContext(logger).With("transport", "gRPC") ln, err := net.Listen("tcp", *grpcAddr) if err != nil { errc <- err return } srv := relay.MakeGRPCServer(ctx, endpoints, tracer, logger) s := grpc.NewServer() pb.RegisterRelayServer(s, srv) logger.Log("addr", *grpcAddr) errc <- s.Serve(ln) }() // Run! logger.Log("exit", <-errc) }
func main() { // The relaycli presumes no service discovery system, and expects users to // provide the direct address of a relaysvc. This presumption is reflected in // the relaycli binary and the the client packages: the -transport.addr flags // and various client constructors both expect host:port strings. var ( grpcAddr = flag.String("grpc.addr", "", "gRPC (HTTP) address of relaysvc") appdashAddr = flag.String("appdash.addr", "", "Enable Appdash tracing via an Appdash server host:port") method = flag.String("method", "connect", "connect, join") ) flag.Parse() if len(flag.Args()) != 1 { fmt.Fprintf(os.Stderr, "usage: relaycli [flags] <s>\n") os.Exit(1) } var tracer stdopentracing.Tracer { if *appdashAddr != "" { tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr)) } else { tracer = stdopentracing.GlobalTracer() // no-op } } var ( service relay.Service err error ) if *grpcAddr != "" { conn, err := grpc.Dial(*grpcAddr, grpc.WithInsecure(), grpc.WithTimeout(time.Second)) if err != nil { fmt.Fprintf(os.Stderr, "error: %v", err) os.Exit(1) } defer conn.Close() service = grpcclient.New(conn, tracer, log.NewNopLogger()) } else { fmt.Fprintf(os.Stderr, "error: no remote address specified\n") os.Exit(1) } if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } switch *method { case "connect": s := flag.Args()[0] v, err := service.Connect(context.Background(), s) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } fmt.Fprintf(os.Stdout, "Connect to %s: %s\n", s, v) case "join": c := flag.Args()[0] v, err := service.Join(context.Background(), c) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } fmt.Fprintf(os.Stdout, "Join channel %s: %s\n", c, v) default: fmt.Fprintf(os.Stderr, "error: invalid method %q\n", method) os.Exit(1) } }
func main() { var ( transport = flag.String("transport", "httpjson", "httpjson, grpc, netrpc, thrift") httpAddrs = flag.String("http.addrs", "localhost:8001", "Comma-separated list of addresses for HTTP (JSON) servers") grpcAddrs = flag.String("grpc.addrs", "localhost:8002", "Comma-separated list of addresses for gRPC servers") netrpcAddrs = flag.String("netrpc.addrs", "localhost:8003", "Comma-separated list of addresses for net/rpc servers") thriftAddrs = flag.String("thrift.addrs", "localhost:8004", "Comma-separated list of addresses for Thrift servers") 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") // Two OpenTracing backends (to demonstrate how they can be interchanged): appdashAddr = flag.String("appdash.addr", "", "Enable Appdash tracing via an Appdash server host:port") lightstepAccessToken = flag.String("lightstep.token", "", "Enable LightStep tracing via a LightStep access token") ) flag.Parse() if len(os.Args) < 4 { fmt.Fprintf(os.Stderr, "\n%s [flags] method arg1 arg2\n\n", filepath.Base(os.Args[0])) flag.Usage() os.Exit(1) } randomSeed := time.Now().UnixNano() root := context.Background() method, s1, s2 := flag.Arg(0), flag.Arg(1), flag.Arg(2) var logger log.Logger logger = log.NewLogfmtLogger(os.Stdout) logger = log.NewContext(logger).With("caller", log.DefaultCaller) logger = log.NewContext(logger).With("transport", *transport) tracingLogger := log.NewContext(logger).With("component", "tracing") // Set up OpenTracing var tracer opentracing.Tracer { switch { case *appdashAddr != "" && *lightstepAccessToken == "": tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr)) case *appdashAddr == "" && *lightstepAccessToken != "": tracer = lightstep.NewTracer(lightstep.Options{ AccessToken: *lightstepAccessToken, }) defer lightstep.FlushLightStepTracer(tracer) case *appdashAddr == "" && *lightstepAccessToken == "": tracer = opentracing.GlobalTracer() // no-op default: panic("specify either -appdash.addr or -lightstep.access.token, not both") } } var ( instances []string sumFactory, concatFactory loadbalancer.Factory ) switch *transport { case "grpc": instances = strings.Split(*grpcAddrs, ",") sumFactory = grpcclient.MakeSumEndpointFactory(tracer, tracingLogger) concatFactory = grpcclient.MakeConcatEndpointFactory(tracer, tracingLogger) case "httpjson": instances = strings.Split(*httpAddrs, ",") for i, rawurl := range instances { if !strings.HasPrefix("http", rawurl) { instances[i] = "http://" + rawurl } } sumFactory = httpjsonclient.MakeSumEndpointFactory(tracer, tracingLogger) concatFactory = httpjsonclient.MakeConcatEndpointFactory(tracer, tracingLogger) case "netrpc": instances = strings.Split(*netrpcAddrs, ",") sumFactory = netrpcclient.SumEndpointFactory concatFactory = netrpcclient.ConcatEndpointFactory case "thrift": instances = strings.Split(*thriftAddrs, ",") thriftClient := thriftclient.New(*thriftProtocol, *thriftBufferSize, *thriftFramed, logger) sumFactory = thriftClient.SumEndpoint concatFactory = thriftClient.ConcatEndpoint default: logger.Log("err", "invalid transport") os.Exit(1) } sum := buildEndpoint(tracer, "sum", instances, sumFactory, randomSeed, logger) concat := buildEndpoint(tracer, "concat", instances, concatFactory, randomSeed, logger) svc := newClient(root, sum, concat, logger) begin := time.Now() switch method { case "sum": a, _ := strconv.Atoi(s1) b, _ := strconv.Atoi(s2) v := svc.Sum(a, b) logger.Log("method", "sum", "a", a, "b", b, "v", v, "took", time.Since(begin)) case "concat": a, b := s1, s2 v := svc.Concat(a, b) logger.Log("method", "concat", "a", a, "b", b, "v", v, "took", time.Since(begin)) default: logger.Log("err", "invalid method "+method) os.Exit(1) } }
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) }
func handleRequest(w http.ResponseWriter, r *http.Request) { var result string span := appdash.NewRootSpanID() fmt.Println("span is ", span) collector := appdash.NewRemoteCollector(":3001") httpClient := &http.Client{ Transport: &httptrace.Transport{ Recorder: appdash.NewRecorder(span, collector), SetName: true, }, } //Service A resp, err := httpClient.Get("http://localhost:6601") if err != nil { log.Println("access serviceA err:", err) } else { log.Println("access serviceA ok") resp.Body.Close() result += "access serviceA ok\n" } //Service B resp, err = httpClient.Get("http://localhost:6602") if err != nil { log.Println("access serviceB err:", err) return } else { log.Println("access serviceB ok") resp.Body.Close() result += "access serviceB ok\n" } // SQL event traceRec := appdash.NewRecorder(span, collector) traceRec.Name("sqlevent example") // A random length for the trace. length := time.Duration(rand.Intn(1000)) * time.Millisecond StartTime := time.Now().Add(-time.Duration(rand.Intn(100)) * time.Minute) traceRec.Event(&sqltrace.SQLEvent{ ClientSend: StartTime, ClientRecv: StartTime.Add(length), SQL: "SELECT * FROM table_name;", Tag: fmt.Sprintf("fakeTag%d", rand.Intn(10)), }) result += "sql event ok\n" // self-customize event - MyEvent StartTime = time.Now().Add(-time.Duration(rand.Intn(100)) * time.Minute) traceRec.Event(&MyEvent{ Name: "MyEvent example", StartTime: StartTime, EndTime: StartTime.Add(length), }) result += "MyEvent ok\n" w.Write([]byte(result)) }
func main() { // The addcli presumes no service discovery system, and expects users to // provide the direct address of an addsvc. This presumption is reflected in // the addcli binary and the the client packages: the -transport.addr flags // and various client constructors both expect host:port strings. For an // example service with a client built on top of a service discovery system, // see profilesvc. var ( httpAddr = flag.String("http.addr", "", "HTTP address of addsvc") grpcAddr = flag.String("grpc.addr", "", "gRPC (HTTP) address of addsvc") thriftAddr = flag.String("thrift.addr", "", "Thrift address of addsvc") 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 Collector 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") method = flag.String("method", "sum", "sum, concat") ) flag.Parse() if len(flag.Args()) != 2 { fmt.Fprintf(os.Stderr, "usage: addcli [flags] <a> <b>\n") os.Exit(1) } // This is a demonstration client, which supports multiple tracers. // Your clients will probably just use one tracer. var tracer stdopentracing.Tracer { if *zipkinAddr != "" { collector, err := zipkin.NewKafkaCollector( strings.Split(*zipkinAddr, ","), zipkin.KafkaLogger(log.NewNopLogger()), ) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) os.Exit(1) } tracer, err = zipkin.NewTracer( zipkin.NewRecorder(collector, false, "localhost:8000", "addcli"), ) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) os.Exit(1) } } else if *appdashAddr != "" { tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr)) } else if *lightstepToken != "" { tracer = lightstep.NewTracer(lightstep.Options{ AccessToken: *lightstepToken, }) defer lightstep.FlushLightStepTracer(tracer) } else { tracer = stdopentracing.GlobalTracer() // no-op } } // This is a demonstration client, which supports multiple transports. // Your clients will probably just define and stick with 1 transport. var ( service addsvc.Service err error ) if *httpAddr != "" { service, err = httpclient.New(*httpAddr, tracer, log.NewNopLogger()) } else if *grpcAddr != "" { conn, err := grpc.Dial(*grpcAddr, grpc.WithInsecure(), grpc.WithTimeout(time.Second)) if err != nil { fmt.Fprintf(os.Stderr, "error: %v", err) os.Exit(1) } defer conn.Close() service = grpcclient.New(conn, tracer, log.NewNopLogger()) } else if *thriftAddr != "" { // It's necessary to do all of this construction in the func main, // because (among other reasons) we need to control the lifecycle of the // Thrift transport, i.e. close it eventually. var protocolFactory thrift.TProtocolFactory switch *thriftProtocol { case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "binary", "": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() default: fmt.Fprintf(os.Stderr, "error: invalid protocol %q\n", *thriftProtocol) os.Exit(1) } var transportFactory thrift.TTransportFactory if *thriftBufferSize > 0 { transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize) } else { transportFactory = thrift.NewTTransportFactory() } if *thriftFramed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } transportSocket, err := thrift.NewTSocket(*thriftAddr) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } transport := transportFactory.GetTransport(transportSocket) if err := transport.Open(); err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } defer transport.Close() client := thriftadd.NewAddServiceClientFactory(transport, protocolFactory) service = thriftclient.New(client) } else { fmt.Fprintf(os.Stderr, "error: no remote address specified\n") os.Exit(1) } if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } switch *method { case "sum": a, _ := strconv.ParseInt(flag.Args()[0], 10, 64) b, _ := strconv.ParseInt(flag.Args()[1], 10, 64) v, err := service.Sum(context.Background(), int(a), int(b)) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } fmt.Fprintf(os.Stdout, "%d + %d = %d\n", a, b, v) case "concat": a := flag.Args()[0] b := flag.Args()[1] v, err := service.Concat(context.Background(), a, b) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) os.Exit(1) } fmt.Fprintf(os.Stdout, "%q + %q = %q\n", a, b, v) default: fmt.Fprintf(os.Stderr, "error: invalid method %q\n", method) os.Exit(1) } }