Ruby Time and DateTime Guide: Modern Timestamp Handling Best Practices

Master Ruby datetime with Time, DateTime, Date classes, ActiveSupport, timezone handling, DST management, and Rails integration. Complete guide for production Ruby applications.

·16 min read·By Timestamp Generator Team
rubydatetimetimetimezonerailsactivesupport

Ruby Time and DateTime Guide

Let's talk about Ruby's approach to time. Unlike some languages that make you choose between twenty different datetime classes, Ruby keeps it elegant with Time, DateTime, and Date. And when you add ActiveSupport? Well, that's when the magic really happens. Let's explore how Ruby makes datetime operations not just powerful, but actually pleasant to work with.

Ruby's DateTime Classes: Which One Do You Actually Need?

Here's the thing about Ruby's datetime classes—they each have a purpose, but you'll mostly stick with one. Let me save you some confusion:

Time - Your go-to for basically everything (use this) DateTime - For astronomy calculations? (seriously, that's about it) Date - When you just need dates, not times (birthdays, anniversaries, that kind of thing)

When to Use Each Class (The Real Answer)

# ✅ Time - Use for most datetime operations (recommended)
time = Time.now
# - Represents moments in time with timezone
# - Native Unix timestamp support
# - Fast and efficient

# ⚠️ DateTime - Only for astronomical datetime calculations
datetime = DateTime.now
# - Supports dates far in past/future
# - Slower than Time
# - Rarely needed in typical apps

# ✅ Date - Use for date-only operations
date = Date.today
# - No time component
# - Calendar calculations
# - Birthdays, anniversaries, etc.

The Time Class

Creating Time Objects

# Current time
now = Time.now
puts now  # 2024-01-15 19:00:00 -0500

# Current time in UTC
utc_now = Time.now.utc
puts utc_now  # 2024-01-16 00:00:00 UTC

# From components
time = Time.new(2024, 1, 15, 19, 0, 0, '+00:00')
# Arguments: year, month, day, hour, min, sec, utc_offset

# From Unix timestamp
timestamp = 1705341600
from_timestamp = Time.at(timestamp)
puts from_timestamp  # 2024-01-15 19:00:00 UTC

# Parse from string
require 'time'
parsed = Time.parse('2024-01-15 19:00:00')
iso_parsed = Time.iso8601('2024-01-15T19:00:00Z')
rfc_parsed = Time.rfc2822('Mon, 15 Jan 2024 19:00:00 +0000')

# Specific formats
require 'time'
custom = Time.strptime('15-Jan-2024 19:00:00', '%d-%b-%Y %H:%M:%S')

Converting to Timestamps

time = Time.new(2024, 1, 15, 19, 0, 0, '+00:00')

# To Unix timestamp (integer seconds)
timestamp = time.to_i
puts timestamp  # 1705341600

# To float (includes fractional seconds)
float_timestamp = time.to_f
puts float_timestamp  # 1705341600.123456

# To ISO 8601 string
iso = time.iso8601
puts iso  # 2024-01-15T19:00:00Z

# To RFC 2822 string
rfc = time.rfc2822
puts rfc  # Mon, 15 Jan 2024 19:00:00 +0000

# Custom formatting
formatted = time.strftime('%Y-%m-%d %H:%M:%S')
puts formatted  # 2024-01-15 19:00:00

# HTTP date format
http_date = time.httpdate
puts http_date  # Mon, 15 Jan 2024 19:00:00 GMT

Format String Reference

time = Time.new(2024, 1, 15, 19, 0, 0, '+00:00')

# Date formats
puts time.strftime('%Y')    # 2024 - Year (4 digits)
puts time.strftime('%y')    # 24   - Year (2 digits)
puts time.strftime('%m')    # 01   - Month (01-12)
puts time.strftime('%B')    # January - Month full name
puts time.strftime('%b')    # Jan  - Month short name
puts time.strftime('%d')    # 15   - Day (01-31)
puts time.strftime('%e')    # 15   - Day (1-31, space padded)
puts time.strftime('%A')    # Monday - Weekday full name
puts time.strftime('%a')    # Mon  - Weekday short name

# Time formats
puts time.strftime('%H')    # 19   - Hour 24h (00-23)
puts time.strftime('%I')    # 07   - Hour 12h (01-12)
puts time.strftime('%M')    # 00   - Minute (00-59)
puts time.strftime('%S')    # 00   - Second (00-59)
puts time.strftime('%L')    # 000  - Millisecond (000-999)
puts time.strftime('%p')    # PM   - AM/PM
puts time.strftime('%P')    # pm   - am/pm

# Timezone formats
puts time.strftime('%Z')    # UTC  - Timezone name
puts time.strftime('%z')    # +0000 - UTC offset

# Common combinations
puts time.strftime('%Y-%m-%d')              # 2024-01-15
puts time.strftime('%Y-%m-%d %H:%M:%S')     # 2024-01-15 19:00:00
puts time.strftime('%B %d, %Y at %I:%M %p') # January 15, 2024 at 07:00 PM

Time Arithmetic

time = Time.new(2024, 1, 15, 19, 0, 0)

# Add/subtract seconds
one_hour_later = time + 3600        # +1 hour
one_day_later = time + (24 * 3600)  # +1 day
one_hour_earlier = time - 3600      # -1 hour

# Difference between times (returns seconds)
start_time = Time.now
sleep 2
end_time = Time.now
elapsed = end_time - start_time
puts "Elapsed: #{elapsed} seconds"  # Elapsed: 2.001234 seconds

# Helper constants (if using ActiveSupport)
require 'active_support/core_ext/numeric/time'

time + 1.hour
time + 1.day
time + 1.week
time + 1.month
time + 1.year

Time Components

time = Time.new(2024, 1, 15, 19, 0, 0, '+00:00')

# Date components
puts time.year   # 2024
puts time.month  # 1
puts time.day    # 15
puts time.wday   # 1 (0=Sunday, 1=Monday, ...)
puts time.yday   # 15 (day of year)
puts time.mday   # 15 (alias for day)

# Time components
puts time.hour   # 19
puts time.min    # 0
puts time.sec    # 0
puts time.usec   # 0 (microseconds)
puts time.nsec   # 0 (nanoseconds)

# Timezone info
puts time.zone   # UTC
puts time.utc_offset  # 0 (seconds from UTC)
puts time.gmt_offset  # 0 (alias for utc_offset)

# Boolean checks
puts time.monday?     # true
puts time.tuesday?    # false
puts time.utc?        # true
puts time.dst?        # false (daylight saving time)

Timezone Handling

Converting Between Timezones

require 'time'

# Create time in UTC
utc_time = Time.new(2024, 1, 15, 19, 0, 0, '+00:00')
puts "UTC: #{utc_time}"

# Convert to local timezone
local_time = utc_time.getlocal
puts "Local: #{local_time}"

# Convert to specific offset
# Eastern Standard Time (UTC-5)
est_time = utc_time.getlocal('-05:00')
puts "EST: #{est_time}"

# Convert to UTC
time = Time.now
utc = time.utc
puts "UTC: #{utc}"

# Clone and convert
original = Time.now
utc_copy = original.dup.utc
puts "Original: #{original}"  # unchanged
puts "UTC copy: #{utc_copy}"

# Check if time is UTC
puts utc.utc?  # true

ActiveSupport Timezone Support

Rails' ActiveSupport provides powerful timezone features:

require 'active_support/all'

# List all timezones
puts ActiveSupport::TimeZone.all.map(&:name)

# Find timezone
ny_tz = ActiveSupport::TimeZone['America/New_York']
tokyo_tz = ActiveSupport::TimeZone['Tokyo']
utc_tz = ActiveSupport::TimeZone['UTC']

# Current time in timezone
ny_now = ny_tz.now
tokyo_now = tokyo_tz.now

puts "New York: #{ny_now}"
puts "Tokyo:    #{tokyo_now}"

# Convert between timezones
utc_time = Time.now.utc
ny_time = utc_time.in_time_zone('America/New_York')
tokyo_time = utc_time.in_time_zone('Asia/Tokyo')
london_time = utc_time.in_time_zone('Europe/London')

puts "UTC:    #{utc_time.strftime('%Y-%m-%d %H:%M:%S %Z')}"
puts "NY:     #{ny_time.strftime('%Y-%m-%d %H:%M:%S %Z')}"
puts "Tokyo:  #{tokyo_time.strftime('%Y-%m-%d %H:%M:%S %Z')}"
puts "London: #{london_time.strftime('%Y-%m-%d %H:%M:%S %Z')}"

# Set default timezone
Time.zone = 'America/New_York'
puts Time.zone.now  # Current time in New York

# Access raw Time object
active_support_time = Time.zone.now
ruby_time = active_support_time.to_time
puts ruby_time.class  # Time

Rails Configuration

# config/application.rb
module MyApp
  class Application < Rails::Application
    # Set default timezone to UTC (recommended)
    config.time_zone = 'UTC'

    # Set Active Record to store times in UTC
    config.active_record.default_timezone = :utc

    # Or set to user's timezone
    # config.time_zone = 'America/New_York'
  end
end

# Per-user timezone in controller
class ApplicationController < ActionController::Base
  around_action :set_time_zone

  private

  def set_time_zone(&block)
    Time.use_zone(current_user.time_zone, &block)
  end
end

ActiveSupport Time Extensions

Now we're getting to the good stuff. This is where Ruby (especially Rails) shows off. Remember writing time + (24 * 60 * 60) to add a day? Yeah, we don't do that anymore.

Time Calculations (The Way They Should Be)

require 'active_support/core_ext/numeric/time'
require 'active_support/core_ext/time/calculations'

now = Time.now

# Add/subtract with readable syntax
now + 1.second
now + 2.minutes
now + 3.hours
now + 4.days
now + 5.weeks
now + 6.months
now + 7.years

# Subtract
now - 1.day
now - 2.weeks

# Ago (past)
1.day.ago
2.weeks.ago
3.months.ago

# From now (future)
1.day.from_now
2.weeks.from_now
3.months.from_now

# Chaining
2.days.ago + 3.hours
1.week.from_now - 2.days

# Since (duration from specific time)
time = Time.new(2024, 1, 15)
1.day.since(time)
2.weeks.since(time)

Beginning and End of Periods

require 'active_support/core_ext/time/calculations'

time = Time.new(2024, 1, 15, 19, 30, 45)

# Beginning/end of day
puts time.beginning_of_day  # 2024-01-15 00:00:00
puts time.end_of_day        # 2024-01-15 23:59:59

# Aliases
puts time.at_beginning_of_day
puts time.at_end_of_day
puts time.midnight  # alias for beginning_of_day

# Week
puts time.beginning_of_week     # 2024-01-15 00:00:00 (Monday)
puts time.end_of_week           # 2024-01-21 23:59:59 (Sunday)
puts time.beginning_of_week(:sunday)  # Start week on Sunday

# Month
puts time.beginning_of_month    # 2024-01-01 00:00:00
puts time.end_of_month          # 2024-01-31 23:59:59

# Quarter
puts time.beginning_of_quarter  # 2024-01-01 00:00:00
puts time.end_of_quarter        # 2024-03-31 23:59:59

# Year
puts time.beginning_of_year     # 2024-01-01 00:00:00
puts time.end_of_year           # 2024-12-31 23:59:59

# Hour/minute
puts time.beginning_of_hour     # 2024-01-15 19:00:00
puts time.end_of_hour           # 2024-01-15 19:59:59
puts time.beginning_of_minute   # 2024-01-15 19:30:00
puts time.end_of_minute         # 2024-01-15 19:30:59

Advance and Change

require 'active_support/core_ext/time/calculations'

time = Time.new(2024, 1, 15, 19, 0, 0)

# Advance by multiple units
future = time.advance(
  years: 1,
  months: 2,
  weeks: 3,
  days: 4,
  hours: 5,
  minutes: 6,
  seconds: 7
)

# Change specific components
modified = time.change(
  year: 2025,
  month: 6,
  day: 20,
  hour: 12,
  min: 30
)

# Partial changes
next_year = time.change(year: 2025)
noon = time.change(hour: 12, min: 0, sec: 0)

# Next/previous occurrences
time.next_week              # Next Monday
time.next_week(:friday)     # Next Friday
time.next_month
time.next_quarter
time.next_year

time.prev_week
time.prev_month
time.prev_quarter
time.prev_year

# Last week/month/year
time.last_week
time.last_month
time.last_year

Comparison and Predicates

require 'active_support/core_ext/time/calculations'

time = Time.new(2024, 1, 15)

# Predicates
time.past?      # Is this time in the past?
time.future?    # Is this time in the future?
time.today?     # Is this time today?
time.yesterday? # Is this time yesterday?
time.tomorrow?  # Is this time tomorrow?

# Day of week
time.monday?
time.tuesday?
time.wednesday?
time.thursday?
time.friday?
time.saturday?
time.sunday?
time.on_weekday?
time.on_weekend?

# Compare
time1 = 1.day.ago
time2 = Time.now
time1 < time2  # true

# Between
start = 1.week.ago
finish = 1.week.from_now
now = Time.now
now.between?(start, finish)  # true

Date Class

Working with Dates

require 'date'

# Current date
today = Date.today
puts today  # 2024-01-15

# Create specific date
date = Date.new(2024, 1, 15)

# Parse from string
parsed = Date.parse('2024-01-15')
iso_date = Date.iso8601('2024-01-15')

# Format
puts date.strftime('%Y-%m-%d')        # 2024-01-15
puts date.strftime('%B %d, %Y')       # January 15, 2024
puts date.strftime('%A, %B %d, %Y')   # Monday, January 15, 2024

# Date arithmetic
tomorrow = date + 1
next_week = date + 7
last_week = date - 7

# Difference (returns days as Rational)
date1 = Date.new(2024, 1, 15)
date2 = Date.new(2024, 1, 20)
diff = date2 - date1
puts diff.to_i  # 5 days

# Components
puts date.year   # 2024
puts date.month  # 1
puts date.day    # 15
puts date.wday   # 1 (0=Sunday)

# Predicates
puts date.monday?
puts date.leap?  # Is this a leap year?

Date with ActiveSupport

require 'active_support/core_ext/date/calculations'

date = Date.today

# Readable arithmetic
date + 1.day
date + 1.week
date + 1.month
date + 1.year

1.day.ago.to_date
1.week.from_now.to_date

# Beginning/end
date.beginning_of_week
date.end_of_week
date.beginning_of_month
date.end_of_month
date.beginning_of_quarter
date.end_of_quarter
date.beginning_of_year
date.end_of_year

# Advance
date.advance(days: 5, months: 2)

# Next/previous
date.next_week
date.next_month
date.next_year

# Predicates
date.past?
date.future?
date.today?
date.yesterday?
date.tomorrow?

# Convert to time
date.to_time
date.to_time(:utc)
date.to_datetime

Handling DST Transitions

Ah yes, DST—the twice-yearly reminder that time is a social construct. Here's how to handle it without losing your mind.

DST-Aware Calculations

require 'active_support/all'

Time.zone = 'America/New_York'

# Spring forward: March 10, 2024, 2:00 AM → 3:00 AM
# 2:30 AM doesn't exist on this day
date = Time.zone.parse('2024-03-10 02:30:00')
puts date
# Automatically adjusted to 03:30:00 EDT

# Fall back: November 3, 2024, 2:00 AM → 1:00 AM
# 1:30 AM occurs twice
date = Time.zone.parse('2024-11-03 01:30:00')
puts date
# First occurrence (EDT)

# Check DST status
summer = Time.zone.parse('2024-07-15 12:00:00')
winter = Time.zone.parse('2024-01-15 12:00:00')

puts summer.dst?  # true
puts winter.dst?  # false

# Offset changes
puts summer.utc_offset  # -14400 (-4 hours, EDT)
puts winter.utc_offset  # -18000 (-5 hours, EST)

Recurring Events and DST

require 'active_support/all'

def schedule_recurring_event(start_time, occurrences = 5)
  Time.zone = 'America/New_York'
  current = Time.zone.parse(start_time)
  events = []

  occurrences.times do |i|
    events << {
      occurrence: i + 1,
      utc: current.utc.iso8601,
      local: current.iso8601,
      offset: current.formatted_offset,
      dst: current.dst?
    }

    # Add 1 week (handles DST automatically)
    current += 1.week
  end

  events
end

# Example spanning DST transition
events = schedule_recurring_event('2024-03-03 02:00:00', 3)

events.each do |event|
  puts "Week #{event[:occurrence]}: #{event[:local]} " \
       "(DST: #{event[:dst]}, Offset: #{event[:offset]})"
end

# Output:
# Week 1: 2024-03-03T02:00:00-05:00 (DST: false, Offset: -05:00)
# Week 2: 2024-03-10T03:00:00-04:00 (DST: true, Offset: -04:00)  ← Adjusted!
# Week 3: 2024-03-17T02:00:00-04:00 (DST: true, Offset: -04:00)

Database Integration

Rails Active Record

# Migration
class CreateEvents < ActiveRecord::Migration[7.0]
  def change
    create_table :events do |t|
      t.string :title
      t.datetime :scheduled_at  # Stored as UTC in database
      t.string :timezone

      t.timestamps  # created_at, updated_at (also UTC)
    end
  end
end

# Model
class Event < ApplicationRecord
  # Timezone-aware attribute
  def scheduled_at_in_timezone
    scheduled_at.in_time_zone(timezone || 'UTC')
  end

  # Setter that accepts timezone-aware time
  def scheduled_at_with_timezone=(time_string, tz)
    Time.use_zone(tz) do
      self.scheduled_at = Time.zone.parse(time_string)
    end
  end

  # Scopes
  scope :upcoming, -> { where('scheduled_at > ?', Time.current) }
  scope :past, -> { where('scheduled_at < ?', Time.current) }

  scope :in_range, ->(start_time, end_time) {
    where(scheduled_at: start_time..end_time)
  }

  scope :today, -> {
    where(scheduled_at: Time.current.beginning_of_day..Time.current.end_of_day)
  }
end

# Usage
event = Event.create(
  title: 'Team Meeting',
  scheduled_at: Time.zone.parse('2024-01-15 14:00:00'),
  timezone: 'America/New_York'
)

# Retrieve and convert
puts event.scheduled_at.iso8601  # UTC: 2024-01-15T19:00:00Z
puts event.scheduled_at_in_timezone  # 2024-01-15 14:00:00 -0500

# Query
upcoming = Event.upcoming
today_events = Event.today

range_start = 1.week.ago
range_end = 1.week.from_now
events_this_week = Event.in_range(range_start, range_end)

Direct Database Access

require 'pg'  # or 'mysql2'
require 'active_support/all'

# PostgreSQL connection
conn = PG.connect(dbname: 'myapp', user: 'postgres')

# Store as UTC
def save_event(conn, title, scheduled_at)
  utc_time = scheduled_at.utc.strftime('%Y-%m-%d %H:%M:%S')

  conn.exec_params(
    'INSERT INTO events (title, scheduled_at) VALUES ($1, $2)',
    [title, utc_time]
  )
end

# Retrieve and convert
def find_event(conn, id, timezone = 'UTC')
  result = conn.exec_params(
    'SELECT title, scheduled_at FROM events WHERE id = $1',
    [id]
  )

  if result.ntuples > 0
    row = result[0]
    utc_time = Time.parse(row['scheduled_at']).utc
    local_time = utc_time.in_time_zone(timezone)

    {
      title: row['title'],
      scheduled_at: local_time
    }
  end
end

# Usage
save_event(conn, 'Meeting', Time.zone.parse('2024-01-15 14:00:00'))
event = find_event(conn, 1, 'America/New_York')
puts event[:scheduled_at]

Testing Time-Dependent Code

Timecop Gem

# Gemfile
gem 'timecop', group: :test

# Test with frozen time
require 'timecop'
require 'minitest/autorun'

class SessionTest < Minitest::Test
  def test_session_expiry
    # Freeze time to specific moment
    Timecop.freeze(Time.new(2024, 1, 15, 19, 0, 0)) do
      session = Session.new(expires_in: 3600)  # 1 hour
      assert session.valid?
    end

    # Travel forward 59 minutes (still valid)
    Timecop.freeze(Time.new(2024, 1, 15, 19, 59, 0)) do
      assert session.valid?
    end

    # Travel forward 61 minutes (expired)
    Timecop.freeze(Time.new(2024, 1, 15, 20, 1, 0)) do
      refute session.valid?
    end
  end

  def test_dst_transition
    # Before DST (EST)
    Timecop.freeze(Time.new(2024, 3, 9, 12, 0, 0, '-05:00')) do
      now = Time.now
      assert_equal(-18000, now.utc_offset)  # -5 hours
      refute now.dst?
    end

    # After DST (EDT)
    Timecop.freeze(Time.new(2024, 3, 11, 12, 0, 0, '-04:00')) do
      now = Time.now
      assert_equal(-14400, now.utc_offset)  # -4 hours
      assert now.dst?
    end
  end

  def teardown
    Timecop.return  # Always restore time after test
  end
end

Rails Time Helpers

require 'active_support/testing/time_helpers'

class SessionTest < ActiveSupport::TestCase
  include ActiveSupport::Testing::TimeHelpers

  test "session expiry" do
    # Travel to specific time
    travel_to Time.new(2024, 1, 15, 19, 0, 0) do
      session = Session.new(expires_in: 3600)
      assert session.valid?
    end

    # Travel forward
    travel 1.hour do
      refute session.valid?
    end
  end

  test "advance time" do
    travel_to Time.new(2024, 1, 15, 19, 0, 0)

    assert_equal Date.new(2024, 1, 15), Date.today

    travel 1.day
    assert_equal Date.new(2024, 1, 16), Date.today

    travel_back  # Return to original time
  end
end

Best Practices

1. Always Store in UTC

# ✅ CORRECT: Store as UTC
class EventService
  def create_event(title, datetime_string, timezone)
    scheduled_at = Time.zone.parse(datetime_string)
                       .in_time_zone(timezone)
                       .utc

    Event.create(
      title: title,
      scheduled_at: scheduled_at,
      timezone: timezone
    )
  end

  def display_event(event_id, user_timezone)
    event = Event.find(event_id)
    local_time = event.scheduled_at.in_time_zone(user_timezone)

    {
      title: event.title,
      scheduled_at: local_time.strftime('%Y-%m-%d %H:%M:%S %Z'),
      relative: time_ago_in_words(local_time)
    }
  end
end

2. Use ActiveSupport Extensions

# ❌ BAD: Manual calculations
time = Time.now
tomorrow = time + (24 * 60 * 60)  # seconds

# ✅ GOOD: Readable syntax
require 'active_support/core_ext/numeric/time'
tomorrow = Time.now + 1.day

# ✅ BETTER: ActiveSupport methods
tomorrow = 1.day.from_now
yesterday = 1.day.ago

3. Set Default Timezone

# config/application.rb (Rails)
config.time_zone = 'UTC'
config.active_record.default_timezone = :utc

# Non-Rails apps
require 'active_support/all'
Time.zone = 'UTC'

4. Validate Time Inputs

class TimeValidator
  def self.parse(input, timezone = 'UTC')
    return input if input.is_a?(Time)

    Time.use_zone(timezone) do
      case input
      when Numeric
        # Unix timestamp
        raise ArgumentError, 'Negative timestamp' if input < 0

        # Check if milliseconds
        input = input / 1000.0 if input > 10_000_000_000

        Time.zone.at(input)

      when String
        Time.zone.parse(input)

      when Date, DateTime
        input.to_time.in_time_zone(timezone)

      else
        raise ArgumentError, "Invalid time input: #{input.class}"
      end
    end
  rescue ArgumentError => e
    raise ArgumentError, "Failed to parse time: #{e.message}"
  end
end

# Usage
time = TimeValidator.parse('2024-01-15 19:00:00', 'America/New_York')
time = TimeValidator.parse(1705341600)
time = TimeValidator.parse(Date.today)

Common Pitfalls

1. Using Time.now Instead of Time.current

# ❌ BAD: Ignores configured timezone
Time.now  # Uses system timezone

# ✅ GOOD: Respects Time.zone
Time.current  # Uses configured timezone
Time.zone.now  # Explicit

# Rails helpers
Date.current  # Respects timezone
Date.today    # Ignores timezone (uses system)

2. Forgetting Timezone Context

# ❌ BAD: Ambiguous
time = Time.parse('2024-01-15 14:00:00')  # Which timezone?

# ✅ GOOD: Explicit timezone
Time.use_zone('America/New_York') do
  time = Time.zone.parse('2024-01-15 14:00:00')
end

# ✅ BETTER: Store with timezone
time = Time.new(2024, 1, 15, 14, 0, 0, '-05:00')

3. Timezone Offset vs. Timezone Name

# ❌ BAD: Offset doesn't handle DST
time = Time.new(2024, 1, 15, 14, 0, 0, '-05:00')
# Always -05:00, even during DST!

# ✅ GOOD: Use timezone name
Time.zone = 'America/New_York'
time = Time.zone.parse('2024-01-15 14:00:00')
# Automatically handles DST transitions

Performance Tips

Avoid Unnecessary Parsing

# ❌ SLOW: Parse every iteration
1000.times do
  time = Time.parse('2024-01-15 19:00:00')
  # ...
end

# ✅ FAST: Parse once
time = Time.parse('2024-01-15 19:00:00')
1000.times do
  # Use time
end

Batch Timezone Conversions

# Set timezone context once
Time.use_zone('America/New_York') do
  timestamps.map do |ts|
    Time.zone.at(ts)
  end
end

Wrapping It Up: Ruby Time Mastery

You know what I love about Ruby's datetime handling? It just feels... right. The standard library gives you the essentials, and ActiveSupport adds all the syntactic sugar you never knew you needed but can't live without now.

Your Ruby Time Toolkit:

  • Time is your workhorse (stick with it)
  • Date when you're calendar-focused
  • DateTime when you're... actually, just use Time
  • ActiveSupport makes everything readable

The Rules That Keep You Sane:

  1. UTC for storage. Every. Single. Time.
  2. Time.current and Time.zone.now in Rails—not Time.now
  3. ActiveSupport's sugar isn't just pretty, it's bug-prevention
  4. Explicit timezones save debugging hours later
  5. Timecop for testing is non-negotiable
  6. Validate inputs. Your production logs will thank you.
  7. Timezone names > offsets (DST will prove this)

Here's the beautiful part: Ruby makes datetime handling so intuitive that once you learn these patterns, they become second nature. You'll write 3.days.from_now without thinking twice, and your code will be both correct and readable. That's the Ruby way.

Further Reading

Building Ruby applications with datetime? Contact us for consultation.