Erlang OTP: Distributed & Fault-Tolerant Systems Programming · レッスン

分散システムのトレースとデバッグ

分散環境で複数のErlangノードにまたがる問題を診断するための、高度なトレースとデバッグの手法を習得します。

「分散システムのトレースとデバッグ」はCoddyKit上の無料Erlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンです。これはレッスン2/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはErlang OTP: Distributed & Fault-Tolerant Systems Programming学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Erlang OTP: Distributed & Fault-Tolerant Systems Programmingコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Debugging Distributed Erlang

Debugging a single Erlang process is already fun, but diagnosing issues across multiple interconnected Erlang nodes can be a real challenge! Why is it so hard?

Concurrency: Many processes running in parallel.
Distribution: Processes spread across different machines.
Asynchrony: Messages sent, not always immediately received.

Erlang provides powerful built-in tools to help us peer into these complex systems.

Starting the Erlang Debugger

The primary tool for in-depth debugging is the Erlang Debugger. It's a graphical interface that lets you inspect processes, set breakpoints, and trace code execution.

You start the debugger from the Erlang shell. Once open, you can connect to local or remote Erlang nodes to begin your investigation.

1> debugger:start().
{ok,<0.88.0>}
2> % The debugger GUI will now appear.
3> % To connect to another node:
4> % debugger:start([{node, 'other_node@hostname'}]).

Inspecting Live Processes

Once connected, the debugger allows you to select any running process on the chosen node. You can then:

View its current state (process dictionary, stack trace).
Examine its message queue (mailbox).
Set breakpoints on functions it's executing.

This is crucial for understanding what a process is doing, or waiting for, at any given moment.

Tracing Local Function Calls

The debugger's tracing capabilities, often accessed via the dbg module, let you monitor function calls. You can trace specific functions and see their arguments and return values.

Let's trace a simple module. Compile it, then use dbg:tp/2 to trace its add/2 function.

-module(my_math).
-export([add/2, multiply/2]).

add(A, B) ->
    A + B.

multiply(A, B) ->
    A * B.

% To run:
% 1> c(my_math).
% 2> dbg:tracer(), dbg:tp(my_math, add, 2, []).
% 3> my_math:add(5, 3).
% {trace, <0.78.0>, call, {my_math,add, [5,3]}}
% {trace, <0.78.0>, return_from, {my_math,add,2}, 8}
% 8
% 4> dbg:stop_clear().

Tracing Across Nodes

One of Erlang's powerful features is the ability to trace across a distributed system. The dbg module can be instructed to trace events on other connected nodes, allowing you to follow the flow of execution and messages between them.

This is essential when a problem involves interaction between processes residing on different machines.

Example: Tracing Remote Calls

Imagine you have a 'worker' process on a remote node. You can instruct your local debugger to trace functions on that remote node. Here's a simple worker module.

If this module was running on worker@remotehost, you could trace its process_task/1 function from your local node using dbg:tp({'worker@remotehost', worker}, process_task, 1, []) after connecting the nodes.

-module(remote_worker).
-export([start_link/0, process_task/1]).

start_link() ->
    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).

process_task(Task) ->
    io:format("~p processing task: ~p~n", [self(), Task]),
    timer:sleep(100), % Simulate work
    {ok, Task}.

% gen_server callbacks omitted for brevity.
% This module would be running on a remote node.

Analyzing Traces with TTB

For complex scenarios, viewing trace output directly in the shell or debugger GUI can be overwhelming. The Trace Tool Builder (TTB) helps by recording traces to a file for later, detailed analysis.

With TTB, you can visually replay and filter events, providing a clearer picture of system behavior over time. It's excellent for post-mortem debugging.

1> ttb:tracer().
% Start tracing and save to a file.
2> dbg:tp(my_module, my_function, 1, []).
3> my_module:my_function(data).
% ... run your system ...
4> ttb:stop().
% Later, to analyze:
5> ttb:start().
6> ttb:p(ttb_file_name, []).

Quick Debugging with Redbug

While dbg is powerful, it can have overhead. For quick, lightweight, on-the-fly tracing in a running system (even production), Redbug is often preferred.

Redbug lets you trace calls to specific functions and see their arguments and return values with minimal impact. It's perfect for quickly verifying assumptions or pinpointing recent activity.

1> redbug:start("my_module:my_function/1").
% Trace my_module:my_function/1
2> my_module:my_function(hello).
% Redbug will print trace output to the shell.
3> redbug:stop().

Redbug for Remote Tracing

Like dbg, Redbug can also trace functions on remote nodes. This makes it invaluable for quickly checking what's happening on a specific process or module on another server without bringing down the system or attaching a heavy debugger.

Here's a module we could trace on a remote node using Redbug.

-module(sensor_data).
-export([collect/1]).

collect(SensorId) ->
    Value = erlang:phash2(SensorId, 100), % Simulate reading
    io:format("Sensor ~p collected value: ~p~n", [SensorId, Value]),
    Value.

% To trace remotely (assuming nodes are connected):
% From node 'local@host':
% redbug:start("sensor_data:collect/1", [{node, 'remote@host'}]).
% Then, on 'remote@host':
% sensor_data:collect(temperature_sensor).

Distributed Debugging Check

Which of the following statements about Erlang's distributed debugging tools are true?

Recap: Tracing & Debugging

You've now explored key tools for tracing and debugging distributed Erlang systems:

The Erlang Debugger (dbg) for in-depth inspection and tracing.
TTB for recording and visualizing complex traces.
Redbug for lightweight, on-the-fly tracing, even in production.

Mastering these tools is essential for building and maintaining robust, fault-tolerant distributed applications with Erlang.

よくある質問

「分散システムのトレースとデバッグ」レッスンは無料ですか？

はい。「分散システムのトレースとデバッグ」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Erlang OTP: Distributed & Fault-Tolerant Systems Programmingコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Erlang OTP: Distributed & Fault-Tolerant Systems Programmingコースには全4レッスンが含まれています。

「分散システムのトレースとデバッグ」で何を学びますか？

分散環境で複数のErlangノードにまたがる問題を診断するための、高度なトレースとデバッグの手法を習得します。ブラウザで直接実行するハンズオンコードでErlang OTP: Distributed & Fault-Tolerant Systems Programmingを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Erlang OTP: Distributed & Fault-Tolerant Systems Programmingを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのErlang OTP: Distributed & Fault-Tolerant Systems Programmingは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン2/4です。

「分散システムのトレースとデバッグ」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このErlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンでコードを書いて実行できますか？

はい。すべてのErlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← Erlang OTP: Distributed & Fault-Tolerant Systems Programmingに戻る