Update tracing.asciidoc

Overview of tools

Author: happi

chapters/tracing.asciidoc

@@ -1,14 +1,45 @@
 [[CH-Tracing]]
 == Tracing
 
-Concurrency and distributed systems present unique challenges and complexities, particularly when it comes to debugging and monitoring.
+Concurrency and distributed systems present unique challenges and complexities, particularly regarding debugging and monitoring.
 Tracing is helpful in this context, offering developers a window into the running system's behavior.
 This chapter begins by exploring the role of tracing on the BEAM.
 
-Tracing provides visibility into process execution, communication between these processes, and the overall behavior of the system.
-Erlang systems are known for their robustness and fault tolerance, traits that we really want to achieve. However, these traits can complicate pinpointing the source of errors or unexpected behavior. Tracing allows developers to follow the execution flow in real-time or through recorded logs, making it easier to identify and rectify bugs.
+Tracing provides visibility into process execution, communication between these processes, and the system's overall behavior.
+Erlang systems are known for their robustness and fault tolerance, traits that we want to achieve. However, these traits can complicate pinpointing the source of errors or unexpected behavior. Tracing allows developers to follow the execution flow in real time or through recorded logs, making identifying and rectifying bugs easier.
 Tracing also serves a vital function in monitoring the performance of Erlang applications.
 Tracing function calls, message passing, and other system activities allows developers to gather data on performance bottlenecks, inefficient code paths, and unexpected system behavior. 
 Erlang's tracing capabilities extend to providing insights into the system's behavior. 
 Tracing helps in understanding how different parts of the system interact, how they scale, and how they recover from failures.
 Tracing thus becomes an educational tool, enabling developers to model and predict system behavior more accurately.
+
+We will review some of the tracing tools provided by ERTS and some built on top of the built-in support.
+
+==== Built-in Erlang Tracing Facilities
+===== `io:format` Tracing
+While not a tracing tool in the conventional sense, `io:format` serves as Erlang's equivalent to traditional debugging techniques like `printf` debugging found in other programming languages. It allows developers to insert print statements within their code, facilitating immediate and simple output of variable states, function call results, and process statuses. This method is highly accessible and requires minimal setup, making it an excellent first step for identifying issues before employing more sophisticated tracing tools.
+
+===== Erlang Trace (erl_trace)
+This tracing facility offers a low-level interface for tracing Erlang functions, messages, and processes.
+It provides the core functionalities upon which higher-level tracing tools are built, delivering essential tracing primitives directly supported by the Erlang runtime.
+
+===== Sequential Tracing (seq_trace)
+Specialized in tracing the flow of messages within distributed Erlang systems, seq_trace enables developers to track the sequence of message passing between processes.
+
+==== Third-party Tools
+===== Redbug
+Redbug is part of the eper performance and debugging suite and is known for its user-friendly interface and minimal performance impact.
+It focuses on safe, efficient tracing, avoiding common pitfalls like overwhelming trace output or system overload, making it an ideal choice for live system analysis.
+
+===== Recon Trace (recon_trace)
+As a component of the recon library for production system diagnosis, recon_trace stands out for its powerful tracing features, designed with safety and minimal performance impact in mind. 
+
+==== Comparison and Use Cases
+The selection among built-in and third-party tools largely depends on the specific debugging needs.
+`io:format` offers a straightforward, quick debugging method, whereas tools like `erl_trace` and `recon_trace` provide deeper insights with more comprehensive tracing capabilities.
+
+Tools designed to minimize operational impact, such as redbug and recon_trace, are particularly valuable in production environments.
+They enable real-time issue diagnosis without significant performance drawbacks.
+
+`seq_trace` provides essential insights into the dynamics of message passing and process interaction across distributed Erlang nodes.
+