Generate UUID in Ruby

Ruby provides built-in UUID generation through the SecureRandom module. The simplest way to generate a UUID version 4 is:

require 'securerandom'

# Generate UUID version 4 - random
uuid = SecureRandom.uuid
puts "Generated UUID: #{uuid}"

# Alternative method
uuid_alt = SecureRandom.random_bytes(16).unpack('H*')[0].gsub(/(.{8})(.{4})(.{4})(.{4})(.{12})/, '\1-\2-\3-\4-\5')
puts "Alternative UUID: #{uuid_alt}"

For generating specific UUID versions, you can use the uuid gem which offers comprehensive UUID support:

require 'uuidtools'

# Generate UUID version 1 - time based
uuid1 = UUIDTools::UUID.timestamp_create
puts "UUID v1: #{uuid1}"

# Generate UUID version 3 - deterministic and hashed with MD5
namespace = UUIDTools::UUID_URL_NAMESPACE
uuid3 = UUIDTools::UUID.md5_create(namespace, 'https://example.com')
puts "UUID v3: #{uuid3}"

# Generate UUID version 4 - random
uuid4 = UUIDTools::UUID.random_create
puts "UUID v4: #{uuid4}"

# Generate UUID version 5 - deterministic and hashed with SHA-1
uuid5 = UUIDTools::UUID.sha1_create(namespace, 'https://example.com')
puts "UUID v5: #{uuid5}"

# Note: v6 and v7 may require additional gems or custom implementation

Installation & Setup

Using Bundler (Gemfile):

# Gemfile
gem 'uuidtools'

# Then run:
# bundle install

Using gem command:

gem install uuidtools

Rails Integration

ActiveRecord Models:

# In your migration
class CreateUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :users, id: :uuid do |t|
      t.string :name, null: false
      t.string :email, null: false
      t.timestamps
    end
  end
end

# In your model
class User < ApplicationRecord
  before_create :set_uuid

  private

  def set_uuid
    self.id = SecureRandom.uuid if id.blank?
  end
end

Rails Configuration for UUID Primary Keys:

# config/application.rb
config.generators do |g|
  g.orm :active_record, primary_key_type: :uuid
end

# config/initializers/generators.rb
Rails.application.config.generators do |g|
  g.orm :active_record, primary_key_type: :uuid
end

Controller Usage:

class UsersController < ApplicationController
  before_action :set_request_id

  def create
    @user = User.new(user_params)
    @user.id = SecureRandom.uuid
    
    if @user.save
      render json: @user, status: :created
    else
      render json: @user.errors, status: :unprocessable_entity
    end
  end

  private

  def set_request_id
    request.headers['X-Request-ID'] = SecureRandom.uuid
  end

  def user_params
    params.require(:user).permit(:name, :email)
  end
end

Advanced Ruby UUID Usage

Custom UUID Generator Class:

require 'securerandom'
require 'uuidtools'

class UUIDGenerator
  NAMESPACE_URL = UUIDTools::UUID_URL_NAMESPACE
  NAMESPACE_DNS = UUIDTools::UUID_DNS_NAMESPACE

  class << self
    def v1
      UUIDTools::UUID.timestamp_create.to_s
    end

    def v3(name, namespace = NAMESPACE_URL)
      UUIDTools::UUID.md5_create(namespace, name).to_s
    end

    def v4
      SecureRandom.uuid
    end

    def v5(name, namespace = NAMESPACE_URL)
      UUIDTools::UUID.sha1_create(namespace, name).to_s
    end

    def validate(uuid_string)
      UUIDTools::UUID.parse(uuid_string)
      true
    rescue ArgumentError
      false
    end

    def parse(uuid_string)
      UUIDTools::UUID.parse(uuid_string)
    rescue ArgumentError => e
      raise "Invalid UUID format: #{e.message}"
    end
  end
end

# Usage
puts "UUID v1: #{UUIDGenerator.v1}"
puts "UUID v3: #{UUIDGenerator.v3('example.com')}"
puts "UUID v4: #{UUIDGenerator.v4}"
puts "UUID v5: #{UUIDGenerator.v5('example.com')}"

# Validation
uuid = UUIDGenerator.v4
puts "Valid UUID: #{UUIDGenerator.validate(uuid)}"

Sinatra Integration:

require 'sinatra'
require 'securerandom'
require 'json'

# Middleware to add request ID
use Rack::CommonLogger

before do
  @request_id = SecureRandom.uuid
  response.headers['X-Request-ID'] = @request_id
end

get '/api/uuid' do
  content_type :json
  {
    uuid: SecureRandom.uuid,
    request_id: @request_id,
    timestamp: Time.now.iso8601
  }.to_json
end

post '/api/users' do
  content_type :json
  user_data = JSON.parse(request.body.read)
  
  user = {
    id: SecureRandom.uuid,
    name: user_data['name'],
    email: user_data['email'],
    created_at: Time.now.iso8601
  }
  
  status 201
  user.to_json
end

Background Jobs with Sidekiq:

require 'sidekiq'
require 'securerandom'

class ProcessUserJob
  include Sidekiq::Worker
  
  def perform(user_id)
    job_id = SecureRandom.uuid
    logger.info "Processing user #{user_id} with job ID #{job_id}"
    
    # Process user logic here
    
    logger.info "Completed job #{job_id}"
  end
end

# Usage
ProcessUserJob.perform_async(SecureRandom.uuid)

Testing with RSpec

UUID Testing Helpers:

# spec/support/uuid_helpers.rb
module UUIDHelpers
  def valid_uuid?(uuid)
    uuid.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
  end

  def generate_uuid
    SecureRandom.uuid
  end
end

RSpec.configure do |config|
  config.include UUIDHelpers
end

# spec/models/user_spec.rb
RSpec.describe User, type: :model do
  describe 'UUID generation' do
    it 'generates a valid UUID on creation' do
      user = User.create(name: 'Test User', email: '[email protected]')
      expect(valid_uuid?(user.id)).to be true
    end

    it 'has a unique ID for each user' do
      user1 = User.create(name: 'User 1', email: '[email protected]')
      user2 = User.create(name: 'User 2', email: '[email protected]')
      
      expect(user1.id).not_to eq(user2.id)
    end
  end
end

UUID Version Comparison

Choose the right version for your Ruby application:

• Version 1 - Time-based, includes MAC address
• Version 3 - MD5 namespace-based, deterministic
• Version 4 - Random, most popular choice (built-in Ruby support)
• Version 5 - SHA-1 namespace-based, more secure than v3
• Version 6 - Time-ordered, better than v1 for databases
• Version 7 - Modern time-based with improved sorting

For Ruby applications:

• Rails models: Use Version 4 for ActiveRecord primary keys
• Background jobs: Consider Version 7 for job queuing and tracking
• API development: Use Version 5 for deterministic resource IDs

How do I generate UUID in other languages?

Web development:

• JavaScript - crypto.randomUUID() & uuid library
• TypeScript - Type-safe frontend development
• Python - Built-in uuid module
• PHP - Built-in functions & ramsey/uuid

Backend systems:

• Java - Enterprise applications
• Go - google/uuid package
• Rust - uuid crate

← Back to Online UUID Generator