Gestión de errores y registro estructurado
Implemente estrategias sólidas de gestión de errores y aprenda a usar registros estructurados para depurar y supervisar eficazmente.
Gestión de errores y registro estructurado es una lección gratuita de Elixir & Phoenix: Scalable Backend Development en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Elixir & Phoenix: Scalable Backend Development, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
Why Error Handling Matters
In any application, things can go wrong. Users might input incorrect data, external services could fail, or files might not exist.
Error handling is about anticipating these issues and designing your application to respond gracefully, preventing crashes and ensuring a smooth user experience.
Elixir's 'Let It Crash' Philosophy
Elixir, built on the Erlang VM, embraces a unique approach called 'Let It Crash'. Instead of trying to prevent every possible error, Elixir processes are designed to be isolated.
If a process crashes, a supervisor can detect it and restart it, ensuring high availability. However, this primarily applies to process-level failures. For expected functional outcomes, a different pattern is used.
Tuples: {:ok, value} or {:error, reason}
For operations that might succeed or fail predictably, Elixir often uses a pattern of returning tuples: {:ok, result} for success and {:error, reason} for failure.
This makes the outcome explicit and avoids exceptions for expected scenarios, leading to clearer code.
defmodule AccountService do
def withdraw(balance, amount) when amount > 0 and balance >= amount do
{:ok, balance - amount}
end
def withdraw(balance, amount) when amount <= 0 do
{:error, :invalid_amount}
end
def withdraw(balance, amount) when balance < amount do
{:error, :insufficient_funds}
end
end
IO.puts "Withdrawal 1: #{inspect AccountService.withdraw(100, 50)}"
IO.puts "Withdrawal 2: #{inspect AccountService.withdraw(100, 150)}"
IO.puts "Withdrawal 3: #{inspect AccountService.withdraw(100, 0)}"Handling Results with `case`
Once a function returns an {:ok, ...} or {:error, ...} tuple, you can use Elixir's powerful pattern matching with a case statement to handle both outcomes explicitly.
This makes your error handling paths very clear and readable.
defmodule PaymentProcessor do
def process_payment(amount, account_balance) do
case AccountService.withdraw(account_balance, amount) do
{:ok, new_balance} ->
IO.puts "Payment successful! New balance: #{new_balance}"
{:ok, new_balance}
{:error, :insufficient_funds} ->
IO.puts "Payment failed: Insufficient funds."
{:error, :payment_failed}
{:error, reason} ->
IO.puts "Payment failed: Unknown reason #{reason}."
{:error, :payment_failed}
end
end
end
# Assuming AccountService from previous scene is available
# Example usage:
PaymentProcessor.process_payment(30, 100)
PaymentProcessor.process_payment(120, 100)The Power of `with` for Chaining
When you have multiple operations that might return {:error, ...} tuples and depend on the success of previous steps, the with special form is incredibly useful.
It allows you to chain these operations, and if any step returns an {:error, ...}, the with block immediately stops and returns that error, simplifying complex flows.
defmodule OrderProcessor do
def process_order(user_id, item_id, quantity) do
with {:ok, user} <- get_user(user_id),
{:ok, item} <- get_item(item_id),
{:ok, total_cost} <- calculate_cost(item, quantity),
{:ok, _} <- deduct_funds(user, total_cost) do
{:ok, "Order processed successfully for user #{user.name}"}
else
{:error, reason} -> {:error, reason}
end
end
defp get_user(1), do: {:ok, %{name: "Alice"}}
defp get_user(_), do: {:error, :user_not_found}
defp get_item(101), do: {:ok, %{price: 20}}
defp get_item(_), do: {:error, :item_not_found}
defp calculate_cost(%{price: p}, q), do: {:ok, p * q}
defp deduct_funds(%{name: "Alice"}, 40), do: {:ok, :deducted}
defp deduct_funds(_, _), do: {:error, :payment_failed}
end
IO.puts "Processing good order: #{inspect OrderProcessor.process_order(1, 101, 2)}"
IO.puts "Processing bad order (item): #{inspect OrderProcessor.process_order(1, 999, 1)}"Beyond Basic Logs: Structured Logging
Traditional logs often look like plain text messages, which are hard for machines to parse and query. Structured logging addresses this by outputting logs in a consistent, machine-readable format, usually JSON.
This makes it much easier to filter, analyze, and visualize your log data using tools like Kibana or Splunk, providing deeper insights into your application's behavior.
Your Go-To: The `Logger` Module
Elixir comes with a powerful built-in logging facility: the Logger module. It allows you to emit log messages at different severity levels, such as :debug, :info, :warn, and :error.
By default, Logger prints to the console, but it's highly configurable to send logs to files, external services, or other destinations.
defmodule MyApp do
require Logger
def start_process(id) do
Logger.info "Starting process with ID: #{id}"
# ... some work ...
if id == 101 do
Logger.warn "Process #{id} encountered a minor issue."
else
Logger.debug "Process #{id} completed successfully."
end
end
def critical_error(message) do
Logger.error "Critical error detected: #{message}"
end
end
MyApp.start_process(100)
MyApp.start_process(101)
MyApp.critical_error("Database connection lost")Contextual Logs with Metadata
One of the best features of Logger for structured logging is the ability to easily add metadata (extra key-value pairs) to your log messages.
This metadata provides crucial context, like a user_id, request_id, or specific parameters, making it much easier to trace issues and understand what happened during an event.
defmodule WebRequestLogger do
require Logger
def log_request(method, path, user_id, duration_ms) do
Logger.info "Request processed",
method: method,
path: path,
user_id: user_id,
duration: "#{duration_ms}ms"
end
def log_error(error_message, user_id, request_id) do
Logger.error error_message,
user_id: user_id,
request_id: request_id,
component: :api_handler
end
end
WebRequestLogger.log_request("GET", "/users/1", 123, 55)
WebRequestLogger.log_error("Invalid API key", 456, "abc-123")Controlling Log Output with Levels
Each log message has a level (debug, info, warn, error, critical). You can configure your Elixir application's Logger to only output messages at or above a certain level.
For example, in a production environment, you might set the level to :info to avoid excessive :debug logs, while in development, you might set it to :debug for full visibility.
- :debug: Detailed information, useful for debugging.
- :info: General operational messages.
- :warn: Potentially harmful situations.
- :error: Error events that might still allow the application to continue.
- :critical: Severe error events that likely cause an application to abort.
Check Your Understanding
Which of these are benefits of using structured logging in Elixir applications?
Lesson Summary: Robustness & Insight
In this lesson, you've learned to build more robust Elixir applications and gain better insights into their behavior:
- Understood Elixir's approach to error handling with the 'Let It Crash' philosophy.
- Mastered the use of
{:ok, value}and{:error, reason}tuples for explicit functional error handling. - Utilized the
withspecial form to elegantly chain operations that might fail. - Discovered the advantages of structured logging for machine-readable, searchable logs.
- Learned to use Elixir's
Loggermodule, including adding valuable metadata to your logs and configuring log levels.
These techniques are fundamental for developing production-ready, observable Elixir systems!
Preguntas frecuentes
¿La lección «Gestión de errores y registro estructurado» es gratis?
Sí — el texto completo de «Gestión de errores y registro estructurado» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Elixir & Phoenix: Scalable Backend Development, actualiza a CoddyKit PRO. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.
¿Qué aprenderé en «Gestión de errores y registro estructurado»?
Implemente estrategias sólidas de gestión de errores y aprenda a usar registros estructurados para depurar y supervisar eficazmente. Practicas Elixir & Phoenix: Scalable Backend Development con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Elixir & Phoenix: Scalable Backend Development?
No se requiere experiencia previa. Elixir & Phoenix: Scalable Backend Development en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Gestión de errores y registro estructurado»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Elixir & Phoenix: Scalable Backend Development?
Sí. Cada lección de Elixir & Phoenix: Scalable Backend Development incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Benchmarking y profiling de Elixir
- Supervisión con Telemetry y métricas
- Gestión de errores y registro estructurado
- Trazabilidad distribuida con OpenTelemetry