func main() { // Create a recent in-memory store, evicting data after 20s. // // The store defines where information about traces (i.e. spans and // annotations) will be stored during the lifetime of the application. This // application uses a MemoryStore store wrapped by a RecentStore with an // eviction time of 20s (i.e. all data after 20s is deleted from memory). memStore := appdash.NewMemoryStore() store := &appdash.RecentStore{ MinEvictAge: 20 * time.Second, DeleteStore: memStore, } // Start the Appdash web UI on port 8700. // // This is the actual Appdash web UI -- usable as a Go package itself, We // embed it directly into our application such that visiting the web server // on HTTP port 8700 will bring us to the web UI, displaying information // about this specific web-server (another alternative would be to connect // to a centralized Appdash collection server). url, err := url.Parse("http://localhost:8700") if err != nil { log.Fatal(err) } tapp, err := traceapp.New(nil, url) if err != nil { log.Fatal(err) } tapp.Store = store tapp.Queryer = memStore log.Println("Appdash web UI running on HTTP :8700") go func() { log.Fatal(http.ListenAndServe(":8700", tapp)) }() // We will use a local collector (as we are running the Appdash web UI // embedded within our app). // // A collector is responsible for collecting the information about traces // (i.e. spans and annotations) and placing them into a store. In this app // we use a local collector (we could also use a remote collector, sending // the information to a remote Appdash collection server). collector := appdash.NewLocalCollector(store) // Here we use the local collector to create a new opentracing.Tracer tracer := appdashtracer.NewTracer(collector) opentracing.InitGlobalTracer(tracer) // Setup our router (for information, see the gorilla/mux docs): router := mux.NewRouter() router.HandleFunc("/", Home) router.HandleFunc("/endpoint", Endpoint) // Setup Negroni for our app (for information, see the negroni docs): n := negroni.Classic() n.UseHandler(router) n.Run(":8699") }
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) } }