Ejercicio práctico de módulos en Ruby: un logger
Un módulo es como una caja de herramientas: la preparas una vez y cualquier clase que la incluya tiene a mano sus herramientas (los métodos) sin copiar nada. Si no conoces los módulos, empieza por Módulos en Ruby.
El enunciado
Crea un módulo que implemente estos métodos:
| Método | Qué hace |
|---|---|
log(nivel, mensaje) |
Escribe el mensaje en el fichero de log. El nivel es :info, :debug o :warn. |
logfile= |
Cambia el fichero en el que se escribe. |
logfile |
Devuelve el fichero en el que se escribe. Por defecto, ./practicaruby.log. |
Cada llamada a log añade una línea con este formato:
[fecha-hora || clase] WARNING: mensaje
Cuando el módulo esté terminado:
- Crea dos clases que incluyan el módulo.
- Escribe desde cada clase varios mensajes de cada nivel.
- Cambia el fichero de log de uno de los objetos y comprueba que escribe en el nuevo.
Una solución
# registrable.rb
module Registrable
NIVELES = {
warn: "WARNING",
info: "INFO",
debug: "DEBUG"
}.freeze
def log(nivel, mensaje)
File.open(logfile, "a") { |fichero| fichero.puts(formatea(nivel, mensaje)) }
end
def logfile=(ruta)
@logfile = ruta
end
def logfile
@logfile || "./practicaruby.log"
end
private
def formatea(nivel, mensaje)
fecha = Time.now.strftime("%d/%m/%Y %H:%M:%S")
etiqueta = NIVELES.fetch(nivel, "UNDEFINED")
"[#{fecha} || #{self.class}] #{etiqueta}: #{mensaje}"
end
end
Claves de la solución:
self.classda el nombre de la clase que incluye el módulo, no el del módulo.NIVELES.fetch(nivel, "UNDEFINED")devuelve"UNDEFINED"si el nivel no existe.File.opencon bloque cierra el fichero al terminar (más en Trabajar con ficheros en Ruby).formateaes privado: las clases lo usan por dentro, pero nadie puede llamarlo desde fuera.Time.now.strftimeda formato a la fecha (lo tienes en Time en Ruby).
Probarlo con dos clases
# ejemplo.rb
require_relative "registrable"
class Pedido
include Registrable
end
class Factura
include Registrable
end
pedido = Pedido.new
pedido.log(:warn, "Esto es un aviso")
pedido.log(:info, "Esto es información")
pedido.log(:debug, "Esto es para depurar")
pedido.log(:inventado, "Nivel que no existe")
factura = Factura.new
factura.log(:warn, "Esto es un aviso")
factura.log(:info, "Esto es información")
pedido.logfile = "./prueba.log"
pedido.log(:warn, "Esto va a otro fichero")
Resultado en practicaruby.log:
[12/11/2026 09:23:49 || Pedido] WARNING: Esto es un aviso
[12/11/2026 09:23:49 || Pedido] INFO: Esto es información
[12/11/2026 09:23:49 || Pedido] DEBUG: Esto es para depurar
[12/11/2026 09:23:49 || Pedido] UNDEFINED: Nivel que no existe
[12/11/2026 09:23:49 || Factura] WARNING: Esto es un aviso
[12/11/2026 09:23:49 || Factura] INFO: Esto es información
Y en prueba.log:
[12/11/2026 09:23:49 || Pedido] WARNING: Esto va a otro fichero
El cambio de fichero solo afecta a pedido: cada objeto guarda su propio @logfile, así que factura sigue escribiendo en practicaruby.log.
Comprobarlo con un test
En lugar de abrir el fichero a ojo, un test lo comprueba cada vez. Usa un directorio temporal para no dejar ficheros sueltos:
# registrable_test.rb
require "minitest/autorun"
require "tmpdir"
require_relative "registrable"
class RegistrableTest < Minitest::Test
class Ejemplo
include Registrable
end
def test_escribe_nivel_y_clase_en_el_fichero
Dir.mktmpdir do |dir|
objeto = Ejemplo.new
objeto.logfile = File.join(dir, "test.log")
objeto.log(:warn, "Cuidado")
assert_match(/\|\| RegistrableTest::Ejemplo\] WARNING: Cuidado\n\z/, File.read(objeto.logfile))
end
end
def test_nivel_desconocido_se_marca_como_undefined
Dir.mktmpdir do |dir|
objeto = Ejemplo.new
objeto.logfile = File.join(dir, "test.log")
objeto.log(:otro, "Algo")
assert_includes File.read(objeto.logfile), "UNDEFINED: Algo"
end
end
def test_cada_objeto_tiene_su_propio_fichero
Dir.mktmpdir do |dir|
uno = Ejemplo.new
otro = Ejemplo.new
uno.logfile = File.join(dir, "uno.log")
assert_equal "./practicaruby.log", otro.logfile
refute_equal uno.logfile, otro.logfile
end
end
end
ruby registrable_test.rb
3 runs, 6 assertions, 0 failures, 0 errors, 0 skips
El tercer test comprueba el punto 3 del enunciado sin escribir nada: cambiar el fichero de un objeto no toca el de los demás.
Si es tu primer test en Ruby, tienes los pasos en Introducción al testing en Ruby.
Errores frecuentes
Estos son los fallos típicos al resolver el ejercicio. Los mensajes son de Ruby 4.0.9; Ruby 3.4.12 da los mismos. Todos parten de registrable.rb tal y como está en la solución.
1. Llamar a log sobre el propio módulo. Los métodos de Registrable son para los objetos que lo incluyen, no para el módulo:
require_relative "registrable"
Registrable.log(:info, "hola")
err_directo.rb:2:in '<main>': undefined method 'log' for module Registrable (NoMethodError)
2. Usar extend en la clase. Con extend, log pasa a ser un método de la clase Pedido, y los pedidos no lo tienen:
require_relative "registrable"
class Pedido
extend Registrable
end
Pedido.new.log(:info, "hola")
err_extend.rb:7:in '<main>': undefined method 'log' for an instance of Pedido (NoMethodError)
La diferencia entre include y extend está explicada con calma en módulos en Ruby.
3. Olvidar el require_relative. Ruby busca la constante dentro de la clase y no la encuentra:
class Pedido
include Registrable
end
err_sin_require.rb:2:in '<class:Pedido>': uninitialized constant Pedido::Registrable (NameError)
Cómo cargar unos ficheros desde otros está en incluir otros archivos en Ruby.
4. Apuntar el log a una carpeta que no existe. File.open en modo "a" crea el fichero, pero no la carpeta:
require_relative "registrable"
class Pedido
include Registrable
end
pedido = Pedido.new
pedido.logfile = "logs/pedidos.log"
pedido.log(:info, "hola")
/work/registrable.rb:10:in 'File#initialize': No such file or directory @ rb_sysopen - logs/pedidos.log (Errno::ENOENT)
from /work/registrable.rb:10:in 'IO.open'
from /work/registrable.rb:10:in 'Registrable#log'
Créala antes con FileUtils.mkdir_p("logs"), o haz que logfile= la cree. Más en trabajar con ficheros en Ruby.
5. Llamar a formatea desde fuera. Es privado a propósito:
require_relative "registrable"
class Pedido
include Registrable
end
Pedido.new.formatea(:info, "hola")
err_privado.rb:7:in '<main>': private method 'formatea' called for an instance of Pedido (NoMethodError)
6. Llamar al módulo Logger. Es el choque que explica la nota de la solución:
require "logger"
module Logger
end
err_logger.rb:3:in '<main>': Logger is not a module (TypeError)
Si el orden es el contrario (primero tu module Logger y después require "logger"), el error sale dentro de la gema, al definir su clase:
/usr/local/lib/ruby/gems/4.0.0/gems/logger-1.7.0/lib/logger/version.rb:3:in '<top (required)>': Logger is not a class (TypeError)
logger_antes.rb:1: previous definition of Logger was here
La ruta de la gema delata el cambio de versión. En el primer caso aparece en la línea previous definition, y en el segundo, en la primera línea: en Ruby 3.4 es /usr/local/lib/ruby/3.4.0/logger/version.rb (biblioteca estándar) y en Ruby 4.0, gems/logger-1.7.0/ (gema). En Ruby 4.0, el segundo caso imprime antes un aviso de que logger ya no es una default gem.
En código real: usa Logger
El ejercicio sirve para practicar módulos, no para sustituir lo que ya trae Ruby. Para un programa de verdad, la clase Logger ya hace esto y más: niveles con filtro, rotación de ficheros y formato configurable. Con un formatter puedes conseguir el mismo formato del enunciado:
require "logger"
logger = Logger.new("practicaruby.log")
logger.formatter = proc do |nivel, fecha, programa, mensaje|
"[#{fecha.strftime('%d/%m/%Y %H:%M:%S')} || #{programa}] #{nivel}: #{mensaje}\n"
end
logger.progname = "Pedido"
logger.level = Logger::INFO
logger.warn("Esto es un aviso")
logger.debug("Esto no sale: está por debajo de INFO")
puts File.read("practicaruby.log")
# Logfile created on 2026-11-12 09:23:51 +0000 by logger.rb/v1.7.0
[12/11/2026 09:23:51 || Pedido] WARN: Esto es un aviso
Con Ruby 3.4.12, la cabecera dice logger.rb/v1.6.4, la versión de logger que trae.
Fíjate en tres diferencias con Registrable: Logger escribe una cabecera al crear el fichero, llama WARN al nivel que el enunciado llama WARNING y descarta los mensajes por debajo del nivel elegido.
Logger y Bundler en Ruby 4.0
Desde Ruby 4.0, logger es una bundled gem: viene instalada con Ruby, pero ya no forma parte de la biblioteca estándar. Sin Bundler, require "logger" funciona igual que antes. Con Bundler, si no está en el Gemfile, falla. Un app.rb que solo contiene require "logger", lanzado con bundle exec ruby app.rb y un Gemfile vacío:
app.rb:1: warning: logger used to be loaded from the standard library, but is not part of the default gems since Ruby 4.0.0.
You can add logger to your Gemfile or gemspec to fix this error.
/usr/local/lib/ruby/4.0.0/bundled_gems.rb:60:in 'Kernel.require': cannot load such file -- logger (LoadError)
Ruby 3.4 lo carga, pero ya avisa de que dejará de hacerlo. La solución en los dos casos es añadir gem "logger" al Gemfile.
Cuándo no usar un módulo como este
- Cuando el log es un servicio compartido. Con
Registrable, cada objeto guarda su propio@logfile: si quieres cambiar el fichero de toda la aplicación, tienes que ir objeto por objeto. Un únicoLoggerque las clases reciben (por ejemplo, en el constructor) se cambia en un solo sitio. - Cuando necesitas probar qué se ha registrado. El módulo escribe directamente en disco y lee la hora del sistema, así que el test tiene que usar una carpeta temporal y no puede comprobar la fecha exacta. Si el objeto recibe dónde escribir y qué reloj usar, el test le pasa unos de prueba.
- Cuando el módulo crece. Si empiezas a añadirle rotación, colores y envío por red, estás reescribiendo
Logger. Es la señal de usar el de Ruby o una gema.
Ejercicios para seguir
- Añade un nivel mínimo:
log_level = :infohace que los:debugno se escriban. Escribe primero el test. - Haz que
logfile=cree la carpeta si no existe y añade un test que lo compruebe conDir.mktmpdir. - Cambia
formateapara que reciba la hora en lugar de llamar aTime.now, y escribe un test que compruebe la línea completa, fecha incluida.
Fuentes
- Documentación oficial de Ruby 4.0: clases y módulos, Hash#fetch, Time#strftime, NEWS de Ruby 4.0 (
logger1.7.0 pasa de default gem a bundled gem; Minitest 6.0.0) y la gema logger (Logger.new,formatter,prognameylevel). - Todo el código se ha ejecutado el 12 de noviembre de 2026 en Docker con las imágenes oficiales
ruby:3.4(Ruby 3.4.12, logger 1.6.4, Minitest 5.25.4) yruby:4.0(Ruby 4.0.9, logger 1.7.0, Minitest 6.0.0, Bundler 4.0.20), con la misma salida en las dos salvo las diferencias deloggerque se indican. Los ficheros de log son los de esa ejecución. En RubyGems, la última versión de Minitest es la 6.1.0; aquí se ha usado la que trae cada versión de Ruby. Las salidas de error están recortadas a las líneas que importan.