DEV Community: luiz filipe neves

How you zip larger files in ruby

luiz filipe neves — Mon, 22 Jun 2026 02:29:51 +0000

Easy way that compress files in ruby is using zip lib.

Zip::File.open('./compress.zip', create: true) do |zip|
  zip.get_output_stream("./stuff_to_ziped.pdf") do |f|
    f.puts File.read("./stuff_to_zip.pdf")
   end
end

When you need to zip larger files or when you need to perform any task that requires opening many files, good practice is to avoid loading all files into memory. To achieve this, you can use stream operations available in IO classes.

Let's look at the code above again but with a thread that monitory the memory for us.

Thread.new do
  loop do
    print "\r memory: %d MB" % "#{`ps -o rss= -p #{Process.pid}`.to_i/1024}\t"
  end
end

Zip::File.open('./compress.zip', create: true) do |zip|
  zip.get_output_stream("./stuff_to_ziped.pdf") do |f|
    f.puts File.read("./stuff_to_zip.pdf")
   end
end

Now you can see how much memory the program consumis until done. The method File.read load all bytes of file in memory. Lets see other implementation.

Thread.new do
  loop do
    print "\r memory: %d MB" % "#{`ps -o rss= -p #{Process.pid}`.to_i/1024}\t"
  end
end


Zip::File.open('./compactados.zip', create: true) do |zip|
    10.times do |i|
        zip.get_output_stream("./copy_#{i}.pdf") do |f| 
            input = File.new("./copy_#{i}.pdf")
            while !input.eof?
                f.puts(input.gets)
            end
        end
    end
end

Making my own “sidekiq” for Rails.

luiz filipe neves — Tue, 12 Dec 2023 17:29:41 +0000

In web development, when we have a task that takes a long time to process, we typically use a background job processor. This means that the task is delegated to another process, allowing the main application to run without being delayed by the time-consuming task.

In most cases in the Ruby on Rails (RoR) world, Sidekiq plays this role. But how does it work?

This post will demonstrate how to create your own version of 'Sidekiq'.

Load dependencies

The first step is to load all dependencies from the main application. The background processor should be aware of how to initialize the main application. In Ruby on Rails (RoR), you can achieve this by running something like the following using irb.

#!/usr/bin/env ruby
require_relative "application"
require_relative "boot"
require_relative "environment"

If you want to know more details about this process, please refer to the Rails documentation.(here)

Let's start a Rails application and attempt to run it using IRB.

rails new my_person_app
cd my_person_app
rails g controller VeryExpensiveTask index
rails g model FooEntity start_task:datetime end_task:datetime
rake db:migrate

Create the class FooEntity.

class FooEntity < ApplicationRecord
 def verify_expensive_task
  self.save if new_record?

  update_column(:start_task, Time.now)
  sleep rand(10..60)
  update_column(:end_task, Time.now)
 end
end

Run this in IRB.

require_relative "application"
require_relative "boot"
require_relative "environment"

FooEntity.new.verify_expensive_task

In the VeryExpensiveTaskController, let's create an action that calls the verify_expensive_task method.

class VeryExpensiveTaskController < ApplicationController
  def index
    FooEntity.new.verify_expensive_task
  end
end

# route.rb

Rails.application.routes.draw do
  get 'very_expensive_task/index'
end

# index.html.erb

<h1>VeryExpensiveTask#index</h1>
<style>
table, th, td {
  border:1px solid black;
}
</style>
<table>
 <thead>
  <th>ID</th>
  <th>Inicio</th>
  <th>Fim</th>
 </thead>
 <tbody>
  <% FooEntity.all.each do |foo| %>
   <tr>
    <td><%= foo.id %></td>
    <td><%= l foo.start_task, format: :short %></td>
    <td><%= foo.end_task ? l(foo.end_task, format: :short) : "-"%></td>
   </tr>
  <% end %>
 </tbody>
</table>

Initialize the application and access the page localhost:3000/very_expensive_task/index. Check the duration of the page load.

Write the background processing

Now, we need a method for exchanging messages between processes—the main application and the background application.

In this example, we'll employ a straightforward method by opening a socket for the main application to send messages. However, there are various methods available for inter-process communication (IPC). You can explore different IPC methods by searching for 'inter-process communication (IPC) methods' on Google.

Create a file(i give voadora.rb name for my file) in config path of project and than put this code.

require 'socket'

require_relative "application"
require_relative "boot"
require_relative "environment"

# Init a tcp server
server = TCPServer.new 2000 # Server bind to port 2000

puts "Waiting for job..."
# Loop that listener connections
loop do
  client = server.accept    # Wait for a client to connect
  if client
    puts "Job receveid" 
  # Using thread for many connections accept. Try run without 
  # threads =(.
    Thread.new do 
        puts "Init job"
          FooEntity.new.verify_expensive_task 
        puts "Finish job"
    end
  end
  client.puts "Job scheduled!"
  client.close
end

Run the code.

ruby config/voadora.rb 
>>> Waiting for job...

Voala!

Change the controller code for send message to background processor.

...
def index
 client = TCPSocket.open('localhost', 2000)
 client.gets
end
...

Reload the page and you can see backgroud process receive message and process the job.

It's a very simple example to show you how you can write a background process, and we can make many improvements to the code. In the next post, I will add Redis for IPC alternative and encapsulate the job definition in one class.

Web "Hello World" in Ruby without RoR!

luiz filipe neves — Tue, 07 Nov 2023 00:31:38 +0000

If you want to understand how things work beyond what's under the hood, the first good step is to try to write something from scratch. So, in this post, I will show you how to write a 'hello world' app for the web in pure Ruby. Above, you'll find the simple 'Hello World' code example.

class MyApp
 def say_hello
   "Hello World"
 end
end
MyApp.new.say_hello

Now we need to turn this code into a Rack app. Rack is an interface for developing web applications in Ruby. The structure of a Rack app looks like this:

run do |env|
  [200, {}, ["Hello World"]]
end

In this case, the code works like this:

class MyApp
 def say_hello
   "Hello World"
 end
end

myapp = proc do |env|
  [200, {'Content-Type' => 'text/plain'}, [MyApp.new.say_hello]]
end
run myapp

Run this using the rackup gem or another supported web server.(read more here)

rackup myapp.ru
--> Puma starting in single mode...
--> * Version 4.2.0 (ruby 2.6.5-p114), codename: Distant Airhorns
--> * Min threads: 0, max threads: 16
--> * Environment: development
--> * Listening on tcp://127.0.0.1:9292
--> * Listening on tcp://[::1]:9292
--> Use Ctrl-C to stop

You can access the app by typing in your browser. 127.0.0.1:9292.

Ruby Pills - Defining Your Own Callbacks in RoR

luiz filipe neves — Sun, 05 Nov 2023 23:24:51 +0000

With the define_callbacks method, it's possible to define your own callbacks. The ActiveSupport::Callbacks module contains all the logic and implementations for defining events in the lifecycle of objects.

class MyModel < ActiveRecord::Base
 define_callbacks :custom_callback
 set_callback :custom_callback, :before do |record|
   puts "before important_thing"
 end
 set_callback :custom_callback, :after do |record|
   puts "after important_thing"
 end

 def important_thing
   run_callback :custom_callback do
     puts "...code"
   end
 end
end

MyModel.new.important_thing

The output:

before important_thing
...code
after important_thing