Troubleshooting Scenario Questions

View the workspace storage metrics

Why wrong: Storage metrics provide information on how much data is consumed by items in a workspace but do not show query execution times or visual performance. They are useful for managing capacity footprint but irrelevant for troubleshooting slow report rendering or inefficient DAX code.

Check the Fabric capacity SKU settings

Why wrong: SKU settings define the compute limits for the entire capacity. While an undersized SKU can lead to throttling, it is unlikely to be the cause of a single report being slow while others function normally. The bottleneck is usually the report design, not the SKU.

Rebuild the semantic model from scratch

Why wrong: Rebuilding the model is a destructive and time-consuming process that does not guarantee improved performance. Without first identifying the root cause of the slowness using diagnostic tools, you may simply recreate the same performance issues in the new model.

Set dynamicAllocation to false and use 50 static executors.

Why wrong: Disabling dynamic allocation and using static executors can lead to resource waste and does not solve the memory pressure within an individual executor. If one executor is running out of memory due to data skew or large partitions, adding more executors will not prevent that specific failure.

Increase the executorCores to 8 to allow more tasks to run.

Why wrong: Increasing the number of cores per executor while keeping memory constant actually reduces the amount of memory available to each individual task. This will likely worsen the Out of Memory situation because more tasks will be competing for the same 16GB of executor heap space.

Set vorderEnabled to false to reduce the memory overhead.

Why wrong: V-Order is an optimization for the write phase and does not significantly impact the memory consumption of Spark transformation tasks during the shuffle or execution phase. Disabling it would negatively impact the read performance of downstream applications without resolving the OOM errors in the current job.

Increase the number of compute nodes.

Why wrong: While adding compute power can sometimes mask poor query performance, it does not address the underlying issue of an inefficient join algorithm chosen by the optimizer. Improving the query plan through statistics is a more cost-effective and sustainable way to optimize performance.

Disable the query optimizer.

Why wrong: The query optimizer is fundamental to the execution of SQL statements. It cannot be disabled, and even if it could, manually managing execution plans is highly complex, error-prone, and unsustainable, especially given that Fabric handles query optimization automatically based on table metadata.

Rewrite the query using a cursor.

Why wrong: Cursors are row-based operations that are notoriously slow in analytical data warehouses. They perform poorly compared to set-based operations and should be avoided at all costs. Using a cursor would likely make the query performance even worse than the current broadcast nested loop join.

The recursive flag is set to true, causing the sink to attempt to merge multiple schemas.

Why wrong: Recursive flag simply tells the activity to look into subdirectories. It does not interfere with the initial schema inference logic itself. While recursive ingestion might lead to schema drift if files differ, it is not the primary cause of an immediate failure to infer the base schema.

AzureBlobFSReadSettings does not support schema inference from delimited files.

Why wrong: AzureBlobFSReadSettings is fully capable of reading delimited files and performing initial column discovery. The issue is not the read capability but rather how the sink interprets the output metadata during the table creation process when moving data between different storage formats in the Fabric environment.

The Copy activity requires an Execute Pipeline activity to initialize the sink.

Why wrong: A Copy activity is sufficient on its own to move data and create tables. There is no architectural requirement for an Execute Pipeline activity to initialize a sink. Adding unnecessary layers of orchestration does not resolve underlying configuration issues related to type mapping or schema definition.

Reduce the number of partitions.

Why wrong: Reducing partitions generally increases the amount of data processed per task, which can lead to memory overflow. It does not reduce the volume of data being shuffled; instead, it might make the shuffle even more unstable by creating larger data chunks for the network to transmit.

Enable auto-vacuuming on the table.

Why wrong: Auto-vacuuming helps clean up orphaned files and manage storage, but it has no impact on the performance of a Spark job's shuffle process. Shuffling is a compute-intensive task that happens in memory and over the network during runtime, not a storage-related background task.

Increase the disk capacity of the Lakehouse.

Why wrong: Shuffle operations in Spark occur in the memory or on the local temporary storage of the executors, not on the primary Lakehouse storage. Increasing Lakehouse storage will not provide any performance benefit for memory-intensive operations like shuffling, making this an ineffective solution for performance tuning.