public static Instant start() {
        return get().startInstant();
    }

    /**
     * Returns the elapsed time since clock initialization.
     * This is a convenience method equivalent to {@code get().elapsedTime()}.
     *
     * @return the duration since clock initialization
     */
    public static Duration elapsed() {
        return get().elapsedTime();
    }

    /**

/**
 * A time source; returns a time value representing the number of nanoseconds elapsed since some
 * fixed but arbitrary point in time. Note that most users should use {@link Stopwatch} instead of
 * interacting with this class directly.
 *
 * <p><b>Warning:</b> this interface can only be used to measure elapsed time, not wall time.
 *
 * @author Kevin Bourrillion

	if l.LogLevel <= Silent {
		return
	}

	elapsed := time.Since(begin)
	sql, rows := fc()
	fields := []slog.Attr{
		slog.String("duration", fmt.Sprintf("%.3fms", float64(elapsed.Nanoseconds())/1e6)),
		slog.String("sql", sql),
	}

	if rows != -1 {
		fields = append(fields, slog.Int64("rows", rows))
	}

	switch {

        long endTime = System.currentTimeMillis();

        long elapsed = endTime - startTime;
        assertTrue("Expected at least 15ms sleep, got " + elapsed + "ms", elapsed >= 15);
        // Generous tolerance for CI environments like GitHub Actions
        assertTrue("Expected less than 200ms sleep, got " + elapsed + "ms", elapsed < 200);
    }

    public void test_waitForNext_withZeroInterval() {

    }

    @Test
    @DisplayName("MonotonicClock elapsed time should increase")
    void testElapsedTime() throws InterruptedException {
        Duration initial = MonotonicClock.elapsed();
        Thread.sleep(50); // Longer delay for more reliable measurement
        Duration later = MonotonicClock.elapsed();

        assertTrue(later.compareTo(initial) > 0, "Elapsed time should increase");
        assertTrue(

    ticker.advance(2);
    assertEquals(0, stopwatch.elapsed(NANOSECONDS));
    stopwatch.start();
    ticker.advance(3);
    assertEquals(3, stopwatch.elapsed(NANOSECONDS));
  }

  public void testReset_whileRunning() {
    ticker.advance(1);
    stopwatch.start();
    assertEquals(0, stopwatch.elapsed(NANOSECONDS));
    ticker.advance(2);
    assertEquals(2, stopwatch.elapsed(NANOSECONDS));
    stopwatch.reset();

		totalBytesToRebal := float64(ps.InitCapacity)*meta.PercentFreeGoal - float64(ps.InitFreeSpace)
		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
		}

		}
	case elapsed > l.SlowThreshold && l.SlowThreshold != 0 && l.LogLevel >= Warn:
		sql, rows := fc()
		slowLog := fmt.Sprintf("SLOW SQL >= %v", l.SlowThreshold)
		if rows == -1 {
			l.Printf(l.traceWarnStr, utils.FileWithLineNum(), slowLog, float64(elapsed.Nanoseconds())/1e6, "-", sql)
		} else {
			l.Printf(l.traceWarnStr, utils.FileWithLineNum(), slowLog, float64(elapsed.Nanoseconds())/1e6, rows, sql)

				)

				if orchestrated && hostResolveToLocalhost(endpoints[i]) {
					// time elapsed
					timeElapsed := time.Since(startTime)
					// log error only if more than a second has elapsed
					if timeElapsed > time.Second {
						reqInfo.AppendTags("elapsedTime",
							humanize.RelTime(startTime,
								startTime.Add(timeElapsed),
								"elapsed",
								"",
							))
						ctx := logger.SetReqInfo(GlobalContext,

) : ConnectionListener() {
  val eventSequence: Deque<ConnectionEvent> = ConcurrentLinkedDeque()

  private val forbiddenLocks = mutableSetOf<Any>()

  /** The timestamp of the last taken event, used to measure elapsed time between events. */
  private var lastTimestampNs: Long? = null

  /** Confirm that the thread does not hold a lock on `lock` during the callback. */
  fun forbidLock(lock: Any) {
    forbiddenLocks.add(lock)
  }