func NewMux()

in internal/beater/api/mux.go [83:164]
76 lines of code
6 McCabe index (conditional complexity)

func NewMux(
	beaterConfig *config.Config,
	batchProcessor modelpb.BatchProcessor,
	authenticator *auth.Authenticator,
	fetcher agentcfg.Fetcher,
	ratelimitStore *ratelimit.Store,
	sourcemapFetcher sourcemap.Fetcher,
	publishReady func() bool,
	semaphore input.Semaphore,
	meterProvider metric.MeterProvider,
	logger *logp.Logger,
) (*mux.Router, error) {
	pool := request.NewContextPool()
	logger = logger.Named(logs.Handler)
	router := mux.NewRouter()
	router.NotFoundHandler = pool.HTTPHandler(notFoundHandler)

	builder := routeBuilder{
		cfg:              beaterConfig,
		authenticator:    authenticator,
		batchProcessor:   batchProcessor,
		ratelimitStore:   ratelimitStore,
		sourcemapFetcher: sourcemapFetcher,
		intakeSemaphore:  semaphore,
		logger:           logger,
	}

	zapLogger := zap.New(logger.Core(), zap.WithCaller(true))
	builder.intakeProcessor = elasticapm.NewProcessor(elasticapm.Config{
		MaxEventSize: beaterConfig.MaxEventSize,
		Semaphore:    semaphore,
		Logger:       zapLogger,
	})

	type route struct {
		path      string
		handlerFn func() (request.Handler, error)
	}

	otlpHandlers := otlp.NewHTTPHandlers(zapLogger, batchProcessor, semaphore, meterProvider)
	rumIntakeHandler := builder.rumIntakeHandler(meterProvider)
	routeMap := []route{
		{RootPath, builder.rootHandler(publishReady, meterProvider)},
		{AgentConfigPath, builder.backendAgentConfigHandler(fetcher, meterProvider)},
		{AgentConfigRUMPath, builder.rumAgentConfigHandler(fetcher, meterProvider)},
		{IntakeRUMPath, rumIntakeHandler},
		{IntakeRUMV3Path, rumIntakeHandler},
		{IntakePath, builder.backendIntakeHandler("apm-server.server.", meterProvider)},
		{OTLPTracesIntakePath, builder.otlpHandler(otlpHandlers.HandleTraces, "apm-server.otlp.http.traces.", meterProvider)},
		{OTLPMetricsIntakePath, builder.otlpHandler(otlpHandlers.HandleMetrics, "apm-server.otlp.http.metrics.", meterProvider)},
		{OTLPLogsIntakePath, builder.otlpHandler(otlpHandlers.HandleLogs, "apm-server.otlp.http.logs.", meterProvider)},
	}

	for _, route := range routeMap {
		h, err := route.handlerFn()
		if err != nil {
			return nil, err
		}
		logger.Infof("Path %s added to request handler", route.path)
		router.Handle(route.path, pool.HTTPHandler(h))
	}
	if beaterConfig.Expvar.Enabled {
		path := beaterConfig.Expvar.URL
		logger.Infof("Path %s added to request handler", path)
		router.Handle(path, http.HandlerFunc(debugVarsHandler))
	}
	if beaterConfig.Pprof.Enabled {
		const path = "/debug/pprof"
		logger.Infof("Path %s added to request handler", path)

		pprofRouter := router.PathPrefix(path).Subrouter().StrictSlash(true)
		pprofRouter.Handle("/", http.HandlerFunc(httppprof.Index))
		for _, p := range pprof.Profiles() {
			pprofRouter.Handle("/"+p.Name(), http.HandlerFunc(httppprof.Index))
		}
		pprofRouter.Handle("/cmdline", http.HandlerFunc(httppprof.Cmdline))
		pprofRouter.Handle("/profile", http.HandlerFunc(httppprof.Profile))
		pprofRouter.Handle("/symbol", http.HandlerFunc(httppprof.Symbol))
		pprofRouter.Handle("/trace", http.HandlerFunc(httppprof.Trace))
	}
	return router, nil
}