Method StartAndReturnService

cmd/tempo/app/server_service.go:82–132

(cfg server.Config, supportGRPCOnHTTP bool, servicesToWaitFor func() []services.Service)

}

func (s *tempoServer) StartAndReturnService(cfg server.Config, supportGRPCOnHTTP bool, servicesToWaitFor func() []services.Service) (services.Service, error) {
	var err error

	metrics := server.NewServerMetrics(cfg)
	DisableSignalHandling(&cfg)

	if !supportGRPCOnHTTP {
		// We don't do any GRPC handling, let the library handle all routing for us
		cfg.Router = s.mux

		s.externalServer, err = server.NewWithMetrics(cfg, metrics)
		if err != nil {
			return nil, fmt.Errorf("failed to create server: %w", err)
		}
		s.handler = s.externalServer.HTTPServer.Handler
	} else {
		// We want to route both GRPC and HTTP requests on the same endpoint
		cfg.Router = nil
		cfg.DoNotAddDefaultHTTPMiddleware = true // we don't want instrumentation on the "root" router, we want it on our mux. it will be added below.

		s.externalServer, err = server.NewWithMetrics(cfg, metrics)
		if err != nil {
			return nil, fmt.Errorf("failed to create server: %w", err)
		}

		// now that we have created the server and service let's setup our grpc/http router if necessary
		// for grpc to work we must enable h2c on the external server
		s.EnableHTTP2()

		// recreate dskit instrumentation here
		cfg.DoNotAddDefaultHTTPMiddleware = false
		httpMiddleware, err := server.BuildHTTPMiddleware(cfg, s.mux, metrics, s.externalServer.Log)
		if err != nil {
			return nil, fmt.Errorf("failed to create http middleware: %w", err)
		}

		s.handler = middleware.Merge(httpMiddleware...).Wrap(s.mux)
		s.externalServer.HTTP.PathPrefix("/").HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
			// route to GRPC server if it's a GRPC request
			if req.ProtoMajor == 2 && strings.Contains(req.Header.Get("Content-Type"), "application/grpc") {
				s.externalServer.GRPC.ServeHTTP(w, req)
				return
			}

			// default to standard http server
			s.handler.ServeHTTP(w, req)
		})
	}

	return NewServerService(s.externalServer, servicesToWaitFor), nil
}

// NewServerService constructs service from Server component.
// servicesToWaitFor is called when server is stopping, and should return all