Exam Bundle

This signal belongs to the adjacent case “A query is delayed by a small set of long-running skewed tasks,” whose remedy is Use Spark UI or Query Profile partition/task timing to diagnose skew. The observed result for the present requirement is The plan reveals join strategy and whether broadcast thresholds were met.

That observation is a valid indicator for “One join stage has an unexpectedly large shuffle and dominates the critical path” when using Inspect Query Profile operators and shuffle bytes. The scenario instead tests “A join unexpectedly uses an expensive sort-merge stage instead of an eligible broadcast join”; the relevant result is The plan reveals join strategy and whether broadcast thresholds were met.

This signal belongs to the adjacent case “A scan reads far more rows than the WHERE clause should need,” whose remedy is Inspect filter pushdown and file/data skipping metrics in Query Profile. The observed result for the present requirement is The plan reveals join strategy and whether broadcast thresholds were met.

Examine Spark task duration distributions and input/shuffle sizes is appropriate when “Only a few tasks take much longer than others in one shuffle stage”; it would be verified by A small subset of tasks dominates the stage execution time. It does not directly satisfy “A Spark stage runs out of memory on one executor repeatedly,” whose relevant acceptance evidence is The failing executor reports OOM and affected task attempts.

This action solves a different issue: “A job has many tiny tasks and scheduling overhead dominates.” Its normal signal is The stage has excessive short tasks relative to meaningful computation. Here the requested behavior is “A Spark stage runs out of memory on one executor repeatedly,” so that signal is not sufficient.

The alternative Inspect driver/executor stack traces for ClassNotFound or ImportError has a distinct purpose—A task fails with a missing dependency after a runtime upgrade. It would not establish the required outcome (A Spark stage runs out of memory on one executor repeatedly); the necessary verification concerns The failing executor reports OOM and affected task attempts.

The logs identify the missing package or incompatible class would demonstrate the separate action Inspect driver/executor stack traces for ClassNotFound or ImportError, which addresses “A task fails with a missing dependency after a runtime upgrade.” It does not verify the requirement “A Spark stage runs out of memory on one executor repeatedly” following Inspect executor logs and Spark UI task failure details.

The suspected stage shows substantial disk spill and associated slowdown would demonstrate the separate action Inspect Spark UI spill metrics and task timelines, which addresses “A stage repeatedly spills large intermediates to disk.” It does not verify the requirement “A Spark stage runs out of memory on one executor repeatedly” following Inspect executor logs and Spark UI task failure details.

That observation is a valid indicator for “Only a few tasks take much longer than others in one shuffle stage” when using Examine Spark task duration distributions and input/shuffle sizes. The scenario instead tests “A Spark stage runs out of memory on one executor repeatedly”; the relevant result is The failing executor reports OOM and affected task attempts.

Inspect executor logs and Spark UI task failure details is appropriate when “A Spark stage runs out of memory on one executor repeatedly”; it would be verified by The failing executor reports OOM and affected task attempts. It does not directly satisfy “A stage repeatedly spills large intermediates to disk,” whose relevant acceptance evidence is The suspected stage shows substantial disk spill and associated slowdown.

Inspect driver/executor stack traces for ClassNotFound or ImportError is appropriate when “A task fails with a missing dependency after a runtime upgrade”; it would be verified by The logs identify the missing package or incompatible class. It does not directly satisfy “A stage repeatedly spills large intermediates to disk,” whose relevant acceptance evidence is The suspected stage shows substantial disk spill and associated slowdown.

This action solves a different issue: “Only a few tasks take much longer than others in one shuffle stage.” Its normal signal is A small subset of tasks dominates the stage execution time. Here the requested behavior is “A stage repeatedly spills large intermediates to disk,” so that signal is not sufficient.

This signal belongs to the adjacent case “A Spark stage runs out of memory on one executor repeatedly,” whose remedy is Inspect executor logs and Spark UI task failure details. The observed result for the present requirement is The suspected stage shows substantial disk spill and associated slowdown.

This signal belongs to the adjacent case “A job has many tiny tasks and scheduling overhead dominates,” whose remedy is Review the Spark UI task count and scheduling timeline. The observed result for the present requirement is The suspected stage shows substantial disk spill and associated slowdown.

This signal belongs to the adjacent case “Only a few tasks take much longer than others in one shuffle stage,” whose remedy is Examine Spark task duration distributions and input/shuffle sizes. The observed result for the present requirement is The suspected stage shows substantial disk spill and associated slowdown.

Inspect Spark UI spill metrics and task timelines is appropriate when “A stage repeatedly spills large intermediates to disk”; it would be verified by The suspected stage shows substantial disk spill and associated slowdown. It does not directly satisfy “Only a few tasks take much longer than others in one shuffle stage,” whose relevant acceptance evidence is A small subset of tasks dominates the stage execution time.

Inspect executor logs and Spark UI task failure details belongs to the separate case “A Spark stage runs out of memory on one executor repeatedly,” where The failing executor reports OOM and affected task attempts would be expected. That differs from the condition in this stem: “Only a few tasks take much longer than others in one shuffle stage.”

Inspect driver/executor stack traces for ClassNotFound or ImportError is appropriate when “A task fails with a missing dependency after a runtime upgrade”; it would be verified by The logs identify the missing package or incompatible class. It does not directly satisfy “Only a few tasks take much longer than others in one shuffle stage,” whose relevant acceptance evidence is A small subset of tasks dominates the stage execution time.

The suspected stage shows substantial disk spill and associated slowdown would demonstrate the separate action Inspect Spark UI spill metrics and task timelines, which addresses “A stage repeatedly spills large intermediates to disk.” It does not verify the requirement “Only a few tasks take much longer than others in one shuffle stage” following Examine Spark task duration distributions and input/shuffle sizes.

That observation is a valid indicator for “A job has many tiny tasks and scheduling overhead dominates” when using Review the Spark UI task count and scheduling timeline. The scenario instead tests “Only a few tasks take much longer than others in one shuffle stage”; the relevant result is A small subset of tasks dominates the stage execution time.

The failing executor reports OOM and affected task attempts pertains to a different control (Inspect executor logs and Spark UI task failure details) and a different need (A Spark stage runs out of memory on one executor repeatedly). It cannot establish that Examine Spark task duration distributions and input/shuffle sizes met the stated goal.

Examine Spark task duration distributions and input/shuffle sizes is appropriate when “Only a few tasks take much longer than others in one shuffle stage”; it would be verified by A small subset of tasks dominates the stage execution time. It does not directly satisfy “A task fails with a missing dependency after a runtime upgrade,” whose relevant acceptance evidence is The logs identify the missing package or incompatible class.

The alternative Review the Spark UI task count and scheduling timeline has a distinct purpose—A job has many tiny tasks and scheduling overhead dominates. It would not establish the required outcome (A task fails with a missing dependency after a runtime upgrade); the necessary verification concerns The logs identify the missing package or incompatible class.

Inspect Spark UI spill metrics and task timelines belongs to the separate case “A stage repeatedly spills large intermediates to disk,” where The suspected stage shows substantial disk spill and associated slowdown would be expected. That differs from the condition in this stem: “A task fails with a missing dependency after a runtime upgrade.”

That observation is a valid indicator for “A job has many tiny tasks and scheduling overhead dominates” when using Review the Spark UI task count and scheduling timeline. The scenario instead tests “A task fails with a missing dependency after a runtime upgrade”; the relevant result is The logs identify the missing package or incompatible class.

This signal belongs to the adjacent case “A stage repeatedly spills large intermediates to disk,” whose remedy is Inspect Spark UI spill metrics and task timelines. The observed result for the present requirement is The logs identify the missing package or incompatible class.

The failing executor reports OOM and affected task attempts pertains to a different control (Inspect executor logs and Spark UI task failure details) and a different need (A Spark stage runs out of memory on one executor repeatedly). It cannot establish that Inspect driver/executor stack traces for ClassNotFound or ImportError met the stated goal.

Inspect driver/executor stack traces for ClassNotFound or ImportError is appropriate when “A task fails with a missing dependency after a runtime upgrade”; it would be verified by The logs identify the missing package or incompatible class. It does not directly satisfy “A job has many tiny tasks and scheduling overhead dominates,” whose relevant acceptance evidence is The stage has excessive short tasks relative to meaningful computation.

Examine Spark task duration distributions and input/shuffle sizes belongs to the separate case “Only a few tasks take much longer than others in one shuffle stage,” where A small subset of tasks dominates the stage execution time would be expected. That differs from the condition in this stem: “A job has many tiny tasks and scheduling overhead dominates.”

Inspect executor logs and Spark UI task failure details is appropriate when “A Spark stage runs out of memory on one executor repeatedly”; it would be verified by The failing executor reports OOM and affected task attempts. It does not directly satisfy “A job has many tiny tasks and scheduling overhead dominates,” whose relevant acceptance evidence is The stage has excessive short tasks relative to meaningful computation.

That observation is a valid indicator for “Only a few tasks take much longer than others in one shuffle stage” when using Examine Spark task duration distributions and input/shuffle sizes. The scenario instead tests “A job has many tiny tasks and scheduling overhead dominates”; the relevant result is The stage has excessive short tasks relative to meaningful computation.

This signal belongs to the adjacent case “A task fails with a missing dependency after a runtime upgrade,” whose remedy is Inspect driver/executor stack traces for ClassNotFound or ImportError. The observed result for the present requirement is The stage has excessive short tasks relative to meaningful computation.

The suspected stage shows substantial disk spill and associated slowdown would demonstrate the separate action Inspect Spark UI spill metrics and task timelines, which addresses “A stage repeatedly spills large intermediates to disk.” It does not verify the requirement “A job has many tiny tasks and scheduling overhead dominates” following Review the Spark UI task count and scheduling timeline.