DEV Community: Shah Zaib

Handling Errors and Job Lifecycles in Rails 7.1: Master ActiveJob with `retry_on`, `discard_on`, and `after_discard`

Shah Zaib — Tue, 05 Nov 2024 00:44:12 +0000

Ruby on Rails 7.1 introduces some pivotal features to ActiveJob, streamlining error handling and job lifecycle management. In this post, I’ll walk you through how to effectively use after_discard, discard_on, and retry_on with examples to make your background job handling more robust.

1. `after_discard` Hook: Custom Actions for Discarded Jobs

Rails 7.1 introduces the after_discard callback, which lets you run custom logic when a job is discarded. It’s handy for logging errors, notifying administrators, or cleaning up resources.

Example:

class MyJob < ApplicationJob
  discard_on CustomError

  after_discard do |job|
    Rails.logger.info "Job #{job.job_id} was discarded."
    # You can add custom actions here, like sending notifications
  end

  def perform
    # Your job logic that might raise a CustomError
  end
end

In this example, if CustomError occurs, the job gets discarded. The after_discard hook then logs the event and can trigger any additional custom behavior you need.

2. `discard_on`: Efficient Handling of Irrecoverable Errors

Use discard_on to specify exceptions that should result in discarding the job instead of retrying. This is crucial for errors you know cannot be fixed by retrying, like invalid data or a permanently missing record.

Example:

class ExampleJob < ApplicationJob
  discard_on ActiveRecord::RecordNotFound

  def perform(record_id)
    record = MyModel.find(record_id) # Raises an error if the record isn’t found
    # Perform your job logic on the record
  end
end

When ActiveRecord::RecordNotFound is raised in this job, it is gracefully discarded without consuming additional resources or retries.

3. `retry_on`: Automatic Retries for Recoverable Errors

For errors that are likely temporary, retry_on provides a way to automatically retry jobs with configurable delays and limits. This is perfect for handling issues like network timeouts or transient service failures.

Example:

class RetryJob < ApplicationJob
  retry_on Net::OpenTimeout, wait: 5.seconds, attempts: 3

  def perform
    # Job logic that might encounter a temporary network issue
  end
end

Here, if a Net::OpenTimeout error occurs, the job will retry up to three times with a 5-second pause between attempts, giving the external service a chance to recover.

Need a Rails Expert?

If you love what Rails can do and need a skilled full-stack developer to help you build robust, high-performance web applications, I'm available for new opportunities!

About Me: Shah Zaib

I’m a Full-Stack Developer and Technologist with 10+ years of experience delivering exceptional web projects. My expertise includes Ruby on Rails, Hotwire, and AI-powered solutions. From real-time app experiences to seamless AI integration, I’m passionate about transforming concepts into impactful software.

🌐 Connect with me on LinkedIn

Let’s discuss how I can help you innovate and elevate your next project!

🚨 New Rails Versions Released: Addressing ReDoS Vulnerabilities 🚨

Shah Zaib — Wed, 16 Oct 2024 00:24:59 +0000

The Rails community has recently released Rails versions 6.1.7.9, 7.0.8.5, 7.1.4.1, and 7.2.1.1, addressing critical ReDoS (Regular Expression Denial of Service) vulnerabilities. If you are using Ruby 3.1 or earlier versions, it's crucial to upgrade to mitigate these security risks.

🚨 Key Issues Resolved:

CVE-2024-47887 - Possible ReDoS vulnerability in HTTP Token authentication within Action Controller.
CVE-2024-41128 - Possible ReDoS vulnerability in query parameter filtering in Action Dispatch.
CVE-2024-47888 - Possible ReDoS vulnerability in plain_text_for_blockquote_node within Action Text.
CVE-2024-47889 - Possible ReDoS vulnerability in block_format within Action Mailer.

💡 Why Should You Upgrade?

Ruby 3.1 is approaching end of life for security support, which means these vulnerabilities specifically affect applications running on Ruby versions below 3.2. By upgrading your Rails version, you're not only patching critical vulnerabilities but also ensuring your application remains secure and optimized for performance.

Rails 8.0.0.beta1 and newer releases are unaffected by these issues since they require Ruby 3.2+.
Many developers still use older Rails versions that may be vulnerable—upgrading to the latest releases ensures you have vital security coverage.

📈 What Does This Mean for Your Application?

Risk for Older Ruby Versions: If you're still on Ruby 3.1, it's time to upgrade to Ruby 3.2 or higher. Ruby 3.2 provides stronger protections against ReDoS attacks and improves overall security.
Extended Maintenance for Rails 6.1: The Rails team has extended support for Rails 6.1 by releasing 6.1.7.9, despite earlier plans to end maintenance. This extension gives teams running older versions time to transition smoothly.

Rails 6.1.7.9 and newer versions provide critical patches and help you secure your application from ReDoS vulnerabilities. Don't delay upgrading!

🚀 What Should You Do Next?

If your application is running on Ruby 3.1 or an earlier Rails version, now is the time to upgrade to the latest Rails releases to protect your application from these vulnerabilities. Ensuring that your application is updated guarantees better security and performance in the long term.

Need assistance with your upgrade process? I'm here to help! Let's work together to get your applications running on the latest Rails versions, keeping them safe and high-performing.

Unlocking the Power of Ruby on Rails 8: What Developers Need to Know

Shah Zaib — Tue, 08 Oct 2024 10:08:12 +0000

Ruby on Rails has always been a game-changer in web development. With Rails 8 on the horizon, it's set to push the boundaries even further. Whether you're a seasoned developer or just starting out, Rails 8 offers improvements that will streamline your work and make your apps more efficient. Let’s dive into the standout features that will redefine how you build web applications. 🚀

1. Turbo 2.0 for Seamless Interactivity ⚡

Turbo 2.0 elevates the Turbo framework, making it easier to build dynamic, interactive applications without writing extensive JavaScript. Form submissions now update HTML without reloading the page—no custom AJAX scripts required.

Why It Matters: Cleaner codebase, enhanced user experience, and faster development.

2. Effortless Deployments with Kamal 2 and Thruster

Deploying apps is smoother than ever with Kamal 2. Whether you're using cloud VMs or in-house servers, Kamal 2 simplifies deployment, while Thruster adds asset caching and HTTP/2 support, ensuring zero-downtime deployments.

Why It Matters: No need for external services like Nginx or PaaS, reducing costs and boosting efficiency.

3. Solid Cache, Solid Queue, and Solid Cable: Redis Alternatives

Rails 8 introduces Solid Cache, Solid Queue, and Solid Cable—tools that replace dependencies like Redis or Memcached. Built on SQLite, they simplify caching, job queues, and WebSocket functionality.

Why It Matters: Reduced third-party dependencies and simplified infrastructure management.

4. SQLite Ready for Production

SQLite is no longer just for development or small projects. Rails 8 optimizes SQLite for production, allowing companies like 37signals to successfully deploy it in real-world applications.

Why It Matters: No need for complex databases like PostgreSQL or MySQL for smaller projects. SQLite can handle serious production loads now.

5. Propshaft: The New Asset Pipeline

Say goodbye to Sprockets! Propshaft is now the default asset pipeline, designed for modern web development. It integrates seamlessly with tools like Esbuild and Vite.

Why It Matters: Faster, more efficient asset management with support for modern development tools.

6. Built-In Authentication System

Rails 8 introduces a fully integrated authentication system. By running rails g authentication, you get a session-based authentication system with password reset functionality.

Why It Matters: No need to integrate third-party authentication solutions, saving time and reducing complexity.

7. New Script Folder and Generator

Rails 8 introduces a new script folder to organize one-off scripts like data migrations or cleanups, making it easier to maintain your codebase.

Why It Matters: Improved organization, leading to cleaner, more maintainable projects.

8. Active Record Enhancements

Rails 8 brings major improvements to Active Record, including support for PostgreSQL table inheritance, reversible schema operations, and faster data seeding with bulk insert fixtures.

Why It Matters: Faster, more reliable database operations for large-scale applications.

9. Simplified Job Handling with Solid Queue

Solid Queue replaces the need for Redis or Sidekiq, using SQLite or PostgreSQL/MySQL for background job handling. This built-in feature makes job processing more efficient and less reliant on external services.

Why It Matters: Simplifies background job processing, reducing infrastructure complexity and cost.

10. PostgreSQL and MySQL Improvements

Rails 8 also brings enhancements for PostgreSQL and MySQL, including better support for float types in PostgreSQL and datetime precision in MySQL.

Why It Matters: Working with complex databases just got a lot easier.

Wrapping Up

Rails 8 isn’t just an upgrade; it’s a revolution. From Kamal 2 for deployments to Solid Cache for streamlined infrastructure, Rails 8 is packed with features that make web development easier, faster, and more scalable. Now is the time to explore everything this new version has to offer!

RubyOnRails #Rails8 #WebDevelopment #Turbo2 #SQLite #SolidCache #Propshaft #Deployment #ActiveRecord #BuiltInAuth #FullStackDevelopment

Effortless Rails 7+ Deployment with Kamal Gem on DigitalOcean

Shah Zaib — Tue, 30 Jul 2024 17:55:18 +0000

Deploying a Rails application can often be daunting, especially when aiming for a production-ready setup. This guide will walk you through deploying a Rails 7.1+ application using the Kamal gem on Digital Ocean. By the end of this post, you'll have your app live and running with minimal hassle.

Prerequisites

Basic knowledge of Ruby on Rails
A Rails 7.1+ application
A Digital Ocean account
Docker installed on your local machine

Step 1: Install Kamal Gem

First, let's install the Kamal gem. Add the gem to your Gemfile and run the bundle command:

bundle add kamal && bundle install

Step 2: Initialize Kamal Configuration

Initialize Kamal configuration by running the following command:

kamal init

This command will generate two crucial files: .env and config/deploy.yml.

Step 3: Configure .env File

Add the following environment variables to your .env file:

RAILS_MASTER_KEY=XXXXXXXXXX
KAMAL_REGISTRY_PASSWORD=XXXXXXXXX

RAILS_MASTER_KEY: Your Rails master key.
KAMAL_REGISTRY_PASSWORD: Your Docker Registry password. To find it, go to hub.docker.com, log in, and create a new token under Account Settings > Security > New Access Token.

Step 4: Update deploy.yml

Purchase a VPS from Digital Ocean and add its IP to the relevant field in deploy.yml. Update the configuration according to your project credentials.

Example `config/deploy.yml`

# Name of your application. Used to uniquely configure containers.
service: myapp

# Docker image
image: username/myapp

# Main server configuration
servers:
  web:
    hosts:
      - 192.168.0.1
    labels:
      traefik.http.routers.messi-web.rule: Host(`intellecta.app`)
      traefik.http.routers.messi-web.tls: true
      traefik.http.routers.messi-web.entrypoints: websecure
      traefik.http.routers.messi-web.tls.certresolver: letsencrypt

  job:
    hosts:
      - 192.168.0.1
    cmd: bundle exec sidekiq -q high_priority -q default -q mailers

Step 5: Registry Configuration

Configure your Docker registry credentials in deploy.yml:

# Credentials for your image host.
registry:
  # Specify the registry server if you're not using Docker Hub
  # server: registry.digitalocean.com / ghcr.io / ...
  username: shahzaib
  password:
    - KAMAL_REGISTRY_PASSWORD

Step 6: Set Environment Variables

Define your environment variables in deploy.yml:

env:
  clear:
    HOSTNAME: 192.168.0.1
    DB_HOST: 192.168.0.1
    RAILS_SERVE_STATIC_FILES: true
    RAILS_LOG_TO_STDOUT: true
  secret:
    - KAMAL_REGISTRY_PASSWORD
    - RAILS_MASTER_KEY
    - POSTGRES_PASSWORD
    - REDIS_URL

Step 7: Configure Accessories

Set up your accessory services like PostgreSQL and Redis:

accessories:
  db:
    image: postgres:16
    host: 192.168.0.1
    env:
      clear:
        POSTGRES_DB: "myapp_production"
      secret:
        - POSTGRES_PASSWORD
    directories:
      - data:/var/lib/postgresql/data
  redis:
    image: redis:7.0
    host: 192.168.0.1
    directories:
      - data:/data

Rails Database Configuration

Update your Rails database configuration in config/database.yml:

production:
  <<: *default
  username: myapp
  password: <%= ENV["POSTGRES_PASSWORD"] %>
  database: myapp_production
  host: <%= ENV["DB_HOST"] %>

Step 8: Configure Traefik

Traefik handles TLS termination, HTTPS redirect, and zero downtime deployments. Add the following configuration to deploy.yml:

traefik:
  options:
    publish:
      - "443:443"
    volume:
      - "/letsencrypt/acme.json:/letsencrypt/acme.json"
  args:
    entryPoints.web.address: ":80"
    entryPoints.websecure.address: ":443"
    entryPoints.web.http.redirections.entryPoint.to: websecure
    entryPoints.web.http.redirections.entryPoint.scheme: https
    entryPoints.web.http.redirections.entrypoint.permanent: true
    certificatesResolvers.letsencrypt.acme.email: "support@intellecta.app"
    certificatesResolvers.letsencrypt.acme.storage: "/letsencrypt/acme.json"
    certificatesResolvers.letsencrypt.acme.httpchallenge: true
    certificatesResolvers.letsencrypt.acme.httpchallenge.entrypoint: web

Step 9: Deployment Commands

Run the following commands to set up and deploy your app:

kamal setup
kamal env push

After 210 seconds, your app will be live. To deploy changes, use:

kamal deploy

Step 10: Troubleshooting Logs

If there are issues, check the logs:

kamal traefik logs
kamal app logs

For live logs:

kamal app logs -f

Step 11: Access Rails Console

Access the Rails console using:

kamal app exec -i "bin/rails c"

Step 12: Access Bash on Server

Access bash on the server using:

kamal server exec --interactive "/bin/bash"

Final `config/deploy.yml`

Here's the overall final look of your config/deploy.yml:

# Name of your application. Used to uniquely configure containers.
service: myapp

# Name of the container image.
image: username/myapp

# Deploy to these servers.
servers:
  web:
    hosts:
      - 192.168.0.1
    labels:
      traefik.http.routers.messi-web.rule: Host(`intellecta.app`)
      traefik.http.routers.messi-web.tls: true
      traefik.http.routers.messi-web.entrypoints: websecure
      traefik.http.routers.messi-web.tls.certresolver: letsencrypt

  job:
    hosts:
      - 192.168.0.1
    cmd: bundle exec sidekiq -q high_priority -q default -q mailers

# Credentials for your image host.
registry:
  # Specify the registry server, if you're not using Docker Hub
  # server: registry.digitalocean.com / ghcr.io / ...
  username: shahzaib
  password:
    - KAMAL_REGISTRY_PASSWORD

# Inject ENV variables into containers (secrets come from .env).
# Remember to run `kamal env push` after making changes!
env:
  clear:
    HOSTNAME: 192.168.0.1
    DB_HOST: 192.168.0.1
    RAILS_SERVE_STATIC_FILES: true
    RAILS_LOG_TO_STDOUT: true
  secret:
    - KAMAL_REGISTRY_PASSWORD
    - RAILS_MASTER_KEY
    - POSTGRES_PASSWORD
    - REDIS_URL

# Use accessory services (secrets come from .env).
accessories:
  db:
    image: postgres:16
    host: 192.168.0.1
    env:
      clear:
        POSTGRES_DB: "myapp_production"
      secret:
        - POSTGRES_PASSWORD
    directories:
      - data:/var/lib/postgresql/data
  redis:
    image: redis:7.0
    host: 192.168.0.1
    directories:
      - data:/data

traefik:
  options:
    publish:
      - "443:443"
    volume:
      - "/letsencrypt/acme.json:/letsencrypt/acme.json"
  args:
    entryPoints.web.address: ":80"
    entryPoints.websecure.address: ":443"
    entryPoints.web.http.redirections.entryPoint.to: websecure
    entryPoints.web.http.redirections.entryPoint.scheme: https
    entryPoints.web.http.redirections.entrypoint.permanent: true
    certificatesResolvers.letsencrypt.acme.email: "support@intellecta.app"
    certificatesResolvers.letsencrypt.acme.storage: "/letsencrypt/acme.json"
    certificatesResolvers.letsencrypt.acme.httpchallenge: true
    certificatesResolvers.letsencrypt.acme.httpchallenge.entrypoint: web

By following these steps, you can easily deploy your Rails 7+ application using the

Kamal gem on Digital Ocean. This guide should help you set up a robust, production-ready environment with minimal effort. Happy deploying!

Enhance Your Rails 7 App with Stimulus.js and JavaScript Integration

Shah Zaib — Thu, 25 Jul 2024 00:05:41 +0000

Enhance Your Rails 7 App with Stimulus.js and JavaScript Integration

Stimulus.js is a modest JavaScript framework that augments your HTML. It's the perfect companion for Rails' built-in functionality. In this post, we'll explore how to use Stimulus.js for JavaScript functionality, integrate it with other JavaScript libraries, and manage JavaScript dependencies effectively using Importmap.

Prerequisites

Before we begin, ensure you have the following:

Rails 7 application setup
Basic knowledge of JavaScript and Rails

Setting Up Stimulus.js in Rails 7

Rails 7 comes with default support for Stimulus.js. To get started, ensure Stimulus is included in your application by running:

rails new my_app
cd my_app

You can find the Stimulus controllers in app/javascript/controllers.

Creating a Stimulus Controller

Let's create a Stimulus controller to handle a simple click event. Run the following command:

rails generate stimulus hello

This will generate a new controller hello_controller.js in app/javascript/controllers. Open the file and add the following code:

// app/javascript/controllers/hello_controller.js
import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
  static targets = ["output"]

  connect() {
    this.outputTarget.textContent = 'Hello, Stimulus!'
  }

  greet() {
    this.outputTarget.textContent = 'Hello, World!'
  }
}

In your HTML, use the Stimulus controller:

<div data-controller="hello">
  <h1 data-hello-target="output"></h1>
  <button data-action="click->hello#greet">Greet</button>
</div>

When the button is clicked, the text will change to "Hello, World!".

Integrating with Other JavaScript Libraries

Stimulus.js can work seamlessly with other JavaScript libraries. For example, let's integrate jQuery with Stimulus.js.

First, add jQuery using Importmap:

Add jQuery to your config/importmap.rb:

pin "jquery", to: "https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js"

Then, import jQuery in your Stimulus controller:

// app/javascript/controllers/hello_controller.js
import { Controller } from "@hotwired/stimulus"
import $ from "jquery"

export default class extends Controller {
  static targets = ["output"]

  connect() {
    this.outputTarget.textContent = 'Hello, Stimulus!'
  }

  greet() {
    $(this.outputTarget).fadeOut().fadeIn().text('Hello, jQuery!')
  }
}

Managing JavaScript Dependencies

Managing JavaScript dependencies in Rails 7 is straightforward with Importmap. Here are some tips:

Add a library: Use pin "library_name", to: "library_url" in your config/importmap.rb to add a new library.
Remove a library: Remove the corresponding line from config/importmap.rb to remove an existing library.
Update libraries: Update the URLs in config/importmap.rb to the latest versions.
Check outdated libraries: Visit the URLs in config/importmap.rb to see if newer versions are available.

You can also add custom JavaScript files to your project. Place them in the app/javascript folder and import them where needed.

Conclusion

Stimulus.js provides a powerful yet simple way to add JavaScript functionality to your Rails application. By integrating it with other JavaScript libraries, you can create a rich and dynamic user experience. Properly managing your JavaScript dependencies ensures your application remains maintainable and up-to-date.

Happy coding!

Solving Common Issues with Hotwire in Ruby on Rails: Tips and Tricks

Shah Zaib — Sat, 20 Jul 2024 06:49:13 +0000

Solving Common Issues with Hotwire in Ruby on Rails: Tips and Tricks

As a Transformational Full-Stack Developer with expertise in Ruby on Rails and Hotwire, I’ve encountered and overcome various challenges when integrating Hotwire into Rails applications. In this post, I’ll share solutions to some common issues you might face, along with tips and tricks to enhance your development process.

Handling Turbo Stream Errors

One common issue developers face is dealing with Turbo Stream errors. Turbo Streams make it easy to update parts of your page, but sometimes things don’t go as planned. Here’s a quick tip to debug and fix these issues:

Solution:

Check the Server Logs: Ensure your Turbo Stream response is correctly formatted.
Validate Turbo Frame IDs: Make sure the IDs in your Turbo Frames and Streams match correctly.
Use debugger in JavaScript: Place a debugger statement in your Stimulus controller to pause execution and inspect the state.

import { Controller } from "stimulus";

export default class extends Controller {
  connect() {
    debugger; // This will pause execution in the browser's dev tools
  }
}

Turbo Drive Navigation Issues

Another frequent problem is navigation issues with Turbo Drive, especially when dealing with forms and redirects.

Solution:

Disable Turbo Drive for Specific Links or Forms: Use data-turbo="false" to opt-out of Turbo Drive for specific elements.
Handle Form Submissions Carefully: Ensure your forms handle redirects properly by returning turbo_stream responses.

<%= form_with model: @user, data: { turbo: false } do |form| %>
  <!-- form fields -->
<% end %>

Stimulus Controller Initialization Problems

Stimulus controllers are fantastic for adding interactivity, but sometimes they don’t initialize as expected.

Solution:

Check Your HTML: Make sure your data-controller attribute matches your controller’s name.
Initialize Manually: If necessary, you can initialize controllers manually in your JavaScript.

import { Application } from "stimulus";
import MyController from "./my_controller";

const application = Application.start();
application.register("my-controller", MyController);

Debugging Cable Ready and Stimulus Reflex

When using Cable Ready and Stimulus Reflex, debugging can become tricky due to the real-time nature of these tools.

Solution:

Use the JavaScript Console: Log useful information to the console to track what’s happening.
Check Network Requests: Inspect WebSocket frames in the network tab of your browser’s developer tools to ensure data is being transmitted correctly.

import CableReady from "cable_ready";
import consumer from "./consumer";

consumer.subscriptions.create("MyChannel", {
  received(data) {
    if (data.cableReady) {
      CableReady.perform(data.operations);
    }
  }
});

Conclusion

By addressing these common issues and leveraging these tips and tricks, you can enhance your Hotwire and Rails development experience. Remember, the key to mastering these tools lies in persistent learning and practical application.

If you have any questions or need further assistance, feel free to leave a comment below or reach out to me directly. Happy coding!

DEV Community: Shah Zaib

Handling Errors and Job Lifecycles in Rails 7.1: Master ActiveJob with `retry_on`, `discard_on`, and `after_discard`

1. after_discard Hook: Custom Actions for Discarded Jobs

Example:

2. discard_on: Efficient Handling of Irrecoverable Errors

Example:

3. retry_on: Automatic Retries for Recoverable Errors

Example:

Need a Rails Expert?

About Me: Shah Zaib

🚨 New Rails Versions Released: Addressing ReDoS Vulnerabilities 🚨

🚨 Key Issues Resolved:

💡 Why Should You Upgrade?

📈 What Does This Mean for Your Application?

🚀 What Should You Do Next?

Unlocking the Power of Ruby on Rails 8: What Developers Need to Know

1. Turbo 2.0 for Seamless Interactivity ⚡

2. Effortless Deployments with Kamal 2 and Thruster

3. Solid Cache, Solid Queue, and Solid Cable: Redis Alternatives

4. SQLite Ready for Production

5. Propshaft: The New Asset Pipeline

6. Built-In Authentication System

7. New Script Folder and Generator

8. Active Record Enhancements

9. Simplified Job Handling with Solid Queue

10. PostgreSQL and MySQL Improvements

Wrapping Up

RubyOnRails #Rails8 #WebDevelopment #Turbo2 #SQLite #SolidCache #Propshaft #Deployment #ActiveRecord #BuiltInAuth #FullStackDevelopment

Effortless Rails 7+ Deployment with Kamal Gem on DigitalOcean

Prerequisites

Step 1: Install Kamal Gem

Step 2: Initialize Kamal Configuration

Step 3: Configure .env File

Step 4: Update deploy.yml

Example config/deploy.yml

Step 5: Registry Configuration

Step 6: Set Environment Variables

Step 7: Configure Accessories

Rails Database Configuration

Step 8: Configure Traefik

Step 9: Deployment Commands

Step 10: Troubleshooting Logs

Step 11: Access Rails Console

Step 12: Access Bash on Server

Final config/deploy.yml

Enhance Your Rails 7 App with Stimulus.js and JavaScript Integration

Enhance Your Rails 7 App with Stimulus.js and JavaScript Integration

Prerequisites

Setting Up Stimulus.js in Rails 7

Creating a Stimulus Controller

Integrating with Other JavaScript Libraries

Managing JavaScript Dependencies

Conclusion

Solving Common Issues with Hotwire in Ruby on Rails: Tips and Tricks

1. `after_discard` Hook: Custom Actions for Discarded Jobs

2. `discard_on`: Efficient Handling of Irrecoverable Errors

3. `retry_on`: Automatic Retries for Recoverable Errors

Example `config/deploy.yml`

Final `config/deploy.yml`