root-cause-tracing

Root-cause tracing involves observing the symptom, identifying the immediate cause in code, then systematically tracing backward up the call stack to find the original trigger of invalid data or incorrect behavior. This prevents superficial fixes by revealing where the problem actually originates.

Use instrumentation and stack trace logging when errors occur deep in execution, stack traces are long, or the origin of invalid data is unclear. Adding debug output at key points captures the call chain and environment context, enabling precise identification of where bad values entered the system.

Test pollution occurs when one test introduces unwanted state affecting others. Use bisection techniques like the provided `find-polluter.sh` script to isolate which test introduces the problem, then trace backward through test execution to identify and fix the root cause.

Fixing a symptom patches the immediate error without addressing its source, risking recurrence. Root-cause tracing reveals the original trigger, enabling defense-in-depth fixes that prevent the problem from reoccurring across your codebase through multi-layer validation and pre-operation logging.

No. Strategic instrumentation at decision points, data entry boundaries, and before error-prone operations captures sufficient context. Focus logging on functions handling external input, state transitions, and areas where invalid data could originate rather than instrumenting comprehensively.

Root-cause tracing captures environment context, stack traces, and data flow patterns that enable reproducibility. Document the conditions leading to the original trigger, add validation to prevent invalid input earlier, and create tests that verify the fix prevents recurrence.