Remove copied code and line references

Author: gyuheon0h

docs/crashtracker-unix-socket-communication.md

@@ -1,25 +1,14 @@
 # Crash Tracker Unix Socket Communication Protocol
 
-**Date**: September 23, 2025
+**Date**: September 24, 2025
 
 ## Overview
 
 This document describes the Unix domain socket communication protocol used between the crash tracker's collector and receiver processes. The crash tracker uses a two-process architecture where the collector (a fork of the crashing process) communicates crash data to the receiver (a fork+execve process) via an anonymous Unix domain socket pair.
 
 ## Socket Creation and Setup
 
-The communication channel is established using `socketpair()` to create an anonymous Unix domain socket pair:
-
-```rust
-let (uds_parent, uds_child) = socket::socketpair(
-    socket::AddressFamily::Unix,
-    socket::SockType::Stream,
-    None,
-    socket::SockFlag::empty(),
-)?;
-```
-
-**Location**: `datadog-crashtracker/src/collector/receiver_manager.rs:78-85`
+The communication channel is established using `socketpair()` to create an anonymous Unix domain socket pair with Unix address family and stream socket type.
 
 ### File Descriptor Management
 
@@ -31,7 +20,7 @@ let (uds_parent, uds_child) = socket::socketpair(
 
 ### Data Format
 
-The crash data is transmitted as a structured text stream with distinct sections delimited by markers defined in `datadog-crashtracker/src/shared/constants.rs`.
+The crash data is transmitted as a structured text stream with distinct sections delimited by predefined markers.
 
 ### Message Structure
 
@@ -85,8 +74,6 @@ DD_CRASHTRACK_END_SIGINFO
 
 Contains signal details extracted from `siginfo_t` structure.
 
-**Implementation**: `datadog-crashtracker/src/collector/emitters.rs:223-263`
-
 #### 4. Process Context Section (ucontext)
 ```
 DD_CRASHTRACK_BEGIN_UCONTEXT
@@ -98,8 +85,6 @@ Contains processor state at crash time from `ucontext_t`. Format varies by platf
 - **Linux**: Direct debug print of `ucontext_t`
 - **macOS**: Includes both `ucontext_t` and machine context (`mcontext`)
 
-**Implementation**: `datadog-crashtracker/src/collector/emitters.rs:190-221`
-
 #### 5. Process Information Section
 ```
 DD_CRASHTRACK_BEGIN_PROCINFO
@@ -154,8 +139,6 @@ DD_CRASHTRACK_END_FILE "/proc/self/maps"
 
 Contains memory mapping information from `/proc/self/maps` for symbol resolution.
 
-**Implementation**: `datadog-crashtracker/src/collector/emitters.rs:184-187`
-
 #### 11. Stack Trace Section
 ```
 DD_CRASHTRACK_BEGIN_STACKTRACE
@@ -172,8 +155,6 @@ Each line represents one stack frame. Frame format depends on symbol resolution
 
 Stack frames with stack pointer less than the fault stack pointer are filtered out to exclude crash tracker frames.
 
-**Implementation**: `datadog-crashtracker/src/collector/emitters.rs:45-117`
-
 #### 12. Completion Marker
 ```
 DD_CRASHTRACK_DONE
@@ -185,69 +166,29 @@ Indicates end of crash report transmission.
 
 ### 1. Collector Side (Write End)
 
-**File**: `datadog-crashtracker/src/collector/collector_manager.rs:92-102`
-
-```rust
-let mut unix_stream = unsafe { UnixStream::from_raw_fd(uds_fd) };
-
-let report = emit_crashreport(
-    &mut unix_stream,
-    config,
-    config_str,
-    metadata_str,
-    sig_info,
-    ucontext,
-    ppid,
-);
-```
-
-The collector:
-1. Creates `UnixStream` from inherited file descriptor
-2. Calls `emit_crashreport()` to serialize and write all crash data
+The collector process performs the following operations:
+1. Creates a Unix stream from the inherited file descriptor
+2. Serializes and writes all crash data sections in the defined order
 3. Flushes the stream after each section for reliability
-4. Exits with `libc::_exit(0)` on completion
+4. Exits cleanly after completing the transmission
 
 ### 2. Receiver Side (Read End)
 
-**File**: `datadog-crashtracker/src/receiver/entry_points.rs:97-119`
-
-```rust
-pub(crate) async fn receiver_entry_point(
-    timeout: Duration,
-    stream: impl AsyncBufReadExt + std::marker::Unpin,
-) -> anyhow::Result<()> {
-    if let Some((config, mut crash_info)) = receive_report_from_stream(timeout, stream).await? {
-        // Process crash data
-        if let Err(e) = resolve_frames(&config, &mut crash_info) {
-            crash_info.log_messages.push(format!("Error resolving frames: {e}"));
-        }
-        if config.demangle_names() {
-            if let Err(e) = crash_info.demangle_names() {
-                crash_info.log_messages.push(format!("Error demangling names: {e}"));
-            }
-        }
-        crash_info.async_upload_to_endpoint(config.endpoint()).await?;
-    }
-    Ok(())
-}
-```
-
-The receiver:
-1. Reads from stdin (Unix socket via `dup2`)
-2. Parses the structured stream into `CrashInfo` and `CrashtrackerConfiguration`
+The receiver process handles crash data processing:
+1. Reads from stdin (Unix socket redirected via `dup2`)
+2. Parses the structured stream into crash information and configuration objects
 3. Performs symbol resolution if configured
-4. Uploads formatted crash report to backend
+4. Demangles symbol names if configured
+5. Uploads the formatted crash report to the configured backend endpoint
 
 ### 3. Stream Parsing
 
-**File**: `datadog-crashtracker/src/receiver/receive_report.rs`
-
-The receiver parses the stream by:
+The receiver parses the incoming stream by:
 1. Reading line-by-line with timeout protection
 2. Matching delimiter patterns to identify sections
 3. Accumulating section data between delimiters
 4. Deserializing JSON sections into appropriate data structures
-5. Handling the `DD_CRASHTRACK_DONE` completion marker
+5. Handling the completion marker to detect end of transmission
 
 ## Error Handling and Reliability
 
@@ -262,11 +203,9 @@ The receiver parses the stream by:
 - Prevents hanging on incomplete/corrupted streams
 
 ### Process Cleanup
-- Parent process uses `wait_for_pollhup()` to detect socket closure
-- Kills child processes with `SIGKILL` if needed
-- Reaps zombie processes to prevent resource leaks
-
-**File**: `datadog-crashtracker/src/collector/process_handle.rs:19-40`
+- Parent process detects socket closure to monitor child completion
+- Terminates unresponsive child processes when necessary
+- Properly reaps zombie processes to prevent resource leaks
 
 ### Data Integrity
 - Each section is flushed immediately after writing
@@ -276,17 +215,7 @@ The receiver parses the stream by:
 ## Alternative Communication Modes
 
 ### Named Socket Mode
-When `unix_socket_path` is configured, the collector connects to an existing Unix socket instead of using the fork+execve receiver:
-
-```rust
-let receiver = if unix_socket_path.is_empty() {
-    Receiver::spawn_from_stored_config()?  // Fork+execve mode
-} else {
-    Receiver::from_socket(unix_socket_path)?  // Named socket mode
-};
-```
-
-This allows integration with long-lived receiver processes.
+When a Unix socket path is configured, the collector connects to an existing Unix socket instead of using the fork+execve receiver. This allows integration with long-lived receiver processes that can handle multiple crash reports.
 
 **Linux Abstract Sockets**: On Linux, socket paths not starting with `.` or `/` are treated as abstract socket names.