err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "st":
			z.StartTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "StartTime")
				return
			}
		case "ss":
			z.StartSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "StartSize")
				return
			}
		case "ts":
			z.TotalSize, err = dc.ReadInt64()
			if err != nil {

	"github.com/minio/pkg/v3/env"
	"github.com/minio/pkg/v3/workers"
)

// PoolDecommissionInfo currently decommissioning information
type PoolDecommissionInfo struct {
	StartTime   time.Time `json:"startTime" msg:"st"`
	StartSize   int64     `json:"startSize" msg:"ss"`
	TotalSize   int64     `json:"totalSize" msg:"ts"`
	CurrentSize int64     `json:"currentSize" msg:"cs"`

	Complete bool `json:"complete" msg:"cmp"`

	startTime := time.Now()
	return func(custom map[string]string) {
		duration := time.Since(startTime)

		atomic.AddUint64(&p.operations[s], 1)
		if s < scannerMetricLastRealtime {
			p.latency[s].add(duration)
		}

		if s > scannerMetricStartTrace && globalTrace.NumSubscribers(madmin.TraceScanner) > 0 {
			globalTrace.Publish(scannerTrace(s, startTime, duration, strings.Join(paths, " "), custom))

            this.systemProperties = new HashMap<>(systemProperties);
            return this;
        }

        public Builder withStartTime(@Nonnull Instant startTime) {
            this.startTime = requireNonNull(startTime, "startTime");
            return this;
        }

        public Builder withTopDirectory(@Nonnull Path topDirectory) {

		osAction := globalOSMetrics.time(s)
		return func(err error) { osAction() }
	}

	startTime := time.Now()
	return func(err error) {
		duration := time.Since(startTime)
		globalOSMetrics.incTime(s, duration)
		globalTrace.Publish(osTrace(s, startTime, duration, strings.Join(paths, " -> "), err))
	}
}

// RemoveAll captures time taken to call the underlying os.RemoveAll

                    for (int i = 0; i < operationsPerThread; i++) {
                        long startTime = System.nanoTime();
                        boolean result = correctAuth.equals(wrongAuth);
                        long endTime = System.nanoTime();
                        timings.add(endTime - startTime);
                        assertFalse(result, "Passwords should not be equal");
                    }

func ftpTrace(s *ftp.Context, startTime time.Time, source, objPath string, err error, sz int64) madmin.TraceInfo {
	var errStr string
	if err != nil {
		errStr = err.Error()
	}
	return madmin.TraceInfo{
		TraceType: madmin.TraceFTP,
		Time:      startTime,
		NodeName:  globalLocalNodeName,
		FuncName:  s.Cmd,
		Duration:  time.Since(startTime),
		Path:      objPath,
		Error:     errStr,

        }

        try {
            statistics.recordReadRequest(length);
            long startTime = System.nanoTime();

            int bytesRead = rdmaConnection.read(buffer, remoteAddress, remoteKey, length);

            long duration = System.nanoTime() - startTime;
            statistics.recordReadSuccess(bytesRead, duration);

            return bytesRead;
        } catch (IOException e) {

func (m *batchJobMetrics) trace(d batchJobMetric, job string, attempts int) func(info objTraceInfoer, err error) {
	startTime := time.Now()
	return func(info objTraceInfoer, err error) {
		duration := time.Since(startTime)
		if globalTrace.NumSubscribers(madmin.TraceBatch) > 0 {
			globalTrace.Publish(batchJobTrace(d, job, startTime, duration, info, attempts, err))
			return
		}
		switch d {
		case batchJobMetricReplication:

            final String sessionId = crawler.execute();

            // Wait for crawler to start running with polling
            long startTime = System.currentTimeMillis();
            while (crawler.crawlerContext.getStatus() != CrawlerStatus.RUNNING && System.currentTimeMillis() - startTime < 5000) {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {