Forem: Sparsh Garg

I Built and Published My First Ruby Gem: Rails API Profiler 🚀

Sparsh Garg — Tue, 13 Jan 2026 09:29:52 +0000

I had been thinking about building a Ruby gem for a long time, but like many developers, I kept postponing it.

Eventually, I decided to stop overthinking and just ship.

That decision led to my first Ruby gem: rails_api_profiler.

❓ The Problem

While working on Rails API applications, I often wanted quick answers to simple questions:

Which API endpoints are slow?
How many database queries does a request trigger?
Is the bottleneck in application code or the database?

Full APM tools are powerful, but sometimes you just need lightweight, local insight.

🧩 What the Gem Does

rails_api_profiler is a middleware-based performance profiler for Rails APIs.

It logs, per request:

Request duration
ActiveRecord query count
Total database execution time

No controller changes. No monkey patching. Minimal setup.

📄 Example Output

[RailsApiProfiler] {
  :method=>"GET",
  :path=>"/api/v1/users",
  :status=>200,
  :duration_ms=>183.21,
  :db_queries=>7,
  :db_time_ms=>41.8
}

⚙️ How It Works (Briefly)

Under the hood, the gem uses:

Rack middleware to measure request time
ActiveSupport::Notifications to track SQL queries
Thread-local storage for request-scoped stats
A Railtie for automatic Rails integration

🧠 What I Learned

Building this gem helped me understand:

Rails middleware and instrumentation
How to structure Rails-compatible gems
Why shipping early beats waiting for perfection

🚀 Try It Out

RubyGems: https://rubygems.org/gems/rails_api_profiler
GitHub: https://github.com/sparsh9/rails-api-profiler

Feedback and contributions are welcome 🙌

MongoDB vs PostgreSQL JSONB: A Deep Dive into Performance and Use Cases

Sparsh Garg — Fri, 13 Jun 2025 07:34:54 +0000

In the age of flexible data models and evolving application needs, developers often debate: "Should I use MongoDB or PostgreSQL for JSON-like data?" While both databases support storing JSON data, their underlying design, performance characteristics, and use cases vary widely.

This post will help you understand the core differences, performance implications, and when to choose what based on your project needs.

🧬 Storage and Internal Representation

Feature	PostgreSQL (JSONB)	MongoDB (BSON)
Format	Binary JSON (compressed, indexed)	BSON (Binary JSON with additional types)
Overhead	Moderate, especially with indexing	Minimal, optimized for document storage
Write Characteristics	Slower due to WAL, ACID compliance	Fast, low write amplification

Conclusion: MongoDB is optimized for document storage, while PostgreSQL adds JSON capabilities to a relational core.

🔍 Indexing and Query Performance

Feature	PostgreSQL	MongoDB
Indexing JSON	GIN indexes on JSONB fields	Native indexing on nested fields
Querying Nested Fields	Operators like `->`, `->>`	Dot notation like `user.address.city`
Index Coverage	Partial for JSONB	Full for indexed paths

Conclusion: MongoDB excels in querying deeply nested fields, especially with proper indexes.

⏱️ Read & Write Performance

Action	PostgreSQL	MongoDB
Single Doc Read	Slower if JSONB is not indexed	Fast and efficient
Bulk Read	Good, slows with deep JSON nesting	Very good with dot-notation queries
Write Speed	Slower (ACID overhead)	Faster (schema-less design)

Conclusion: MongoDB leads in both read and write speed for JSON-heavy applications.

🧠 Schema Flexibility

Feature	PostgreSQL	MongoDB
Schema Evolution	Manual (migrations needed)	Native, schema-less
Validation	Strong schema enforcement	Optional, supports JSON schema validation

Conclusion: MongoDB is great for evolving data models; PostgreSQL is ideal for structured, validated data.

🛡️ Transactions and Integrity

Feature	PostgreSQL	MongoDB
ACID Transactions	Fully supported	Supported (since v4.0)
Data Consistency	Strong, mature	Good, but less mature in distributed setups

Conclusion: PostgreSQL is your go-to when you need guaranteed integrity across multiple rows or tables.

📈 Scaling and Distribution

Feature	PostgreSQL	MongoDB
Read Scaling	Manual (read replicas)	Built-in
Write Scaling	Limited (scale-up)	Sharding (scale-out)
Geo Distribution	Requires tooling	First-class support

Conclusion: MongoDB is better suited for distributed, horizontally scalable applications.

✅ When to Use What?

Choose MongoDB if:

Your data is semi-structured or varies often
You need high-speed reads/writes with nested documents
Your application evolves rapidly
You need to scale horizontally

Choose PostgreSQL if:

You require strong consistency and complex joins
Your data is mostly relational with some flexible fields
You need robust reporting, window functions, or transactions

Final Thoughts

While PostgreSQL has powerful JSON capabilities, it still operates within a relational model. MongoDB, on the other hand, is purpose-built for flexibility and performance with document-based data.

In the end, the best database is the one that fits your specific use case — and now you’re better equipped to make that decision.

How YouTube Might Track “Most Replayed” Parts of a Video — in Ruby on Rails

Sparsh Garg — Thu, 15 May 2025 10:16:20 +0000

Have you ever noticed the spiky graph above the YouTube timeline showing "Most Replayed" sections?

In this post, we’ll build a simplified version of that system using Ruby on Rails — to track, store, and visualize which parts of a video are being re-watched the most.

🧱 Step 1: Database Design

We'll use two tables:

videos – to store video metadata
video_interactions – to log when a user scrubs, replays, or pauses at a specific second

✅ Migration: `videos`

# db/migrate/20250515120000_create_videos.rb
class CreateVideos < ActiveRecord::Migration[7.0]
  def change
    create_table :videos do |t|
      t.string :title
      t.integer :duration_seconds
      t.references :uploaded_by, foreign_key: { to_table: :users }

      t.timestamps
    end
  end
end

✅ Migration: `video_interactions`

# db/migrate/20250515120500_create_video_interactions.rb
class CreateVideoInteractions < ActiveRecord::Migration[7.0]
  def change
    create_table :video_interactions do |t|
      t.references :video, null: false, foreign_key: true
      t.references :user, foreign_key: true
      t.string :interaction_type  # e.g. 'replay', 'scrub'
      t.integer :timestamp_in_video  # second in timeline

      t.timestamps
    end
  end
end

🧠 Step 2: Models

# app/models/video.rb
class Video < ApplicationRecord
  has_many :video_interactions, dependent: :destroy
end

# app/models/video_interaction.rb
class VideoInteraction < ApplicationRecord
  belongs_to :video
  belongs_to :user, optional: true

  enum interaction_type: { replay: 'replay', scrub: 'scrub', pause: 'pause' }

  validates :timestamp_in_video, presence: true
end

🔁 Step 3: API Endpoint to Track Interactions

Let’s make an endpoint to log interactions.

# config/routes.rb
Rails.application.routes.draw do
  resources :videos do
    resources :video_interactions, only: [:create]
  end
end

# app/controllers/video_interactions_controller.rb
class VideoInteractionsController < ApplicationController
  def create
    interaction = VideoInteraction.new(interaction_params)
    if interaction.save
      render json: { status: "ok" }, status: :created
    else
      render json: { errors: interaction.errors.full_messages }, status: :unprocessable_entity
    end
  end

  private

  def interaction_params
    params.require(:video_interaction).permit(
      :video_id,
      :user_id,
      :interaction_type,
      :timestamp_in_video
    )
  end
end

📈 Step 4: Aggregating the "Most Replayed" Data

Now let’s create a method to find which parts of the video were replayed the most.

# app/models/video.rb
def replay_heatmap
  video_interactions
    .where(interaction_type: 'replay')
    .group(:timestamp_in_video)
    .order(:timestamp_in_video)
    .count
end

def most_replayed_second
  replay_heatmap.max_by { |_, count| count }&.first
end

This gives you a hash like:

{
  5 => 3,
  6 => 3,
  7 => 14,  # 👈 most replayed second
  8 => 2
}

💻 Step 5: Visualizing on the Frontend

You can send the replay_heatmap hash to your frontend via an API, and render a chart using any JS library like:

Chart.js
ApexCharts
D3.js

GET /videos/123/replay_heatmap

{
  "5": 3,
  "6": 3,
  "7": 14,
  "8": 2
}

You can then show a hoverable graph above your video player like YouTube.

🚀 Bonus: Background Summary Table (Optional)

To speed up performance on popular videos, you can pre-aggregate data using a background job:

rails generate model VideoReplaySummary video:references timestamp_in_video:integer replay_count:integer

Use a job (e.g. with Sidekiq or ActiveJob) to refresh this hourly.

🧪 Testing It Locally

Use curl or Postman to simulate a replay:

curl -X POST http://localhost:3000/videos/1/video_interactions \
  -H "Content-Type: application/json" \
  -d '{
    "video_interaction": {
      "user_id": 1,
      "interaction_type": "replay",
      "timestamp_in_video": 142
    }
  }'

📦 Summary

Part	Description
`videos` table	Stores basic video info
`video_interactions`	Logs every replay/scrub with timestamp
Aggregation method	Groups interactions by timestamp for heatmap
Visualization	Displays the graph on video timeline

Capistrano: The Ultimate Guide to Automated Deployments for Rails Applications

Sparsh Garg — Wed, 13 Nov 2024 07:15:22 +0000

Deploying web applications manually can be a time-consuming and error-prone process. This is where Capistrano comes into play — a powerful Ruby-based tool designed to automate and simplify the deployment of web applications. In this comprehensive guide, we’ll explore what Capistrano is, how it works, its key features, and provide a step-by-step tutorial with practical examples to help you set it up for your Ruby on Rails application.

What is Capistrano?

Capistrano is an open-source tool for automating the deployment of web applications to remote servers via SSH. It streamlines repetitive tasks such as code fetching, dependency installation, database migrations, and server restarts, making the deployment process fast, reliable, and consistent.

Key Features of Capistrano:

Automated Deployment: Reduces human error by automating repetitive deployment tasks.
Multi-server Support: Easily deploys applications across multiple servers and roles (e.g., web, app, db).
Rollbacks: Allows you to quickly revert to previous releases in case of deployment failures.
Customizable Tasks: Provides flexibility to define custom tasks tailored to your application needs.
Integration with Popular Tools: Supports plugins like capistrano-rails, capistrano-rvm, and capistrano-bundler for Rails-specific tasks and Ruby version management.

Getting Started with Capistrano

Installation

First, add Capistrano and necessary plugins to your Rails project’s Gemfile:

# Gemfile
gem 'capistrano', '~> 3.17'
gem 'capistrano-rails', '~> 1.6'
gem 'capistrano-rvm', '~> 0.2.0'
gem 'capistrano-bundler', '~> 2.0'
gem 'capistrano-passenger', '~> 0.2'

Run bundle install to install the gems.

Setting Up Capistrano

To initialize Capistrano in your project, run:

bundle exec cap install

This command generates the following files:

Capfile: The main configuration file where plugins are required.
config/deploy.rb: Global configuration settings for the deployment.
config/deploy/production.rb: Environment-specific configuration (e.g., for production).

Capistrano Configuration Files Explained

1. Capfile

The Capfile is where you require necessary libraries and plugins:

require 'capistrano/setup'
require 'capistrano/deploy'
require 'capistrano/rvm'
require 'capistrano/bundler'
require 'capistrano/rails'
require 'capistrano/passenger'

install_plugin Capistrano::RVM
install_plugin Capistrano::Bundler
install_plugin Capistrano::Rails::Migrations
install_plugin Capistrano::Passenger

2. Global Configuration (`config/deploy.rb`)

The deploy.rb file defines the main configuration for your application:

set :application, "my_app"
set :repo_url, "git@github.com:username/my_app.git"
set :deploy_to, "/var/www/#{fetch(:application)}"
set :branch, "main"
set :format, :pretty
set :log_level, :info
set :keep_releases, 5

# RVM Configuration
set :rvm_type, :user
set :rvm_ruby_version, '2.7.8'

# Linked Files & Directories
set :linked_files, %w{config/database.yml .env}
set :linked_dirs, %w{log tmp/pids tmp/cache tmp/sockets public/system}

3. Environment Configuration (`config/deploy/production.rb`)

This file specifies server details and environment-specific configurations:

server '123.45.67.89', user: 'deploy', roles: %w{app web db}, primary: true

set :rails_env, 'production'
set :ssh_options, {
  keys: %w(~/.ssh/id_rsa),
  forward_agent: true,
  auth_methods: %w(publickey)
}

Deployment Workflow Explained

Capistrano follows a series of automated steps during the deployment process:

Setup: Initializes the deployment structure on the server (directories like /releases and /shared).
Fetch Code: Pulls the latest code from the Git repository.
Install Dependencies: Uses Bundler to install Ruby gems (bundle install).
Run Migrations: Executes rake db:migrate to update the database schema.
Precompile Assets: Runs rake assets:precompile for Rails applications.
Restart Server: Restarts the application server (e.g., Passenger or Puma).
Cleanup: Removes old releases to free up disk space.

To deploy your application, run:

bundle exec cap production deploy

Rolling Back a Deployment

If something goes wrong, you can quickly roll back to the previous release:

bundle exec cap production deploy:rollback

Custom Tasks in Capistrano

Capistrano allows you to define custom tasks to fit your deployment needs. Here are some useful examples:

Example 1: Clearing Sidekiq Logs

namespace :logs do
  desc "Clear Sidekiq logs"
  task :clear_sidekiq_log do
    on roles(:app) do
      execute "echo '' > #{shared_path}/log/sidekiq.log"
      puts "Sidekiq logs cleared!"
    end
  end
end

after 'deploy:finished', 'logs:clear_sidekiq_log'

Example 2: Update File Permissions

namespace :deploy do
  desc "Update permissions"
  task :update_permissions do
    on roles(:app) do
      execute "chmod -R 755 #{release_path}/"
      puts "Permissions updated for #{release_path}"
    end
  end
end

after 'deploy:finishing', 'deploy:update_permissions'

Example 3: Restarting Nginx

namespace :nginx do
  desc "Restart Nginx"
  task :restart do
    on roles(:web) do
      execute "sudo systemctl restart nginx"
      puts "Nginx restarted successfully!"
    end
  end
end

after 'deploy:finishing', 'nginx:restart'

Troubleshooting Common Issues

1. SSH Authentication Errors

Ensure your SSH key is correctly configured and added to the SSH agent:

ssh-add ~/.ssh/id_rsa

2. Permission Errors

If you encounter permission errors, adjust the permissions of the deployment directory:

sudo chown -R deploy:deploy /var/www/my_app

3. Git Repository Access Issues

Verify that your SSH key has access to the Git repository and SSH agent forwarding is enabled:

set :ssh_options, forward_agent: true

Best Practices for Using Capistrano

Use SSH Key Forwarding: This avoids storing your private SSH key on the server.
Limit Release History: Use set :keep_releases, 5 to avoid filling up the server with old releases.
Test Deployments Locally: Use --dry-run to safely test your deployment commands without making changes.

Conclusion

Capistrano is a robust and versatile tool that can handle complex deployment scenarios with ease. By leveraging its automation capabilities, you can save time, reduce human errors, and focus more on building features rather than managing deployments. With proper configuration and custom tasks, Capistrano can fit seamlessly into your DevOps workflow, making your deployments reliable and efficient.

Start using Capistrano today and take your deployment process to the next level. 🚀

Happy deploying!

Unlock Superior Security: Implementing 2FA in Ruby on Rails with a Twist!

Sparsh Garg — Sun, 21 Apr 2024 08:24:20 +0000

Introduction:

Welcome to our interactive guide on enhancing your Ruby on Rails application's security with two-factor authentication (2FA)! In this engaging tutorial, we'll show you how to add an extra layer of protection using OTPs and QR codes. But wait, there's more! We'll also optimize the code and give the models a fresh new look! Let's dive in and make your app more secure and user-friendly!

Step 1: Setting up the ROTP Gem 🛠️

Let's start by adding some magic to your Gemfile! 🧙‍♂️

gem 'rotp'

Run bundle install to install the ROTP gem and unlock the power of OTP generation in your Rails app!

Step 2: Creating the User Model 🧑‍💼

Meet your User model, the guardian of your app's security! 🛡️

class User < ApplicationRecord
  attr_accessor :otp

  before_create :create_passkey

  # Add methods for passkey creation and verification
end

Step 3: Generating QR Codes with RQRCode 🌈

Let's add some color to your authentication process with QR codes! 🌟

gem 'rqrcode'

Create a QR code generation method in your QrController to make setting up 2FA a breeze! 🚀

Step 4: Verifying OTPs on Login 🔒

Time to put your 2FA to the test during login! 🚪

Add the verify_passkey method to your ApplicationController to ensure only the rightful users gain access! 🗝️

Optimisation:

💡

Let's optimise the passkey_verification method in the User model for better performance:

def self.passkey_verification(email, otp)
  user = User.find_by(email: email)
  return false unless user

  totp = ROTP::TOTP.new(user.passkey)
  totp.verify(otp)
end

Conclusion:

🎉

Congratulations! You've successfully leveled up your app's security with 2FA in Ruby on Rails! 🚀 By following these steps and adding a touch of magic with gems like ROTP and RQRCode, you've made your app more secure and user-friendly. Keep exploring and enhancing your app's security to provide a top-notch experience for your users! 🌟

Keeping Secrets Safe: The Importance of Encrypting API Data

Sparsh Garg — Wed, 22 Nov 2023 09:41:05 +0000

In the world of apps and websites, keeping secrets safe is like hiding treasures from sneaky pirates. When you get information from an API (like a secret message from a friend), it's essential to keep it safe on your end.

Let's talk about why it's crucial to always take encrypted data from an API and decrypt it on your backend.

The Secret Code: Encryption

Imagine you have a magical way to turn your messages into secret codes before sending them to your friends. This secret code, called encryption, keeps your messages safe from prying eyes. It's like putting your message inside a treasure chest that only you and your friend can open.

Why Always Choose Encryption?

Guarding Secrets: When you get data from an API, it might contain important information—like user passwords or special messages. If this data is encrypted, it's like having a secret map that only you can read.
Protection from Pirates: Just like pirates try to steal treasures, there are bad folks on the internet trying to steal information. Encryption is your shield, protecting your data even if someone tries to sneak a peek.
Trustworthy Communication: If you're talking to your friend through a messenger bird (API), you'd want your message to be in code. This way, even if the bird stops at other places, your secret message stays safe until it reaches your friend.

Example: Super-Secret Messaging API

Let's imagine a real-life scenario. You have a messaging app, and your friend's API sends you encrypted messages. Here's a simple example:

# Getting an encrypted message from the API
require 'net/http'
require 'uri'

api_url = 'https://super-secret-messenger-api/messages'
uri = URI.parse(api_url)

# Make a request to the API
response = Net::HTTP.get_response(uri)
encrypted_message = response.body

# Decrypting the message on your backend
def decrypt(encrypted_message, your_secret_key)
  # Imagine using a special decoder here
  # Replace 'your_secret_key' with your actual secret key
  decrypted_message = magic_decoding_spell(encrypted_message, your_secret_key)
  puts "Decrypted Message: #{decrypted_message}"
end

# Replace 'your_secret_key' with the actual secret key
decrypt(encrypted_message, 'your_secret_key')

In this example, the API sends you an encrypted message, and you use a magical decoding spell (decryption) on your end to read the original message. It's like opening a treasure chest and finding your friend's secret note inside.

Conclusion: Keep Your Secrets Safe

In the grand adventure of building apps and websites, always remember the importance of keeping your secrets safe. When dealing with data from an API, make sure it's like a secret map that only you can understand. Choose encryption, use your magical decoding spells wisely, and keep the treasures of information safe from the internet pirates!

Optimising Git Usage: Essential Tips for Efficient Code Management from Local to Global

Sparsh Garg — Wed, 30 Aug 2023 13:09:57 +0000

Hello aspiring developers!

Embarking on your software development journey means embracing tools like GitHub, a powerful platform that fosters collaboration and version control. This article is designed to guide beginners in the art of using GitHub commands effectively, ensuring smoother collaboration and better code management.

1. Creating a New Branch for Development:

When starting a new feature or addressing an issue, creating a new branch helps keep your work isolated from the main codebase. Use the following commands:

# Create a new branch and switch to it
git checkout -b new-feature

# Push the new branch to the remote repository
git push origin new-feature

2. Always Pull from Origin:

Before starting any development, ensure you're working with the latest code. Pulling from the remote repository prevents conflicts down the line:

# Switch to your development branch
git checkout new-feature

# Pull the latest changes from the remote repository
git pull origin new-feature

3. Committing Only Necessary Files:

Keep your commits focused and concise by only including relevant changes. Use git status to see modified files and git add to stage them:

# Stage specific files for commit
git add file1.js file2.css

# Commit the staged changes
git commit -m "Implemented feature X and updated styling"

4. Adding a Proper Commit Message:

Writing informative commit messages helps you and your collaborators understand the purpose of each change. Follow this format:

git commit -m "Short description of your changes

More detailed explanation, if needed.
Issue #123"

5. Resolving Merge Conflicts via Terminal:

Conflicts can arise when merging branches. To resolve them:

# Fetch the latest changes from the remote repository
git fetch origin

# Switch to your development branch
git checkout new-feature

# Merge the changes from the main branch
git merge origin/main

# Resolve any conflicts in your code files

# After resolving, commit the changes
git commit -m "Resolved merge conflicts"

# Push the resolved changes to the remote repository
git push origin new-feature

Remember, practice makes perfect. Embrace these GitHub commands in your workflow to streamline collaboration and manage your codebase effectively. As you become more comfortable, you'll find yourself contributing seamlessly to projects and collaborating with confidence.

Happy coding! 🚀👩‍💻👨‍💻

Understanding Caching in Ruby on Rails: Boosting Performance and Efficiency

Sparsh Garg — Wed, 30 Aug 2023 12:03:55 +0000

Caching is a powerful technique that can significantly enhance the performance and efficiency of your Ruby on Rails applications. By storing frequently accessed data or rendered views, you can reduce database queries and server processing, resulting in faster response times for your users. In this article, we'll explore caching in Ruby on Rails and provide code snippets to illustrate how to implement caching effectively.

1. Caching Basics:

Caching involves storing copies of data in a faster storage layer (such as memory) so that future requests for the same data can be served quickly without the need for time-consuming computations or database queries.

2. Types of Caching in Rails:

Rails offers several caching mechanisms:

Page Caching: Caches entire HTML pages as static files. Ideal for pages with content that rarely changes.

Action Caching: Caches the output of controller actions. Useful when you have dynamic content that doesn't change frequently.

Fragment Caching: Caches specific parts (fragments) of a view. Great for components shared across different views.

Model Caching: Caches individual records or collections fetched from the database.

3. Implementing Fragment Caching:

Fragment caching is commonly used to cache specific parts of a view. Let's consider a scenario where we want to cache the list of recent blog posts on our homepage.

<!-- app/views/home/index.html.erb -->

<% cache 'recent_blog_posts' do %>
  <h2>Recent Blog Posts</h2>
  <ul>
    <% @recent_posts.each do |post| %>
      <li><%= link_to post.title, post_path(post) %></li>
    <% end %>
  </ul>
<% end %>

In this example, the content within the cache block will be cached. If the underlying data changes, Rails will regenerate the cache. You can also set an expiration time for the cache.

4. Using Low-Level Caching:

Rails provides low-level caching methods that allow you to manually manage cache entries. For instance, you can cache the result of a complex database query:

# app/controllers/posts_controller.rb

def index
  @posts = Rails.cache.fetch('all_posts', expires_in: 1.day) do
    Post.all
  end
end

In this code, the result of Post.all is cached with the key 'all_posts' for a day. Subsequent calls to the same key will fetch data from the cache rather than executing the query again.

5. Clearing the Cache:

To maintain data consistency, it's important to clear the cache when relevant data changes:

Rails.cache.delete('recent_blog_posts')  # Clear the cache for recent_blog_posts
Rails.cache.clear  # Clear the entire cache

Conclusion:

Caching is a fundamental technique for optimizing the performance of Ruby on Rails applications. By utilizing various caching strategies such as fragment caching and low-level caching, you can reduce database queries and improve response times. Keep in mind that while caching enhances performance, it requires careful consideration and management to ensure that cached data remains accurate and up-to-date.

Incorporating caching into your Rails applications can greatly enhance user experience and server efficiency, making it a valuable skill for every Rails developer to master.

Connecting Multiple Databases in Rails 5

Sparsh Garg — Tue, 29 Aug 2023 12:54:35 +0000

Ruby on Rails is a powerful web framework that makes building web applications a breeze. In some scenarios, you might find yourself needing to work with multiple databases within a single Rails application. This could be due to various reasons, such as managing different types of data or segregating data for performance optimisation. In this article, we'll explore how to connect and interact with multiple databases in a Rails 5 application.

Setting Up the Databases

Before we dive into the code snippets, let's set up the scenario. Imagine you have a Rails application that needs to interact with two separate databases: a primary database for user data and a secondary database for product information. Here's how you can configure your database.yml file to define the connection settings for both databases:

# config/database.yml

default: &default
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  username: your_username
  password: your_password
  host: localhost

development:
  <<: *default
  database: primary_db_development

secondary_development:
  <<: *default
  database: secondary_db_development

In the above configuration, we have defined two separate sections: development for the primary database and secondary_development for the secondary database. Make sure to replace your_username and your_password with the appropriate credentials.

Defining Database Models

Next, we need to create models for each of the databases. Let's create two models: User for the primary database and Product for the secondary database.

# app/models/user.rb

class User < ApplicationRecord
  establish_connection :development # Connect to the primary database
end

# app/models/product.rb

class Product < ApplicationRecord
  establish_connection :secondary_development # Connect to the secondary database
end

In the above code, we use the establish_connection method to specify which database connection to use for each model. This way, the User model will use the primary database connection, and the Product model will use the secondary database connection.

Performing Database Operations

Now that we have our models set up, let's see how to perform basic database operations on each database.

Primary Database Operations

# Create a new user in the primary database
user = User.create(name: 'John Doe', email: 'john@example.com')

# Retrieve users from the primary database
users = User.where(age: 25)

# Update a user's information
user.update(name: 'Jane Doe')

# Delete a user
user.destroy

Secondary Database Operations

# Create a new product in the secondary database
product = Product.create(name: 'Widget', price: 19.99)

# Retrieve products from the secondary database
products = Product.where(category: 'Electronics')

# Update a product's information
product.update(price: 24.99)

# Delete a product
product.destroy

Running Migrations

When you're working with multiple databases, you need to run migrations separately for each database. To achieve this, you can specify the database connection when running migrations:

rails db:migrate          # Run migrations for the primary database
rails db:migrate RAILS_ENV=development_secondary # Run migrations for the secondary database

Conclusion

In this article, we've explored how to connect and interact with multiple databases within a single Rails 5 application. By configuring the database.yml file, defining separate models for each database, and using the establish_connection method, you can seamlessly work with different databases in your application. Whether you're dealing with diverse data types or optimizing performance, Rails provides the flexibility you need to manage multiple databases effectively.

Using Database Level Associations v/s Active Record Associations in Ruby On Rails

Sparsh Garg — Tue, 07 Feb 2023 07:07:08 +0000

What are database level associations?

Database level associations refers to relationships between tables in a database that are established through foreign keys. These relationships are defined and managed directly in the database schema.
For example - Suppose you have two tables in your database, 'users' and 'posts', where each user can have multiple posts. So to establish a one-to-many relationship between these two tables, you can create a foreign key constraint in the 'posts' table that references the 'id' column in the 'users' table.

What are active record associations?

Associations in rails allow you to specify relationships between your models and their related data in database. They are defined using ActiveRecord and are used to simplify the process of working with related data.
For example - Suppose you have two models in you application, 'User' and 'Post', where each user can have multiple posts. To define their relationship you would add the following code to your 'User' model:

class User < ApplicationRecord
  has_many :posts
end

and the following code to your 'Post' model:

class Post < ApplicationRecord
  belongs_to :user
end

Using database level associations

Using database level associations has it's own advantage which make a huge difference

Performance: It can be faster than using ActiveRecord associations, especially in complex, multi-layer associations.

Fine-grained control: It allow you to have fine-grained control over your database interactions, giving you the ability to optimise your database queries and interactions to meet the specific requirements of your application.

Simplicity: By avoiding the overhead of the ActiveRecord association abstractions, database-level associations can make your code simpler and easier to understand.

Increased flexibility: With database-level associations, you are not limited to the abstractions provided by the framework and can implement custom relationships between your tables if needed.

Scalability: In large, high-performance applications, database-level associations can be more scalable than using ActiveRecord associations, especially in terms of memory usage and query performance.

Apart from these benefits there are some drawbacks also, such as

Complexity- Increased complexity by directly using database level associations.

Schema Changes - The need to change relationships directly in the database schema.

Maintenance - It can make your code less maintainable because they are not as abstracted as ActiveRecord associations. You would have to write more raw SQL code, which can be error-prone.

Portability: If you use database-level associations, it might be harder to switch to a different ORM (Object-Relational Mapping) framework or database in the future. ActiveRecord associations, on the other hand, provide a higher level of abstraction and are more portable.

Ultimately, the choice between database-level associations and ActiveRecord associations will depend on the specific requirements of your application, such as performance, scalability, and maintainability.

Pagination without using any gems in Ruby On Rails

Sparsh Garg — Sat, 28 Jan 2023 07:28:07 +0000

What is pagination?

Pagination refers to the process of dividing a list of items into multiple pages that can be navigated through using buttons or links. This is commonly used for displaying large sets of data, such as search results or articles, in a more manageable format.

Why to use pagination?

Pagination is used to improve the user experience and performance of a website by dividing large sets of data into smaller, more manageable chunks.

User experience: Large lists of data can be overwhelming for users and make it difficult to find the information they are looking for. Pagination allows users to easily navigate through the data and find the specific information they need. It also allows users to quickly scan through the data to find relevant information.

Performance: Loading large amounts of data at once can slow down a website, especially for users with slow internet connections. Pagination allows for smaller amounts of data to be loaded at a time, improving the overall performance of the website. Additionally, it helps to reduce the load on the server, which can also improve performance.

Accessibility: Pagination also helps with accessibility, because it allows users to easily access the specific data they need and it enables them to skip irrelevant data.

Search Engine Optimization: Search engines can also benefit from pagination because it allows them to crawl and index the content on a website more efficiently.

In summary, Pagination improves the user experience, performance, accessibility, and search engine optimization of a website.

Pagination in Ruby On Rails

In Ruby on Rails, pagination can be implemented using the "will_paginate" gem or the "kaminari" gem. Both of these gems provide a simple and easy way to add pagination to a Rails application.

The "will_paginate" gem adds a paginate method to the ActiveRecord::Relation class, which can be used to paginate any database query. For example, to paginate a list of users, you would write

User.paginate(:page => params[:page], :per_page => 10)

The "kaminari" gem provides similar functionality, with a page method that can be used to paginate any database query. For example, to paginate a list of users, you would write

User.page(params[:page]).per(10)

Once you have paginated your data, both gems provide helper methods for generating the HTML for the pagination links. In the views, you can use the will_paginate or kaminari_paginate helper method to generate the HTML for the pagination links.

Both gems are well-documented and easy to use, and you can choose the one that better fits your needs or preferences.

Additionally, Rails has built-in pagination feature in rails 6, which is called "built-in pagination" using the pagy gem.

But recently I have used one more method of pagination i.e using SQL.

def show_method
     total_page = (ModelName.all.count.to_f / 5).ceil
     current_page = (params[:page] || 1).to_i
     per_page = 5
     records_fetch_point = (current_page - 1) * per_page
     model = ModelName.order(id: :desc).limit(per_page).offset(records_fetch_point)
     page = {
       page_number: current_page,
       per_page: per_page,
       total_page: total_page
     }
     if model.empty?
       render json: {error: 'No data found'}, status: :not_found
     else
       render json: {data: model, message: "Data", meta: page}, status: :ok
     end
   end

I have used this method because :-

I wanted to try some custom method for pagination.
Sometimes gems like pagy, kaminari, will_paginate does not work due to version or configuration issues.

Using Rails Model or SQL query in Ruby On Rails

Sparsh Garg — Wed, 17 Aug 2022 06:53:00 +0000

Although there can be multiple ways you can get data from your database, but here are two ways you can get data.

Using Rails Model -> In this method of data fetching we use rails model, which we create using rails g model model_name.

So the code is as follows:

def index
    @data = ModelName.all
    render_success_response @data
  end

In above piece of code

index -> name of the method

@data -> name of variable to store the data

.all -> rails method to get all the data from the respective table associated with the model

render_success_response -> default rails method to render a success response

Now there can be multiple methods we can use. Check out devhints for references.

Using SQL Query -> In this method of data fetching we use direct SQL queries.

So the code is as follows:

def index
    sql = "select * from table_name"
    @data = ActiveRecord::Base.connection.execute(sql)
    render_success_response @data
  end

In above piece of code

ActiveRecord::Base.connection.execute() -> it is used to run sql queries in ruby on rails.

Conclusion
You can use both rails model or sql query in you code according to your use case.

References
Dev Hints

Forem: Sparsh Garg

I Built and Published My First Ruby Gem: Rails API Profiler 🚀

❓ The Problem

🧩 What the Gem Does

📄 Example Output

⚙️ How It Works (Briefly)

🧠 What I Learned

🚀 Try It Out

MongoDB vs PostgreSQL JSONB: A Deep Dive into Performance and Use Cases

🧬 Storage and Internal Representation

🔍 Indexing and Query Performance

⏱️ Read & Write Performance

🧠 Schema Flexibility

🛡️ Transactions and Integrity

📈 Scaling and Distribution

✅ When to Use What?

Choose MongoDB if:

Choose PostgreSQL if:

Final Thoughts

How YouTube Might Track “Most Replayed” Parts of a Video — in Ruby on Rails

🧱 Step 1: Database Design

✅ Migration: videos

✅ Migration: video_interactions

🧠 Step 2: Models

🔁 Step 3: API Endpoint to Track Interactions

📈 Step 4: Aggregating the "Most Replayed" Data

💻 Step 5: Visualizing on the Frontend

🚀 Bonus: Background Summary Table (Optional)

🧪 Testing It Locally

📦 Summary

Capistrano: The Ultimate Guide to Automated Deployments for Rails Applications

What is Capistrano?

Key Features of Capistrano:

Getting Started with Capistrano

Installation

Setting Up Capistrano

Capistrano Configuration Files Explained

1. Capfile

2. Global Configuration (config/deploy.rb)

3. Environment Configuration (config/deploy/production.rb)

Deployment Workflow Explained

Rolling Back a Deployment

Custom Tasks in Capistrano

Example 1: Clearing Sidekiq Logs

Example 2: Update File Permissions

Example 3: Restarting Nginx

Troubleshooting Common Issues

1. SSH Authentication Errors

2. Permission Errors

3. Git Repository Access Issues

Best Practices for Using Capistrano

Conclusion

Unlock Superior Security: Implementing 2FA in Ruby on Rails with a Twist!

Introduction:

Optimisation:

Conclusion:

Keeping Secrets Safe: The Importance of Encrypting API Data

The Secret Code: Encryption

Why Always Choose Encryption?

Example: Super-Secret Messaging API

Conclusion: Keep Your Secrets Safe

Optimising Git Usage: Essential Tips for Efficient Code Management from Local to Global

Understanding Caching in Ruby on Rails: Boosting Performance and Efficiency

1. Caching Basics:

2. Types of Caching in Rails:

3. Implementing Fragment Caching:

4. Using Low-Level Caching:

5. Clearing the Cache:

Conclusion:

Connecting Multiple Databases in Rails 5

Setting Up the Databases

Defining Database Models

Performing Database Operations

Primary Database Operations

Secondary Database Operations

Running Migrations

Conclusion

Using Database Level Associations v/s Active Record Associations in Ruby On Rails

What are database level associations?

What are active record associations?

✅ Migration: `videos`

✅ Migration: `video_interactions`

2. Global Configuration (`config/deploy.rb`)

3. Environment Configuration (`config/deploy/production.rb`)