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,

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:

        TermQueryBuilder builder = regTermQ("startTime", startTime);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setStartTime_NotEqual(Long startTime) {
        setStartTime_NotTerm(startTime, null);
    }

    public void setStartTime_NotTerm(Long startTime) {

        this.scriptType = value;
    }

    public Long getStartTime() {
        checkSpecifiedProperty("startTime");
        return startTime;
    }

    public void setStartTime(Long value) {
        registerModifiedProperty("startTime");
        this.startTime = value;
    }

    public String getTarget() {
        checkSpecifiedProperty("target");

	}

	if stat.VirtualMemory() > 0 {
		m.Set(processVirtualMemoryBytes, float64(stat.VirtualMemory()))
	}

	startTime, err := stat.StartTime()
	if err != nil {
		metricsLogIf(ctx, err)
	} else if startTime > 0 {
		m.Set(processStartTimeSeconds, float64(startTime))
	}
}

func loadProcIOMetrics(ctx context.Context, io procfs.ProcIO, m MetricValues) {
	if io.RChar > 0 {

      return 0L;
    } else {
      long startTime = System.nanoTime();
      return (startTime == 0L) ? 1L : startTime;
    }
  }

  /**
   * Returns the remaining nanos until the given timeout, or 0L if the timeout has already elapsed.
   * Caller must have previously sanitized timeoutNanos using toSafeNanos.
   */
  private static long remainingNanos(long startTime, long timeoutNanos) {

    }

    public void setStartTime_Avg(ConditionOptionCall<AvgAggregationBuilder> opLambda) {
        setStartTime_Avg("startTime", opLambda);
    }

    public void setStartTime_Avg(String name, ConditionOptionCall<AvgAggregationBuilder> opLambda) {
        AvgAggregationBuilder builder = regAvgA(name, "startTime");
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

        }

        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 sftpTrace(s *sftp.Request, startTime time.Time, source string, user 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.Method,
		Duration:  time.Since(startTime),
		Path:      s.Filepath,
		Error:     errStr,

		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			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":