In modern data centers, time synchronization isn't just about clocks - it's about maintaining causality in distributed systems. The Network Time Protocol (NTP) typically achieves synchronization within 1-50 milliseconds across servers, but some applications demand even tighter tolerances:

// Example of timestamp-sensitive transaction processing
function processTransaction(timestamp, event) {
  // Financial systems often require ≤1ms tolerance
  if (Math.abs(Date.now() - timestamp) > 1) {
    throw new Error('Clock drift exceeds tolerance');
  }
  // Process atomic operation
}

Consider these real-world scenarios where unsynchronized clocks cause failures:

• Database replication conflicts when timestamps disagree
• Distributed lock expiration races
• Event sequencing errors in stream processing

# Linux chrony configuration for microsecond precision
pool 0.pool.ntp.org iburst
pool 1.pool.ntp.org iburst
driftfile /var/lib/chrony/drift
makestep 1.0 3
leapsecmode slew
maxdistance 16.0

Modern operating systems implement leap second smearing to avoid discontinuities:

// Kernel time handling pseudocode
void handle_leap_second() {
  if (leap_second_occurring) {
    // Spread adjustment over 24-hour window
    gradual_adjustment(86400);
  }
}

Implement time drift detection with Prometheus and Grafana:

# prometheus.yml rule for NTP monitoring
- name: time_sync
  rules:
  - alert: ClockDriftExceeded
    expr: abs(ntp_offset_seconds) > 0.005
    for: 5m
    labels:
      severity: critical

In distributed systems where transactions span multiple servers, even millisecond-level time discrepancies can cause:

• Race conditions in distributed locking mechanisms
• Inconsistent database replication timestamps
• Event ordering errors in stream processing
• SSL certificate validation failures

Consider this Kafka consumer scenario where events arrive out of order:

// Problem scenario with 500ms clock drift
const eventA = {
  id: "evt-1",
  timestamp: 1625097600123 // Server A's clock
};

const eventB = {
  id: "evt-2", 
  timestamp: 1625097600118 // Server B's clock (5ms earlier)
};

// Processing pipeline sorts by timestamp
const events = [eventA, eventB].sort((a,b) => a.timestamp - b.timestamp);
// Result: [eventB, eventA] - INCORRECT chronological order

For Linux systems using chrony (more accurate than ntpd):

# /etc/chrony.conf
pool time.google.com iburst
pool 0.pool.ntp.org iburst
pool 1.pool.ntp.org iburst

# Enable kernel PPS discipline
refclock PPS /dev/pps0 lock NMEA prefer
driftfile /var/lib/chrony/drift
makestep 1.0 3
local stratum 10

Modern approaches prefer smearing rather than abrupt jumps:

// Google's leap second smear implementation (simplified)
function applyLeapSecondSmear() {
  const smearDuration = 24 * 60 * 60 * 1000; // 24 hours
  const smearIncrement = 1 / (smearDuration / 1000);
  
  let currentOffset = 0;
  
  setInterval(() => {
    currentOffset += smearIncrement;
    SystemClock.adjust(currentOffset);
  }, 1000);
}

Essential metrics to track:

# Prometheus monitoring rules
- alert: ClockDriftExceeded
  expr: abs(ntp_offset_seconds) > 0.01
  for: 5m
  labels:
    severity: critical
  annotations:
    summary: "Clock drift exceeds 10ms threshold"
    description: "Node {{ $labels.instance }} has offset {{ $value }}s"