Tracing e debugging dei sistemi distribuiti
Padroneggi tecniche avanzate di tracing e debugging per diagnosticare problemi su più nodi Erlang in un ambiente distribuito
Tracing e debugging dei sistemi distribuiti è una lezione Erlang OTP: Distributed & Fault-Tolerant Systems Programming gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Erlang OTP: Distributed & Fault-Tolerant Systems Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Erlang OTP: Distributed & Fault-Tolerant Systems Programming include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
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.
Domande Frequenti
La lezione «Tracing e debugging dei sistemi distribuiti» è gratuita?
Sì — il testo completo di «Tracing e debugging dei sistemi distribuiti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Erlang OTP: Distributed & Fault-Tolerant Systems Programming, passa a CoddyKit PRO. Il corso Erlang OTP: Distributed & Fault-Tolerant Systems Programming include 4 lezioni in totale.
Cosa imparerò in «Tracing e debugging dei sistemi distribuiti»?
Padroneggi tecniche avanzate di tracing e debugging per diagnosticare problemi su più nodi Erlang in un ambiente distribuito Eserciti Erlang OTP: Distributed & Fault-Tolerant Systems Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Erlang OTP: Distributed & Fault-Tolerant Systems Programming?
Non è richiesta alcuna esperienza precedente. Erlang OTP: Distributed & Fault-Tolerant Systems Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Tracing e debugging dei sistemi distribuiti»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Erlang OTP: Distributed & Fault-Tolerant Systems Programming?
Sì. Ogni lezione Erlang OTP: Distributed & Fault-Tolerant Systems Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Tecniche di profilazione in Erlang
- Tracing e debugging dei sistemi distribuiti
- Integrazione di metriche e monitoraggio
- Analisi della memoria e ottimizzazione del garbage collection