DEV Community: Ahmad Raza

Google Login in Rails 7 with devise

Ahmad Raza — Tue, 20 Jun 2023 06:06:37 +0000

Google login can provide a convenient and seamless authentication option for your users. In this comprehensive guide, we'll walk you through the steps to integrate Google login into your Rails 7 app, allowing users to authenticate using their Google accounts.

I'm assuming that you already have installed and implemented devise gem in your rails app. If not check this article.

Let's get started!

Step 1: Add Required Gems

In your Rails app's Gemfile, make sure you have the following gems:



gem 'omniauth-google-oauth2'
gem "omniauth-rails_csrf_protection"

Then, run the following command to install the gems:



bundle install

Step 2: Configure Devise Model

Add the following code in your devise model (i'll be using User):



# models/user.rb
:omniauthable, omniauth_providers: [:google_oauth2]

Now we need to add two fields uid and provider in our devise model (in my case User).

uid (User ID): It stores a unique identifier associated with the user's account from the OAuth provider (in this case, Google). Each user has a distinct uid assigned by the provider, which allows your application to uniquely identify them.
provider: It indicates the name of the OAuth provider being used for authentication (e.g., "google_oauth2"). This field helps differentiate between different authentication methods and allows your application to handle multiple authentication providers if needed.

Generate the migration:



rails g migration AddFieldsToUser

Add the below code in your migration:



def change
  change_table :users, bulk: true do |t|
    t.string :provider
    t.string :uid
  end
end

Run rails db:migrate to add these fields to your table.

Now, add the below code in your devise model. Mine in user.rb:



def self.from_google(u)
    create_with(uid: u[:uid], provider: 'google',
                password: Devise.friendly_token[0, 20]).find_or_create_by!(email: u[:email])
end

Step 3: Configure Controller

Create a users/omniauth_callbacks_controller.rb file inside the controllers directory and paste the below code:



# app/controllers/users/omniauth_callbacks_controller.rb
class Users::OmniauthCallbacksController < Devise::OmniauthCallbacksController
   def google_oauth2
     user = User.from_google(from_google_params)

     if user.present?
       sign_out_all_scopes
       flash[:notice] = t 'devise.omniauth_callbacks.success', kind: 'Google'
       sign_in_and_redirect user, event: :authentication
     else
       flash[:alert] = t 'devise.omniauth_callbacks.failure', kind: 'Google', reason: "#{auth.info.email} is not authorized."
       redirect_to new_user_session_path
     end
    end

    def from_google_params
      @from_google_params ||= {
        uid: auth.uid,
        email: auth.info.email
      }
    end

    def auth
      @auth ||= request.env['omniauth.auth']
    end
end

Step 4: Add Routes

Open config/routes.rb and the routes:



# config/routes.rb
devise_for :user,
      controllers: {
         omniauth_callbacks: 'users/omniauth_callbacks'
      }

Step 5: Set Up a Google API Console Project

Visit the Google API Console and create a new project as below:

You can give any name to your project. I named it Google Login.

After entering the name click Create.

And then go into your google login project. There will be a dropdown in the navbar (i've showed it in the first picture), you can use it to change your project.

Go to OAuth consent screen
Choose user type External
Click Create
Fill all the fields
Scroll down and click Save and continue.

Next follow the below steps:

Select Application Type Web application
Enter any name
Go to your console/terminal and type the command rails routes | grep /callback. Copy the URL...
Go to your browser and click on Add URI button
Paste the copied url in URL field such as http://localhost:3000/user/auth/google_oauth2/callback
Click Create

Once you have created the project, a popup will display your client ID and client secret. Make sure to save this information for future use.

Now that you have obtained your client ID and client secret, let's proceed with the configuration of Google login in your Rails app.

Step 6: Implement Google Login

Open up config/initializers/devise.rb file and paste the below code:



# config/initializers/devise.rb

config.omniauth :google_oauth2, 'GOOGLE_OAUTH_CLIENT_ID', 'GOOGLE_OAUTH_CLIENT_SECRET'

My file looks like this:



# config/initializers/devise.rb

# ==> OmniAuth
# Add a new OmniAuth provider. Check the wiki for more information on setting
# up on your models and hooks.
# config.omniauth :github, 'APP_ID', 'APP_SECRET', scope: 'user,public_repo'
config.omniauth :google_oauth2, 'GOOGLE_OAUTH_CLIENT_ID', 'GOOGLE_OAUTH_CLIENT_SECRET'

Now just add the login button in any of your views.



<%= button_to 'Login with Google', user_google_oauth2_omniauth_authorize_path, method: :post, :data => {turbo: "false"} %>

Congratulations! 🎉 You have successfully added Google login to your Rails 7 app.

You can check the gem's repo here.

Thanks for reading! 🙂

The Impact of AI in Modern Business

Ahmad Raza — Wed, 14 Jun 2023 13:19:04 +0000

Artificial Intelligence (AI) has revolutionised the business landscape, transforming the way organizations operate and make decisions. With its ability to analyze vast amounts of data, learn from patterns, and make predictions, AI has become a game-changer for businesses across industries. In this article, we will explore the significant impact of AI on modern businesses and the opportunities it presents.

1. Enhanced Efficiency and Productivity

AI-powered automation has streamlined various business processes, enabling organizations to achieve higher levels of efficiency and productivity. Tasks that were once time-consuming and labor-intensive can now be automated, allowing employees to focus on more strategic and creative endeavors. From customer service chatbots to automated data analysis, AI has expedited workflows and reduced operational costs.

2. Improved Customer Experience

AI has transformed the way businesses interact with their customers, delivering personalized and seamless experiences. Chatbots and virtual assistants powered by AI can handle customer inquiries and provide instant support, enhancing customer satisfaction and engagement. AI algorithms can also analyze customer data to offer personalized recommendations, improving cross-selling and upselling opportunities.

3. Advanced Data Analysis

The abundance of data in today's business environment can be overwhelming, but AI algorithms excel at analyzing and extracting valuable insights from large datasets. By leveraging AI-powered analytics tools, businesses can uncover hidden patterns, trends, and correlations in their data. This enables informed decision-making, predictive modeling, and the ability to anticipate market trends, giving organizations a competitive edge.

4. Enhanced Cybersecurity

As businesses increasingly rely on digital systems and data, cybersecurity has become a critical concern. AI plays a pivotal role in detecting and preventing cyber threats in real-time. AI algorithms can analyze network traffic, identify anomalies, and flag potential security breaches. Additionally, AI can learn from past incidents and adapt its defense mechanisms, staying one step ahead of cybercriminals.

5. Automation of Repetitive Tasks

AI enables the automation of repetitive and mundane tasks that do not require human intervention. This frees up valuable time for employees to focus on more strategic, creative, and value-added activities. From data entry and invoice processing to inventory management, AI-driven automation can significantly reduce errors and improve overall operational efficiency.

In conclusion, the impact of artificial intelligence on modern business is profound. From enhanced efficiency and productivity to improved customer experiences and advanced data analysis, AI is reshaping the way organizations operate and compete in the digital age. Embracing AI technologies and leveraging their potential can unlock new possibilities, drive growth, and ensure long-term success in an increasingly competitive business landscape.

Remember, the key to successfully harnessing AI lies in striking the right balance between automation and human expertise. By embracing AI as a tool for empowerment and innovation, businesses can unlock its full potential and thrive in the digital era.

Note: This article provides an overview of the impact of AI in modern business and is not an exhaustive analysis of the topic.

Authentication using Devise in Rails 7

Ahmad Raza — Tue, 06 Jun 2023 03:58:32 +0000

Introduction

In this article, we will explore how to implement authentication in a Rails 7 application using the popular devise gem. Authentication is a crucial aspect of web development, allowing users to securely access and interact with your application. By following this step-by-step guide, you will learn how to set up devise, configure authentication routes, create user models, and enhance your application with authentication features.

Prerequisites

Before we dive into the implementation, make sure you have the following set up on your development environment:

Ruby (version >= 2.7.0)
Rails (version >= 7.0.0)
Bundler gem

Let's get started!

Step 1: Creating a New Rails Application

First, let's create a new Rails application. Open your terminal and execute the following command:

rails new authentication-app

# If you want to use a CSS Framework
# rails new authentication-app -c [tailwind|bootstrap|bulma|postcss|sass]

cd authentication-app

Step 2: Adding Devise to the Gemfile

Next, let's add the Devise gem to our application's Gemfile. Open the Gemfile using a text editor and add the following line:

gem 'devise'

Save the file and run the following command in your terminal to install the gem:

bundle install

Step 3: Setting up Devise

To set up Devise in our application, we need to run a few generator commands. Execute the following command in your terminal:

rails generate devise:install

Upon running this command, you will see some instructions in your terminal. I have listed them here, so that you don't have to worry about them 🙂 Just follow the below steps:

1: Add the below code in config/environments/development.rb:

config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }

2: Devise recommends to have a root url in the application. To do this, we need to generate a controller and a view:

rails g controller home index

This will generate controller with the name home and a view index.html.erb.

Now, add the below route in your config/routes file:

root 'home#index'

3: Add the below code above <%= yield %> tag in your app/views/layouts/application.html.erb:

<p class="notice"><%= notice %></p>
<p class="alert"><%= alert %></p>

This will display the flash notifications.

4: To generate views for authentication(login, signup etc.) pages, run the following command:

rails g devise:views

Step 4: Creating a User Model

Let's create a User model using Devise. Run the following command:

rails generate devise User

This will generate a User model with Devise's authentication features.

After generating the model, run migrations:

rails db:migrate

Step 5: Adding Authentication Links to Views

Now, let's add authentication links to our views. Open your application's layout file (app/views/layouts/application.html.erb) and paste the following code:

<% if user_signed_in? %>
  <%= button_to "Sign Out", destroy_user_session_path, method: :destroy %>
<% else %>
  <%= link_to 'Sign In', new_user_session_path %>
  <%= link_to 'Sign Up', new_user_registration_path %>
<% end %>

This code will display "Sign Out" if the user is signed in, and "Sign In" and "Sign Up" if the user is not signed in.

Last Step: Testing Authentication

At this point, we have set up authentication in our Rails application using Devise. You can now start your Rails server (rails server) and navigate to the appropriate routes to test the authentication functionality.

Conclusion

Congratulations! You have successfully implemented authentication in your Rails 7 application using the Devise gem. With Devise, you can easily handle user registration, sign-in, and sign-out processes. This step-by-step guide should have provided you with a solid foundation to build upon and customize authentication features according to your application's needs.

Remember to explore Devise's documentation for further customisation options and advanced features.

Happy coding! ✨

Must-Have CSS Tools for Effortless Styling 🚀

Ahmad Raza — Sun, 28 May 2023 10:25:29 +0000

CSS plays a crucial role in web development, allowing us to style and design beautiful websites. While writing CSS from scratch is essential, leveraging CSS generators can significantly enhance your productivity and efficiency. In this article, we'll explore a collection of handy CSS generators that can streamline your styling workflow and save you time.

1. CSS Gradient Generators

Creating eye-catching gradients can be a time-consuming task. CSS gradient generators simplify this process by providing an intuitive interface to generate CSS code for stunning gradients. Some popular CSS gradient generators include:

2. CSS Box Shadow Generators

Adding shadows to elements can elevate the visual appeal of your design. CSS box shadow generators enable you to create box shadows with various settings and get the corresponding CSS code instantly. Check out these handy CSS box shadow generators:

3. CSS Animation Generators

CSS animations can bring life and interactivity to your web designs. However, creating complex animations manually can be challenging. CSS animation generators simplify the process by providing a visual interface to create and customize animations. Explore these CSS animation generators:

4. CSS Grid Generators

CSS Grid is a powerful layout system that allows for flexible and responsive grid-based designs. However, setting up grid layouts manually can be time-consuming. CSS grid generators offer an easy way to generate CSS code for grid layouts, making your life easier. Here are some notable CSS grid generators:

Other Generators

Using these CSS generators can significantly speed up your styling workflow and help you create visually appealing designs. Experiment with them, explore their features, and integrate them into your development process to unleash their full potential. Happy generating!

5 Tips to Optimize Your Ruby on Rails App's Performance

Ahmad Raza — Mon, 01 May 2023 06:25:10 +0000

Performance is a critical factor for any application, and Ruby on Rails is no exception. Slow performance can cause user frustration and even lead to decreased revenue. Fortunately, there are several ways to optimize the performance of your Ruby on Rails application.

1. Use Caching

Caching is a simple and effective way to improve the performance of your application. It stores frequently accessed data in memory, so it can be quickly retrieved when needed. In Ruby on Rails, you can use the built-in caching mechanisms such as Fragment Caching, Action Caching and Page Caching. Fragment Caching allows you to cache only specific parts of a page, while Action Caching caches the entire action response and Page Caching caches the entire HTML page.

2. Optimize Database Queries

Database queries are often the biggest bottleneck in a Ruby on Rails application. You can optimize your queries in several ways, including:

Use includes method to eager-load associated objects
Use select to retrieve only the necessary columns
Use joins to join tables and avoid N+1 queries
Use pluck to retrieve only specific fields of a table

3. Use Background Jobs

Background jobs allow long-running tasks to be performed asynchronously, freeing up server resources and improving performance. You can use tools like Sidekiq or Resque to handle background jobs in your Ruby on Rails application.

However, I'd recommend using Sidekiq.

4. Use a Content Delivery Network (CDN)

A Content Delivery Network (CDN) can improve the performance of your application by caching and delivering content from servers located closer to the user. This reduces latency and improves the user experience. There are several CDN providers available, such as Cloudflare, Akamai, and Amazon CloudFront.

5. Optimize Asset Management

Assets such as images, CSS, and JavaScript files can significantly impact the performance of your application. You can optimize asset management by compressing and minifying files, using a Content Delivery Network (CDN) to serve static assets, and using a tool like Asset Pipeline to compile and bundle your assets.

Conclusion

Optimizing the performance of a Ruby on Rails application requires a combination of techniques and tools. Caching, optimizing database queries, using background jobs, using a Content Delivery Network, and optimizing asset management can all help improve the performance of your application. By implementing these techniques, you can provide a faster and smoother experience for your users, leading to increased engagement and revenue.

Is CDN Right for Your Rails App? and good for large scale applications?

Ahmad Raza — Tue, 25 Apr 2023 06:15:29 +0000

As websites have become more complex and content-heavy, page load time has become a critical factor in user experience. One solution to speed up page load times is to use a Content Delivery Network (CDN). In this blog post, we'll discuss what a CDN is, why it's important, and whether you should use one in your Rails application.

What is a CDN?

A CDN is a network of servers distributed around the world that store cached versions of your website's static assets, such as images, JavaScript, and CSS files. When a user requests a webpage from your application, the CDN will serve the assets from the server that is closest to the user, reducing the time it takes for the content to be delivered.

Why use a CDN?

There are several benefits to using a CDN:

Faster Page Load Times

By serving content from a server that is closer to the user, CDNs can dramatically reduce the time it takes for your website to load. This is especially important for users who are located far away from your application's server.

Reduced Server Load

When you use a CDN, your application's server doesn't have to serve static assets, which can help reduce server load and improve overall performance.

Increased Availability

CDNs are designed to handle high volumes of traffic, so they can help ensure that your website remains available during periods of high demand.

Improved Security

Many CDNs offer additional security features, such as DDoS protection and SSL certificates, that can help protect your website from attacks.

Should You Use a CDN in Rails?

Whether you should use a CDN in your Rails 7 application depends on a few factors:

Size of Your Application
If your application is relatively small and doesn't have a lot of static assets, a CDN might not provide much benefit.

Geographical Distribution of Your Users
If your application has users located all over the world, a CDN can help ensure that your website loads quickly for everyone.

Cost
CDNs can be expensive, especially for smaller applications. Be sure to weigh the cost of a CDN against the potential benefits before making a decision.

Security
If security is a concern, a CDN can offer additional protection for your website.

How to Use a CDN in Rails

If you decide to use a CDN in your Rails 7 application, you can do so by configuring your web server to serve your static assets from the CDN's server. You'll need to provide the CDN with the URL for your assets, and the CDN will handle the rest.

Configuring the Asset Host

In your config/application.rb file, you can set the config.asset_host variable to the URL for your CDN. For example:

config.asset_host = 'https://cdn.example.com'

This will cause all of your asset tags to use the CDN's URL.

Configuring Rails to Serve Assets

If you're using the default Rails asset pipeline, you'll need to modify your web server's configuration to serve your assets from the CDN's server. If you're using a web server like Nginx or Apache, you can configure it to serve assets from the CDN by adding the following configuration:

location ~ ^/assets/ {
  expires 1y;
  add_header Cache-Control public;

  # Set the CDN as the asset host
  proxy_set_header Host cdn.example.com;

  # Serve assets from the CDN
  proxy_pass https://cdn.example.com;
}

Conclusion

In conclusion, using a CDN in Rails 7 can be a great way to improve the performance of your web application. However, it's important to consider the potential downsides (such as additional complexity and cost) before making a decision.

How to use Sidekiq in Rails 7: Background Jobs

Ahmad Raza — Sat, 22 Apr 2023 10:52:02 +0000

In this blog, we'll explore how to use background jobs with Sidekiq in Rails 7 to handle long-running tasks, including:

What are background jobs and why use them
Setting up Sidekiq in your Rails 7 application
Creating and running background jobs using Sidekiq
Debugging and monitoring background jobs with Sidekiq

What are Background Jobs and Why Use Them?

In Rails, background jobs are used to process long-running tasks asynchronously, such as sending emails, generating reports, or processing large datasets. Rather than blocking the main thread of the application and potentially slowing down the user experience, background jobs allow you to run tasks in the background, freeing up the main thread to handle other requests.

There are several advantages to using background jobs:

Improved user experience: By moving long-running tasks to the background, your users won't be blocked from using your application while the tasks are being processed.
Scalability: Running tasks in the background allows your application to scale more effectively. Since background jobs are typically run on a separate thread, your application can process multiple requests at once.
Increased reliability: Background jobs can be retried automatically in case of failure, ensuring that tasks are completed successfully.

Setting up Sidekiq in Your Rails 7 Application

Sidekiq is a popular background job processing framework for Rails. It uses Redis to manage and process jobs, providing a simple and efficient way to manage background jobs. To use Sidekiq in your Rails 7 application, follow these steps:

Add the sidekiq gem to your Gemfile:

gem 'sidekiq'

Run bundle install to install the gem.
Update your config/application.rb file to include the Sidekiq middleware:

config.active_job.queue_adapter = :sidekiq

Creating and Running Background Jobs using Sidekiq

To create and run background jobs using Sidekiq in Rails 7, follow these steps:

Create a new job using the rails generate job command:

rails generate job MyJob

This will create a new job file in the app/jobs directory.

Edit the job file to define the work to be done:

class MyJob < ApplicationJob
  queue_as :default

  def perform(*args)
    # Add your long-running task here
  end
end

Enqueue the job in your application code:

MyJob.perform_later(args)

This will enqueue the job to the default queue.

Start Sidekiq to process the job:

bundle exec sidekiq

Debugging and Monitoring Background Jobs with Sidekiq

While background jobs can make your application more efficient and responsive, they can also introduce new challenges for debugging and monitoring. Fortunately, Sidekiq provides a simple web interface for monitoring and debugging your background jobs.

To access the Sidekiq web interface, add below code in your routes:

require 'sidekiq/web'
mount Sidekiq::Web => '/sidekiq'

Now, start the Sidekiq server by running bundle exec sidekiq in your Rails application's directory. Then, navigate to http://localhost:3000/sidekiq in your web browser to view the Sidekiq dashboard.

The dashboard displays information about the Sidekiq server, including the number of currently running and enqueued jobs. You can also view information about individual jobs, such as their status and any errors that occurred.

In addition to the web interface, Sidekiq provides several other tools for monitoring and debugging your background jobs. For example, you can configure Sidekiq to send email notifications when jobs fail, or use the Sidekiq API to retrieve information about your jobs programmatically.

Conclusion

Mastering Eager Loading and Beyond! Rails 7

Ahmad Raza — Sat, 11 Mar 2023 20:26:04 +0000

If you're building a web application using Ruby on Rails, you might find that your queries are becoming slow as the size of your database grows. One way to improve performance is to use eager loading, which allows you to load associated records upfront instead of making separate queries for each record.

Eager Loading
Lazy Loading
Preloading
Include vs Joins

Eager Loading

Eager loading is a technique that allows you to load associated records in a single query instead of querying the database multiple times. This can significantly improve the performance of your application by reducing the number of database calls.

For example, let's say you have a User model that has_many posts. If you were to retrieve all the users and their associated posts, you could use eager loading like this:

@users = User.includes(:posts)

This will retrieve all the users and their associated posts in a single query, rather than making a separate query for each user's posts.

Other Types of Loading

In addition to eager loading, Rails also provides other types of loading that you can use to optimize your queries:

Lazy Loading

Lazy loading is the opposite of eager loading. Instead of loading associated records upfront, lazy loading loads them when they are needed. This can be useful when you have a large number of associations and don't want to load them all at once.

@user = User.find(1)
@posts = @user.posts # Posts are loaded when called

Preloading

Preloading is similar to eager loading, but instead of joining the associated records in a single query, it makes a separate query for each association. This can be useful when you need to modify the association's query, or when the associated records are not needed in every query.

@users = User.preload(:posts)

Include vs Joins

Both includes and joins can be used for eager loading, but they behave differently, .includes will load the associated records using separate queries, while joins will join the associated records into a single query.

# Includes
@users = User.includes(:posts)

# Joins
@users = User.joins(:posts)

Use includes when you don't need the associated records in every query, and joins when you do.

Conclusion

Optimizing database queries is an important part of building high-performance web applications. Eager loading, lazy loading, preloading, and other types of loading can help you achieve this goal. By understanding these techniques and when to use them, you can improve the performance of your Ruby on Rails application.

What is indexing in DB?

Ahmad Raza — Wed, 01 Mar 2023 17:19:55 +0000

What is Index?

Indexes are database structures that improve the performance of search queries. They work like a phone book index, where you can quickly look up a person's phone number without having to go through every entry in the book.

In a similar way, a database index helps to speed up the search for data by creating a sorted reference to the values stored in one or more columns of a table. This makes it faster for the database to retrieve data, which can be especially important for large tables or complex queries.

So, Whenever a query is executed, the database engine searches the index for the keyword and retrieves the corresponding rows from the table. This process is much faster than scanning the entire table to find the matching rows.

Drawbacks of Indexes

Indexes can significantly improve query performance, but they also have some drawbacks. Creating and maintaining indexes takes time and resources, and they can consume a significant amount of storage space. Additionally, indexes can actually slow down write operations because they need to be updated every time a row is inserted, updated, or deleted.

When to use indexes?

Here are some examples when you might want to use an index:

Primary keys: When you create a table, you can specify one or more columns as the primary key. This creates a unique index on those columns, which is used to enforce the primary key constraint and ensure that each row has a unique identifier.
Foreign keys: When you create a foreign key constraint, the database engine automatically creates an index on the foreign key column(s) in the referencing table. This speeds up queries that join the referencing and referenced tables.
Frequently searched columns: If you have a table with a large number of rows and one or more columns that are frequently searched, you can create an index on those columns to speed up those queries.
Order by and group by clauses: If your queries frequently include an order by or group by clause, you can create an index on the column(s) being sorted or grouped.
Where clauses: If your queries frequently include a where clause that filters the results based on a specific value or range of values, you can create an index on the column(s) being filtered.

It's important to note that not all columns need an index. In fact, too many indexes can actually slow down performance because the database engine has to spend more time maintaining them. It's best to create indexes selectively based on the needs of your queries.

Caching in Ruby on Rails 7

Ahmad Raza — Sat, 25 Feb 2023 10:39:06 +0000

Caching is an essential technique used to improve the performance of web applications. It helps reduce the time taken to load and serve data by storing frequently accessed data in a fast and easily accessible storage medium, like memory and disk.

In Ruby on Rails, caching is easier than ever to implement and can have a significant impact on the performance of your web application.

In this article, we will explore caching in Ruby on Rails 7 and why it's important.

Why is Caching Important?

Caching is important because it allows you to avoid performing expensive operations repeatedly.

For example, if you have a page that displays a list of the top 10 most popular products on your website, you may need to query your database to retrieve this data. Without caching, this query would be executed every time the page is loaded, which could slow down page load times and put unnecessary strain on your server.

Types of Caching in Ruby on Rails

1. Page Caching

Page caching is the simplest form of caching in Rails. It involves caching an entire page as an HTML file, which is served to subsequent users who request the same page.

It allows the request for a generated page, to be fulfilled by the web server (i.e. Apache or NGINX) without having to go through the entire Rails stack.

This is ideal for pages that are mostly static and do not change frequently.

A subsequent user is a user who visits a website after the initial user has already visited it.

2. Action Caching

Page Caching cannot be used for actions that have before filters. For example, pages that require authentication.

This is where Action Caching comes in.

Action caching is similar to page caching, but instead of caching the entire page, only the action (i.e., the controller method) is cached. It works like Page Caching except the incoming web request hits the Rails stack, so that before filters can be run on it before the cache is served.

3. Fragment Caching

Fragment caching involves caching a small part of a page, such as a sidebar or a comment section. This is useful for pages that have some dynamic content but also contain mostly static content.

For example, if you wanted to cache each product on a page, you could use this code:

<% @products.each do |product| %>
  <% cache product do %>
    <%= render product %>
  <% end %>
<% end %>

When your application receives its first request to this page, Rails will write a new cache entry with a unique key. A key looks something like this:

views/products/index:bea67108094918eeba42cd4a6e786901/products/1

4. Low-Level Caching

Low-level caching is a more advanced form of caching that allows you to cache any data that can be represented as an object. This can include data from your database or external APIs.

Low-level caching is basically dealing with key-value-based caching structures. This is a very commonly used caching type in which the key can be read or written as below:

Rails.cache.write('some-cache-key', 123)
Rails.cache.read('some-cache-key') # => 123
Rails.cache.read('anonymous-cache-key') # => nil

Conclusion

Caching is a powerful technique that can significantly improve the performance of your Ruby on Rails application. By understanding the different types of caching available and how to implement them, you can create a faster and more responsive user experience for your users.

Slack Notifications in Rails 7

Ahmad Raza — Mon, 13 Feb 2023 10:52:04 +0000

Wondering how to send a slack notification with your Rails App? You have come to the right place!

With the ability to send notifications to Slack, your Rails App can become even more dynamic and effective.

There are many common use cases for Slack notifications, including:

Keeping track of new user sign-ups
Monitoring system errors and exception notifications
Reporting real-time progress of background jobs
Notifying stakeholders of key events, such as a successful deployment
Sharing updates and changes in your project
Keeping the team informed of important deadlines or tasks

And many more.....

Setup the Slack App

Firstly you need to create a Slack app from https://api.slack.com/apps. Click on the Create New App button to create a new App:

Select From Scratch option in the modal/popup.
Type a name for your app such as: “My First App”, and select your workspace.
Activate Incoming Webhooks for your slack app. By clicking the following option, you'll see a page where you can activate it:

Click "Add New Webhook to Workspace" button at the end of the page. And select a channel where messages will be posted.
Copy the webhook url:

Setup Integration in Ruby on Rails

To send slack notifications, we are going to use a gem called slack-notifier.

So just add it in your Gemfile:

gem 'slack-notifier', '~> 2.4' # Change it with the latest version

And run:

bundle install

Now run rails c in your terminal and type:

notifier = Slack::Notifier.new "WEBHOOK_URL",
           channel: "#random",
           username: "notifier"

notifier.ping "Hello random"
# => will ping the "#random" channel

To get more information about the gem, you can visit this url.

So go ahead and give it a try! And if you get stuck, don't hesitate to reach out.

Docker for Beginners

Ahmad Raza — Sun, 12 Feb 2023 18:17:18 +0000

Introduction

Hey there! Are you curious about Docker, but have no idea what it is or how it works? No worries, you're not alone! Many people feel overwhelmed by the idea of learning a new technology, especially when it comes to DevOps.

But trust me, Docker is actually a pretty simple concept.

What is Docker?

Docker is a game-changer in the world of software development. It makes it easy for developers to create, deploy, and run applications in containers, without worrying about the underlying infrastructure. In this article, we will take a beginner-friendly approach to understanding and using Docker.

A container is a lightweight, standalone, and executable software package that includes everything needed to run an application, including the code, runtime, libraries, and system tools. Think of containers like a shipping container for your code.

Just like how a shipping container protects your belongings from the elements, a software container protects your code from the complexities of the underlying infrastructure.

Why use Docker?

Docker has become a popular tool in the world of software development because it provides several benefits, including:

Portability: Docker containers can run on any operating system and any infrastructure, making it easy to move your application from development to production.
Isolation: Each container runs in its own isolated environment, which helps prevent conflicts between different applications and reduces the risk of security vulnerabilities.
Reproducibility: Docker containers ensure that your application will always run the same way, no matter where it is deployed.

How to Use Docker

So, how do you actually use Docker? Well, it starts with creating a Dockerfile. A Dockerfile is like a recipe that tells Docker how to build your application. Once you have your Dockerfile, you can use the docker build command to create an image of your application.

Then, you can use the docker run command to start a container from that image. You can even use the docker compose command to manage multiple containers at once.

And that's basically it! Of course, there are a lot more details to learn about Docker, but these are the basics.

Getting Started with Docker

Now that you have a basic understanding of what Docker is and why it's useful, let's dive into how you can start using it.

First you need to install Docker on your computer. You can download Docker for free from the official website.

Open a terminal or command prompt and run the following command to see if Docker is installed and working properly:

docker run hello-world

You should see a message similar to the following:

Hello from Docker!
This message shows that your installation appears to be working correctly.

Conclusion

So there you have it! Docker is a simple and powerful platform that makes it easier to manage your applications. Whether you're a beginner or an experienced developer, learning Docker is definitely worth your time.

So go ahead and give it a try! And if you get stuck, don't hesitate to reach out to the Docker community for help. They're a friendly and helpful bunch!

Get Started with Docker Today! 🚀

DEV Community: Ahmad Raza

Google Login in Rails 7 with devise

Step 1: Add Required Gems

Step 2: Configure Devise Model

Step 3: Configure Controller

Step 4: Add Routes

Step 5: Set Up a Google API Console Project

Step 6: Implement Google Login

The Impact of AI in Modern Business

1. Enhanced Efficiency and Productivity

2. Improved Customer Experience

3. Advanced Data Analysis

4. Enhanced Cybersecurity

5. Automation of Repetitive Tasks

Authentication using Devise in Rails 7

Introduction

Prerequisites

Step 1: Creating a New Rails Application

Step 2: Adding Devise to the Gemfile

Step 3: Setting up Devise

Step 4: Creating a User Model

Step 5: Adding Authentication Links to Views

Last Step: Testing Authentication

Conclusion

Must-Have CSS Tools for Effortless Styling 🚀

1. CSS Gradient Generators

2. CSS Box Shadow Generators

3. CSS Animation Generators

4. CSS Grid Generators

Other Generators

5 Tips to Optimize Your Ruby on Rails App's Performance

1. Use Caching

2. Optimize Database Queries

3. Use Background Jobs

4. Use a Content Delivery Network (CDN)

5. Optimize Asset Management

Is CDN Right for Your Rails App? and good for large scale applications?

What is a CDN?

Why use a CDN?

Faster Page Load Times

Reduced Server Load

Increased Availability

Improved Security

Should You Use a CDN in Rails?

How to Use a CDN in Rails

Configuring the Asset Host

Configuring Rails to Serve Assets

Conclusion

How to use Sidekiq in Rails 7: Background Jobs

What are Background Jobs and Why Use Them?

Setting up Sidekiq in Your Rails 7 Application

Creating and Running Background Jobs using Sidekiq

Debugging and Monitoring Background Jobs with Sidekiq

Conclusion

Mastering Eager Loading and Beyond! Rails 7

Table of contents

Eager Loading

Lazy Loading

Preloading

Include vs Joins

Conclusion

What is indexing in DB?

What is Index?

Drawbacks of Indexes

When to use indexes?

Caching in Ruby on Rails 7

Why is Caching Important?

Types of Caching in Ruby on Rails

Conclusion

Slack Notifications in Rails 7

Setup the Slack App

Setup Integration in Ruby on Rails

Docker for Beginners

Introduction

What is Docker?

Why use Docker?

How to Use Docker

Getting Started with Docker

Conclusion