diff --git a/src/activity.c b/src/activity.c
index c3010c5..a2d3189 100644
--- a/src/activity.c
+++ b/src/activity.c
@@ -13,11 +13,11 @@
 #include <haproxy/activity-t.h>
 #include <haproxy/api.h>
 #include <haproxy/cfgparse.h>
+#include <haproxy/clock.h>
 #include <haproxy/channel.h>
 #include <haproxy/cli.h>
 #include <haproxy/freq_ctr.h>
 #include <haproxy/stream_interface.h>
-#include <haproxy/time.h>
 #include <haproxy/tools.h>
 #include <haproxy/xxhash.h>
 
diff --git a/src/cfgparse.c b/src/cfgparse.c
index 2ef62af..7aeffaa 100644
--- a/src/cfgparse.c
+++ b/src/cfgparse.c
@@ -46,6 +46,7 @@
 #include <haproxy/channel.h>
 #include <haproxy/check.h>
 #include <haproxy/chunk.h>
+#include <haproxy/clock.h>
 #ifdef USE_CPU_AFFINITY
 #include <haproxy/cpuset.h>
 #endif
@@ -82,7 +83,6 @@
 #include <haproxy/tcp_rules.h>
 #include <haproxy/tcpcheck.h>
 #include <haproxy/thread.h>
-#include <haproxy/time.h>
 #include <haproxy/tools.h>
 #include <haproxy/uri_auth-t.h>
 #include <haproxy/xprt_quic.h>
@@ -2403,7 +2403,7 @@
 	 */
 
 	/* will be needed further to delay some tasks */
-	tv_update_date(0,1);
+	clock_update_date(0,1);
 
 	if (!global.tune.max_http_hdr)
 		global.tune.max_http_hdr = MAX_HTTP_HDR;
diff --git a/src/clock.c b/src/clock.c
new file mode 100644
index 0000000..ecaeca9
--- /dev/null
+++ b/src/clock.c
@@ -0,0 +1,253 @@
+/*
+ * General time-keeping code and variables
+ *
+ * Copyright 2000-2021 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <sys/time.h>
+#include <time.h>
+
+#include <haproxy/api.h>
+#include <haproxy/clock.h>
+#include <haproxy/time.h>
+#include <haproxy/tinfo-t.h>
+#include <haproxy/tools.h>
+
+struct timeval                   start_date;      /* the process's start date in wall-clock time */
+volatile ullong                  global_now;      /* common monotonic date between all threads (32:32) */
+volatile uint                    global_now_ms;   /* common monotonic date in milliseconds (may wrap) */
+
+THREAD_ALIGNED(64) static ullong now_offset;      /* global offset between system time and global time */
+
+THREAD_LOCAL uint                now_ms;          /* internal monotonic date in milliseconds (may wrap) */
+THREAD_LOCAL struct timeval      now;             /* internal monotonic date derived from real clock */
+THREAD_LOCAL struct timeval      date;            /* the real current date (wall-clock time) */
+THREAD_LOCAL struct timeval      before_poll;     /* system date before calling poll() */
+THREAD_LOCAL struct timeval      after_poll;      /* system date after leaving poll() */
+
+static THREAD_LOCAL unsigned int iso_time_sec;     /* last iso time value for this thread */
+static THREAD_LOCAL char         iso_time_str[34]; /* ISO time representation of gettimeofday() */
+
+/* returns the system's monotonic time in nanoseconds if supported, otherwise zero */
+uint64_t now_mono_time(void)
+{
+	uint64_t ret = 0;
+#if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0) && defined(_POSIX_MONOTONIC_CLOCK)
+	struct timespec ts;
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+	ret = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
+#endif
+	return ret;
+}
+
+/* returns the current thread's cumulated CPU time in nanoseconds if supported, otherwise zero */
+uint64_t now_cpu_time(void)
+{
+	uint64_t ret = 0;
+#if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0) && defined(_POSIX_THREAD_CPUTIME)
+	struct timespec ts;
+	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
+	ret = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
+#endif
+	return ret;
+}
+
+/* returns another thread's cumulated CPU time in nanoseconds if supported, otherwise zero */
+uint64_t now_cpu_time_thread(const struct thread_info *thr)
+{
+	uint64_t ret = 0;
+#if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0) && defined(_POSIX_THREAD_CPUTIME)
+	struct timespec ts;
+	clock_gettime(thr->clock_id, &ts);
+	ret = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
+#endif
+	return ret;
+}
+
+/* clock_update_date: sets <date> to system time, and sets <now> to something as
+ * close as possible to real time, following a monotonic function. The main
+ * principle consists in detecting backwards and forwards time jumps and adjust
+ * an offset to correct them. This function should be called once after each
+ * poll, and never farther apart than MAX_DELAY_MS*2. The poll's timeout should
+ * be passed in <max_wait>, and the return value in <interrupted> (a non-zero
+ * value means that we have not expired the timeout).
+ *
+ * clock_init_process_date() must have been called once first, and
+ * clock_init_thread_date() must also have been called once for each thread.
+ *
+ * An offset is used to adjust the current time (date), to figure a monotonic
+ * local time (now). The offset is not critical, as it is only updated after a
+ * clock jump is detected. From this point all threads will apply it to their
+ * locally measured time, and will then agree around a common monotonic
+ * global_now value that serves to further refine their local time. As it is
+ * not possible to atomically update a timeval, both global_now and the
+ * now_offset values are instead stored as 64-bit integers made of two 32 bit
+ * values for the tv_sec and tv_usec parts. The offset is made of two signed
+ * ints so that the clock can be adjusted in the two directions.
+ */
+void clock_update_date(int max_wait, int interrupted)
+{
+	struct timeval min_deadline, max_deadline, tmp_now;
+	uint old_now_ms;
+	ullong old_now;
+	ullong new_now;
+	ullong ofs, ofs_new;
+	uint sec_ofs, usec_ofs;
+
+	gettimeofday(&date, NULL);
+
+	/* compute the minimum and maximum local date we may have reached based
+	 * on our past date and the associated timeout. There are three possible
+	 * extremities:
+	 *    - the new date cannot be older than before_poll
+	 *    - if not interrupted, the new date cannot be older than
+	 *      before_poll+max_wait
+	 *    - in any case the new date cannot be newer than
+	 *      before_poll+max_wait+some margin (100ms used here).
+	 * In case of violation, we'll ignore the current date and instead
+	 * restart from the last date we knew.
+	 */
+	_tv_ms_add(&min_deadline, &before_poll, max_wait);
+	_tv_ms_add(&max_deadline, &before_poll, max_wait + 100);
+
+	ofs = HA_ATOMIC_LOAD(&now_offset);
+
+	if (unlikely(__tv_islt(&date, &before_poll)                    || // big jump backwards
+		     (!interrupted && __tv_islt(&date, &min_deadline)) || // small jump backwards
+		     __tv_islt(&max_deadline, &date))) {                  // big jump forwards
+		if (!interrupted)
+			_tv_ms_add(&now, &now, max_wait);
+	} else {
+		/* The date is still within expectations. Let's apply the
+		 * now_offset to the system date. Note: ofs if made of two
+		 * independent signed ints.
+		 */
+		now.tv_sec  = date.tv_sec  + (int)(ofs >> 32); // note: may be positive or negative
+		now.tv_usec = date.tv_usec + (int)ofs;         // note: may be positive or negative
+		if ((int)now.tv_usec < 0) {
+			now.tv_usec += 1000000;
+			now.tv_sec  -= 1;
+		} else if (now.tv_usec >= 1000000) {
+			now.tv_usec -= 1000000;
+			now.tv_sec  += 1;
+		}
+	}
+
+	/* now that we have bounded the local time, let's check if it's
+	 * realistic regarding the global date, which only moves forward,
+	 * otherwise catch up.
+	 */
+	old_now    = global_now;
+	old_now_ms = global_now_ms;
+
+	do {
+		tmp_now.tv_sec  = (unsigned int)(old_now >> 32);
+		tmp_now.tv_usec = old_now & 0xFFFFFFFFU;
+
+		if (__tv_islt(&now, &tmp_now))
+			now = tmp_now;
+
+		/* now <now> is expected to be the most accurate date,
+		 * equal to <global_now> or newer.
+		 */
+		new_now = ((ullong)now.tv_sec << 32) + (uint)now.tv_usec;
+		now_ms = __tv_to_ms(&now);
+
+		/* let's try to update the global <now> (both in timeval
+		 * and ms forms) or loop again.
+		 */
+	} while (((new_now != old_now    && !_HA_ATOMIC_CAS(&global_now, &old_now, new_now)) ||
+		  (now_ms  != old_now_ms && !_HA_ATOMIC_CAS(&global_now_ms, &old_now_ms, now_ms))) &&
+		 __ha_cpu_relax());
+
+	/* <now> and <now_ms> are now updated to the last value of global_now
+	 * and global_now_ms, which were also monotonically updated. We can
+	 * compute the latest offset, we don't care who writes it last, the
+	 * variations will not break the monotonic property.
+	 */
+
+	sec_ofs  = now.tv_sec  - date.tv_sec;
+	usec_ofs = now.tv_usec - date.tv_usec;
+	if ((int)usec_ofs < 0) {
+		usec_ofs += 1000000;
+		sec_ofs  -= 1;
+	}
+	ofs_new = ((ullong)sec_ofs << 32) + usec_ofs;
+	if (ofs_new != ofs)
+		HA_ATOMIC_STORE(&now_offset, ofs_new);
+}
+
+/* must be called once at boot to initialize some global variables */
+void clock_init_process_date(void)
+{
+	now_offset = 0;
+	gettimeofday(&date, NULL);
+	now = after_poll = before_poll = date;
+	global_now = ((ullong)date.tv_sec << 32) + (uint)date.tv_usec;
+	global_now_ms = now.tv_sec * 1000 + now.tv_usec / 1000;
+	ti->idle_pct = 100;
+	clock_update_date(0, 1);
+}
+
+/* must be called once per thread to initialize their thread-local variables.
+ * Note that other threads might also be initializing and running in parallel.
+ */
+void clock_init_thread_date(void)
+{
+	ullong old_now;
+
+	gettimeofday(&date, NULL);
+	after_poll = before_poll = date;
+
+	old_now = _HA_ATOMIC_LOAD(&global_now);
+	now.tv_sec = old_now >> 32;
+	now.tv_usec = (uint)old_now;
+	ti->idle_pct = 100;
+	clock_update_date(0, 1);
+}
+
+/* returns the current date as returned by gettimeofday() in ISO+microsecond
+ * format. It uses a thread-local static variable that the reader can consume
+ * for as long as it wants until next call. Thus, do not call it from a signal
+ * handler. If <pad> is non-0, a trailing space will be added. It will always
+ * return exactly 32 or 33 characters (depending on padding) and will always be
+ * zero-terminated, thus it will always fit into a 34 bytes buffer.
+ * This also always include the local timezone (in +/-HH:mm format) .
+ */
+char *timeofday_as_iso_us(int pad)
+{
+	struct timeval new_date;
+	struct tm tm;
+	const char *offset;
+	char c;
+
+	gettimeofday(&new_date, NULL);
+	if (new_date.tv_sec != iso_time_sec || !new_date.tv_sec) {
+		get_localtime(new_date.tv_sec, &tm);
+		offset = get_gmt_offset(new_date.tv_sec, &tm);
+		if (unlikely(strftime(iso_time_str, sizeof(iso_time_str), "%Y-%m-%dT%H:%M:%S.000000+00:00", &tm) != 32))
+			strcpy(iso_time_str, "YYYY-mm-ddTHH:MM:SS.000000-00:00"); // make the failure visible but respect format.
+		iso_time_str[26] = offset[0];
+		iso_time_str[27] = offset[1];
+		iso_time_str[28] = offset[2];
+		iso_time_str[30] = offset[3];
+		iso_time_str[31] = offset[4];
+		iso_time_sec = new_date.tv_sec;
+	}
+
+	/* utoa_pad adds a trailing 0 so we save the char for restore */
+	c = iso_time_str[26];
+	utoa_pad(new_date.tv_usec, iso_time_str + 20, 7);
+	iso_time_str[26] = c;
+	if (pad) {
+		iso_time_str[32] = ' ';
+		iso_time_str[33] = 0;
+	}
+	return iso_time_str;
+}
diff --git a/src/debug.c b/src/debug.c
index 303e282..c5b78ed 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -23,6 +23,7 @@
 #include <haproxy/api.h>
 #include <haproxy/buf.h>
 #include <haproxy/cli.h>
+#include <haproxy/clock.h>
 #include <haproxy/debug.h>
 #include <haproxy/fd.h>
 #include <haproxy/global.h>
@@ -33,6 +34,7 @@
 #include <haproxy/stream_interface.h>
 #include <haproxy/task.h>
 #include <haproxy/thread.h>
+#include <haproxy/time.h>
 #include <haproxy/tools.h>
 #include <import/ist.h>
 
diff --git a/src/ev_epoll.c b/src/ev_epoll.c
index d376cd9..03888d0 100644
--- a/src/ev_epoll.c
+++ b/src/ev_epoll.c
@@ -16,12 +16,12 @@
 
 #include <haproxy/activity.h>
 #include <haproxy/api.h>
+#include <haproxy/clock.h>
 #include <haproxy/fd.h>
 #include <haproxy/global.h>
 #include <haproxy/signal.h>
 #include <haproxy/ticks.h>
 #include <haproxy/task.h>
-#include <haproxy/time.h>
 #include <haproxy/tools.h>
 
 
@@ -195,7 +195,7 @@
 		int timeout = (global.tune.options & GTUNE_BUSY_POLLING) ? 0 : wait_time;
 
 		status = epoll_wait(epoll_fd[tid], epoll_events, global.tune.maxpollevents, timeout);
-		tv_update_date(timeout, status);
+		clock_update_date(timeout, status);
 
 		if (status) {
 			activity[tid].poll_io++;
diff --git a/src/ev_evports.c b/src/ev_evports.c
index f8c7f34..23bf11f 100644
--- a/src/ev_evports.c
+++ b/src/ev_evports.c
@@ -20,12 +20,12 @@
 
 #include <haproxy/activity.h>
 #include <haproxy/api.h>
+#include <haproxy/clock.h>
 #include <haproxy/fd.h>
 #include <haproxy/global.h>
 #include <haproxy/signal.h>
 #include <haproxy/task.h>
 #include <haproxy/ticks.h>
-#include <haproxy/time.h>
 
 /*
  * Private data:
@@ -191,7 +191,7 @@
 				break;
 			}
 		}
-		tv_update_date(timeout, nevlist);
+		clock_update_date(timeout, nevlist);
 
 		if (nevlist || interrupted)
 			break;
diff --git a/src/ev_kqueue.c b/src/ev_kqueue.c
index 3a53e07..df8eae2 100644
--- a/src/ev_kqueue.c
+++ b/src/ev_kqueue.c
@@ -19,12 +19,12 @@
 
 #include <haproxy/activity.h>
 #include <haproxy/api.h>
+#include <haproxy/clock.h>
 #include <haproxy/fd.h>
 #include <haproxy/global.h>
 #include <haproxy/signal.h>
 #include <haproxy/task.h>
 #include <haproxy/ticks.h>
-#include <haproxy/time.h>
 
 
 /* private data */
@@ -161,7 +161,7 @@
 		                kev,       // struct kevent *eventlist
 		                fd,        // int nevents
 		                &timeout_ts); // const struct timespec *timeout
-		tv_update_date(timeout, status);
+		clock_update_date(timeout, status);
 
 		if (status) {
 			activity[tid].poll_io++;
diff --git a/src/ev_poll.c b/src/ev_poll.c
index b08bfca..9b93c92 100644
--- a/src/ev_poll.c
+++ b/src/ev_poll.c
@@ -19,11 +19,11 @@
 
 #include <haproxy/activity.h>
 #include <haproxy/api.h>
+#include <haproxy/clock.h>
 #include <haproxy/fd.h>
 #include <haproxy/global.h>
 #include <haproxy/task.h>
 #include <haproxy/ticks.h>
-#include <haproxy/time.h>
 
 
 #ifndef POLLRDHUP
@@ -205,7 +205,7 @@
 	sched_entering_poll();
 	activity_count_runtime();
 	status = poll(poll_events, nbfd, wait_time);
-	tv_update_date(wait_time, status);
+	clock_update_date(wait_time, status);
 	sched_leaving_poll(wait_time, status);
 
 	thread_harmless_end();
diff --git a/src/ev_select.c b/src/ev_select.c
index 12c7341..47da75d 100644
--- a/src/ev_select.c
+++ b/src/ev_select.c
@@ -16,11 +16,11 @@
 
 #include <haproxy/activity.h>
 #include <haproxy/api.h>
+#include <haproxy/clock.h>
 #include <haproxy/fd.h>
 #include <haproxy/global.h>
 #include <haproxy/task.h>
 #include <haproxy/ticks.h>
-#include <haproxy/time.h>
 
 
 /* private data */
@@ -180,7 +180,7 @@
 			writenotnull ? tmp_evts[DIR_WR] : NULL,
 			NULL,
 			&delta);
-	tv_update_date(delta_ms, status);
+	clock_update_date(delta_ms, status);
 	sched_leaving_poll(delta_ms, status);
 
 	thread_harmless_end();
diff --git a/src/haproxy.c b/src/haproxy.c
index 1ab2bf6..618efb3 100644
--- a/src/haproxy.c
+++ b/src/haproxy.c
@@ -95,6 +95,7 @@
 #include <haproxy/cfgparse.h>
 #include <haproxy/chunk.h>
 #include <haproxy/cli.h>
+#include <haproxy/clock.h>
 #include <haproxy/connection.h>
 #ifdef USE_CPU_AFFINITY
 #include <haproxy/cpuset.h>
@@ -1506,7 +1507,7 @@
 #endif
 
 	tzset();
-	tv_init_process_date();
+	clock_init_process_date();
 	start_date = now;
 
 	ha_random_boot(argv);
@@ -2615,7 +2616,7 @@
 {
 	int next, wake;
 
-	tv_update_date(0,1);
+	clock_update_date(0,1);
 	while (1) {
 		wake_expired_tasks();
 
@@ -2720,7 +2721,7 @@
 		init_left = global.nbthread;
 	init_left--;
 
-	tv_init_thread_date();
+	clock_init_thread_date();
 
 	/* per-thread alloc calls performed here are not allowed to snoop on
 	 * other threads, so they are free to initialize at their own rhythm
diff --git a/src/hlua.c b/src/hlua.c
index 7e75954..d5d3f59 100644
--- a/src/hlua.c
+++ b/src/hlua.c
@@ -32,6 +32,7 @@
 #include <haproxy/cfgparse.h>
 #include <haproxy/channel.h>
 #include <haproxy/cli.h>
+#include <haproxy/clock.h>
 #include <haproxy/connection.h>
 #include <haproxy/filters.h>
 #include <haproxy/h1.h>
@@ -1325,7 +1326,7 @@
 		MAY_LJMP(hlua_yieldk(L, 0, 0, NULL, TICK_ETERNITY, HLUA_CTRLYIELD));
 
 	/* If we cannot yield, update the clock and check the timeout. */
-	tv_update_date(0, 1);
+	clock_update_date(0, 1);
 	hlua->run_time += now_ms - hlua->start_time;
 	if (hlua->max_time && hlua->run_time >= hlua->max_time) {
 		lua_pushfstring(L, "execution timeout");
@@ -1411,7 +1412,7 @@
 		/* Check if the execution timeout is expired. It it is the case, we
 		 * break the Lua execution.
 		 */
-		tv_update_date(0, 1);
+		clock_update_date(0, 1);
 		lua->run_time += now_ms - lua->start_time;
 		if (lua->max_time && lua->run_time > lua->max_time) {
 			lua_settop(lua->T, 0); /* Empty the stack. */
diff --git a/src/log.c b/src/log.c
index 0e880c9..d15377d 100644
--- a/src/log.c
+++ b/src/log.c
@@ -27,6 +27,7 @@
 #include <haproxy/api.h>
 #include <haproxy/applet-t.h>
 #include <haproxy/cfgparse.h>
+#include <haproxy/clock.h>
 #include <haproxy/fd.h>
 #include <haproxy/frontend.h>
 #include <haproxy/global.h>
diff --git a/src/sample.c b/src/sample.c
index bda5908..970dabb 100644
--- a/src/sample.c
+++ b/src/sample.c
@@ -25,6 +25,7 @@
 #include <haproxy/base64.h>
 #include <haproxy/buf.h>
 #include <haproxy/chunk.h>
+#include <haproxy/clock.h>
 #include <haproxy/errors.h>
 #include <haproxy/fix.h>
 #include <haproxy/global.h>
@@ -39,7 +40,6 @@
 #include <haproxy/sample.h>
 #include <haproxy/sink.h>
 #include <haproxy/stick_table.h>
-#include <haproxy/time.h>
 #include <haproxy/tools.h>
 #include <haproxy/uri_auth-t.h>
 #include <haproxy/vars.h>
diff --git a/src/stats.c b/src/stats.c
index 4c8ea0c..da6fc36 100644
--- a/src/stats.c
+++ b/src/stats.c
@@ -33,6 +33,7 @@
 #include <haproxy/channel.h>
 #include <haproxy/check.h>
 #include <haproxy/cli.h>
+#include <haproxy/clock.h>
 #include <haproxy/compression.h>
 #include <haproxy/debug.h>
 #include <haproxy/errors.h>
diff --git a/src/task.c b/src/task.c
index 27a4ca7..d547359 100644
--- a/src/task.c
+++ b/src/task.c
@@ -18,11 +18,11 @@
 #include <haproxy/api.h>
 #include <haproxy/activity.h>
 #include <haproxy/cfgparse.h>
+#include <haproxy/clock.h>
 #include <haproxy/fd.h>
 #include <haproxy/list.h>
 #include <haproxy/pool.h>
 #include <haproxy/task.h>
-#include <haproxy/time.h>
 #include <haproxy/tools.h>
 
 extern struct task *process_stream(struct task *t, void *context, unsigned int state);
@@ -882,7 +882,7 @@
 }
 
 /* Update the idle time value twice a second, to be called after
- * tv_update_date() when called after poll(), and currently called only by
+ * clock_update_date() when called after poll(), and currently called only by
  * sched_leaving_poll() below. It relies on <before_poll> to be updated to
  * the system time before calling poll().
  */
diff --git a/src/thread.c b/src/thread.c
index a340001..ad5327a 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -43,11 +43,11 @@
 #endif
 
 #include <haproxy/cfgparse.h>
+#include <haproxy/clock.h>
 #include <haproxy/fd.h>
 #include <haproxy/global.h>
 #include <haproxy/log.h>
 #include <haproxy/thread.h>
-#include <haproxy/time.h>
 #include <haproxy/tools.h>
 
 struct thread_info ha_thread_info[MAX_THREADS] = { };
diff --git a/src/time.c b/src/time.c
index 99aed11..280b522 100644
--- a/src/time.c
+++ b/src/time.c
@@ -10,27 +10,11 @@
  *
  */
 
-#include <unistd.h>
 #include <sys/time.h>
 
 #include <haproxy/api.h>
 #include <haproxy/time.h>
-#include <haproxy/ticks.h>
-#include <haproxy/tools.h>
 
-THREAD_LOCAL unsigned int   now_ms;          /* internal date in milliseconds (may wrap) */
-THREAD_LOCAL struct timeval now;             /* internal date is a monotonic function of real clock */
-THREAD_LOCAL struct timeval date;            /* the real current date */
-struct timeval start_date;      /* the process's start date */
-THREAD_LOCAL struct timeval before_poll;     /* system date before calling poll() */
-THREAD_LOCAL struct timeval after_poll;      /* system date after leaving poll() */
-
-static unsigned long long now_offset;        /* global offset between system time and global time */
-volatile unsigned long long global_now;      /* common monotonic date between all threads (32:32) */
-volatile unsigned int global_now_ms;         /* common monotonic date in milliseconds (may wrap) */
-
-static THREAD_LOCAL unsigned int iso_time_sec;     /* last iso time value for this thread */
-static THREAD_LOCAL char         iso_time_str[34]; /* ISO time representation of gettimeofday() */
 
 /*
  * adds <ms> ms to <from>, set the result to <tv> and returns a pointer <tv>
@@ -155,186 +139,6 @@
 	return __tv_isgt(tv1, tv2);
 }
 
-/* tv_update_date: sets <date> to system time, and sets <now> to something as
- * close as possible to real time, following a monotonic function. The main
- * principle consists in detecting backwards and forwards time jumps and adjust
- * an offset to correct them. This function should be called once after each
- * poll, and never farther apart than MAX_DELAY_MS*2. The poll's timeout should
- * be passed in <max_wait>, and the return value in <interrupted> (a non-zero
- * value means that we have not expired the timeout).
- *
- * tv_init_process_date() must have been called once first, and
- * tv_init_thread_date() must also have been called once for each thread.
- *
- * An offset is used to adjust the current time (date), to figure a monotonic
- * local time (now). The offset is not critical, as it is only updated after a
- * clock jump is detected. From this point all threads will apply it to their
- * locally measured time, and will then agree around a common monotonic
- * global_now value that serves to further refine their local time. As it is
- * not possible to atomically update a timeval, both global_now and the
- * now_offset values are instead stored as 64-bit integers made of two 32 bit
- * values for the tv_sec and tv_usec parts. The offset is made of two signed
- * ints so that the clock can be adjusted in the two directions.
- */
-void tv_update_date(int max_wait, int interrupted)
-{
-	struct timeval min_deadline, max_deadline, tmp_now;
-	unsigned int old_now_ms;
-	unsigned long long old_now;
-	unsigned long long new_now;
-	ullong ofs, ofs_new;
-	uint sec_ofs, usec_ofs;
-
-	gettimeofday(&date, NULL);
-
-	/* compute the minimum and maximum local date we may have reached based
-	 * on our past date and the associated timeout. There are three possible
-	 * extremities:
-	 *    - the new date cannot be older than before_poll
-	 *    - if not interrupted, the new date cannot be older than
-	 *      before_poll+max_wait
-	 *    - in any case the new date cannot be newer than
-	 *      before_poll+max_wait+some margin (100ms used here).
-	 * In case of violation, we'll ignore the current date and instead
-	 * restart from the last date we knew.
-	 */
-	_tv_ms_add(&min_deadline, &before_poll, max_wait);
-	_tv_ms_add(&max_deadline, &before_poll, max_wait + 100);
-
-	ofs = HA_ATOMIC_LOAD(&now_offset);
-
-	if (unlikely(__tv_islt(&date, &before_poll)                    || // big jump backwards
-		     (!interrupted && __tv_islt(&date, &min_deadline)) || // small jump backwards
-		     __tv_islt(&max_deadline, &date))) {                  // big jump forwards
-		if (!interrupted)
-			_tv_ms_add(&now, &now, max_wait);
-	} else {
-		/* The date is still within expectations. Let's apply the
-		 * now_offset to the system date. Note: ofs if made of two
-		 * independent signed ints.
-		 */
-		now.tv_sec  = date.tv_sec  + (int)(ofs >> 32); // note: may be positive or negative
-		now.tv_usec = date.tv_usec + (int)ofs;         // note: may be positive or negative
-		if ((int)now.tv_usec < 0) {
-			now.tv_usec += 1000000;
-			now.tv_sec  -= 1;
-		} else if (now.tv_usec >= 1000000) {
-			now.tv_usec -= 1000000;
-			now.tv_sec  += 1;
-		}
-	}
-
-	/* now that we have bounded the local time, let's check if it's
-	 * realistic regarding the global date, which only moves forward,
-	 * otherwise catch up.
-	 */
-	old_now = global_now;
-	old_now_ms = global_now_ms;
-
-	do {
-		tmp_now.tv_sec  = (unsigned int)(old_now >> 32);
-		tmp_now.tv_usec = old_now & 0xFFFFFFFFU;
-
-		if (__tv_islt(&now, &tmp_now))
-			now = tmp_now;
-
-		/* now <now> is expected to be the most accurate date,
-		 * equal to <global_now> or newer.
-		 */
-		new_now = ((ullong)now.tv_sec << 32) + (uint)now.tv_usec;
-		now_ms = __tv_to_ms(&now);
-
-		/* let's try to update the global <now> (both in timeval
-		 * and ms forms) or loop again.
-		 */
-	} while (((new_now != old_now    && !_HA_ATOMIC_CAS(&global_now, &old_now, new_now)) ||
-		  (now_ms  != old_now_ms && !_HA_ATOMIC_CAS(&global_now_ms, &old_now_ms, now_ms))) &&
-		 __ha_cpu_relax());
-
-	/* <now> and <now_ms> are now updated to the last value of global_now
-	 * and global_now_ms, which were also monotonically updated. We can
-	 * compute the latest offset, we don't care who writes it last, the
-	 * variations will not break the monotonic property.
-	 */
-
-	sec_ofs  = now.tv_sec  - date.tv_sec;
-	usec_ofs = now.tv_usec - date.tv_usec;
-	if ((int)usec_ofs < 0) {
-		usec_ofs += 1000000;
-		sec_ofs  -= 1;
-	}
-	ofs_new = ((ullong)sec_ofs << 32) + usec_ofs;
-	if (ofs_new != ofs)
-		HA_ATOMIC_STORE(&now_offset, ofs_new);
-}
-
-/* must be called once at boot to initialize some global variables */
-void tv_init_process_date()
-{
-	now_offset = 0;
-	gettimeofday(&date, NULL);
-	now = after_poll = before_poll = date;
-	global_now = ((ullong)date.tv_sec << 32) + (uint)date.tv_usec;
-	global_now_ms = now.tv_sec * 1000 + now.tv_usec / 1000;
-	ti->idle_pct = 100;
-	tv_update_date(0, 1);
-}
-
-/* must be called once per thread to initialize their thread-local variables.
- * Note that other threads might also be initializing and running in parallel.
- */
-void tv_init_thread_date()
-{
-	ullong old_now;
-
-	gettimeofday(&date, NULL);
-	after_poll = before_poll = date;
-
-	old_now = _HA_ATOMIC_LOAD(&global_now);
-	now.tv_sec = old_now >> 32;
-	now.tv_usec = (uint)old_now;
-	ti->idle_pct = 100;
-	tv_update_date(0, 1);
-}
-
-/* returns the current date as returned by gettimeofday() in ISO+microsecond
- * format. It uses a thread-local static variable that the reader can consume
- * for as long as it wants until next call. Thus, do not call it from a signal
- * handler. If <pad> is non-0, a trailing space will be added. It will always
- * return exactly 32 or 33 characters (depending on padding) and will always be
- * zero-terminated, thus it will always fit into a 34 bytes buffer.
- * This also always include the local timezone (in +/-HH:mm format) .
- */
-char *timeofday_as_iso_us(int pad)
-{
-	struct timeval new_date;
-	struct tm tm;
-	const char *offset;
-	char c;
-	gettimeofday(&new_date, NULL);
-	if (new_date.tv_sec != iso_time_sec || !new_date.tv_sec) {
-		get_localtime(new_date.tv_sec, &tm);
-		offset = get_gmt_offset(new_date.tv_sec, &tm);
-		if (unlikely(strftime(iso_time_str, sizeof(iso_time_str), "%Y-%m-%dT%H:%M:%S.000000+00:00", &tm) != 32))
-			strcpy(iso_time_str, "YYYY-mm-ddTHH:MM:SS.000000-00:00"); // make the failure visible but respect format.
-		iso_time_str[26] = offset[0];
-		iso_time_str[27] = offset[1];
-		iso_time_str[28] = offset[2];
-		iso_time_str[30] = offset[3];
-		iso_time_str[31] = offset[4];
-		iso_time_sec = new_date.tv_sec;
-	}
-	/* utoa_pad adds a trailing 0 so we save the char for restore */
-	c = iso_time_str[26];
-	utoa_pad(new_date.tv_usec, iso_time_str + 20, 7);
-	iso_time_str[26] = c;
-	if (pad) {
-		iso_time_str[32] = ' ';
-		iso_time_str[33] = 0;
-	}
-	return iso_time_str;
-}
-
 /*
  * Local variables:
  *  c-indent-level: 8
diff --git a/src/wdt.c b/src/wdt.c
index f1aa3ec..066f109 100644
--- a/src/wdt.c
+++ b/src/wdt.c
@@ -13,12 +13,12 @@
 #include <time.h>
 
 #include <haproxy/api.h>
+#include <haproxy/clock.h>
 #include <haproxy/debug.h>
 #include <haproxy/errors.h>
 #include <haproxy/global.h>
 #include <haproxy/signal-t.h>
 #include <haproxy/thread.h>
-#include <haproxy/time.h>
 #include <haproxy/tools.h>