Milliseconds vs Seconds Mix-up

// Dangerous: Assuming timestamp units
function processEvent(timestamp, data) {
  // Is this seconds or milliseconds? Who knows!
  const eventDate = new Date(timestamp);
  
  if (eventDate.getFullYear() < 2000) {
    // Oops, probably got seconds instead of milliseconds
    console.log("Event from 1970? That can't be right...");
  }
  
  return {
    date: eventDate,
    data: data
  };
}

// API response - what unit is this?
const response = {
  created_at: 1692134400,  // Seconds? Milliseconds? 🤷‍♂️
  event_data: {...}
};

// Safe: Explicit timestamp handling
class TimestampUtils {
  static ensureMilliseconds(timestamp) {
    // If it looks like seconds (10 digits), convert to milliseconds
    if (timestamp.toString().length === 10) {
      return timestamp * 1000;
    }
    
    // If it looks like milliseconds (13 digits), use as-is
    if (timestamp.toString().length === 13) {
      return timestamp;
    }
    
    throw new Error(`Invalid timestamp: ${timestamp}`);
  }
  
  static ensureSeconds(timestamp) {
    // If it looks like milliseconds, convert to seconds
    if (timestamp.toString().length === 13) {
      return Math.floor(timestamp / 1000);
    }
    
    // If it looks like seconds, use as-is
    if (timestamp.toString().length === 10) {
      return timestamp;
    }
    
    throw new Error(`Invalid timestamp: ${timestamp}`);
  }
  
  static validateTimestamp(timestamp) {
    const date = new Date(this.ensureMilliseconds(timestamp));
    const year = date.getFullYear();
    
    // Reasonable range: 1990-2100
    if (year < 1990 || year > 2100) {
      throw new Error(`Timestamp out of reasonable range: ${date.toISOString()}`);
    }
    
    return date;
  }
}

// Usage
const eventDate = TimestampUtils.validateTimestamp(apiResponse.timestamp);

{
  "event": {
    // Explicit units in field names
    "created_at_seconds": 1692134400,
    "created_at_ms": 1692134400000,
    
    // Even better: use ISO 8601 strings
    "created_at": "2023-08-15T22:00:00.000Z",
    
    // Multiple formats for compatibility
    "timestamps": {
      "iso": "2023-08-15T22:00:00.000Z",
      "unix_seconds": 1692134400,
      "unix_milliseconds": 1692134400000
    }
  }
}

import time
from datetime import datetime
from typing import Union

class TimestampConverter:
    @staticmethod
    def to_datetime(timestamp: Union[int, float, str]) -> datetime:
        """Convert various timestamp formats to datetime object"""
        
        if isinstance(timestamp, str):
            # Assume ISO 8601 string
            return datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
        
        # Numeric timestamp - detect unit by magnitude
        if timestamp > 1e12:  # Looks like milliseconds
            return datetime.fromtimestamp(timestamp / 1000)
        elif timestamp > 1e9:  # Looks like seconds
            return datetime.fromtimestamp(timestamp)
        else:
            raise ValueError(f"Timestamp {timestamp} doesn't look valid")
    
    @staticmethod
    def ensure_seconds(timestamp: Union[int, float]) -> int:
        """Ensure timestamp is in seconds"""
        if timestamp > 1e12:  # Milliseconds
            return int(timestamp / 1000)
        elif timestamp > 1e9:  # Already seconds
            return int(timestamp)
        else:
            raise ValueError(f"Invalid timestamp: {timestamp}")
    
    @staticmethod
    def ensure_milliseconds(timestamp: Union[int, float]) -> int:
        """Ensure timestamp is in milliseconds"""
        if timestamp > 1e12:  # Already milliseconds
            return int(timestamp)
        elif timestamp > 1e9:  # Seconds
            return int(timestamp * 1000)
        else:
            raise ValueError(f"Invalid timestamp: {timestamp}")

# Usage examples
converter = TimestampConverter()

# These all work regardless of input unit
dt1 = converter.to_datetime(1692134400)      # Seconds
dt2 = converter.to_datetime(1692134400000)   # Milliseconds
dt3 = converter.to_datetime("2023-08-15T22:00:00Z")  # ISO string