エラー処理と構造化ログ
堅牢なエラー処理戦略を実装し、効果的なデバッグと監視のための構造化ログの使い方を学びます。
「エラー処理と構造化ログ」はCoddyKit上の無料Elixir & Phoenix: Scalable Backend Developmentレッスンです。 これはレッスン3/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはElixir & Phoenix: Scalable Backend Development学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Elixir & Phoenix: Scalable Backend Developmentコースには全4レッスンが含まれています。
このレッスンの一部はまだ翻訳されておらず、英語で表示されています。
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!
よくある質問
「エラー処理と構造化ログ」レッスンは無料ですか？
はい。「エラー処理と構造化ログ」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Elixir & Phoenix: Scalable Backend Developmentコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Elixir & Phoenix: Scalable Backend Developmentコースには全4レッスンが含まれています。
「エラー処理と構造化ログ」で何を学びますか？
堅牢なエラー処理戦略を実装し、効果的なデバッグと監視のための構造化ログの使い方を学びます。 ブラウザで直接実行するハンズオンコードでElixir & Phoenix: Scalable Backend Developmentを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。
Elixir & Phoenix: Scalable Backend Developmentを始めるのに経験は必要ですか？
事前経験は必要ありません。CoddyKitのElixir & Phoenix: Scalable Backend Developmentは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン3/4です。
「エラー処理と構造化ログ」レッスンにはどのくらい時間がかかりますか？
ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。
このElixir & Phoenix: Scalable Backend Developmentレッスンでコードを書いて実行できますか？
はい。すべてのElixir & Phoenix: Scalable Backend Developmentレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。