var listener net.Listener
	var err error
	if listener, err = net.Listen("tcp", fmt.Sprintf(":%d", port)); err != nil {
		log.Errorf("unable to listen on socket: %v", err)
		return
	}
	exporter, err := monitoring.RegisterPrometheusExporter(nil, nil)
	if err != nil {
		log.Errorf("could not set up prometheus exporter: %v", err)
		return
	}
	mux.Handle(path, exporter)
	monitoringServer := &http.Server{
		Handler: mux,
	}
	go func() {

)

func init() {
	otel.SetLogger(log.NewLogrAdapter(monitoringLogger))
}

// RegisterPrometheusExporter sets the global metrics handler to the provided Prometheus registerer and gatherer.
// Returned is an HTTP handler that can be used to read metrics from.
func RegisterPrometheusExporter(reg prometheus.Registerer, gatherer prometheus.Gatherer) (http.Handler, error) {
	if reg == nil {

	)
)

func init() {
	pilotVersion.With(versionTag.Value(version.Info.String())).Record(1)
}

func addMonitor(mux *http.ServeMux) error {
	exporter, err := monitoring.RegisterPrometheusExporter(nil, nil)
	if err != nil {
		return fmt.Errorf("could not set up prometheus exporter: %v", err)
	}
	mux.Handle(metricsPath, metricsMiddleware(exporter))

	registry := ctrlmetrics.Registry.(*prometheus.Registry)
	wrapped := prometheus.WrapRegistererWithPrefix("istio_install_operator_", registry)

	if _, err := monitoring.RegisterPrometheusExporter(wrapped, registry); err != nil {
		log.Warnf("Error while building exporter: %v", err)
	}

	log.Info("Registering Components.")

	// Setup Scheme for all resources

	// TODO: do not use a global and/or add a way to reset (https://github.com/open-telemetry/opentelemetry-go/issues/4291)
	reg := prometheus.NewRegistry()
	_, err := monitoring.RegisterPrometheusExporter(reg, reg)
	if err != nil {
		return nil, err
	}
	return reg, nil
})

func TestRegistry(t test.Failer) prometheus.Gatherer {
	r, err := reg.Get()
	if err != nil {
		t.Fatal(err)
	}

		}
	}
	return nil
}

func (s *Instance) startMetricsServer() {
	mux := http.NewServeMux()

	exporter, err := monitoring.RegisterPrometheusExporter(nil, nil)
	if err != nil {
		log.Errorf("could not set up prometheus exporter: %v", err)
		return
	}
	mux.Handle("/metrics", LogRequests(exporter))
	s.metricsServer = &http.Server{
		Handler: mux,

	wrapped.MustRegister(collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}))
	wrapped.MustRegister(collectors.NewGoCollector())

	_, err := monitoring.RegisterPrometheusExporter(wrapped, registry)
	if err != nil {
		return nil, fmt.Errorf("could not setup exporter: %v", err)
	}
	return registry, nil
}

// NewServer creates a new status server.