tb := t.current.Load()
	if tb != nil {
		tbb := *tb
		return tbb.Name()
	}
	return ""
}

func (t *testLogger) Endpoint() string {
	return ""
}

func (t *testLogger) Stats() types.TargetStats {
	return types.TargetStats{}
}

func (t *testLogger) Init(ctx context.Context) error {
	return nil
}

func (t *testLogger) IsOnline(ctx context.Context) bool {

		}
	}

	replicationStatsList := globalReplicationStats.Load().GetAll()
	bucketStatsMap := BucketStatsMap{
		Stats:     make(map[string]BucketStats, len(replicationStatsList)),
		Timestamp: UTCNow(),
	}
	for k, replicationStats := range replicationStatsList {
		bucketStatsMap.Stats[k] = BucketStats{
			ReplicationStats: replicationStats,
			ProxyStats:       globalReplicationStats.Load().getProxyStats(k),
		}
	}

			ReplicationStats: v,
			ProxyStats:       globalReplicationStats.Load().getProxyStats(k),
		}
	}
	return &BucketStatsMap{Stats: bucketStatsMap, Timestamp: time.Now()}, nil
}

// GetBucketStatsHandler - fetches current in-memory bucket stats, currently only
// returns BucketStats, that currently includes ReplicationStats.

        regA(builder);
        return builder;
    }

    protected StatsAggregationBuilder regStatsA(String name, String field) {
        StatsAggregationBuilder builder = AggregationBuilders.stats(name).field(field);
        regA(builder);
        return builder;
    }

    protected PercentilesAggregationBuilder regPercentilesA(String name, String field) {

func httpTracerMiddleware(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Setup a http request response recorder - this is needed for
		// http stats requests and audit if enabled.
		respRecorder := xhttp.NewResponseRecorder(w)

		// Setup a http request body recorder
		reqRecorder := &xhttp.RequestRecorder{Reader: r.Body}
		r.Body = reqRecorder

		p, err := procfs.Self()
		if err != nil {
			metricsLogIf(ctx, err)
		} else {
			loadProcFSMetrics(ctx, p, m)
		}
	}

	if globalIsDistErasure && globalLockServer != nil {
		st := globalLockServer.stats()
		m.Set(processLocksReadTotal, float64(st.Reads))
		m.Set(processLocksWriteTotal, float64(st.Writes))
	}
	return nil

                          },
                          {
                            "name": "istio.stats",
                            "typed_config": {
                              "@type": "type.googleapis.com/udpa.type.v1.TypedStruct",
                              "type_url": "type.googleapis.com/stats.PluginConfig",
                              "value": {
                                "reporter": "SERVER_GATEWAY"

   * {@link Cache#stats} will return zero for all statistics. Note that recording stats requires
   * bookkeeping to be performed with each operation, and thus imposes a performance penalty on
   * cache operation.
   *
   * @return this {@code CacheBuilder} instance (for chaining)
   * @since 12.0 (previously, stats collection was automatic)
   */
  @CanIgnoreReturnValue

	globalDriveMonitoring = env.Get("_MINIO_DRIVE_ACTIVE_MONITORING", config.EnableOn) == config.EnableOn

	// Is MINIO_CI_CD set?
	globalIsCICD bool

	globalRootDiskThreshold uint64

	// Used for collecting stats for netperf
	globalNetPerfMinDuration     = time.Second * 10
	globalNetPerfRX              netPerfRX
	globalSiteNetPerfRX          netPerfRX
	globalObjectPerfBucket       = "minio-perf-test-tmp-bucket"

		adminRouter.Methods(http.MethodGet).Path(adminVersion + "/tier/{tier}").HandlerFunc(adminMiddleware(adminAPI.VerifyTierHandler))
		// Tier stats
		adminRouter.Methods(http.MethodGet).Path(adminVersion + "/tier-stats").HandlerFunc(adminMiddleware(adminAPI.TierStatsHandler))

		// Cluster Replication APIs