"templates/service.yaml", "templates/reader-serviceaccount.yaml",
			},
		},
		// TODO https://github.com/istio/istio/issues/22347 this is broken for overriding things to default value
		// This can be seen from REGISTRY_ONLY not applying
		{
			desc:       "pilot_merge_meshconfig",
			diffSelect: "ConfigMap:*:istio$",
			fileSelect: []string{"templates/configmap.yaml", "templates/_helpers.tpl"},
		},
		{

	}

	metricGroups := newMetricGroups(registry)

	return &metricsV3Server{
		registry: registry,
		opts: promhttp.HandlerOpts{
			ErrorLog:            promLogger{},
			ErrorHandling:       promhttp.HTTPErrorOnError,
			Registry:            registry,
			MaxRequestsInFlight: 2,
		},
		authFn: authFn,

		metricsData: metricGroups,
	}
}

// metricDisplay - contains info on a metric for display purposes.

	// mrf backlog stats
	mrfStats ReplicationMRFStats
	// for bucket replication, continue to use existing cache
	Cache             map[string]*BucketReplicationStats
	mostRecentStats   BucketStatsMap
	registry          metrics.Registry
	sync.RWMutex                 // mutex for Cache
	mostRecentStatsMu sync.Mutex // mutex for mostRecentStats

	wlock sync.RWMutex // mutex for active workers

	// hub is the hub for the operator image.
	hub string
	// tag is the tag for the operator image.
	tag string
	// imagePullSecrets is an array of imagePullSecret to pull operator image from the private registry
	imagePullSecrets []string
	// operatorNamespace is the namespace the operator controller is installed into.
	operatorNamespace string

}

// Describe sends the super-set of all possible descriptors of metrics
func (c *minioResourceCollector) Describe(ch chan<- *prometheus.Desc) {
	ch <- c.desc
}

// Collect is called by the Prometheus registry when collecting metrics.
func (c *minioResourceCollector) Collect(out chan<- prometheus.Metric) {
	var wg sync.WaitGroup
	publish := func(in <-chan MetricV2) {
		defer wg.Done()
		for metric := range in {

			disk.DrivePath,
		)
	}
}

func metricsHandler() http.Handler {
	registry := prometheus.NewRegistry()

	logger.CriticalIf(GlobalContext, registry.Register(minioVersionInfo))

	logger.CriticalIf(GlobalContext, registry.Register(newMinioCollector()))

	gatherers := prometheus.Gatherers{
		prometheus.DefaultGatherer,
		registry,
	}

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

func metricsNodeHandler() http.Handler {
	registry := prometheus.NewRegistry()

	logger.CriticalIf(GlobalContext, registry.Register(nodeCollector))
	if err := registry.Register(prometheus.NewProcessCollector(prometheus.ProcessCollectorOpts{
		Namespace:    minioNamespace,
		ReportErrors: true,
	})); err != nil {
		logger.CriticalIf(GlobalContext, err)
	}
	if err := registry.Register(prometheus.NewGoCollector()); err != nil {

	TagFlagHelpStr                     = `The tag for the operator controller image.`
	ImagePullSecretsHelpStr            = `The imagePullSecrets are used to pull the operator image from the private registry,
could be secret list separated by comma, eg. '--imagePullSecrets imagePullSecret1,imagePullSecret2'`
	OperatorNamespaceHelpstr  = `The namespace the operator controller is installed into.`

type ActiveWorkerStat struct {
	Curr int     `json:"curr"`
	Avg  float32 `json:"avg"`
	Max  int     `json:"max"`
	hist metrics.Histogram
}

func newActiveWorkerStat(r metrics.Registry) *ActiveWorkerStat {
	h := metrics.NewHistogram(metrics.NewUniformSample(100))
	r.Register("replication.active_workers", h)
	return &ActiveWorkerStat{
		hist: h,
	}
}

// update curr and max workers;

//     that gets offloaded). The same registry key setting overwrites the storage-defined setting.
//     Optional value, default 64, range: 1-unlimited
//
//   - <S3MultiObjectDeleteLimit>
//     Some of the Veeam products use Multi Delete operations. This setting can reduce how many objects are included in one
//     multi-delete operation. The same registry key setting overwrites the storage-defined setting.