elapsed := time.Since(ps.Info.StartTime)
		eta := time.Duration(totalBytesToRebal * float64(elapsed) / float64(ps.Bytes))
		if !ps.Info.EndTime.IsZero() {
			stopTime = ps.Info.EndTime
		}

		if !stopTime.IsZero() { // rebalance is stopped or completed
			elapsed = stopTime.Sub(ps.Info.StartTime)
			eta = 0
		}

		r.Pools[i].Progress = rebalPoolProgress{

			}
		case "ResetID":
			z.ResetID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "ResetID")
				return
			}
		case "StartTime":
			z.StartTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "StartTime")
				return
			}
		case "EndTime":
			z.EndTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "EndTime")
				return

            Properties executionProperties,
            Date startTime) {
        this(
                container,
                settings,
                localRepository,
                eventDispatcher,
                unused,
                goals,
                executionRootDir,
                executionProperties,
                null,
                startTime);
    }

    @Deprecated

                    System.currentTimeMillis() - startTime);
            if (logger.isDebugEnabled()) {
                logger.debug("[RAG:INTENT] Intent detection completed. intent={}, query={}, reasoning={}, elapsedTime={}ms",
                        result.getIntent(), result.getQuery(), result.getReasoning(), System.currentTimeMillis() - startTime);
            }

            return result;

      },
      "scriptData": {
        "type": "keyword"
      },
      "scriptResult": {
        "type": "keyword"
      },
      "lastUpdated": {
        "type": "long"
      },
      "startTime": {
        "type": "long"
      },
      "endTime": {
        "type": "long"
      }
    }

        private final AtomicLong executeTime = new AtomicLong(0);
        private final AtomicBoolean committed = new AtomicBoolean(false);
        private final long startTime = System.currentTimeMillis();

        @Override
        public void store(DataStoreParams paramMap, Map<String, Object> dataMap) {
            documentCount.incrementAndGet();
        }

        @Override

import org.elasticsearch.gradle.internal.info.BuildParams
import org.gradle.initialization.BuildRequestMetaData
import org.elasticsearch.gradle.internal.test.rerun.TestRerunPlugin
import java.util.concurrent.TimeUnit

long startTime = project.gradle.services.get(BuildRequestMetaData).getStartTime()

buildScan {
  background {
    URL jenkinsUrl = System.getenv('JENKINS_URL') ? new URL(System.getenv('JENKINS_URL')) : null

                                    <tr>
                                        <th><la:message key="labels.joblog_startTime"/></th>
                                        <td>${f:h(startTime)}<la:hidden property="startTime"/></td>
                                    </tr>
                                    <tr>
                                        <th><la:message key="labels.joblog_endTime"/></th>

            // Should complete even with slow searcher
            final long startTime = System.currentTimeMillis();
            final List<Map<String, Object>> results = processor.search("*", new TestSearchRequestParams(0, 10, 0), OptionalThing.empty());
            final long elapsed = System.currentTimeMillis() - startTime;

            assertNotNull(results);

}

func (p *rebalanceMetrics) log(r rebalanceMetric, poolIdx int, paths ...string) func(sz int64, err error) {
	startTime := time.Now()
	return func(sz int64, err error) {
		duration := time.Since(startTime)
		if globalTrace.NumSubscribers(madmin.TraceRebalance) > 0 {
			globalTrace.Publish(rebalanceTrace(r, poolIdx, startTime, duration, err, strings.Join(paths, " "), sz))
		}
	}