Forem: Marcelo Junior

[PT-BR] Shoryuken Vs Sidekiq

Marcelo Junior — Mon, 20 Nov 2023 18:55:08 +0000

Quando pensamos em processamento em background no mundo Ruby, levamos em conta atualmente com algumas Gems que fazem esse trabalho. Atualmente as que mais se destacam é a Shoryuken e a Sidekiq, e nesse post vamos ver quais são suas diferenças e quando usar cada uma delas.

(Esse artigo leva em conta apenas o Sidekiq em sua versão gratuita)

Sidekiq

Visto que a Gem mais velha é a Sidekiq, é importante olharmos para ela primeiro e entender qual é a função que ela desempenha.

Diferente da Resque, a Sidekiq veio com a ideia de processar os jobs de forma concorrente usando threads. Antes era necessário aumentar o número de processos, para conseguir processar mais jobs, de forma que era usado mais memória.

Mas também há semelhanças com o Resque, uma delas é o uso do Redis para armazenar e processar os jobs. Por ser um banco in-memory, tanto a escrita como sua leitura são bem rápidas, já que essas operações serão feitas apenas sobre a memória RAM.

Levando em conta esses pontos, porque usar o Shoryuken? O que ele entrega, que o Sidekiq não entrega (pelo menos na versão Free)?

Shoryuken

A principal diferença entre o Shoryuken e o Sidekiq está no armazenamento e processamento dos jobs. O Shoryuken usa o serviço SQS da AWS, ou seja, não temos que configurar e manter uma instancia do Redis, todo esse trabalho fica a cargo da AWS.

Por que usar o SQS?

Segundo a própria AWS os beneficios de se usar o SQS são:

Segurança: você controla quem pode enviar e receber mensagens em uma fila do Amazon SQS. Você pode optar pela transmissão de dados sigilosos protegendo o conteúdo das mensagens em filas por meio da criptografia do lado do servidor (SSE) gerenciada pelo Amazon SQS ou das chaves de SSE gerenciadas no AWS Key Management Service (AWS KMS).
Durabilidade: para garantir a segurança de suas mensagens, o Amazon SQS as armazena em vários servidores. As filas comuns são compatíveis com a entrega de mensagens pelo menos uma vez, e as filas FIFO são compatíveis com o processamento de mensagens exatamente uma vez e com o modo de alto throughput.
Disponibilidade: o Amazon SQS usa infraestrutura redundante para fornecer acesso altamente simultâneo às mensagens, além de alta disponibilidade para produzir e consumir mensagens.
Escalabilidade: o Amazon SQS pode processar cada solicitação em buffer de forma independente, escalando de forma transparente para lidar com qualquer aumento ou pico de carga sem nenhuma instrução de provisionamento.
Confiabilidade: o Amazon SQS bloqueia suas mensagens durante o processamento, para que vários produtores possam enviar, e vários consumidores possam receber, mensagens ao mesmo tempo.
Personalização: suas filas não precisam ser exatamente iguais. Você pode definir um atraso padrão em uma fila, por exemplo. Você pode armazenar o conteúdo de mensagens maiores que 256 KB usando o Amazon Simple Storage Service (Amazon S3) ou o Amazon DynamoDB, com o Amazon SQS mantendo um ponteiro no objeto do Amazon S3, ou pode dividir uma mensagem grande em mensagens menores.

E o melhor, temos 1 milhão de requests grátis para cada mês de uso!

Desempenho

Assim como o Sidekiq, o Shoryuken também utiliza de threads para processar suas mensagens. Há um benchmarking de um artigo que li, mostrando que há um pequena vantagem do Sidekiq sobre o Shoryuken, porém não acredito ser um ponto tão importante quando vamos escolher entre um dos dois.

Armazenamento

Quando usamos o Redis para armazenar os nossos jobs, precisamos ter em mente que esse banco de dados PODE estar apenas na memória RAM. Falo "PODE", porque existe algumas features do Redis que é possivel configurar-lo para que armazene o que está na RAM para o disco rígido. Caso aconteça da instância que está rodando o Redis morra, podemos perder jobs importantes que não foram processados.

Já para o SQS não temos que nos preocupar com isso, poís é garantido pela AWS que não iremos perder de forma alguma nossas mensagens.

Escalabilidade

Outro ponto que temos que levar em conta é a escalabilidade.

Se houver um pico de usuário que não foi planejado anteriormente, o seu sistema está pronto para continuar atuando da mesma maneira em relação ao processamento em background?

Quando usamos o Redis para guardar nossos jobs, temos que nos preocupar com isso.
Já quando usamos o SQS não é necessário, pois de novo, a AWS garante que irá atender todos os produtores e consumidores da fila, mesmo quando houver picos de acesso.

Conclusão

A decisão entre Shoryuken e Sidekiq está mais atrelada a Redis e SQS.

Para decidir qual das duas GEMs usar, deve-se levar em conta o quão importante é não perder o job que será enfileirado e processado.
Além de também levar em conta de há hoje um time que irá conseguir dar manutenção necessária, para que no caso do Redis, não tenha grandes problemas.

Referencias

Creating a Gem

Marcelo Junior — Mon, 26 Jun 2023 11:33:08 +0000

Creating a Gem

After compiling and testing our C Extension for Ruby, we can now create a Gem!
First, we should create some folders to organize the project.

See below:

Second, create the file lib/foo.rb:

require 'foo/foo'

(You can create other classes inside this file if you desire.)

And finally, create the file foo.gemspec inside the root of the project:

Gem::Specification.new "foo", "0.0.0" do |s|
  s.summary     = "A SUMMARY"
  s.description = "A DESCRIPTION"
  s.authors     = ["author"]
  s.email       = "email@example.com"
  s.files       = %w[lib/foo.rb lib/foo/foo.so]
  s.homepage    = "http://anylink.com"
  s.license     = "MIT"
  s.extensions  = %w[ext/foo/extconf.rb]
end

Now you can run on the root project:

gem build foo.gemspec
gem install foo

To test the gem you can open the irb and past this code:

require 'foo'

Greeting.hello
# hello!

🎉 Yeahhhh!!! We have a Gem!!! 🎉

Writing our C Extension

Marcelo Junior — Wed, 21 Jun 2023 10:42:24 +0000

How to compile C code for use in the program Ruby?

Write a Makefile to compile this program as shared lib to a program Ruby to use can be hard work, to solve this problem Ruby's core created the module MakeMakefile.

First: write a script in Ruby to "make our MakeFile" named extconf.rb on the same folder of program C:

require 'mkmf'

create_makefile 'foo'

This simple code generates a MakeFile to the file foo.c.

Second: Run ruby extconf.rb

We'll find our Makefile in the current path! 🎉

But... and the file foo.c?

Writing our C Extension

See below basic skeleton of our C Extension:

#include "ruby.h"

void Init_foo()
{
  // Your C code goes here
}

First include the lib ruby.h to use functions, constants... of Ruby.

Second create a function that returns void, named Init_ plus the name used in extconf.rb. In this example Init_foo.

Bingo! Our first C Extension is done!

To see the shared lib compiled by this code:

$ ruby extconf.rb
$ make
$ ls
Makefile  extconf.rb  foo.c  foo.o  foo.so

Let's create a Class and a Method to say "hello"?

Adding Class and Method to foo.c

See below how file.c turned out:

#include "ruby.h"

VALUE rb_hello(VALUE class) {
  VALUE str = rb_str_new_cstr("hello!");
  rb_funcall(rb_mKernel, rb_intern("puts"), 1, str);
  return Qnil;
}

void Init_foo()
{
  VALUE class = rb_define_class("Greeting", rb_cObject);
  rb_define_singleton_method(class, "hello", rb_hello, 0);
}

Like the first part of this article, we'll define the class Greeting using the function rb_define_class inheriting from Object. And we'll define the method of class hello using rb_define_singleton_method passing the function rb_hello as a parameter.

The function rb_hello should return VALUE and receive as a parameter the class. This function transforms a string of C to a string of Ruby using the method rb_str_new_cstr, then call method puts of Kernel through of function rb_funcall(rb_mKernel, rb_intern("puts"), 1, str). And finally returns Qnil, the same nil of Ruby.

In Ruby this code is like this:

class Greeting
  def self.hello
    Kernel.puts "hello" # or puts "hello"
  end
end

LET'S RUN IT!

To test our work until here compile the C Extension again:

$ ruby extconf.rb
$ make

Then open the irb inside of folder of shared lib and run this code:

require './foo'

Greeting.hello
# hello!

🎉 🎉 YEAH! ITS DONE! 🎉 🎉

Next steps

Finally, we compile our C Extension! However, we don't create a Gem yet 🙄...

In the next article, we'll make this!

See you later 😀

Basic about Ruby C API

Marcelo Junior — Tue, 20 Jun 2023 11:53:07 +0000

Creating a Gem using Ruby C API

Sometimes we want to use a lib built with C language without any Ruby version, to make this we'll find a gem that integrates the lib C with Ruby. But, how this Gem was built?

In this article I'll show how to make this, using as an example the project musicrb, this Gem uses the lib of C vlc to play music on Ruby.

How is possible to integrate Ruby and C?

It's simple: Ruby is built using C, so we'll build a shared lib to the interpreter of Ruby use.

But do not trust in me, see the repository of language!

Basic about Ruby C API

Before starting to code our lib, we'll see some features in Ruby C API that we will use (p.s.: this tutorial is very basic if you want deep in this theme, my recommendation is the book Ruby Under a Microscope).

VALUE

See VALUE as a pointer to a Ruby's Object, since the Ruby is dynamic this feature is required. Then String, Number, Class, Module ... are accessed and modified by VALUE through functions of Ruby C API.

This is an example using VALUE as a pointer to String:

VALUE x;
x = rb_str_new_cstr("Hello, world!");

VALUE str;
str = rb_sprintf("pi = %f. %"PRIsVALUE" inspected: %+"PRIsVALUE, M_PI, x, x);

/* pi = 3.141593. Hello, world! inspected: "Hello, world!" */

We can see that isn't required to pass the type of VALUE to methods like a programRuby!

DEFINE

The Gem musicrb has a class named Music, and has two static methods: play and stop.

Define this class and methods using Ruby is very simple:

class Music
  def play
    # Implementation ...
  end

  def stop
    # Implementation ...
  end
end

The code in C will be like this:

// Headers ...

// Global variables ...
VALUE rb_cMusic;

VALUE
rb_music_stop(VALUE msc)
{
  // Implementation ...
}

VALUE
rb_music_play(VALUE msc, VALUE rpath)
{
  // Implementation ...
}

void
Init_musicrb(void)
{
  rb_cMusic = rb_define_class("Music", rb_cObject);
  rb_define_singleton_method(rb_cMusic, "play", rb_music_play, 1);
  rb_define_singleton_method(rb_cMusic, "stop", rb_music_stop, 0);
}

rb_define_class: Define a class named "Music" that has a heritage with "Object".
rb_define_singleton_method: Define a singleton method to class "Music", in other words, a method of class. The last parameter of the function is the number of args.

Again, don't trust me!
See here the code.

Next steps

Okay, we already see the basics about the Ruby C API, but how to compile and test this code?

This post is already too long... I will follow up on the subject in the next article!

Goodbye, see you soon!

[Monkey Patch] Chamando o método original

Marcelo Junior — Thu, 26 Mar 2020 14:02:35 +0000

Mesmo que não seja uma pratica tão elegante e até perigosa, o Monkey Patch é uma realidade para os programadores Ruby (on Rails). E por este motivo decidi escrever este artigo relatando um desafio que encontrei esses dias, e como resolvi o mesmo.

O desafio encontrado foi: "Tratar a exceção que um método que uma gem levantava". Para isso eu precisava chamar o método antigo, e não sabia bem como fazer isso.

Sem mais delongas, a forma que eu encontrei foi a seguinte:

class ClasseDaGem
  def metodo
    raise "ERROR!!!!"
  end
end

class ClasseDaGem
  alias_method :antigo_metodo, :metodo

  def metodo
    begin
      antigo_metodo
    rescue
      p "Faça o que precisar aqui!"
    end
  end
end

Caso você tenha uma solução melhor, não deixe de comentar ✌